Minor changes after benchmarking

[?]

Feb 5, 2021, 4:30 PM

6DCQHIFPEH4GZKSRRS32GMKDRPZH4MTCGOUEI7YEUVKWENBF3JWAC

Dependencies

[2] G4JEQLLX Debugging synchronisation
[3] UUUVNC4D Debugging/cleanup around cursors
[4] UAQX27N4 Tests
[5] ONES3V46 reference counting works for put
[6] 6DMPXOAT More debugging
[7] WS4ZQM4R Debugging, tests, etc.
[8] QEUTVAZ4 Splitting btree::page
[9] FMN7X4J2 Micro-improvements, now noticeably faster than std::collections::BTreeMap
[10] OP6SVMOD Resetting history
[11] OTWDDJE7 Trait/type cleanup
[12] H3FVSQIQ Unsized pages
[13] YWFYZNLZ Cleanup + inter-process concurrency
[14] DV4A2LR7 Double-inserts (rebalancing near an internal deletion)
[15] EAAYH6BQ Debugging put
[16] NQBEOCFO Tests cleanup
[17] APPY2E7M Unsized deletions + custom sizes back
[18] 6UVFCERM Formatting, debugging, etc.

Change contents

replacement in sanakirja-core/src/btree/put.rs at line 70

[4.175]→[4.5205:5216](∅→∅),[4.5205]→[4.5205:5216](∅→∅)

