implementing prev() on cursors (+ some cleanup)

Dependencies

• [2] T7QB6QEP Adding debug.rs
• [3] EYNN7RLS Tests++ (including UUID)
• [4] SO25TWFL A few features for integrating it into Pijul
• [5] 6UVFCERM Formatting, debugging, etc.
• [6] W26CFMAQ Improving safety of cursors
• [7] YXKP4AIW New file locks, with multiple sets of free pages
• [8] WS4ZQM4R Debugging, tests, etc.
• [9] QEUTVAZ4 Splitting btree::page
• [10] H3FVSQIQ Unsized pages
• [11] X3QVVQIS More debugging (del seems to work now)
• [12] UAQX27N4 Tests
• [13] KX3WVNZW Testing/debugging "rebalance causes split of the root"
• [14] 6DCQHIFP Minor changes after benchmarking
• [15] AOX2XQIS Actually, with the correct functions, Unsized pages are always slower than Sized pages (especially for writing)
• [16] FMN7X4J2 Micro-improvements, now noticeably faster than std::collections::BTreeMap
• [17] 7WJNSPEW Using the same definition of the "occupied" field uniform everywhere
• [18] APPY2E7M Unsized deletions + custom sizes back
• [19] 6DMPXOAT More debugging
• [20] NQBEOCFO Tests cleanup
• [21] KMT3MF5N Drop a database
• [22] OP6SVMOD Resetting history
• [23] G4JEQLLX Debugging synchronisation
• [24] EAAYH6BQ Debugging put
• [25] OTWDDJE7 Trait/type cleanup
• [26] PXF3R6SV Improving test coverage for btree::cursor
• [27] YWFYZNLZ Cleanup + inter-process concurrency
• [28] ONES3V46 reference counting works for put
• [29] UUUVNC4D Debugging/cleanup around cursors
• [30] EHJFNMB2 Debugging
• [31] DV4A2LR7 Double-inserts (rebalancing near an internal deletion)
• [32] S4V4QZ5C Debugging reference-counting for put

Change contents

• replacement in sanakirja-core/src/btree/put.rs at line 29
  [4.4317]→[4.4317:4355](∅→∅)
  − let mut cursor = Cursor::new(db);
  [4.4317]

  [4.4355]
  + let mut cursor = Cursor::new(txn, db)?;
• replacement in sanakirja-core/src/btree/put.rs at line 38
  [4.50]→[4.4587:4625](∅→∅),[4.118]→[4.4587:4625](∅→∅),[4.4587]→[4.4587:4625](∅→∅)
  − cur.cursor.as_ref().unwrap(),
  [4.50]

  [4.4625]
  + &cur.cursor,
• replacement in sanakirja-core/src/btree/put.rs at line 46
  [4.4718]→[4.4718:4780](∅→∅)
  − db.db = put_cascade(txn, &mut cursor, put, &mut free)?.0;
  [4.4718]

  [4.45]
  + db.db = put_cascade(txn, &mut cursor, put, &mut free)?.0.offset;
• replacement in sanakirja-core/src/btree/put.rs at line 88
  [4.190]→[4.279:333](∅→∅),[4.279]→[4.279:333](∅→∅)
  − cur.cursor.as_ref().unwrap(),
  [4.190]

  [4.333]
  + &cur.cursor,
• replacement in sanakirja-core/src/btree/put.rs at line 105
  [4.5879]→[4.921:978](∅→∅)
  − &P::first_cursor(p.0.as_page()),
  [4.5879]

  [4.5927]
  + &P::cursor_first(p.0.as_page()),
• replacement in sanakirja-core/src/btree/put.rs at line 125
  [4.330]→[4.810:865](∅→∅),[4.810]→[4.810:865](∅→∅)
  − curs.cursor.as_ref().unwrap(),
  [4.330]

  [4.865]
  + &curs.cursor,
• replacement in sanakirja-core/src/btree/put.rs at line 171
  [4.8159]→[4.1010:1067](∅→∅)
  − let mut c = P::first_cursor(cur.page.as_page());
  [4.8159]

  [4.1067]
  + let mut c = P::cursor_before(cur.page.as_page());

  + P::move_next(cur.page.as_page(), &mut c);
• edit in sanakirja-core/src/btree/page_unsized.rs at line 75
  [4.3909]

  [4.3909]
  + assert!(c.cur >= 0);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 77
  [4.3929]→[4.3929:4014](∅→∅)
  − put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, k1v1, 0, 0)
  [4.3929]

  [4.4014]
  + put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, 0, 0)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 79
  [4.4031]→[4.4031:4120](∅→∅)
  − put::put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, k1v1, l, r)
  [4.4031]

  [4.4120]
  + put::put::<_, _, _, Internal>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, l, r)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 124
  [4.5716]→[4.5716:5754](∅→∅)
  − assert!(c.cur < c.total + 1);
  [4.5716]

  [4.5754]
  + assert!(c.cur < c.total as isize + 1);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 138
  [4.6121]→[4.6121:6155](∅→∅)
  − assert!(c.cur < c.total);
  [4.1340]

  [4.6155]
  + assert!(c.cur >= 0 && c.cur < c.total as isize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 146
  [4.6448]→[4.6448:6514](∅→∅)
  − let ptr = p.add(HDR + c.cur * 2) as *mut u16;
  [4.6448]

  [4.6514]
  + let ptr = p.add(HDR + c.cur as usize * 2) as *mut u16;
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 149
  [4.6630]→[4.6630:6698](∅→∅)
  − core::ptr::copy(ptr.offset(1), ptr, n - c.cur);
  [4.6630]

  [4.6698]
  + core::ptr::copy(ptr.offset(1), ptr, n - c.cur as usize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 152
  [4.6759]→[4.6759:6825](∅→∅)
  − let ptr = p.add(HDR + c.cur * 8) as *mut u64;
  [4.6759]

  [4.6825]
  + let ptr = p.add(HDR + c.cur as usize * 8) as *mut u64;
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 156
  [4.6998]→[4.6998:7081](∅→∅)
  − core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur);
  [4.6998]

  [4.7081]
  + core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur as usize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 176
  [4.7800]→[4.7800:7854](∅→∅)
  − let (s0, s1) = s.split_at(c.cur);
  [4.7800]

  [4.7854]
  + let (s0, s1) = s.split_at(c.cur as usize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 182
  [4.8148]→[4.8148:8202](∅→∅)
  − let (s0, s1) = s.split_at(c.cur);
  [4.8148]

  [4.8202]
  + let (s0, s1) = s.split_at(c.cur as usize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 241
  [4.10222]→[4.10222:10286](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.10222]

  [4.10286]
  + let rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 286
  [4.11833]→[4.11833:11858](∅→∅)
  − c.cur >= c.total
  [4.11833]

  [4.11858]
  + c.cur >= c.total as isize
• edit in sanakirja-core/src/btree/page_unsized.rs at line 288
  [4.11864]

  [4.11864]
  +

  + fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {

  + c.cur < 0

  + }
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 293
  [4.11890]→[4.11890:12093](∅→∅)
  − fn first_cursor(p: crate::Page) -> Self::Cursor {

  − let hdr = header(p);

  − Cursor {

  − cur: 0,

  − total: hdr.n() as usize,

  − is_leaf: hdr.is_leaf(),

  − }
  [4.11890]

  [4.12093]
  + fn cursor_before(p: crate::Page) -> Self::Cursor {

  + Cursor::new(p, -1)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 296
  [4.12099]→[4.12099:12329](∅→∅)
  − fn last_cursor(p: crate::Page) -> Self::Cursor {

  − let hdr = header(p);

  − let total = hdr.n() as usize;

  − Cursor {

  − cur: total - 1,

  − total,

  − is_leaf: hdr.is_leaf(),

  − }
  [4.12099]

  [4.12329]
  + fn cursor_after(p: crate::Page) -> Self::Cursor {

  + Cursor::after(p)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 299
  [4.12335]→[4.12335:12385](∅→∅)
  − unsafe fn unchecked_current<'a, T: LoadPage>(
  [4.12335]

  [4.12385]
  + fn current<'a, T: LoadPage>(
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 303
  [4.12459]→[4.12459:12513](∅→∅),[4.12513]→[4.1441:1564](∅→∅),[4.1564]→[4.12648:12733](∅→∅),[4.12648]→[4.12648:12733](∅→∅),[4.12733]→[4.1565:1720](∅→∅)
  − ) -> (&'a K, &'a V, u64) {

  − if c.is_leaf {

  − let off =

  − { u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize };

  − let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));

  − (

  − K::from_raw_ptr(txn, k as *const u8),

  − V::from_raw_ptr(txn, v as *const u8),

  − 0,

  − )
  [4.12459]

  [4.12825]
  + ) -> Option<(&'a K, &'a V, u64)> {

  + if c.cur < 0 || c.cur >= c.total as isize {

  + None

  + } else if c.is_leaf {

  + unsafe {

  + let off =

  + { u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16)) as usize };

  + let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off));

  + Some((

  + K::from_raw_ptr(txn, k as *const u8),

  + V::from_raw_ptr(txn, v as *const u8),

  + 0,

  + ))

  + }
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 318
  [4.12842]→[4.12842:13030](∅→∅),[4.13030]→[4.1721:1887](∅→∅)
  − let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur));

  − let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));

  − (

  − K::from_raw_ptr(txn, k as *const u8),

  − V::from_raw_ptr(txn, v as *const u8),

  − off & !0xfff,

  − )
  [4.12842]

  [4.13133]
  + unsafe {

  + let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur));

  + let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));

  + Some((

  + K::from_raw_ptr(txn, k as *const u8),

  + V::from_raw_ptr(txn, v as *const u8),

  + off & !0xfff,

  + ))

  + }
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 331
  [4.13283]→[4.13283:13375](∅→∅)
  − u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize
  [4.13283]

  [4.13375]
  + u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16)) as usize
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 333
  [4.13392]→[4.13392:13485](∅→∅)
  − (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64)) & 0xfff)
  [4.13392]

  [4.13485]
  + (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 341
  [4.13715]→[4.13715:13792](∅→∅)
  − *(page.data.as_ptr().add(HDR) as *const u16).add(c.cur),
  [4.13715]

  [4.1888]
  + *(page.data.as_ptr().add(HDR) as *const u16).offset(c.cur),
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 345
  [4.13967]→[4.13967:14067](∅→∅)
  − (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur)) & 0xfff)
  [4.13967]

  [4.14067]
  + (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur)) & 0xfff)
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 352
  [4.14219]→[4.14219:14248](∅→∅)
  − if c.cur < c.total {
  [4.14219]

  [4.14248]
  + if c.cur < c.total as isize {
• edit in sanakirja-core/src/btree/page_unsized.rs at line 364
  [4.14490]

  [4.14490]
  + c.cur = -1;
• edit in sanakirja-core/src/btree/page_unsized.rs at line 369
  [4.14588]

  [4.14588]
  + assert!(c.cur >= 0);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 373
  [4.14642]→[4.14642:14739](∅→∅)
  − let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur * 8) - 8) as *const u64) };
  [4.14642]

  [4.14739]
  + let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
• edit in sanakirja-core/src/btree/page_unsized.rs at line 378
  [4.14859]

  [4.14859]
  + assert!(c.cur < c.total as isize);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 382
  [4.14913]→[4.14913:15004](∅→∅)
  − let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64) };
  [4.14913]

  [4.15004]
  + let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64) };
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 414
  [4.16089]→[4.16089:16111](∅→∅)
  − n
  [4.16089]

  [4.16111]
  + n as isize
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 418
  [4.16194]→[4.16194:16216](∅→∅)
  − n
  [4.16194]

  [4.16216]
  + n as isize
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 429
  [4.16424]→[4.16424:16454](∅→∅)
  − total: c.cur,
  [4.16424]

  [4.16454]
  + total: c.cur.max(0) as usize,
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 504
  [4.18917]→[4.18917:18970](∅→∅)
  − cur: usize,

  − total: usize,

  − is_leaf: bool,
  [4.18917]

  [4.18970]
  + pub(in super) cur: isize,

  + pub(in super) total: usize,

  + pub(in super) is_leaf: bool,

  + }

  +

  + impl Cursor {

  + pub(in super) fn new(p: crate::Page, cur: isize) -> Cursor {

  + let hdr = header(p);

  + assert!(cur < hdr.n() as isize);

  + Cursor {

  + cur,

  + total: hdr.n() as usize,

  + is_leaf: hdr.is_leaf(),

  + }

  + }

  + pub(in super) fn after(p: crate::Page) -> Cursor {

  + let hdr = header(p);

  + let total = hdr.n();

  + Cursor {

  + cur: total as isize,

  + total: total as usize,

  + is_leaf: hdr.is_leaf(),

  + }

  + }

  + pub(in super) fn last(p: crate::Page) -> Cursor {

  + let hdr = header(p);

  + let total = hdr.n();

  + Cursor {

  + cur: (total - 1) as isize,

  + total: total as usize,

  + is_leaf: hdr.is_leaf(),

  + }

  + }
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 590
  [4.20399]→[4.20399:20467](∅→∅)
  − let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.20399]

  [4.20467]
  + let mut rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 597
  [4.20764]→[4.20764:20832](∅→∅)
  − let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.20764]

  [4.20832]
  + let mut rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 647
  [4.22584]→[4.22584:22640](∅→∅)
  − let new_ptr = new.0.data.add(off_new as usize);
  [4.22584]

  [4.22640]
  + let new_ptr = new.0.data.add(off_new);
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 18
  [4.23324]→[4.23324:23384](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.23324]

  [4.23384]
  + let rc = super::Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 20
  [4.23447]→[4.23447:23540](∅→∅)
  − let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &rc) };
  [4.23447]

  [4.23540]
  + let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc).unwrap();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 51
  [4.520]→[4.520:656](∅→∅)
  − let mut lc = <Page<K, V>>::last_cursor(m.modified.page.as_page());

  − <Page<K, V>>::move_next(m.modified.page.as_page(), &mut lc);
  [4.24242]

  [4.656]
  + let lc = Cursor::after(m.modified.page.as_page());
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 101
  [4.25320]→[4.25320:25475](∅→∅)
  − let lc = <Page<K, V>>::last_cursor(m.other.as_page());

  − let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &lc) };
  [4.25320]

  [4.25475]
  + let lc = super::Cursor::last(m.other.as_page());

  + let (k0, v0, r0) = <Page<K, V>>::current(txn, m.other.as_page(), &lc).unwrap();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 105
  [4.25516]→[4.25516:25584](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.modified.page.as_page());
  [4.25516]

  [4.25584]
  + let rc = super::Cursor::new(m.modified.page.as_page(), 0);
• edit in sanakirja-core/src/btree/page.rs at line 12
  [4.94]

  [4.94]
  + pub use super::page_unsized::Cursor;
• edit in sanakirja-core/src/btree/page.rs at line 93
  [4.11143]

  [4.1824]
  + assert!(c.cur >= 0);
• replacement in sanakirja-core/src/btree/page.rs at line 95
  [4.1844]→[4.118:203](∅→∅)
  − put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, k1v1, 0, 0)
  [4.1844]

  [4.1918]
  + put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, 0, 0)
• replacement in sanakirja-core/src/btree/page.rs at line 97
  [4.1935]→[4.204:293](∅→∅)
  − put::put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, k1v1, l, r)
  [4.1935]

  [4.11455]
  + put::put::<_, _, _, Internal>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, l, r)