loop {

[4.175]

[4.5216]

for _ in 0..N_CURSORS {
edit in sanakirja-core/src/btree/put.rs at line 134

[4.7436]

[4.7436]

unreachable!()
edit in sanakirja-core/src/btree/page.rs at line 132

[4.11691]→[4.1521:1671](∅→∅)

debug!(
"update_left_child: {:?} {:?} {:?}",
page,
mutable,
header(page.as_page())
);
edit in sanakirja-core/src/btree/page.rs at line 137

[4.2293]→[4.215:254](∅→∅)

debug!("new = {:?}", new);
edit in sanakirja-core/src/btree/page.rs at line 161

[4.5311]→[4.148:191](∅→∅),[4.1880]→[4.148:191](∅→∅),[4.2758]→[4.148:191](∅→∅)

debug!("del: {:?} {:?}", page, l);
edit in sanakirja-core/src/btree/page.rs at line 235

[4.3087]→[4.3087:3218](∅→∅)

debug!(
"size = {:?} {:?} {:?} {:?} {:?}",
mod_size, mid_size, occupied, hdr_size, size
);
replacement in sanakirja-core/src/btree/page.rs at line 462

[4.9543]→[3.228:323](∅→∅)

unsafe fn lookup<T, K: Representable + core::fmt::Debug, V: Representable + core::fmt::Debug>(

[4.9543]

[4.9608]

fn leaf_linear_search<T, K: Representable, V: Representable>(
txn: &T,
k0: &K,
s: &[Tuple<K, V>]
) -> Result<usize, usize> {
let mut n = 0;
for sm in s.iter() {
match sm.k.compare(txn, k0) {
Ordering::Less => n += 1,
Ordering::Greater => return Err(n),
Ordering::Equal => return Ok(n),
}
}
Err(n)
}

unsafe fn lookup<T, K: Representable, V: Representable>(
edit in sanakirja-core/src/btree/page.rs at line 495

[4.45837]→[3.324:355](∅→∅)

debug!("s = {:?}", s);
replacement in sanakirja-core/src/btree/page.rs at line 501

[4.10502]→[4.46037:46098](∅→∅)

s.binary_search_by(|tup| tup.k.compare(txn, k0))

[4.10502]

[4.11275]

// leaf_binary_search(txn, k0, s)
leaf_linear_search(txn, k0, s)
edit in sanakirja-core/src/btree/page.rs at line 551

[4.34802]→[4.1788:1818](∅→∅)

debug!("modify {:?}", m);
edit in sanakirja-core/src/btree/page.rs at line 618

[4.38969]→[4.22552:22604](∅→∅)

debug!("clone: {:?} {:?}", r, off);
edit in sanakirja-core/src/btree/page.rs at line 621

[4.6805]→[4.22756:22804](∅→∅),[4.22756]→[4.22756:22804](∅→∅)

debug!("size: {:?}", size);
edit in sanakirja-core/src/btree/page.rs at line 623

[4.10150]→[4.22916:22970](∅→∅),[4.22916]→[4.22916:22970](∅→∅)

debug!("off_new: {:?}", off_new);
edit in sanakirja-core/src/btree/page.rs at line 659

[4.6978]→[4.6101:6140](∅→∅)

debug!("off_new = {:?}", off_new);
edit in sanakirja-core/src/btree/page/rebalance.rs at line 78

[4.47285]→[4.47285:47338](∅→∅)

debug!("tuple = {:?}", t.assume_init());
edit in sanakirja-core/src/btree/page/put.rs at line 28

[4.6531]→[4.6531:6587](∅→∅)

debug!("put {:?} {:?} {:?}", u, mutable, is_dirty);
edit in sanakirja-core/src/btree/page/put.rs at line 29

[4.6224]→[4.6673:6702](∅→∅),[4.6673]→[4.6673:6702](∅→∅)

debug!("can alloc");
edit in sanakirja-core/src/btree/page/put.rs at line 40

[4.7197]→[4.7197:7239](∅→∅)

debug!("can compact: {:?}", new);
edit in sanakirja-core/src/btree/page/put.rs at line 60

[4.8060]→[4.8060:8085](∅→∅)

debug!("split");
edit in sanakirja-core/src/btree/page/put.rs at line 93

[4.8993]→[4.8993:9051](∅→∅)

debug!("u = {:?}, k = {:?} {:?} {:?}", u, k, s0, s1);
edit in sanakirja-core/src/btree/page/put.rs at line 99

[4.8484]→[4.9337:9449](∅→∅),[4.9337]→[4.9337:9449](∅→∅)

debug!("k = {:?}, v = {:?} r = {:?}", k, v, r);
debug!("k = {:?}", k as *const K as *const u8);
edit in sanakirja-core/src/btree/page/put.rs at line 104

[4.9566]→[4.9566:9622](∅→∅)

debug!("mutable dirty {:?} >= {:?}", u, k);
edit in sanakirja-core/src/btree/page/put.rs at line 113

[4.10040]→[4.10040:10092](∅→∅)

debug!("immutable {:?} >= {:?}", u, k);
edit in sanakirja-core/src/btree/page/put.rs at line 147

[4.8957]→[4.11545:11582](∅→∅),[4.11545]→[4.11545:11582](∅→∅)

debug!("{:?} < {:?}", u, k);
replacement in sanakirja/src/tests.rs at line 84

[4.1316]→[4.4544:4572](∅→∅),[4.25811]→[4.4544:4572](∅→∅),[4.4544]→[4.4544:4572](∅→∅)

let n = 100_000 as u64;

[4.25811]

[4.4616]

let n = 10_000_000 as u64;
replacement in sanakirja/src/tests.rs at line 90

[4.4839]→[4.4839:4910](∅→∅)

del(&mut txn, &mut db, &((i * i) % 1_000_000), None).unwrap();

[4.4786]

[4.4910]

del(&mut txn, &mut db, &((i * i) % 1_000), None).unwrap();
}
txn.commit().unwrap();
}

#[test]
pub fn u64_u64() {
env_logger::try_init().unwrap_or(());
let env = Env::new_anon(409600000, 1).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();
let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
let n = 1_000_000 as u64;
for i in 0..n {
put(&mut txn, &mut db, &((i * i) % 1_000), &i).unwrap();
edit in sanakirja/src/tests.rs at line 431

[2.3038]

[4.12890]

}

#[test]
fn lmdb() {
use lmdb_rs::*;
env_logger::try_init().unwrap_or(());
for i in 1..12 {
let n = i * 1_000_000;
std::fs::remove_dir_all("/tmp/sanakirja0").unwrap_or(());
std::fs::create_dir_all("/tmp/sanakirja0").unwrap();

let env = Env::new("/tmp/sanakirja0", 409_600_000, 2).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();

let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();

let mut times = [0f64; 12];

let mut test = Vec::with_capacity(n);
let mut rng = rand::thread_rng();
for _ in 0..n {
use rand::Rng;
test.push((rng.gen(), rng.gen()))
}
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert!(put(&mut txn, &mut db, k, v).unwrap());
}
times[0] = now.elapsed().unwrap().as_secs_f64();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert_eq!(btree::get(&txn, &db, &k, None).unwrap(), Some((k, v)))
}
times[1] = now.elapsed().unwrap().as_secs_f64();

let env = Env::new_anon(409_600_000, 2).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();
let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert!(put(&mut txn, &mut db, k, v).unwrap());
}
times[2] = now.elapsed().unwrap().as_secs_f64();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert_eq!(btree::get(&txn, &db, &k, None).unwrap(), Some((k, v)))
}
times[3] = now.elapsed().unwrap().as_secs_f64();

let mut b = std::collections::BTreeMap::new();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
b.insert(*k, *v);
}
times[4] = now.elapsed().unwrap().as_secs_f64();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert_eq!(b.get(k), Some(v));
}
times[5] = now.elapsed().unwrap().as_secs_f64();