• replacement in sanakirja-core/src/btree/page.rs at line 141
  [4.12313]→[4.13:51](∅→∅)
  − assert!(c.cur < c.total + 1);
  [4.12313]

  [4.12351]
  + assert!(c.cur >= 0 && (c.cur as usize) < c.total + 1);
• replacement in sanakirja-core/src/btree/page.rs at line 155
  [4.2758]→[4.12658:12692](∅→∅),[4.191]→[4.12658:12692](∅→∅),[4.12658]→[4.12658:12692](∅→∅)
  − assert!(c.cur < c.total);
  [4.5311]

  [4.2759]
  + assert!(c.cur >= 0 && (c.cur as usize) < c.total);
• replacement in sanakirja-core/src/btree/page.rs at line 166
  [4.44789]→[4.44789:44830](∅→∅)
  − let off = c.cur * f;
  [4.44789]

  [4.44830]
  + let off = c.cur as usize * f;
• replacement in sanakirja-core/src/btree/page.rs at line 168
  [4.44886]→[4.44886:44967](∅→∅)
  − core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur - 1));
  [4.44886]

  [4.44967]
  + core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur as usize - 1));
• replacement in sanakirja-core/src/btree/page.rs at line 171
  [4.2569]→[4.2569:2635](∅→∅),[4.2065]→[4.2065:2148](∅→∅)
  − let ptr = p.add(HDR + c.cur * 8) as *mut u64;

  − core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur);
  [4.2569]

  [4.5374]
  + let ptr = p.add(HDR + c.cur as usize * 8) as *mut u64;

  + core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur as usize);
• replacement in sanakirja-core/src/btree/page.rs at line 192
  [4.4646]→[4.14825:14879](∅→∅),[4.14825]→[4.14825:14879](∅→∅)
  − let (s0, s1) = s.split_at(c.cur);
  [4.4646]

  [4.14932]
  + let (s0, s1) = s.split_at(c.cur as usize);
• replacement in sanakirja-core/src/btree/page.rs at line 198
  [4.4891]→[4.15205:15259](∅→∅),[4.15205]→[4.15205:15259](∅→∅)
  − let (s0, s1) = s.split_at(c.cur);
  [4.4891]

  [4.15312]
  + let (s0, s1) = s.split_at(c.cur as usize);
• replacement in sanakirja-core/src/btree/page.rs at line 256
  [4.17328]→[4.5779:5843](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.17328]

  [4.5843]
  + let rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page.rs at line 301
  [4.6739]→[4.18794:18819](∅→∅),[4.18794]→[4.18794:18819](∅→∅)
  − c.cur >= c.total
  [4.6739]

  [4.18819]
  + c.cur >= c.total as isize

  + }

  +

  + fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {

  + c.cur < 0
• replacement in sanakirja-core/src/btree/page.rs at line 308
  [4.18851]→[4.6740:6933](∅→∅),[4.6933]→[4.19098:19108](∅→∅),[4.19098]→[4.19098:19108](∅→∅)
  − fn first_cursor(p: crate::Page) -> Self::Cursor {

  − let hdr = header(p);

  − Cursor {

  − cur: 0,

  − total: hdr.n() as usize,

  − is_leaf: hdr.is_leaf(),

  − }
  [4.18851]

  [4.19108]
  + fn cursor_before(p: crate::Page) -> Self::Cursor {

  + Cursor::new(p, -1)
• replacement in sanakirja-core/src/btree/page.rs at line 311
  [4.19114]→[4.6934:7154](∅→∅),[4.7154]→[4.19392:19402](∅→∅),[4.19392]→[4.19392:19402](∅→∅)
  − fn last_cursor(p: crate::Page) -> Self::Cursor {

  − let hdr = header(p);

  − let total = hdr.n() as usize;

  − Cursor {

  − cur: total - 1,

  − total,

  − is_leaf: hdr.is_leaf(),

  − }
  [4.19114]

  [4.19402]
  + fn cursor_after(p: crate::Page) -> Self::Cursor {

  + Cursor::after(p)
• replacement in sanakirja-core/src/btree/page.rs at line 314
  [4.19408]→[4.3055:3105](∅→∅)
  − unsafe fn unchecked_current<'a, T: LoadPage>(
  [4.19408]

  [4.3105]
  + fn current<'a, T: LoadPage>(
• replacement in sanakirja-core/src/btree/page.rs at line 318
  [4.3872]→[4.3872:3903](∅→∅),[4.3903]→[4.19505:19528](∅→∅),[4.7257]→[4.19505:19528](∅→∅),[4.19505]→[4.19505:19528](∅→∅)
  − ) -> (&'a K, &'a V, u64) {

  − if c.is_leaf {
  [4.3872]

  [4.1529]
  + ) -> Option<(&'a K, &'a V, u64)> {

  + if c.cur < 0 || c.cur >= c.total as isize {

  + None

  + } else if c.is_leaf {
• replacement in sanakirja-core/src/btree/page.rs at line 326
  [4.19696]→[4.19696:19728](∅→∅)
  − hdr + c.cur * f
  [4.19696]

  [4.19836]
  + hdr + c.cur as usize * f
• replacement in sanakirja-core/src/btree/page.rs at line 328
  [4.19851]→[4.3186:3271](∅→∅),[4.3271]→[4.5498:5653](∅→∅)
  − let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));

  − (

  − K::from_raw_ptr(txn, k as *const u8),

  − V::from_raw_ptr(txn, v as *const u8),

  − 0,

  − )
  [4.19851]

  [4.19944]
  + debug!("current {:?}", off);

  + unsafe {

  + let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));

  + debug!("k {:?}", K::from_raw_ptr(txn, k as *const u8));

  + Some((

  + K::from_raw_ptr(txn, k as *const u8),

  + V::from_raw_ptr(txn, v as *const u8),

  + 0,

  + ))

  + }
• replacement in sanakirja-core/src/btree/page.rs at line 339
  [4.19961]→[4.7462:7555](∅→∅),[4.7555]→[4.3364:3459](∅→∅),[4.3459]→[4.5654:5820](∅→∅)
  − let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur));

  − let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));

  − (

  − K::from_raw_ptr(txn, k as *const u8),

  − V::from_raw_ptr(txn, v as *const u8),

  − off & !0xfff,

  − )
  [4.19961]

  [4.20159]
  + unsafe {

  + let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize));

  + let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));

  + Some((

  + K::from_raw_ptr(txn, k as *const u8),

  + V::from_raw_ptr(txn, v as *const u8),

  + off & !0xfff,

  + ))

  + }
• edit in sanakirja-core/src/btree/page.rs at line 351
  [4.7771]

  [4.7771]
  + assert!(c.cur >= 0 && c.cur < c.total as isize);
• replacement in sanakirja-core/src/btree/page.rs at line 356
  [4.45403]→[4.45403:45431](∅→∅)
  − hdr + c.cur * f
  [4.45403]

  [4.20611]
  + hdr + c.cur as usize * f
• replacement in sanakirja-core/src/btree/page.rs at line 358
  [4.20628]→[4.3904:3997](∅→∅)
  − (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64)) & 0xfff)
  [4.20628]

  [4.3997]
  + (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)
• edit in sanakirja-core/src/btree/page.rs at line 363
  [4.8086]

  [4.20807]
  + assert!(c.cur >= 0 && c.cur < c.total as isize);
• replacement in sanakirja-core/src/btree/page.rs at line 369
  [4.3817]→[4.4224:4324](∅→∅),[4.8295]→[4.4224:4324](∅→∅)
  − (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur)) & 0xfff)
  [4.3817]

  [4.4324]
  + (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize)) & 0xfff)
• replacement in sanakirja-core/src/btree/page.rs at line 376
  [4.8475]→[4.21513:21542](∅→∅),[4.21513]→[4.21513:21542](∅→∅)
  − if c.cur < c.total {
  [4.8475]

  [4.21542]
  + if c.cur < c.total as isize {
• edit in sanakirja-core/src/btree/page.rs at line 388
  [4.8626]

  [4.8626]
  + c.cur = -1;
• edit in sanakirja-core/src/btree/page.rs at line 393
  [4.8724]

  [4.21699]
  + assert!(c.cur >= 0);
• replacement in sanakirja-core/src/btree/page.rs at line 397
  [4.21753]→[4.8725:8822](∅→∅)
  − let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur * 8) - 8) as *const u64) };
  [4.21753]

  [4.21841]
  + let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
• edit in sanakirja-core/src/btree/page.rs at line 402
  [4.8888]

  [4.21962]
  + assert!(c.cur < c.total as isize);
• replacement in sanakirja-core/src/btree/page.rs at line 406
  [4.22016]→[4.8889:8980](∅→∅)
  − let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64) };
  [4.22016]

  [4.22098]
  + let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
• replacement in sanakirja-core/src/btree/page.rs at line 439
  [4.25430]→[4.25430:25452](∅→∅)
  − n
  [4.25430]

  [4.25452]
  + n as isize
• replacement in sanakirja-core/src/btree/page.rs at line 443
  [4.25535]→[4.25535:25557](∅→∅)
  − n
  [4.25535]

  [4.25557]
  + n as isize
• replacement in sanakirja-core/src/btree/page.rs at line 454
  [4.25765]→[4.25765:25795](∅→∅)
  − total: c.cur,
  [4.25765]

  [4.25795]
  + total: c.cur.max(0) as usize,
• edit in sanakirja-core/src/btree/page.rs at line 533
  [4.12029]→[4.26193:26296](∅→∅),[4.26193]→[4.26193:26296](∅→∅),[4.34628]→[4.34628:34631](∅→∅)
  − #[derive(Debug, Clone, Copy)]

  − pub struct Cursor {

  − cur: usize,

  − total: usize,

  − is_leaf: bool,

  − }

  −
• replacement in sanakirja-core/src/btree/page.rs at line 583
  [4.6207]→[4.20589:20657](∅→∅),[4.20589]→[4.20589:20657](∅→∅)
  − let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.6207]

  [4.20657]
  + let mut rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page.rs at line 590
  [4.36081]→[4.20937:21005](∅→∅)
  − let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.36081]

  [4.21005]
  + let mut rc = Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 17
  [4.823]→[4.823:883](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.other.as_page());
  [4.823]

  [4.883]
  + let rc = super::Cursor::new(m.other.as_page(), 0);
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 19
  [4.946]→[4.7123:7216](∅→∅)
  − let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &rc) };
  [4.946]

  [4.1034]
  + let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc).unwrap();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 50
  [4.1795]→[4.2256:2392](∅→∅)
  − let mut lc = <Page<K, V>>::last_cursor(m.modified.page.as_page());

  − <Page<K, V>>::move_next(m.modified.page.as_page(), &mut lc);
  [4.1736]

  [4.2392]
  + let lc = Cursor::after(m.modified.page.as_page());
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 131
  [4.4231]→[4.4231:4290](∅→∅),[4.4290]→[4.7490:7586](∅→∅)
  − let lc = <Page<K, V>>::last_cursor(m.other.as_page());

  − let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &lc) };
  [4.4231]

  [4.4381]
  + let lc = Cursor::last(m.other.as_page());

  + let (k0, v0, r0) = <Page<K, V>>::current(txn, m.other.as_page(), &lc).unwrap();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 135
  [4.4422]→[4.4422:4490](∅→∅)
  − let rc = <Page<K, V>>::first_cursor(m.modified.page.as_page());
  [4.4422]

  [4.4490]
  + let rc = super::Cursor::new(m.modified.page.as_page(), 0);
• edit in sanakirja-core/src/btree/page/put.rs at line 35
  [4.6984]

  [4.7815]
  + debug!("{:?} {:?} {:?}", l, r, n);
• edit in sanakirja-core/src/btree/mod.rs at line 9
  [4.50142]

  [4.45830]
  + use log::*;
• replacement in sanakirja-core/src/btree/mod.rs at line 32
  [4.46263]→[4.28315:28406](∅→∅)
  − fn first_cursor(p: Page) -> Self::Cursor;

  − fn last_cursor(p: Page) -> Self::Cursor;
  [4.46263]

  [4.8055]
  +

  + /// Returns a cursor set before the first element of the page

  + /// (i.e. set to -1).

  + fn cursor_before(p: Page) -> Self::Cursor;

  + fn cursor_first(p: Page) -> Self::Cursor {

  + let mut c = Self::cursor_before(p);

  + debug!("cursor_first {:?}", c);

  + Self::move_next(p, &mut c);

  + debug!("cursor_first {:?}", c);

  + c

  + }

  + /// Returns a cursor set after the last element of the page

  + /// (i.e. to element n)

  + fn cursor_after(p: Page) -> Self::Cursor;

  + fn cursor_last(p: Page) -> Self::Cursor {

  + let mut c = Self::cursor_after(p);

  + Self::move_prev(p, &mut c);

  + c

  + }
• edit in sanakirja-core/src/btree/mod.rs at line 76
  [4.28958]→[4.8331:8475](∅→∅)
  − unsafe fn unchecked_current<'a, T: LoadPage>(

  − txn: &T,

  − p: Page<'a>,

  − c: &Self::Cursor,

  − ) -> (&'a K, &'a V, u64);
• replacement in sanakirja-core/src/btree/mod.rs at line 80
  [4.8572]→[4.8572:8611](∅→∅),[4.29132]→[4.46909:46977](∅→∅),[4.8611]→[4.46909:46977](∅→∅),[4.13744]→[4.46909:46977](∅→∅),[4.46909]→[4.46909:46977](∅→∅),[4.46977]→[4.8612:8676](∅→∅),[4.29220]→[4.47025:47041](∅→∅),[4.8676]→[4.47025:47041](∅→∅),[4.47025]→[4.47025:47041](∅→∅)
  − ) -> Option<(&'a K, &'a V, u64)> {

  − if Self::is_empty(p, c) {

  − None

  − } else {

  − unsafe { Some(Self::unchecked_current(txn, p, c)) }

  − }

  − }
  [4.8572]

  [4.29221]
  + ) -> Option<(&'a K, &'a V, u64)>;
• edit in sanakirja-core/src/btree/mod.rs at line 94
  [4.29659]

  [4.47598]
  + fn is_init(p: Page, c: &Self::Cursor) -> bool;
• replacement in sanakirja-core/src/btree/mod.rs at line 288
  [4.50887]→[4.31135:31156](∅→∅),[4.126]→[4.31135:31156](∅→∅),[4.9926]→[4.31135:31156](∅→∅),[4.15028]→[4.31135:31156](∅→∅),[4.52110]→[4.31135:31156](∅→∅)
  − pub db: CowPage,
  [4.9926]

  [4.50888]
  + pub db: u64,
• edit in sanakirja-core/src/btree/mod.rs at line 293
  [4.52187]

  [4.52187]
  +

  + pub type Db<K, V> = Db_<K, V, page::Page<K, V>>;