std::fs::remove_dir_all("/tmp/test-lmdb").unwrap_or(());
std::fs::create_dir_all("/tmp/test-lmdb").unwrap_or(());
let env = EnvBuilder::new()
.map_size(1 << 30)
.open("/tmp/test-lmdb", 0o777)
.unwrap();

let db_handle = env.get_default_db(lmdb_rs::core::DbIntKey).unwrap();
let txn = env.new_transaction().unwrap();
{
let db = txn.bind(&db_handle);
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
db.set(k, v).unwrap();
}
times[6] = now.elapsed().unwrap().as_secs_f64();
}

// Note: `commit` is choosen to be explicit as
// in case of failure it is responsibility of
// the client to handle the error
match txn.commit() {
Err(_) => panic!("failed to commit!"),
Ok(_) => (),
}

let reader = env.get_reader().unwrap();
let db = reader.bind(&db_handle);
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
let name = db.get::<u64>(k).ok();
assert_eq!(name, Some(*v))
}
times[7] = now.elapsed().unwrap().as_secs_f64();

std::fs::remove_dir_all("/tmp/test-sled").unwrap_or(());
std::fs::create_dir_all("/tmp/test-sled").unwrap_or(());
let db: sled::Db = sled::open("/tmp/test-sled").unwrap();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
unsafe {
db.insert(
std::slice::from_raw_parts(k as *const u64 as *const u8, 8),
std::slice::from_raw_parts(v as *const u64 as *const u8, 8),
)
.unwrap();
}
}
times[8] = now.elapsed().unwrap().as_secs_f64();
let now = std::time::SystemTime::now();
for (k, _v) in test.iter() {
unsafe {
db.get(std::slice::from_raw_parts(k as *const u64 as *const u8, 8))
.unwrap();
}
}
times[9] = now.elapsed().unwrap().as_secs_f64();

{
use old_sanakirja::*;
std::fs::remove_dir_all("/tmp/sanakirja1").unwrap_or(());
std::fs::create_dir_all("/tmp/sanakirja1").unwrap();
let env = Env::new("/tmp/sanakirja1", 409_600_000).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();
let mut db = txn.create_db::<u64, u64>().unwrap();
let now = std::time::SystemTime::now();
let mut rng = rand::thread_rng();
for (k, v) in test.iter() {
assert!(txn.put(&mut rng, &mut db, *k, *v).unwrap());
}
times[10] = now.elapsed().unwrap().as_secs_f64();
let now = std::time::SystemTime::now();
for (k, v) in test.iter() {
assert_eq!(txn.get(&db, *k, None).unwrap(), Some(*v))
}
times[11] = now.elapsed().unwrap().as_secs_f64();
}

print!("{}", n);
for t in times.iter() {
print!(", {}", t)
}
println!();
}
replacement in sanakirja/Cargo.toml at line 24

[2.3736]→[2.3736:3752](∅→∅)

# lmdb-rs = "*"

[2.3736]

lmdb-rs = "*"
sled = "*"
rand = "*"
old-sanakirja = { package = "sanakirja", version = "0.15", features = ["mmap"] }