• replacement in sanakirja-core/src/btree/mod.rs at line 297
  [4.221]→[4.221:265](∅→∅)
  − pub fn from_page(db: CowPage) -> Self {
  [4.221]

  [4.265]
  + pub fn from_page(db: u64) -> Self {
• edit in sanakirja-core/src/btree/mod.rs at line 307
  [4.440]→[4.15084:15133](∅→∅),[4.52188]→[4.15084:15133](∅→∅),[4.15133]→[4.182:183](∅→∅),[4.182]→[4.182:183](∅→∅)
  − pub type Db<K, V> = Db_<K, V, page::Page<K, V>>;

  −
• replacement in sanakirja-core/src/btree/mod.rs at line 318
  [4.258]→[4.52429:52449](∅→∅),[4.52429]→[4.52429:52449](∅→∅)
  − db: page.0,
  [4.258]

  [4.51071]
  + db: page.0.offset,
• replacement in sanakirja-core/src/btree/mod.rs at line 344
  [4.586]→[4.4086:4118](∅→∅),[4.15515]→[4.4086:4118](∅→∅),[4.4086]→[4.4086:4118](∅→∅)
  − txn.incr_rc(db.db.offset)?;
  [4.15515]

  [4.587]
  + txn.incr_rc(db.db)?;
• replacement in sanakirja-core/src/btree/mod.rs at line 379
  [4.771]→[4.771:797](∅→∅)
  − let mut page = db.db;
  [4.771]

  [4.797]
  + let mut page = txn.load_page(db.db)?;
• replacement in sanakirja-core/src/btree/mod.rs at line 381
  [4.833]→[4.833:891](∅→∅)
  − let mut cursor = P::first_cursor(page.as_page());
  [4.833]

  [4.891]
  + let mut cursor = P::cursor_before(page.as_page());
• replacement in sanakirja-core/src/btree/mod.rs at line 409
  [4.837]→[4.471:517](∅→∅),[4.471]→[4.471:517](∅→∅)
  − drop_::<T, K, V, P>(txn, db.db.as_page())
  [4.837]

  [4.4199]
  + drop_::<T, K, V, P>(txn, txn.load_page(db.db)?.as_page())
• replacement in sanakirja-core/src/btree/mod.rs at line 422
  [4.798]→[4.798:894](∅→∅)
  − let mut cursor = P::first_cursor(p);

  − let left_page = P::left_child(p, &cursor);
  [4.798]

  [4.894]
  + let mut cursor = P::cursor_before(p);

  + let left_page = P::right_child(p, &cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 29
  [4.53511]→[4.53511:53549](∅→∅)
  − let mut cursor = Cursor::new(db);
  [4.53511]

  [4.53549]
  + let mut cursor = Cursor::new(txn, db)?;
• replacement in sanakirja-core/src/btree/del.rs at line 55
  [4.16452]→[4.1055:1094](∅→∅)
  − let (delk, delv, _) = unsafe {
  [4.16452]

  [4.16469]
  + let (delk, delv, _) = {
• replacement in sanakirja-core/src/btree/del.rs at line 57
  [4.16509]→[4.1095:1183](∅→∅)
  − P::unchecked_current(txn, cur.page.as_page(), cur.cursor.as_ref().unwrap())
  [4.16509]

  [4.1183]
  + P::current(txn, cur.page.as_page(), &cur.cursor).unwrap()
• replacement in sanakirja-core/src/btree/del.rs at line 137
  [4.61365]→[4.32373:32463](∅→∅)
  − let mut left_page = P::right_child(cur.page.as_page(), cur.cursor.as_ref().unwrap());
  [4.61365]

  [4.31432]
  + let mut left_page = P::right_child(cur.page.as_page(), &cur.cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 146
  [4.61547]→[4.32464:32516](∅→∅)
  − let curs = P::first_cursor(page.as_page());
  [4.61547]

  [4.32516]
  + let curs = P::cursor_first(page.as_page());
• replacement in sanakirja-core/src/btree/del.rs at line 150
  [4.61726]→[4.61726:61758](∅→∅)
  − cursor: Some(curs),
  [4.61726]

  [4.61758]
  + cursor: curs,
• replacement in sanakirja-core/src/btree/del.rs at line 171
  [4.1674]→[4.31983:32069](∅→∅),[4.18674]→[4.31983:32069](∅→∅),[4.31983]→[4.31983:32069](∅→∅)
  − let (c0, c1) = P::split_at(curs0.page.as_page(), curs0.cursor.as_ref().unwrap());
  [4.1674]

  [4.1675]
  + debug!("curs0 = {:?}", curs0);

  + let (c0, c1) = P::split_at(curs0.page.as_page(), &curs0.cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 188
  [4.32866]→[4.1717:1806](∅→∅)
  − let (k, v, _) = unsafe { P::unchecked_current(txn, curs0.page.as_page(), &c0) };
  [4.32866]

  [4.1806]
  + debug!("{:?}", c0);

  + let (k, v, _) = P::current(txn, curs0.page.as_page(), &c1).unwrap();
• replacement in sanakirja-core/src/btree/del.rs at line 228
  [4.33791]→[4.32702:32745](∅→∅),[4.62136]→[4.32702:32745](∅→∅)
  − let c = curs.cursor.as_mut().unwrap();
  [4.33791]

  [4.33792]
  + // let c = curs.cursor.as_mut().unwrap();
• replacement in sanakirja-core/src/btree/del.rs at line 232
  [4.3071]→[4.19576:19655](∅→∅),[4.19576]→[4.19576:19655](∅→∅)
  − let other = txn.load_page(P::left_child(curs.page.as_page(), c))?;
  [4.3071]

  [4.19655]
  + let other = txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))?;
• replacement in sanakirja-core/src/btree/del.rs at line 244
  [4.33071]→[4.19874:19957](∅→∅)
  − let (k, v, r) = if let Some(x) = P::current(txn, curs.page.as_page(), c) {
  [4.33071]

  [4.8793]
  + let (k, v, r) = if let Some(x) = P::current(txn, curs.page.as_page(), &curs.cursor) {
• replacement in sanakirja-core/src/btree/del.rs at line 250
  [4.33213]→[4.19958:20033](∅→∅),[4.20033]→[4.33283:33342](∅→∅),[4.33283]→[4.33283:33342](∅→∅)
  − let (k, v, _) = P::prev(txn, curs.page.as_page(), c).unwrap();

  − let l = P::left_child(curs.page.as_page(), c);
  [4.33213]

  [4.33342]
  + let (k, v, _) = P::prev(txn, curs.page.as_page(), &mut curs.cursor).unwrap();

  + let l = P::left_child(curs.page.as_page(), &curs.cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 283
  [4.34502]→[4.34502:34609](∅→∅)
  − let c = curs.cursor.as_ref().unwrap();

  − let (c0, c1) = P::split_at(curs.page.as_page(), c);
  [4.34502]

  [4.34609]
  + let (c0, c1) = P::split_at(curs.page.as_page(), &curs.cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 503
  [4.23988]→[4.23988:24023](∅→∅)
  − db.db = txn.load_page(d)?;
  [4.23988]

  [4.10589]
  + db.db = d;
• replacement in sanakirja-core/src/btree/del.rs at line 513
  [4.38748]→[4.38748:38775](∅→∅)
  − db.db = page.0
  [4.38748]

  [4.38775]
  + db.db = page.0.offset
• edit in sanakirja-core/src/btree/del.rs at line 526
  [4.39035]

  [4.39035]
  + let mut c = P::cursor_before(page.0.as_page());

  + P::move_next(page.0.as_page(), &mut c);
• replacement in sanakirja-core/src/btree/del.rs at line 532
  [4.39122]→[4.39122:39174](∅→∅)
  − &P::first_cursor(page.0.as_page()),
  [4.39122]

  [4.39174]
  + &c,
• replacement in sanakirja-core/src/btree/del.rs at line 550
  [4.39551]→[4.39551:39578](∅→∅)
  − db.db = page.0
  [4.39551]

  [4.39578]
  + db.db = page.0.offset
• replacement in sanakirja-core/src/btree/cursor.rs at line 10
  [4.33822]→[4.63921:63956](∅→∅),[4.63921]→[4.63921:63956](∅→∅)
  − pub cursor: Option<P::Cursor>,
  [4.33822]

  [4.63956]
  + pub cursor: P::Cursor,
• replacement in sanakirja-core/src/btree/cursor.rs at line 69
  [4.11112]→[4.24828:24872](∅→∅),[4.65307]→[4.24828:24872](∅→∅)
  − pub fn new(db: &Db_<K, V, P>) -> Self {
  [4.11112]

  [4.65353]
  + pub fn new<T: LoadPage>(txn: &T, db: &Db_<K, V, P>) -> Result<Self, T::Error> {
• edit in sanakirja-core/src/btree/cursor.rs at line 71
  [4.65424]

  [4.597]
  + let page = txn.load_page(db.db)?;
• replacement in sanakirja-core/src/btree/cursor.rs at line 73
  [4.646]→[4.65473:65498](∅→∅),[4.65473]→[4.65473:65498](∅→∅),[4.65498]→[4.3301:3327](∅→∅)
  − page: db.db,

  − cursor: None,
  [4.646]

  [4.3327]
  + page,

  + cursor: P::cursor_before(page.as_page()),
• replacement in sanakirja-core/src/btree/cursor.rs at line 76
  [4.65536]→[4.65536:65553](∅→∅)
  − Cursor {
  [4.3339]

  [4.65553]
  + Ok(Cursor {
• replacement in sanakirja-core/src/btree/cursor.rs at line 80
  [4.671]→[4.65635:65645](∅→∅),[4.65635]→[4.65635:65645](∅→∅)
  − }
  [4.671]

  [4.3424]
  + })
• replacement in sanakirja-core/src/btree/cursor.rs at line 127
  [4.66515]→[4.66515:66557](∅→∅)
  − if current.cursor.is_none() {
  [4.66515]

  [4.34164]
  + /*if current.cursor.is_none() {
• replacement in sanakirja-core/src/btree/cursor.rs at line 129
  [4.34236]→[4.66620:66693](∅→∅),[4.66620]→[4.66620:66693](∅→∅)
  − }

  − let cursor = current.cursor.as_mut().unwrap();
  [4.34236]

  [4.811]
  + }*/

  + let ref mut cursor = current.cursor;
• edit in sanakirja-core/src/btree/cursor.rs at line 145
  [4.67194]

  [4.933]
  + let page = txn.load_page(next_page)?;
• replacement in sanakirja-core/src/btree/cursor.rs at line 147
  [4.972]→[4.34573:34660](∅→∅),[4.34573]→[4.34573:34660](∅→∅)
  − page: txn.load_page(next_page)?,

  − cursor: None,
  [4.972]

  [4.34660]
  + page,

  + cursor: P::cursor_before(page.as_page()),
• edit in sanakirja-core/src/btree/cursor.rs at line 166
  [4.34944]→[4.67731:67858](∅→∅),[4.11340]→[4.67731:67858](∅→∅),[4.25213]→[4.67731:67858](∅→∅),[4.67731]→[4.67731:67858](∅→∅)
  − // Set the "cursor stack" by setting a skip list cursor in

  − // each page from the root to the appropriate leaf.
• edit in sanakirja-core/src/btree/cursor.rs at line 167
  [4.67886]

  [4.67886]
  + assert_eq!(self.pointer, 0);

  + let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };

  + current.cursor = P::cursor_last(current.page.as_page());
• edit in sanakirja-core/src/btree/cursor.rs at line 172
  [4.67983]

  [4.67983]
  + debug!("{:?}", current.page);
• replacement in sanakirja-core/src/btree/cursor.rs at line 176
  [4.68135]→[4.68135:68177](∅→∅),[4.68177]→[4.34945:35024](∅→∅),[4.35024]→[4.68247:68320](∅→∅),[4.68247]→[4.68247:68320](∅→∅),[4.68320]→[4.25214:25312](∅→∅)
  − if current.cursor.is_none() {

  − current.cursor = Some(P::last_cursor(current.page.as_page()));

  − }

  − let cursor = current.cursor.as_mut().unwrap();

  − let (k, v, r) = unsafe { P::unchecked_current(txn, current.page.as_page(), cursor) };
  [4.68135]

  [4.68404]
  + debug!("cursor = {:?}", current.cursor);

  + let (k, v, r) = P::current(txn, current.page.as_page(), &mut current.cursor).unwrap();
• edit in sanakirja-core/src/btree/cursor.rs at line 179
  [4.68443]

  [4.68443]
  + debug!("k {:?} v {:?} r = {:?}", k, v, r);
• replacement in sanakirja-core/src/btree/cursor.rs at line 181
  [4.68466]→[4.68466:68653](∅→∅)
  − self.pointer += 1;

  − self.stack[self.pointer] = MaybeUninit::new(PageCursor {

  − page: txn.load_page(r)?,

  − cursor: None,
  [4.68466]

  [4.68653]
  + let page = txn.load_page(r)?;

  + self.push(PageCursor {

  + page,

  + cursor: P::cursor_last(page.as_page()),
• edit in sanakirja-core/src/btree/cursor.rs at line 194
  [4.3459]

  [4.3459]
  + 'a,
• replacement in sanakirja-core/src/btree/cursor.rs at line 197
  [4.3567]→[4.3567:3595](∅→∅)
  − P: BTreePage<K, V>,
  [4.3567]

  [4.3595]
  + P: BTreePage<K, V> + 'a,
• replacement in sanakirja-core/src/btree/cursor.rs at line 200
  [4.3619]→[4.11341:11441](∅→∅),[4.1155]→[4.11341:11441](∅→∅),[4.68806]→[4.11341:11441](∅→∅)
  − pub fn next<'a, T: LoadPage>(&mut self, txn: &'a mut T) -> Result<Option<(&K, &V)>, T::Error> {
  [4.3619]

  [4.1156]
  + pub fn next<T: LoadPage>(&mut self, txn: &T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
• replacement in sanakirja-core/src/btree/cursor.rs at line 205
  [4.82]→[4.82:286](∅→∅),[4.286]→[4.25419:25502](∅→∅),[4.25502]→[4.364:395](∅→∅),[4.364]→[4.364:395](∅→∅),[4.395]→[4.1234:1281](∅→∅),[4.1281]→[4.396:449](∅→∅),[4.70566]→[4.396:449](∅→∅),[4.449]→[4.70622:70713](∅→∅),[4.70622]→[4.70622:70713](∅→∅),[4.70713]→[4.11442:11491](∅→∅),[4.11491]→[4.1282:1359](∅→∅),[4.1359]→[4.584:646](∅→∅),[4.584]→[4.584:646](∅→∅)
  − if let Some(ref mut c) = current.cursor {

  − // We're inside the page, and have already

  − // processed the left child of the current page

  − // cursor.

  − if let Some((k, v, r)) = P::next(txn, current.page.as_page(), c) {

  − if r > 0 {

  − self.push(PageCursor {

  − page: txn.load_page(r)?,

  − cursor: None,

  − })

  − }

  − return Ok(Some((&*k, &*v)));

  − } else if self.pointer > 0 {

  − self.pop();

  − } else {

  − return Ok(None);
  [4.82]

  [4.646]
  + if P::is_init(current.page.as_page(), &current.cursor) {

  + P::move_next(current.page.as_page(), &mut current.cursor);

  + let left = P::left_child(current.page.as_page(), &current.cursor);

  + // Then visit the right child (if any), i.e. push.

  + if left != 0 {

  + let page = txn.load_page(left)?;

  + self.push(PageCursor {

  + page,

  + cursor: P::cursor_before(page.as_page()),

  + })

  + }

  + } else if let Some((k, v, r)) = P::current(txn, current.page.as_page(), &current.cursor) {

  + P::move_next(current.page.as_page(), &mut current.cursor);

  + if r > 0 {

  + let page = txn.load_page(r)?;

  + self.push(PageCursor {

  + page,

  + cursor: P::cursor_before(page.as_page()),

  + })
• edit in sanakirja-core/src/btree/cursor.rs at line 225
  [4.664]

  [4.664]
  + return Ok(Some((k, v)));

  + } else if self.pointer > 0 {

  + self.pop();
• replacement in sanakirja-core/src/btree/cursor.rs at line 229
  [4.685]→[4.685:1060](∅→∅)
  − current.cursor = Some(P::first_cursor(current.page.as_page()));

  − // First element of a page (not a binding).

  − let cursor = current.cursor.as_ref().unwrap();

  − let left = P::left_child(current.page.as_page(), cursor);

  − // Then visit the right child (if any), i.e. push.

  − if left != 0 {
  [4.685]

  [4.1360]
  + return Ok(None);

  + }

  + }

  + }

  +

  + pub fn prev<T: LoadPage>(&mut self, txn: &T) -> Result<Option<(&'a K, &'a V)>, T::Error> {

  + loop {

  + let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };

  + if P::is_empty(current.page.as_page(), &current.cursor) {

  + P::move_prev(current.page.as_page(), &mut current.cursor);

  + let right = P::right_child(current.page.as_page(), &current.cursor);

  + if right != 0 {

  + let page = txn.load_page(right)?;
• replacement in sanakirja-core/src/btree/cursor.rs at line 243
  [4.1403]→[4.1176:1266](∅→∅),[4.1176]→[4.1176:1266](∅→∅)
  − page: txn.load_page(left)?,

  − cursor: None,
  [4.1403]

  [4.1266]
  + page,

  + cursor: P::cursor_after(page.as_page()),

  + })

  + }

  + } else if let Some((k, v, _)) = P::current(txn, current.page.as_page(), &current.cursor) {

  + P::move_prev(current.page.as_page(), &mut current.cursor);

  + let l = P::right_child(current.page.as_page(), &current.cursor);

  + if l > 0 {

  + let page = txn.load_page(l)?;

  + self.push(PageCursor {

  + page,

  + cursor: P::cursor_after(page.as_page()),
• edit in sanakirja-core/src/btree/cursor.rs at line 257
  [4.70731]

  [4.70731]
  + return Ok(Some((k, v,)))

  + } else if self.pointer > 0 {

  + self.pop();

  + } else {

  + return Ok(None);
• edit in sanakirja-core/src/btree/cursor.rs at line 265
  [4.70761]

  [4.70761]
  +

  +
• replacement in sanakirja/src/tests.rs at line 29
  [4.1150]→[4.1288:1312](∅→∅),[4.25649]→[4.1288:1312](∅→∅),[4.1288]→[4.1288:1312](∅→∅)
  − let n = 100_000u64;
  [4.25649]

  [4.1312]
  + let n = 1_000u64;
• replacement in sanakirja/src/tests.rs at line 45
  [4.1953]→[4.1953:2005](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.1953]

  [4.2005]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 47
  [4.2025]→[4.2025:2086](∅→∅)
  − while let Some((k, _v)) = curs.next(&mut txn).unwrap() {
  [4.2025]

  [4.2148]
  + while let Some((k, v)) = curs.next(&mut txn).unwrap() {

  + debug!("{:?} {:?}", k, v.0[0]);
• replacement in sanakirja/src/tests.rs at line 57
  [4.11543]→[4.2389:2441](∅→∅),[4.2389]→[4.2389:2441](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.11543]

  [4.2441]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 65
  [4.2627]→[4.2627:2679](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.2627]

  [4.25714]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 74
  [4.2931]→[4.2931:2983](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.2931]

  [4.2983]
  + crate::debug::debug(&txn, &[&db], "debug0", true);

  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 124
  [4.1517]→[4.5540:5592](∅→∅),[4.5540]→[4.5540:5592](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.1517]

  [4.5592]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 186
  [4.121]→[4.6625:6677](∅→∅),[4.1992]→[4.6625:6677](∅→∅),[4.6625]→[4.6625:6677](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.6528]

  [4.6677]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 193
  [4.6847]→[4.6847:6899](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.6847]

  [4.26151]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
• replacement in sanakirja/src/tests.rs at line 197
  [4.6988]→[4.6988:7041](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db2);
  [4.6988]

  [4.7041]
  + let mut curs = btree::cursor::Cursor::new(&txn, &db2).unwrap();
• replacement in sanakirja/src/tests.rs at line 247
  [4.615]→[4.7458:7487](∅→∅),[4.7458]→[4.7458:7487](∅→∅)
  − if txn.free.offset > 0 {
  [4.615]

  [4.7487]
  + if txn.free > 0 {
• replacement in sanakirja/src/tests.rs at line 254
  [4.7597]→[4.26875:26968](∅→∅)
  − let mut curs: btree::cursor::Cursor<_, _, B> = btree::cursor::Cursor::new(&db_free);
  [4.7597]

  [4.7693]
  + let mut curs: btree::cursor::Cursor<_, _, B> =

  + btree::cursor::Cursor::new(txn, &db_free).unwrap();
• replacement in sanakirja/src/tests.rs at line 272
  [4.8067]→[4.27076:27126](∅→∅)
  − debug!("------ add_refs {:?}", db.db.offset);
  [4.8067]

  [4.8067]
  + debug!("------ add_refs {:?}", db.db);
• replacement in sanakirja/src/tests.rs at line 276
  [4.27161]→[4.8138:8176](∅→∅),[4.8138]→[4.8138:8176](∅→∅)
  − match pages.entry(p.offset) {
  [4.27161]

  [4.8176]
  + match pages.entry(p) {
• replacement in sanakirja/src/tests.rs at line 279
  [4.8239]→[4.8239:8297](∅→∅)
  − let mut c = P::first_cursor(p.as_page());
  [4.8239]

  [4.8297]
  + let p = txn.load_page(p)?;

  + let mut c = P::cursor_first(p.as_page());
• replacement in sanakirja/src/tests.rs at line 284
  [4.8380]→[4.8380:8431](∅→∅)
  − stack.push(txn.load_page(l)?);
  [4.8380]

  [4.27202]
  + stack.push(l);
• replacement in sanakirja/src/tests.rs at line 287
  [4.27333]→[4.8510:8564](∅→∅),[4.8510]→[4.8510:8564](∅→∅)
  − stack.push(txn.load_page(r)?)
  [4.27333]

  [4.8564]
  + stack.push(r);
• replacement in sanakirja/src/tests.rs at line 317
  [4.1215]→[4.1215:1297](∅→∅)
  − debug!("db = {:?}", db.db.offset);

  − txn.set_root(0, db.db.offset);
  [4.1215]

  [4.1297]
  + debug!("db = {:?}", db.db);

  + txn.set_root(0, db.db);
• replacement in sanakirja/src/tests.rs at line 330
  [4.1915]→[4.1915:1997](∅→∅)
  − debug!("db = {:?}", db.db.offset);

  − txn.set_root(0, db.db.offset);
  [4.1915]

  [4.1997]
  + debug!("db = {:?}", db.db);

  + txn.set_root(0, db.db);
• edit in sanakirja/src/tests.rs at line 438
  [4.1074]

  [4.1074]
  + #[ignore]
• replacement in sanakirja/src/tests.rs at line 623
  [3.533]→[3.533:553](∅→∅)
  − mut p: CowPage,
  [3.533]

  [3.553]
  + mut p: u64,
• replacement in sanakirja/src/tests.rs at line 627
  [3.614]→[3.614:718](∅→∅)
  − let cursor = P::first_cursor(p.as_page());

  − let l = P::left_child(p.as_page(), &cursor);
  [3.614]

  [3.718]
  + let pp = txn.load_page(p)?;

  + let cursor = P::cursor_first(pp.as_page());

  + let l = P::left_child(pp.as_page(), &cursor);
• replacement in sanakirja/src/tests.rs at line 633
  [3.774]→[3.774:805](∅→∅)
  − p = txn.load_page(l)?;
  [3.774]

  [3.805]
  + p = l;
• edit in sanakirja/src/tests.rs at line 661
  [3.839]

  [3.839]
  + #[ignore]
• replacement in sanakirja/src/environment/muttxn.rs at line 17
  [4.2579]→[4.1290:1320](∅→∅),[4.80384]→[4.1290:1320](∅→∅)
  − pub(crate) free: CowPage,
  [4.2579]

  [4.27437]
  + pub(crate) free: u64,
• replacement in sanakirja/src/environment/muttxn.rs at line 104
  [4.82918]→[4.37416:37453](∅→∅),[4.37453]→[4.82952:83075](∅→∅),[4.82952]→[4.82952:83075](∅→∅)
  − let free = CowPage {

  − data: env_.find_offset(header.free_db),

  − offset: header.free_db,

  − };
  [4.82918]

  [4.83075]
  + let free = header.free_db;
• replacement in sanakirja/src/environment/muttxn.rs at line 109
  [4.83210]→[4.37454:37492](∅→∅),[4.37492]→[4.83245:83388](∅→∅),[4.83245]→[4.83245:83388](∅→∅)
  − db: CowPage {

  − offset: header.rc_db,

  − data: env_.find_offset(header.rc_db),

  − },
  [4.83210]

  [4.52819]
  + db: header.rc_db,
• replacement in sanakirja/src/environment/muttxn.rs at line 139
  [4.84183]→[4.3092:3232](∅→∅)
  − let mut free_db: btree::Db<u64, ()> =

  − btree::Db::from_page(std::mem::replace(&mut self.free, CowPage::null()));
  [4.84183]

  [4.84575]
  + let mut free_db: btree::Db<u64, ()> = btree::Db::from_page(self.free);
• replacement in sanakirja/src/environment/muttxn.rs at line 156
  [4.85441]→[4.85441:85506](∅→∅)
  − (&mut *globptr).free_db = free_db.db.offset.to_le();
  [4.85441]

  [4.3233]
  + (&mut *globptr).free_db = free_db.db.to_le();
• replacement in sanakirja/src/environment/muttxn.rs at line 211
  [4.86463]→[4.86463:86498](∅→∅)
  − if self.free.offset == 0 {
  [4.86463]

  [4.86498]
  + if self.free == 0 {
• replacement in sanakirja/src/environment/muttxn.rs at line 220
  [4.86708]→[4.86708:86764](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&db);
  [4.86708]

  [4.86764]
  + let mut curs = btree::cursor::Cursor::new(self, &db)?;
• replacement in sanakirja/src/environment/muttxn.rs at line 267
  [4.88548]→[4.88548:88609](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&rc_);
  [4.88548]

  [4.88609]
  + let mut curs = btree::cursor::Cursor::new(self, &rc_)?;
• replacement in sanakirja/src/environment/muttxn.rs at line 300
  [4.89329]→[4.89329:89390](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&rc_);
  [4.89329]

  [4.38881]
  + let mut curs = btree::cursor::Cursor::new(self, &rc_)?;
• replacement in sanakirja/src/environment/muttxn.rs at line 335
  [4.90170]→[4.90170:90231](∅→∅)
  − let mut curs = btree::cursor::Cursor::new(&rc_);
  [4.90170]

  [4.39392]
  + let mut curs = btree::cursor::Cursor::new(self, &rc_)?;
• replacement in sanakirja/src/environment/muttxn.rs at line 388
  [4.4442]→[4.12893:12945](∅→∅)
  − fn root_db<K: Representable, V: Representable>(
  [4.4442]

  [4.4529]
  + fn root_db<

  + K: Representable + ?Sized,

  + V: Representable + ?Sized,

  + P: crate::btree::BTreePage<K, V>,

  + >(
• replacement in sanakirja/src/environment/muttxn.rs at line 395
  [4.4562]→[4.27644:27710](∅→∅),[4.27710]→[4.4634:4672](∅→∅),[4.4634]→[4.4634:4672](∅→∅)
  − ) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Error> {

  − use sanakirja_core::LoadPage;
  [4.4562]

  [4.4672]
  + ) -> Option<sanakirja_core::btree::Db_<K, V, P>> {
• replacement in sanakirja/src/environment/muttxn.rs at line 397
  [4.4718]→[4.4718:4808](∅→∅)
  − Ok(Some(sanakirja_core::btree::Db {

  − db: self.load_page(*db)?,
  [4.4718]

  [4.53239]
  + Some(sanakirja_core::btree::Db_ {

  + db: *db,
• replacement in sanakirja/src/environment/muttxn.rs at line 402
  [4.53374]→[4.4858:4874](∅→∅),[4.4858]→[4.4858:4874](∅→∅)
  − }))
  [4.53374]

  [4.4874]
  + })
• replacement in sanakirja/src/environment/muttxn.rs at line 415
  [4.5228]→[4.5228:5333](∅→∅)
  − Ok(Some(sanakirja_core::btree::Db {

  − db: self.load_page(db)?,
  [4.5228]

  [4.53375]
  + Some(sanakirja_core::btree::Db_ {

  + db,
• replacement in sanakirja/src/environment/muttxn.rs at line 420
  [4.53534]→[4.5391:5415](∅→∅),[4.5391]→[4.5391:5415](∅→∅)
  − }))
  [4.53534]

  [4.5415]
  + })
• replacement in sanakirja/src/environment/muttxn.rs at line 422
  [4.5440]→[4.5440:5469](∅→∅)
  − Ok(None)
  [4.5440]

  [4.5469]
  + None
• replacement in sanakirja/src/environment/mod.rs at line 426
  [4.106701]→[4.6117:6170](∅→∅),[4.6170]→[4.13120:13172](∅→∅)
  − pub trait RootDb: Sized + sanakirja_core::LoadPage {

  − fn root_db<K: Representable, V: Representable>(
  [4.106701]

  [4.6257]
  + pub trait RootDb {

  + fn root_db<

  + K: Representable + ?Sized,

  + V: Representable + ?Sized,

  + P: crate::btree::BTreePage<K, V>,

  + >(

  + &self,

  + n: usize,

  + ) -> Option<sanakirja_core::btree::Db_<K, V, P>>;

  + }

  +

  + impl<E: Borrow<Env>> RootDb for Txn<E> {

  + fn root_db<

  + K: Representable + ?Sized,

  + V: Representable + ?Sized,

  + P: crate::btree::BTreePage<K, V>,

  + >(
• replacement in sanakirja/src/environment/mod.rs at line 445
  [4.6290]→[4.27764:27835](∅→∅)
  − ) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Self::Error>;
  [4.6290]

  [4.6367]
  + ) -> Option<sanakirja_core::btree::Db_<K, V, P>> {

  + unsafe {

  + let env = self.env.borrow();

  + let db = {

  + let maps = env.mmaps.lock();

  + *(maps[0]

  + .ptr

  + .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)

  + as *mut u64)

  + };

  + if db != 0 {

  + Some(sanakirja_core::btree::Db_ {

  + db,

  + k: std::marker::PhantomData,

  + v: std::marker::PhantomData,

  + p: std::marker::PhantomData,

  + })

  + } else {

  + None

  + }

  + }

  + }
• replacement in sanakirja/src/debug.rs at line 28
  [2.663]→[2.663:746](∅→∅)
  − print_page::<T, K, V, PP>(t, &mut h, &mut buf, &db.db.as_page(), recurse);
  [2.663]

  [2.746]
  + print_page::<T, K, V, PP>(

  + t,

  + &mut h,

  + &mut buf,

  + &t.load_page(db.db).unwrap().as_page(),

  + recurse,

  + );
• replacement in sanakirja/src/debug.rs at line 95
  [2.2191]→[2.2191:2233](∅→∅)
  − let mut cursor = P::first_cursor(*p);
  [2.2191]

  [2.2233]
  + let mut cursor = P::cursor_first(*p);