Cleanup + docs

Dependencies

• [2] QBDBAQXY Better graphviz debugging (include values)
• [3] SQ7MD7OW Unsized pages: decrement n on deletions
• [4] ESUI5EUZ Making as_page() unsafe
• [5] OP6SVMOD Resetting history
• [6] APPY2E7M Unsized deletions + custom sizes back
• [7] 7WJNSPEW Using the same definition of the "occupied" field uniform everywhere
• [8] KM3JAFGP Adding a test for next/prev
• [9] AOX2XQIS Actually, with the correct functions, Unsized pages are always slower than Sized pages (especially for writing)
• [10] G4JEQLLX Debugging synchronisation
• [11] W26CFMAQ Improving safety of cursors
• [12] UUUVNC4D Debugging/cleanup around cursors
• [13] 6DCQHIFP Minor changes after benchmarking
• [14] SO25TWFL A few features for integrating it into Pijul
• [15] WS4ZQM4R Debugging, tests, etc.
• [16] ONES3V46 reference counting works for put
• [17] KX3WVNZW Testing/debugging "rebalance causes split of the root"
• [18] S4V4QZ5C Debugging reference-counting for put
• [19] LROAI3NB Two iterators (convenience functions), along with tests to move cursors (put and del still destroy cursors though)
• [20] OFINGD26 implementing prev() on cursors (+ some cleanup)
• [21] QEUTVAZ4 Splitting btree::page
• [22] EAAYH6BQ Debugging put
• [23] RV2L6CZW A few comments
• [24] 6UVFCERM Formatting, debugging, etc.
• [25] UAQX27N4 Tests
• [26] FMN7X4J2 Micro-improvements, now noticeably faster than std::collections::BTreeMap
• [27] XEU2QVLC Debugging after plugging this into Pijul
• [28] WAKPPBKO Fixing a double-free of roots after deletions (the root was freed both by handle_merge and by update_root)
• [29] Q7DRIBBR Debugging replace (which cannot be del+put)
• [30] PXF3R6SV Improving test coverage for btree::cursor
• [31] 6DMPXOAT More debugging
• [32] DV4A2LR7 Double-inserts (rebalancing near an internal deletion)
• [33] OTWDDJE7 Trait/type cleanup
• [34] T73WR2BX Cleaner RC increments for keys and values containing references + more comments in `del`
• [35] H3FVSQIQ Unsized pages
• [36] EYNN7RLS Tests++ (including UUID)
• [37] HN6Z5DU4 Cleanup
• [38] NXMFNPZ7 Comments + debugging drop
• [39] X3QVVQIS More debugging (del seems to work now)
• [40] T7QB6QEP Adding debug.rs
• [41] MSRWB47Y Deletions at immutable leaves weren't really deleting anything
• [42] KMT3MF5N Drop a database
• [43] 73Z2UB3J Cleanup + comments

Change contents

• edit in sanakirja-core/src/lib.rs at line 1
  [5.91]

  [5.0]
  + #![no_std]

  +
• replacement in sanakirja-core/src/lib.rs at line 5
  [5.140]→[5.140:255](∅→∅)
  − //! memory-mapped files, but if that environment is threatened, might

  − //! seek refuge in lower-level environments.
  [5.140]

  [5.255]
  + //! memory-mapped files, but if that environment is threatened, they

  + //! might seek refuge in lower-level environments.
• replacement in sanakirja-core/src/lib.rs at line 28
  [5.1317]→[5.92:103](∅→∅),[5.91]→[5.92:103](∅→∅)
  − #![no_std]
  [5.1317]

  [5.103]
  +
• edit in sanakirja-core/src/lib.rs at line 31
  [5.1]

  [5.1]
  + /// There's a hard-coded assumption that pages have 4K bytes. This is

  + /// true for normal memory pages on almost all platforms.
• edit in sanakirja-core/src/lib.rs at line 35
  [5.119]

  [5.0]
  + /// Types that can be stored on disk.
• edit in sanakirja-core/src/lib.rs at line 37
  [5.44]→[5.148:444](∅→∅),[5.26]→[5.148:444](∅→∅),[5.148]→[5.148:444](∅→∅),[5.444]→[5.37:115](∅→∅),[5.65]→[5.505:506](∅→∅),[5.115]→[5.505:506](∅→∅),[5.95]→[5.505:506](∅→∅),[5.505]→[5.505:506](∅→∅)
  − /// An iterator over the offsets to pages contained in this

  − /// value. Only values from this crate can generate non-empty

  − /// iterators, but combined values (like tuples) must chain the

  − /// iterators returned by method `page_offsets`.

  − type PageOffsets: Iterator<Item = u64>;

  −

  − fn compare<T: LoadPage>(&self, txn: &T, b: &Self) -> core::cmp::Ordering;

  −
• edit in sanakirja-core/src/lib.rs at line 41
  [5.701]

  [5.701]
  +

  + /// Some datastructures expect this to be at least the memory size

  + /// of `Self` (as returned by `core::mem::size_of::<Self>()`). For

  + /// example, the sized implementation of B trees sometimes

  + /// allocates an instance of `Self` on the stack, and copy it from

  + /// the
• edit in sanakirja-core/src/lib.rs at line 48
  [5.732]

  [5.0]
  +

  + /// If `Self::SIZE.is_some()`, this must return the same

  + /// value. The default implementation is `Self;:SIZE.unwrap()`.
• edit in sanakirja-core/src/lib.rs at line 54
  [5.64]

  [5.116]
  +

  + /// Form a pointer to `Self` from a raw pointer. The purpose of

  + /// this function is that the output can be a slim or a fat

  + /// pointer (like for `&[u8]`).
• edit in sanakirja-core/src/lib.rs at line 59
  [5.196]

  [5.65]
  +

  + /// Read the size from an on-page entry. If `Self::SIZE.is_some()`

  + /// this must be the same value.
• edit in sanakirja-core/src/lib.rs at line 65
  [5.150]

  [5.50]
  +

  + /// Write to a page. Must not overwrite the allocated size, but

  + /// this isn't checkde (which is why it's unsafe).
• edit in sanakirja-core/src/lib.rs at line 69
  [5.98]

  [5.761]
  +

  + /// This is required for B trees, not necessarily for other

  + /// structures. The default implementation panics.

  + fn compare<T: LoadPage>(&self, _txn: &T, _b: &Self) -> core::cmp::Ordering {

  + unimplemented!()

  + }

  +

  + /// An iterator over the offsets to pages contained in this

  + /// value. Only values from this crate can generate non-empty

  + /// iterators, but combined values (like tuples) must chain the

  + /// iterators returned by method `page_offsets`.

  + type PageOffsets: Iterator<Item = u64>;
• replacement in sanakirja-core/src/lib.rs at line 151
  [5.280]→[5.73:86](∅→∅),[5.73]→[5.73:86](∅→∅)
  − txn: &T,
  [5.280]

  [5.86]
  + _txn: &T,
• replacement in sanakirja-core/src/lib.rs at line 154
  [5.1476]→[5.575:621](∅→∅),[5.134]→[5.575:621](∅→∅),[5.575]→[5.575:621](∅→∅)
  − let s = K::size(K::from_raw_ptr(txn, k));
  [5.134]

  [5.1641]
  + let s = K::onpage_size(k);
• replacement in sanakirja-core/src/lib.rs at line 179
  [5.2399]→[5.1478:1508](∅→∅),[5.1508]→[5.2399:2429](∅→∅),[5.2399]→[5.2399:2429](∅→∅)
  − /// Representation of a page.

  − #[derive(Debug, Clone, Copy)]
  [5.2399]

  [5.261]
  + /// Representation of a mutable or shared page.

  + #[derive(Debug)]

  + #[repr(C)]
• edit in sanakirja-core/src/lib.rs at line 188
  [5.2524]

  [5.316]
  + #[repr(C)]
• replacement in sanakirja-core/src/lib.rs at line 195
  [5.412]→[4.0:43](∅→∅)
  − pub unsafe fn as_page(&self) -> Page {
  [5.412]

  [5.1509]
  + pub fn as_page(&self) -> Page {
• replacement in sanakirja-core/src/lib.rs at line 197
  [5.1524]→[4.44:103](∅→∅)
  − data: &*(self.data as *const [u8; PAGE_SIZE]),
  [5.1524]

  [5.1594]
  + data: unsafe { &*(self.data as *const [u8; PAGE_SIZE]) },
• replacement in sanakirja-core/src/btree/put.rs at line 31
  [5.475]→[5.4449:4485](∅→∅),[5.674]→[5.4449:4485](∅→∅),[5.4449]→[5.4449:4485](∅→∅)
  − let ref cur = cursor.current();
  [5.475]

  [5.4485]
  + let p = cursor.len(); // Save the position of the leaf cursor.

  + let is_owned = p < cursor.first_rc_len;

  +

  + // Insert the key and value at the leaf, i.e. pop the top level of

  + // the stack (the leaf) and insert in there.

  + let cur = cursor.pop().unwrap();
• replacement in sanakirja-core/src/btree/put.rs at line 40
  [5.4538]→[5.0:50](∅→∅)
  − cursor.pointer() < cursor.first_rc_level,
  [5.4538]

  [5.0]
  + is_owned,
• edit in sanakirja-core/src/btree/put.rs at line 65
  [5.4718]→[5.1166:1240](∅→∅)
  − let p = cursor.pointer(); // Save the position of cursor at the leaf.
• replacement in sanakirja-core/src/btree/put.rs at line 103
  [5.1695]→[5.1695:1696](∅→∅)
  −
  [5.1695]

  [5.1696]
  + debug!("Want to split the root");
• replacement in sanakirja-core/src/btree/put.rs at line 105
  [5.1770]→[5.81:123](∅→∅),[5.81]→[5.81:123](∅→∅),[5.123]→[5.1771:1911](∅→∅),[5.1911]→[5.79:113](∅→∅),[5.123]→[5.79:113](∅→∅),[5.123]→[5.70:118](∅→∅),[5.113]→[5.70:118](∅→∅),[5.70]→[5.70:118](∅→∅)
  − if cursor.pointer() > 0 {

  − // If we aren't at the root, just pop the cursor

  − // stack and insert a new entry in the page above.

  − cursor.pop();

  − let cur = cursor.current();
  [5.1770]

  [5.118]
  + let is_owned = cursor.len() < cursor.first_rc_len;

  + if let Some(cur) = cursor.pop() {

  + // In this case, there's a page above the page

  + // that just split (since we can pop the stack),

  + // so the page that just split isn't the root (but

  + // `cur` might be).
• replacement in sanakirja-core/src/btree/put.rs at line 114
  [5.215]→[5.124:190](∅→∅)
  − cursor.pointer() < cursor.first_rc_level,
  [5.215]

  [5.16]
  + is_owned,
• replacement in sanakirja-core/src/btree/put.rs at line 124
  [5.532]→[5.1912:2088](∅→∅)
  − // If we are at the root, the root has

  − // split. Insert the split key/value in a new page

  − // above the entire tree.
  [5.532]

  [5.832]
  + // No page above the split, so the root has just

  + // split. Insert the split key/value into a new

  + // page above the entire tree.
• replacement in sanakirja-core/src/btree/put.rs at line 159
  [5.2656]→[5.221:263](∅→∅),[5.221]→[5.221:263](∅→∅)
  − if cursor.pointer() > 0 {
  [5.2656]

  [5.2657]
  + let is_owned = cursor.len() < cursor.first_rc_len;

  + if let Some(curs) = cursor.pop() {
• edit in sanakirja-core/src/btree/put.rs at line 162
  [5.2729]→[5.114:148](∅→∅),[5.263]→[5.114:148](∅→∅),[5.263]→[5.573:626](∅→∅),[5.148]→[5.573:626](∅→∅),[5.573]→[5.573:626](∅→∅)
  − cursor.pop();

  − let ref curs = cursor.current();
• replacement in sanakirja-core/src/btree/put.rs at line 165
  [5.746]→[5.264:330](∅→∅)
  − cursor.pointer() < cursor.first_rc_level,
  [5.746]

  [5.233]
  + is_owned,
• replacement in sanakirja-core/src/btree/put.rs at line 191
  [5.1017]→[5.358:408](∅→∅)
  − if cursor.pointer() < cursor.first_rc_level {
  [5.7700]

  [5.2893]
  + if cursor.len() < cursor.first_rc_len {
• replacement in sanakirja-core/src/btree/put.rs at line 195
  [5.3053]→[5.409:449](∅→∅),[5.7814]→[5.409:449](∅→∅)
  − free[cursor.pointer()] = freed;
  [5.3053]

  [5.7852]
  + free[cursor.len()] = freed;
• replacement in sanakirja-core/src/btree/put.rs at line 199
  [5.3172]→[5.450:505](∅→∅),[5.227]→[5.450:505](∅→∅),[5.92]→[5.450:505](∅→∅)
  − if cursor.pointer() == cursor.first_rc_level {
  [5.3172]

  [5.7918]
  + if cursor.len() == cursor.first_rc_len {
• replacement in sanakirja-core/src/btree/put.rs at line 201
  [5.7958]→[5.506:550](∅→∅)
  − free[cursor.pointer()] = freed;
  [5.7958]

  [5.8113]
  + free[cursor.len()] = freed;
• replacement in sanakirja-core/src/btree/put.rs at line 213
  [5.2136]→[4.104:173](∅→∅)
  − let left = P::left_child(unsafe { cur.page.as_page() }, &c);
  [5.2136]

  [5.3668]
  + let left = P::left_child(cur.page.as_page(), &c);
• replacement in sanakirja-core/src/btree/put.rs at line 220
  [5.3887]→[4.174:264](∅→∅)
  − while let Some((k, v, r)) = P::next(txn, unsafe { cur.page.as_page() }, &mut c) {
  [5.3887]

  [5.8397]
  + while let Some((k, v, r)) = P::next(txn, cur.page.as_page(), &mut c) {
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 97
  [5.5268]→[4.265:341](∅→∅)
  − let l = header(unsafe { page.as_page() }).left_page() & !0xfff;
  [5.5268]

  [5.5333]
  + let l = header(page.as_page()).left_page() & !0xfff;
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 100
  [5.5411]→[4.342:421](∅→∅)
  − let s = Internal::offset_slice::<K, V>(unsafe { page.as_page() });
  [5.5411]

  [5.5479]
  + let s = Internal::offset_slice::<K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 102
  [5.5506]→[4.422:507](∅→∅)
  − clone::<K, V, Internal>(unsafe { page.as_page() }, &mut new, s, &mut n);
  [5.5506]

  [5.2189]
  + clone::<K, V, Internal>(page.as_page(), &mut new, s, &mut n);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 188
  [5.8658]→[5.8658:8698](∅→∅)
  − m: &mut Concat<'a, K, V, Self>,
  [5.8658]

  [5.8698]
  + m: Concat<'a, K, V, Self>,
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 198
  [5.9028]→[4.508:568](∅→∅)
  − let hdr = header(unsafe { m.other.as_page() });
  [5.9028]

  [5.9077]
  + let hdr = header(m.other.as_page());
• edit in sanakirja-core/src/btree/page_unsized.rs at line 210
  [5.9489]

  [5.332]
  + let freed = {

  + let b0 = if m.modified.page.is_dirty() { 1 } else { 0 };

  + let b1 = if m.other.is_dirty() { 1 } else { 0 };

  + [m.modified.page.offset | b0, m.other.offset | b1]

  + };
• edit in sanakirja-core/src/btree/page_unsized.rs at line 220
  [5.9736]→[5.2288:2418](∅→∅)
  − let b0 = if m.modified.page.is_dirty() { 1 } else { 0 };

  − let b1 = if m.other.is_dirty() { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 222
  [5.10070]→[5.10070:10145](∅→∅)
  − freed: [m.modified.page.offset | b0, m.other.offset | b1],
  [5.10070]

  [5.10145]
  + freed,
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 227
  [5.2466]→[4.569:657](∅→∅)
  − let first_size = <Page<K, V>>::current_size(unsafe { m.other.as_page() }, &rc);
  [5.2466]

  [5.10363]
  + let first_size = <Page<K, V>>::current_size(m.other.as_page(), &rc);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 274
  [5.722]→[4.658:713](∅→∅)
  − let hdr = header(unsafe { m.page.as_page() });
  [5.722]

  [5.766]
  + let hdr = header(m.page.as_page());
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 286
  [5.1117]→[4.714:835](∅→∅)
  − total -= <Page<K, V> as BTreePage<K, V>>::current_size(unsafe { m.page.as_page() }, &m.c1)

  − as usize;
  [5.1117]

  [5.1215]
  + total -= <Page<K, V> as BTreePage<K, V>>::current_size(m.page.as_page(), &m.c1) as usize;
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 550
  [5.19262]→[4.836:1012](∅→∅)
  − let mut l = <Page<K, V>>::left_child(unsafe { m.page.as_page() }, &m.c0);

  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.page.as_page() }, &mut m.c0) {
  [5.19262]

  [5.19416]
  + let mut l = <Page<K, V>>::left_child(m.page.as_page(), &m.c0);

  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c0) {
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 566
  [5.19817]→[4.1013:1111](∅→∅)
  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.page.as_page() }, &mut m.c1) {
  [5.19817]

  [5.19904]
  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c1) {
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 584
  [5.20250]→[5.20250:20288](∅→∅)
  − m: &mut Concat<K, V, Page<K, V>>,
  [5.20250]

  [5.20288]
  + mut m: Concat<K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 590
  [5.2962]→[4.1112:1189](∅→∅)
  − let l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);
  [5.2962]

  [5.20533]
  + let l = <Page<K, V>>::left_child(m.other.as_page(), &rc);
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 592
  [5.20596]→[4.1190:1291](∅→∅)
  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.other.as_page() }, &mut rc) {
  [5.20596]

  [5.20686]
  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
• replacement in sanakirja-core/src/btree/page_unsized.rs at line 597
  [5.3014]→[4.1292:1474](∅→∅)
  − let mut l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.other.as_page() }, &mut rc) {
  [5.3014]

  [5.20992]
  + let mut l = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 12
  [5.23132]→[5.23132:23174](∅→∅)
  − m: &mut Concat<'a, K, V, Page<K, V>>,
  [5.23132]

  [5.23174]
  + m: Concat<'a, K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 19
  [5.3065]→[4.1475:1641](∅→∅)
  − let rl = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

  − let (k, v, r) = <Page<K, V>>::current(txn, unsafe { m.other.as_page() }, &rc).unwrap();
  [5.3065]

  [5.23540]
  + let rl = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc).unwrap();

  + // Extend the lifetimes of k and v.

  + let (k, v): (&K, &V) = unsafe { (core::mem::transmute(k), core::mem::transmute(v)) };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 27
  [5.1976]

  [5.1615]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 41
  [5.225]→[4.1642:1727](∅→∅),[4.1727]→[5.299:387](∅→∅),[5.299]→[5.299:387](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.225]

  [5.387]
  + let b = if is_dirty { 1 } else { 0 };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 49
  [5.24156]

  [5.1977]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 58
  [5.812]→[4.1728:1809](∅→∅),[5.2108]→[5.877:949](∅→∅),[4.1809]→[5.877:949](∅→∅),[5.877]→[5.877:949](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.812]

  [5.949]
  + let b = if is_dirty { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 63
  [5.2129]→[5.3066:3116](∅→∅),[5.3116]→[5.1699:1759](∅→∅),[5.2188]→[5.1699:1759](∅→∅)
  − let lc = PageCursor::after(&m.modified.page);

  − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
  [5.2129]

  [5.1759]
  + let lc = PageCursor::after(&new_left.0);

  + let new_left = if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 67
  [5.1842]→[5.2321:2375](∅→∅),[5.2321]→[5.2321:2375](∅→∅)
  − assert_eq!(page.0.offset, new_left.0.offset);
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 68
  [5.2405]

  [5.1018]
  + page
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 73
  [5.24372]

  [5.2406]
  + let b = {

  + let hdr = &*header(m.other.as_page());

  + if hdr.is_dirty() {

  + 1

  + } else {

  + 0

  + }

  + };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 82
  [5.2497]→[5.2497:2587](∅→∅)
  − let (k, v): (&K, &V) = unsafe { (core::mem::transmute(k), core::mem::transmute(v)) };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 83
  [5.2606]→[4.1810:1868](∅→∅),[4.1868]→[5.24670:24722](∅→∅),[5.24670]→[5.24670:24722](∅→∅)
  − let hdr = &*header(unsafe { m.other.as_page() });

  − let b = if hdr.is_dirty() { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 103
  [5.25161]→[5.25161:25203](∅→∅)
  − m: &mut Concat<'a, K, V, Page<K, V>>,
  [5.25161]

  [5.25203]
  + m: Concat<'a, K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 107
  [5.25320]→[4.1869:2032](∅→∅)
  − let lc = super::PageCursor::last(unsafe { m.other.as_page() });

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

  [5.25475]
  + let lc = super::PageCursor::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 112
  [5.3175]→[4.2033:2115](∅→∅)
  − let rl = <Page<K, V>>::left_child(unsafe { m.modified.page.as_page() }, &rc);
  [5.3175]

  [5.25655]
  + let rl = <Page<K, V>>::left_child(m.modified.page.as_page(), &rc);
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 117
  [5.2697]

  [5.1843]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 131
  [5.1252]→[4.2116:2201](∅→∅),[4.2201]→[5.1326:1414](∅→∅),[5.1326]→[5.1326:1414](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.1252]

  [5.1414]
  + let b = if is_dirty { 1 } else { 0 };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 139
  [5.26272]

  [5.2698]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 148
  [5.1533]→[4.2202:2283](∅→∅),[5.2829]→[5.1599:1671](∅→∅),[4.2283]→[5.1599:1671](∅→∅),[5.1599]→[5.1599:1671](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.1533]

  [5.1671]
  + let b = if is_dirty { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 153
  [5.2850]→[5.3176:3234](∅→∅)
  − if let Put::Ok(Ok { freed, .. }) = <Page<K, V>>::put(
  [5.2850]

  [5.1987]
  + let new_right = if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 166
  [5.3070]

  [5.26515]
  + page
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 171
  [5.26559]

  [5.3071]
  + let k = unsafe { core::mem::transmute(k0) };

  + let v = unsafe { core::mem::transmute(v0) };

  + let b = {

  + let hdr = &*header(m.other.as_page());

  + if hdr.is_dirty() {

  + 1

  + } else {

  + 0

  + }

  + };
• edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 183
  [5.3180]→[4.2284:2342](∅→∅),[4.2342]→[5.26712:26764](∅→∅),[5.26712]→[5.26712:26764](∅→∅)
  − let hdr = &*header(unsafe { m.other.as_page() });

  − let b = if hdr.is_dirty() { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 188
  [5.26893]→[5.26893:26989](∅→∅)
  − k: unsafe { core::mem::transmute(k0) },

  − v: unsafe { core::mem::transmute(v0) },
  [5.26893]

  [5.42]
  + k,

  + v,
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 30
  [5.3328]→[4.2343:2437](∅→∅)
  − let cur_size = Internal::current_size::<K, V>(unsafe { page.as_page() }, u as isize);
  [5.3328]

  [5.3411]
  + let cur_size = Internal::current_size::<K, V>(page.as_page(), u as isize);
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 35
  [5.3495]→[4.2438:2487](∅→∅)
  − let hdr = header(unsafe { page.as_page() });
  [5.3495]

  [5.27583]
  + let hdr = header(page.as_page());
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 38
  [5.27674]→[4.2488:2574](∅→∅)
  − if mutable && is_dirty && L::can_alloc(header(unsafe { page.as_page() }), size) {
  [5.27674]

  [5.27757]
  + if mutable && is_dirty && L::can_alloc(header(page.as_page()), size) {
• edit in sanakirja-core/src/btree/page_unsized/put.rs at line 43
  [5.3556]

  [5.3556]
  + let p = page.0.data;

  + let hdr = header_mut(&mut page);
• edit in sanakirja-core/src/btree/page_unsized/put.rs at line 47
  [5.3614]→[5.3614:3651](∅→∅)
  − let p = page.0.data;
• edit in sanakirja-core/src/btree/page_unsized/put.rs at line 52
  [5.3967]→[3.0:49](∅→∅)
  − let hdr = header_mut(&mut page);
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 68
  [5.28439]→[4.2575:2643](∅→∅)
  − let s = L::offset_slice::<K, V>(unsafe { page.as_page() });
  [5.28439]

  [5.28496]
  + let s = L::offset_slice::<K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 72
  [5.28566]→[4.2644:2719](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut new, s0, &mut n);
  [5.28566]

  [5.28630]
  + clone::<K, V, L>(page.as_page(), &mut new, s0, &mut n);
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 79
  [5.28882]→[4.2720:2795](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut new, s1, &mut n);
  [5.28882]

  [5.53]
  + clone::<K, V, L>(page.as_page(), &mut new, s1, &mut n);
• replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 88
  [5.29136]→[4.2796:3023](∅→∅)
  − return split_unsized::<_, _, _, L>(

  − txn,

  − unsafe { page.as_page() },

  − replace,

  − u,

  − k0,

  − v0,

  − k1v1,

  − l,

  − r,

  − );
  [5.29136]

  [5.29224]
  + return split_unsized::<_, _, _, L>(txn, page.as_page(), replace, u, k0, v0, k1v1, l, r);
• edit in sanakirja-core/src/btree/page.rs at line 14
  [5.95]

  [5.44313]
  + /// This struct is used to allocate a pair `(K, V)` on the stack, and

  + /// copy it from a C pointer from a page.

  + ///

  + /// This is also used to form slices of pairs in order to use

  + /// functions from the core library.
• edit in sanakirja-core/src/btree/page.rs at line 26
  [5.8683]→[5.279:494](∅→∅),[5.494]→[5.494:497](∅→∅)
  − fn tuple_size<K: Representable, V: Representable>() -> usize {

  − let s = ((K::SIZE.unwrap() + V::ALIGN - 1) & !(V::ALIGN - 1)) + V::SIZE.unwrap();

  − let al = K::ALIGN.max(V::ALIGN);

  − (s + al - 1) & !(al - 1)

  − }

  −
• replacement in sanakirja-core/src/btree/page.rs at line 55
  [5.2954]→[5.2954:2996](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.2954]

  [5.2996]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page.rs at line 87
  [5.4139]→[5.4139:4176](∅→∅)
  − tuple_size::<K, V>()
  [5.4139]

  [5.4176]
  + core::mem::size_of::<Tuple<K, V>>()
• replacement in sanakirja-core/src/btree/page.rs at line 146
  [5.5875]→[5.5875:5929](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.5875]

  [5.5929]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page.rs at line 264
  [5.1693]→[4.3024:3100](∅→∅)
  − let l = header(unsafe { page.as_page() }).left_page() & !0xfff;
  [5.1693]

  [5.320]
  + let l = header(page.as_page()).left_page() & !0xfff;
• replacement in sanakirja-core/src/btree/page.rs at line 267
  [5.328]→[4.3101:3183](∅→∅)
  − let s = Internal::offset_slice::<T, K, V>(unsafe { page.as_page() });
  [5.328]

  [5.2431]
  + let s = Internal::offset_slice::<T, K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 269
  [5.2458]→[4.3184:3269](∅→∅)
  − clone::<K, V, Internal>(unsafe { page.as_page() }, &mut new, s, &mut n);
  [5.2458]

  [5.3656]
  + clone::<K, V, Internal>(page.as_page(), &mut new, s, &mut n);
• replacement in sanakirja-core/src/btree/page.rs at line 294
  [5.1693]→[5.1439:1485](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.1693]

  [5.1693]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page.rs at line 359
  [5.15740]→[5.2591:2631](∅→∅)
  − m: &mut Concat<'a, K, V, Self>,
  [5.15740]

  [5.15779]
  + m: Concat<'a, K, V, Self>,
• replacement in sanakirja-core/src/btree/page.rs at line 363
  [5.15906]→[5.1486:1528](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.15906]

  [5.45058]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page.rs at line 372
  [5.5253]→[4.3270:3330](∅→∅)
  − let hdr = header(unsafe { m.other.as_page() });
  [5.5253]

  [5.16415]
  + let hdr = header(m.other.as_page());
• edit in sanakirja-core/src/btree/page.rs at line 380
  [5.2861]

  [5.7356]
  + let freed = {

  + let b0 = if m.modified.page.is_dirty() { 1 } else { 0 };

  + let b1 = if m.other.is_dirty() { 1 } else { 0 };

  + [m.modified.page.offset | b0, m.other.offset | b1]

  + };
• edit in sanakirja-core/src/btree/page.rs at line 390
  [5.16918]→[5.3769:3899](∅→∅)
  − let b0 = if m.modified.page.is_dirty() { 1 } else { 0 };

  − let b1 = if m.other.is_dirty() { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page.rs at line 392
  [5.17176]→[5.17176:17251](∅→∅)
  − freed: [m.modified.page.offset | b0, m.other.offset | b1],
  [5.17176]

  [5.17251]
  + freed,
• replacement in sanakirja-core/src/btree/page.rs at line 397
  [5.3947]→[4.3331:3419](∅→∅)
  − let first_size = <Page<K, V>>::current_size(unsafe { m.other.as_page() }, &rc);
  [5.3947]

  [5.3352]
  + let first_size = <Page<K, V>>::current_size(m.other.as_page(), &rc);
• replacement in sanakirja-core/src/btree/page.rs at line 442
  [5.7721]→[4.3420:3475](∅→∅)
  − let hdr = header(unsafe { m.page.as_page() });
  [5.7721]

  [5.7765]
  + let hdr = header(m.page.as_page());
• replacement in sanakirja-core/src/btree/page.rs at line 459
  [5.8236]→[4.3476:3597](∅→∅)
  − total -= <Page<K, V> as BTreePage<K, V>>::current_size(unsafe { m.page.as_page() }, &m.c1)

  − as usize;
  [5.8236]

  [5.26184]
  + total -= <Page<K, V> as BTreePage<K, V>>::current_size(m.page.as_page(), &m.c1) as usize;
• replacement in sanakirja-core/src/btree/page.rs at line 580
  [5.34802]→[4.3598:3774](∅→∅)
  − let mut l = <Page<K, V>>::left_child(unsafe { m.page.as_page() }, &m.c0);

  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.page.as_page() }, &mut m.c0) {
  [5.34802]

  [5.5637]
  + let mut l = <Page<K, V>>::left_child(m.page.as_page(), &m.c0);

  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c0) {
• replacement in sanakirja-core/src/btree/page.rs at line 596
  [5.35214]→[4.3775:3873](∅→∅)
  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.page.as_page() }, &mut m.c1) {
  [5.35214]

  [5.35287]
  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c1) {
• replacement in sanakirja-core/src/btree/page.rs at line 614
  [5.20528]→[5.6103:6141](∅→∅)
  − m: &mut Concat<K, V, Page<K, V>>,
  [5.20528]

  [5.35590]
  + mut m: Concat<K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page.rs at line 620
  [5.5784]→[4.3874:3951](∅→∅)
  − let l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);
  [5.5784]

  [5.6208]
  + let l = <Page<K, V>>::left_child(m.other.as_page(), &rc);
• replacement in sanakirja-core/src/btree/page.rs at line 622
  [5.6271]→[4.3952:4053](∅→∅)
  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.other.as_page() }, &mut rc) {
  [5.6271]

  [5.6361]
  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
• replacement in sanakirja-core/src/btree/page.rs at line 627
  [5.5836]→[4.4054:4236](∅→∅)
  − let mut l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

  − while let Some((k, v, r)) = <Page<K, V>>::next(txn, unsafe { m.other.as_page() }, &mut rc) {
  [5.5836]

  [5.6507]
  + let mut l = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
• replacement in sanakirja-core/src/btree/page.rs at line 659
  [5.39419]→[5.1708:1753](∅→∅)
  − let size = tuple_size::<K, V>();
  [5.39419]

  [5.39476]
  + let size = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 12
  [5.628]→[5.7080:7122](∅→∅)
  − m: &mut Concat<'a, K, V, Page<K, V>>,
  [5.628]

  [5.673]
  + m: Concat<'a, K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 18
  [5.5887]→[4.4237:4403](∅→∅)
  − let rl = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

  − let (k, v, r) = <Page<K, V>>::current(txn, unsafe { m.other.as_page() }, &rc).unwrap();
  [5.5887]

  [5.1034]
  + let rl = <Page<K, V>>::left_child(m.other.as_page(), &rc);

  + 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 23
  [5.1209]→[5.1209:1271](∅→∅)
  − let mut new_left = if let Some((k, v)) = m.modified.ins {
  [5.1209]

  [5.8369]
  + let new_left = if let Some((k, v)) = m.modified.ins {

  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 38
  [5.2040]→[4.4404:4489](∅→∅),[4.4489]→[5.2114:2202](∅→∅),[5.2114]→[5.2114:2202](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.2040]

  [5.2202]
  + let b = if is_dirty { 1 } else { 0 };
• edit in sanakirja-core/src/btree/page/rebalance.rs at line 46
  [5.1650]

  [5.7894]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 55
  [5.7977]→[4.4490:4571](∅→∅),[4.4571]→[5.8047:8119](∅→∅),[5.8047]→[5.8047:8119](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.7977]

  [5.8119]
  + let b = if is_dirty { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 60
  [5.1736]→[5.5888:5938](∅→∅),[5.5938]→[5.8453:8513](∅→∅),[5.1491]→[5.8453:8513](∅→∅)
  − let lc = PageCursor::after(&m.modified.page);

  − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
  [5.1736]

  [5.8513]
  + let lc = PageCursor::after(&new_left.0);

  + let new_left = if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 64
  [5.8596]→[5.2525:2548](∅→∅),[5.2525]→[5.2525:2548](∅→∅),[5.2548]→[4.4572:4648](∅→∅),[4.4648]→[5.2613:2754](∅→∅),[5.2613]→[5.2613:2754](∅→∅)
  − if freed > 0 {

  − let b = if header(unsafe { new_left.0.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };

  − freed_[0] = freed | b;

  − }

  − new_left = page
  [5.8596]

  [5.2754]
  + assert_eq!(freed, 0);

  + page
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 70
  [5.2798]→[4.4649:4707](∅→∅),[4.4707]→[5.1754:1788](∅→∅),[5.1916]→[5.1754:1788](∅→∅)
  − let right_hdr = header(unsafe { m.other.as_page() });

  − let f = tuple_size::<K, V>();
  [5.2798]

  [5.46209]
  + let right_hdr = header(m.other.as_page());

  + let f = core::mem::size_of::<Tuple<K, V>>();
• edit in sanakirja-core/src/btree/page/rebalance.rs at line 100
  [5.47398]

  [5.8177]
  + let k = unsafe { core::mem::transmute(k) };

  + let v = unsafe { core::mem::transmute(v) };

  +

  + let is_dirty = m.other.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 106
  [5.8290]→[4.4708:4770](∅→∅),[4.4770]→[5.8341:8432](∅→∅),[5.8341]→[5.8341:8432](∅→∅)
  − let hdr = &*header(unsafe { m.other.as_page() });

  − let b = if hdr.is_dirty() { 1 } else { 0 };

  − freed_[1] = freed | b;
  [5.8290]

  [5.47416]
  + freed_[1] = freed | if is_dirty { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 108
  [5.47426]→[5.8433:8509](∅→∅)
  − unsafe { (page, core::mem::transmute(k), core::mem::transmute(v)) }
  [5.47426]

  [5.3471]
  + (page, k, v)
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 113
  [5.3752]→[5.3752:3846](∅→∅)
  − k: unsafe { core::mem::transmute(k) },

  − v: unsafe { core::mem::transmute(v) },
  [5.3752]

  [5.84]
  + k,

  + v,
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 128
  [5.4069]→[5.7447:7489](∅→∅)
  − m: &mut Concat<'a, K, V, Page<K, V>>,
  [5.4069]

  [5.4114]
  + m: Concat<'a, K, V, Page<K, V>>,
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 132
  [5.4231]→[4.4771:4927](∅→∅)
  − let lc = PageCursor::last(unsafe { m.other.as_page() });

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

  [5.4381]
  + let lc = PageCursor::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 137
  [5.5997]→[4.4928:5010](∅→∅)
  − let rl = <Page<K, V>>::left_child(unsafe { m.modified.page.as_page() }, &rc);
  [5.5997]

  [5.4561]
  + let rl = <Page<K, V>>::left_child(m.modified.page.as_page(), &rc);
• edit in sanakirja-core/src/btree/page/rebalance.rs at line 142
  [5.8569]

  [5.8597]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 155
  [5.5094]→[4.5011:5092](∅→∅),[4.5092]→[5.3032:3104](∅→∅),[5.3032]→[5.3032:3104](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.5094]

  [5.3104]
  + let b = if is_dirty { 1 } else { 0 };
• edit in sanakirja-core/src/btree/page/rebalance.rs at line 162
  [5.5178]

  [5.8570]
  + let is_dirty = m.modified.page.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 171
  [5.3205]→[4.5093:5174](∅→∅),[5.8701]→[5.3271:3343](∅→∅),[4.5174]→[5.3271:3343](∅→∅),[5.3271]→[5.3271:3343](∅→∅)
  − let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {

  − 1

  − } else {

  − 0

  − };
  [5.3205]

  [5.3343]
  + let b = if is_dirty { 1 } else { 0 };
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 176
  [5.8722]→[5.8681:8741](∅→∅)
  − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
  [5.8722]

  [5.8741]
  + let new_right = if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 189
  [5.8887]→[5.8887:8942](∅→∅)
  − assert_eq!(new_right.0.offset, page.0.offset);
  [5.8887]

  [5.5421]
  + page
• edit in sanakirja-core/src/btree/page/rebalance.rs at line 194
  [5.5465]

  [5.8943]
  + let k = unsafe { core::mem::transmute(k0) };

  + let v = unsafe { core::mem::transmute(v0) };

  +

  + let is_dirty = m.other.is_dirty();
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 200
  [5.9052]→[4.5175:5233](∅→∅),[4.5233]→[5.5618:5670](∅→∅),[5.5618]→[5.5618:5670](∅→∅),[5.5670]→[5.9053:9083](∅→∅)
  − let hdr = &*header(unsafe { m.other.as_page() });

  − let b = if hdr.is_dirty() { 1 } else { 0 };

  − freed_[1] = freed | b
  [5.9052]

  [5.5708]
  + freed_[1] = freed | if is_dirty { 1 } else { 0 }
• replacement in sanakirja-core/src/btree/page/rebalance.rs at line 205
  [5.5799]→[5.5799:5895](∅→∅)
  − k: unsafe { core::mem::transmute(k0) },

  − v: unsafe { core::mem::transmute(v0) },
  [5.5799]

  [5.126]
  + k,

  + v,
• replacement in sanakirja-core/src/btree/page/put.rs at line 27
  [5.6458]→[4.5234:5283](∅→∅)
  − let hdr = header(unsafe { page.as_page() });
  [5.6458]

  [5.6496]
  + let hdr = header(page.as_page());
• replacement in sanakirja-core/src/btree/page/put.rs at line 29
  [5.6531]→[4.5284:5378](∅→∅)
  − if mutable && is_dirty && L::can_alloc::<K, V>(header(unsafe { page.as_page() }), size) {
  [5.6531]

  [5.9104]
  + if mutable && is_dirty && L::can_alloc::<K, V>(header(page.as_page()), size) {
• edit in sanakirja-core/src/btree/page/put.rs at line 31
  [5.9142]

  [5.6764]
  + let p = page.0.data;

  + let hdr = header_mut(&mut page);
• edit in sanakirja-core/src/btree/page/put.rs at line 37
  [5.9222]→[5.9222:9259](∅→∅)
  − let p = page.0.data;
• edit in sanakirja-core/src/btree/page/put.rs at line 42
  [5.9575]→[5.9575:9624](∅→∅)
  − let hdr = header_mut(&mut page);
• replacement in sanakirja-core/src/btree/page/put.rs at line 58
  [5.7370]→[4.5379:5450](∅→∅)
  − let s = L::offset_slice::<T, K, V>(unsafe { page.as_page() });
  [5.7370]

  [5.7430]
  + let s = L::offset_slice::<T, K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page/put.rs at line 62
  [5.7500]→[4.5451:5526](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut new, s0, &mut n);
  [5.7500]

  [5.9784]
  + clone::<K, V, L>(page.as_page(), &mut new, s0, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 71
  [5.9871]→[4.5527:5715](∅→∅)
  − debug!(

  − "alloc: {:?}",

  − header(unsafe { new.0.as_page() }).left_page()

  − );

  − clone::<K, V, L>(unsafe { page.as_page() }, &mut new, s1, &mut n);
  [5.9871]

  [5.9940]
  + debug!("alloc: {:?}", header(new.0.as_page()).left_page());

  + clone::<K, V, L>(page.as_page(), &mut new, s1, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 82
  [5.8085]→[5.1789:1827](∅→∅)
  − let s = tuple_size::<K, V>();
  [5.8060]

  [5.47480]
  + let s = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page/put.rs at line 106
  [5.8738]→[4.5716:5765](∅→∅)
  − let hdr = header(unsafe { page.as_page() });
  [5.8738]

  [5.8776]
  + let hdr = header(page.as_page());
• replacement in sanakirja-core/src/btree/page/put.rs at line 113
  [5.8894]→[4.5766:5833](∅→∅)
  − let s = L::offset_slice::<T, K, V>(unsafe { page.as_page() });
  [5.8894]

  [5.8950]
  + let s = L::offset_slice::<T, K, V>(page.as_page());
• replacement in sanakirja-core/src/btree/page/put.rs at line 120
  [5.9266]→[4.5834:5921](∅→∅)
  − let (k, v, r) = L::kv(txn, unsafe { page.as_page() }, s1a.first::<T, K, V>());
  [5.9266]

  [5.9449]
  + let (k, v, r) = L::kv(txn, page.as_page(), s1a.first::<T, K, V>());
• edit in sanakirja-core/src/btree/page/put.rs at line 125
  [5.9527]

  [5.9527]
  + // If we are here, u >= k, i.e. the insertion is in the right-hand

  + // side of the split.

  + let mut right = txn.alloc_page()?;

  + <Page<K, V> as BTreeMutPage<K, V>>::init(&mut right);

  + if u > k as usize {

  + let mut n = 0;

  + let kk = u as usize - k as usize - 1;

  + let (s1a, s1b) = s1.split_at(kk);

  + L::set_right_child(&mut right, -1, mid_child);

  + clone::<K, V, L>(page.as_page(), &mut right, s1a, &mut n);

  + alloc::<K, V, L>(&mut right, k0, v0, l, r, &mut n);

  + clone::<K, V, L>(page.as_page(), &mut right, s1b, &mut n);

  + } else {

  + let mut n = 0;

  + clone::<K, V, L>(page.as_page(), &mut right, s1, &mut n);

  + }

  +
• replacement in sanakirja-core/src/btree/page/put.rs at line 153
  [5.10119]→[4.5922:6002](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut left, s0, &mut n);
  [5.10119]

  [5.10191]
  + clone::<K, V, L>(page.as_page(), &mut left, s0, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 156
  [5.10249]→[5.10249:10420](∅→∅),[5.10420]→[5.8555:8617](∅→∅),[5.8617]→[5.10485:10668](∅→∅),[5.10485]→[5.10485:10668](∅→∅),[5.10668]→[4.6003:6085](∅→∅),[4.6085]→[5.8689:8753](∅→∅),[5.8689]→[5.8689:8753](∅→∅),[5.8753]→[4.6086:6168](∅→∅),[4.6168]→[5.10883:10900](∅→∅),[5.8824]→[5.10883:10900](∅→∅),[5.10883]→[5.10883:10900](∅→∅)
  − // If we are here, u >= k, i.e. the insertion is in the right-hand

  − // side of the split.

  − let mut n = 0;

  − let mut right = txn.alloc_page()?;

  − <Page<K, V> as BTreeMutPage<K, V>>::init(&mut right);

  − if u > k as usize {

  − let kk = u as usize - k as usize - 1;

  − let (s1a, s1b) = s1.split_at(kk);

  − L::set_right_child(&mut right, -1, mid_child);

  − clone::<K, V, L>(unsafe { page.as_page() }, &mut right, s1a, &mut n);

  − alloc::<K, V, L>(&mut right, k0, v0, l, r, &mut n);

  − clone::<K, V, L>(unsafe { page.as_page() }, &mut right, s1b, &mut n);

  − } else {
  [5.10249]

  [5.10900]
  +

  + if u == k as usize {
• edit in sanakirja-core/src/btree/page/put.rs at line 163
  [5.11212]→[4.6169:6250](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut right, s1, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 175
  [5.11605]→[4.6251:6324](∅→∅)
  − let ll = header(unsafe { page.as_page() }).left_page() & !0xfff;
  [5.11605]

  [5.11667]
  + let ll = header(page.as_page()).left_page() & !0xfff;
• replacement in sanakirja-core/src/btree/page/put.rs at line 178
  [5.11764]→[4.6325:6402](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut left, s0a, &mut n);
  [5.11764]

  [5.9024]
  + clone::<K, V, L>(page.as_page(), &mut left, s0a, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 180
  [5.9083]→[4.6403:6480](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut left, s0b, &mut n);
  [5.9083]

  [5.11964]
  + clone::<K, V, L>(page.as_page(), &mut left, s0b, &mut n);
• replacement in sanakirja-core/src/btree/page/put.rs at line 198
  [5.12573]→[4.6481:6562](∅→∅)
  − clone::<K, V, L>(unsafe { page.as_page() }, &mut right, s1, &mut n);
  [5.12573]

  [5.12646]
  + clone::<K, V, L>(page.as_page(), &mut right, s1, &mut n);
• replacement in sanakirja-core/src/btree/page/alloc.rs at line 62
  [5.19432]→[5.1828:1877](∅→∅)
  − let size = tuple_size::<K, V>();
  [5.19432]

  [5.19493]
  + let size = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page/alloc.rs at line 76
  [5.6547]→[5.1878:1916](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.6547]

  [5.47719]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page/alloc.rs at line 100
  [5.21047]→[5.1917:1955](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.21047]

  [5.48138]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• edit in sanakirja-core/src/btree/page/alloc.rs at line 107
  [5.48345]

  [5.7012]
  + // This performs a rotation by 1 without all the rotation

  + // machinery from the core lib.
• replacement in sanakirja-core/src/btree/page/alloc.rs at line 147
  [5.23632]→[5.1956:1994](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.23632]

  [5.7284]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/page/alloc.rs at line 222
  [5.27048]→[5.1995:2033](∅→∅)
  − let f = tuple_size::<K, V>();
  [5.27048]

  [5.7767]
  + let f = core::mem::size_of::<Tuple<K, V>>();
• replacement in sanakirja-core/src/btree/mod.rs at line 216
  [5.49260]→[5.14429:14472](∅→∅)
  − m: &'b mut Concat<'a, K, V, Self>,
  [5.49260]

  [5.49299]
  + m: Concat<'a, K, V, Self>,
• replacement in sanakirja-core/src/btree/mod.rs at line 392
  [5.6429]→[4.6563:6663](∅→∅)
  − if let Ok((kk, vv, _)) = P::set_cursor(txn, unsafe { page.as_page() }, &mut cursor, k, v) {
  [5.6429]

  [5.980]
  + if let Ok((kk, vv, _)) = P::set_cursor(txn, page.as_page(), &mut cursor, k, v) {
• replacement in sanakirja-core/src/btree/mod.rs at line 397
  [5.1107]→[4.6664:6758](∅→∅)
  − } else if let Some((k, v, _)) = P::current(txn, unsafe { page.as_page() }, &cursor) {
  [5.1107]

  [5.4387]
  + } else if let Some((k, v, _)) = P::current(txn, page.as_page(), &cursor) {
• replacement in sanakirja-core/src/btree/mod.rs at line 407
  [5.4800]→[4.6759:6834](∅→∅)
  − let next_page = P::left_child(unsafe { page.as_page() }, &cursor);
  [5.4800]

  [5.1399]
  + let next_page = P::left_child(page.as_page(), &cursor);
• edit in sanakirja-core/src/btree/mod.rs at line 456
  [5.7259]

  [5.7259]
  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),

  + MaybeUninit::uninit(),
• replacement in sanakirja-core/src/btree/mod.rs at line 485
  [5.5321]→[4.6835:6934](∅→∅)
  − if let Some((k, v, _)) = P::current(txn, unsafe { cur.page.as_page() }, &cur.cursor) {
  [5.5321]

  [5.2319]
  + if let Some((k, v, _)) = P::current(txn, cur.page.as_page(), &cur.cursor) {
• replacement in sanakirja-core/src/btree/mod.rs at line 494
  [5.2490]→[4.6935:7018](∅→∅)
  − let r = P::left_child(unsafe { cur.page.as_page() }, &cur.cursor);
  [5.2490]

  [5.2562]
  + let r = P::left_child(cur.page.as_page(), &cur.cursor);
• replacement in sanakirja-core/src/btree/del.rs at line 43
  [5.53969]→[5.1023:1054](∅→∅)
  − let p0 = cursor.pointer();
  [5.53969]

  [5.53998]
  + let p0 = cursor.len();
• replacement in sanakirja-core/src/btree/del.rs at line 53
  [5.7959]→[5.16416:16452](∅→∅),[5.16416]→[5.16416:16452](∅→∅)
  − if p0 < cursor.first_rc_level {
  [5.7959]

  [5.9636]
  + if p0 < cursor.first_rc_len {
• replacement in sanakirja-core/src/btree/del.rs at line 56
  [5.16509]→[4.7019:7100](∅→∅)
  − P::current(txn, unsafe { cur.page.as_page() }, &cur.cursor).unwrap()
  [5.16509]

  [5.1183]
  + P::current(txn, cur.page.as_page(), &cur.cursor).unwrap()
• replacement in sanakirja-core/src/btree/del.rs at line 66
  [5.7994]→[4.7101:7185](∅→∅)
  − let mut left_page = P::right_child(unsafe { cur.page.as_page() }, &cur.cursor);
  [5.7994]

  [5.8067]
  + let mut left_page = P::right_child(cur.page.as_page(), &cur.cursor);
• edit in sanakirja-core/src/btree/del.rs at line 68
  [5.8093]

  [5.8093]
  + if cursor.first_rc_len >= N_CURSORS && txn.rc(left_page)? >= 2 {

  + cursor.first_rc_len = cursor.len()

  + }
• replacement in sanakirja-core/src/btree/del.rs at line 73
  [5.8182]→[4.7186:7255](∅→∅)
  − left_page = P::left_child(unsafe { page.as_page() }, &curs);
  [5.8182]

  [5.8240]
  + left_page = P::left_child(page.as_page(), &curs);
• edit in sanakirja-core/src/btree/del.rs at line 76
  [5.8302]

  [5.6150]
  + let leaf_is_shared = cursor.len() >= cursor.first_rc_len;
• replacement in sanakirja-core/src/btree/del.rs at line 86
  [5.8473]→[5.8473:8524](∅→∅)
  − if cursor.pointer() >= cursor.first_rc_level {
  [5.8473]

  [5.8524]
  + if leaf_is_shared {
• replacement in sanakirja-core/src/btree/del.rs at line 92
  [5.55587]→[5.17067:17134](∅→∅),[5.1308]→[5.1308:1341](∅→∅),[5.1341]→[5.386:408](∅→∅),[5.1341]→[5.17136:17471](∅→∅),[5.408]→[5.17136:17471](∅→∅),[5.17136]→[5.17136:17471](∅→∅),[5.17471]→[5.2443:2510](∅→∅)
  − // Then, climb up the stack, performing the operations lazily.

  − while cursor.pointer() > 0 {

  − cursor.pop();

  − // Prepare a plan for merging the current modified page (that

  − // page is at level cursor.pointer + 1) with one of its

  − // neighbours.

  − //

  − // This is a little bit convoluted, but we do have to get up

  − // one level in order to fetch the right or left sibling of

  − // the modified page.

  − let mut concat = concat(txn, cursor, p0, &k0v0, last_op)?;
  [5.55587]

  [5.17538]
  + // Then, climb up the stack, performing the operations lazily. At

  + // each step, we are one level above the page that we plan to

  + // modify, since `last_op` is the result of popping the

  + // stack.

  + //

  + // We iterate up to the root. The last iteration builds a modified

  + // page for the root, but doesn't actually execute it.

  + while cursor.len() > 0 {

  + // Prepare a plan for merging the current modified page (which

  + // is stored in `last_op`) with one of its neighbours.

  + let concat = concat(txn, cursor, p0, &k0v0, last_op)?;

  + let mil = concat.mod_is_left;
• replacement in sanakirja-core/src/btree/del.rs at line 105
  [5.17539]→[5.17539:17603](∅→∅),[5.17603]→[5.848:1078](∅→∅),[5.1078]→[5.4202:4264](∅→∅),[5.30986]→[5.4202:4264](∅→∅),[5.6963]→[5.4202:4264](∅→∅),[5.17624]→[5.4202:4264](∅→∅),[5.32226]→[5.4202:4264](∅→∅)
  − // Execute the plan, resulting in one of four different

  − // outcomes. This mutates or clones the children page,

  − // i.e. the page at level `cursor.pointer + 1`, returning an

  − // `Op` describing what happened (between update, merge,

  − // rebalance and split).

  − let merge = P::merge_or_rebalance(txn, &mut concat)?;
  [5.17539]

  [5.17625]
  + // Execute the modification plan, resulting in one of four

  + // different outcomes (described in the big match in

  + // `handle_merge`). This mutates or clones the current

  + // modified page, returning an `Op` describing what happened

  + // (between update, merge, rebalance and split).

  + let merge = P::merge_or_rebalance(txn, concat)?;
• replacement in sanakirja-core/src/btree/del.rs at line 112
  [5.17626]→[5.17626:17696](∅→∅),[5.17696]→[5.1079:1200](∅→∅),[5.1200]→[5.30987:31025](∅→∅),[5.17789]→[5.30987:31025](∅→∅),[5.7002]→[5.30987:31025](∅→∅)
  − // Prepare a description (`last_op`) of the page modification

  − // to be performed at level `p` (i.e. at level

  − // `cursor.pointer`), without mutating/cloning that page.

  − let mil = concat.mod_is_left;
  [5.17626]

  [5.2511]
  + // Prepare a description (`last_op`) of the next page

  + // modification, without mutating nor cloning that page.
• replacement in sanakirja-core/src/btree/del.rs at line 119
  [5.8769]→[5.8769:8824](∅→∅)
  − if cursor.pointer() >= cursor.first_rc_level {
  [5.8769]

  [5.8824]
  + //

  + // Since `handle_merge` pops the stack, the modified page is

  + // at level `cursor.len() + 1`.

  + if cursor.len() + 1 >= cursor.first_rc_len {
• replacement in sanakirja-core/src/btree/del.rs at line 127
  [5.32228]→[5.17870:17985](∅→∅),[5.17985]→[5.8874:8927](∅→∅)
  − // The last operation was on the root (i.e. at level 1), and that

  − // operation still needs to be executed.

  − let root_is_shared = cursor.first_rc_level == 0;
  [5.32228]

  [5.8927]
  + // The last modification plan was on the root, and still needs to

  + // be executed.

  + let root_is_shared = cursor.first_rc_len == 1;
• replacement in sanakirja-core/src/btree/del.rs at line 161
  [5.2827]→[5.1527:1674](∅→∅)
  − let is_rc = cursor.pointer() >= cursor.first_rc_level;

  − let del_at_internal = p0 < cursor.pointer();

  − let ref mut curs0 = cursor.last();
  [5.2827]

  [5.11652]
  + let is_rc = cursor.len() >= cursor.first_rc_len;

  + let del_at_internal = p0 < cursor.len();

  + let curs0 = cursor.pop().unwrap();
• replacement in sanakirja-core/src/btree/del.rs at line 171
  [5.9352]→[4.7256:7344](∅→∅)
  − let (k, v, _) = P::current(txn, unsafe { curs0.page.as_page() }, &c1).unwrap();
  [5.9352]

  [5.1806]
  + let (k, v, _) = P::current(txn, curs0.page.as_page(), &c1).unwrap();
• replacement in sanakirja-core/src/btree/del.rs at line 195
  [5.61790]→[5.2008:2068](∅→∅)
  − /// From a cursor at level `p = cursor.pointer()`, form the
  [5.61790]

  [5.2068]
  + /// From a cursor at level `p = cursor.len()`, form the
• replacement in sanakirja-core/src/btree/del.rs at line 211
  [5.19536]→[5.2053:2083](∅→∅),[5.2083]→[5.2201:2243](∅→∅)
  − let p = cursor.pointer();

  − let rc_level = cursor.first_rc_level;
  [5.19536]

  [5.33754]
  + let p = cursor.len();

  + let rc_level = cursor.first_rc_len;
• replacement in sanakirja-core/src/btree/del.rs at line 224
  [5.2697]→[4.7345:7442](∅→∅)
  − let other = txn.load_page(P::left_child(unsafe { curs.page.as_page() }, &curs.cursor))?;
  [5.2697]

  [5.2783]
  + let other = txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))?;
• replacement in sanakirja-core/src/btree/del.rs at line 249
  [5.3889]→[4.7443:7936](∅→∅)
  − let ((k, v, r), mod_is_left) = if let Some(x) =

  − P::current(txn, unsafe { curs.page.as_page() }, &curs.cursor)

  − {

  − // Not the last element of the page.

  − (x, true)

  − } else {

  − // Last element of the page.

  − let (k, v, _) = P::prev(txn, unsafe { curs.page.as_page() }, &mut curs.cursor).unwrap();

  − let l = P::left_child(unsafe { curs.page.as_page() }, &curs.cursor);

  − ((k, v, l), false)

  − };
  [5.3889]

  [5.62649]
  + let ((k, v, r), mod_is_left) =

  + if let Some(x) = P::current(txn, curs.page.as_page(), &curs.cursor) {

  + // Not the last element of the page.

  + (x, true)

  + } else {

  + // Last element of the page.

  + 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);

  + ((k, v, l), false)

  + };
• replacement in sanakirja-core/src/btree/del.rs at line 282
  [5.4516]→[5.4516:4539](∅→∅)
  − /// cursor.pointer()`.
  [5.4516]

  [5.33961]
  + /// cursor.len()`.
• replacement in sanakirja-core/src/btree/del.rs at line 298
  [5.20246]→[5.2084:2144](∅→∅)
  − let mutable = cursor.pointer() < cursor.first_rc_level;
  [5.20246]

  [5.34437]
  + let mutable = cursor.len() < cursor.first_rc_len;
• replacement in sanakirja-core/src/btree/del.rs at line 300
  [5.34461]→[5.34461:34502](∅→∅)
  − let curs = cursor.current_mut();
  [5.34461]

  [5.11763]
  + // Beware, a stack pop happens here, all subsequent references

  + // to the pointer must be updated.

  + let curs = cursor.pop().unwrap();
• replacement in sanakirja-core/src/btree/del.rs at line 317
  [5.4610]→[5.4610:4679](∅→∅)
  − // level `cursor.pointer() + 1`, and build the modification plan
  [5.4610]

  [5.4679]
  + // level `cursor.len() + 1`, and build the modification plan
• replacement in sanakirja-core/src/btree/del.rs at line 319
  [5.4735]→[5.4735:4763](∅→∅)
  − // `cursor.pointer()`).
  [5.4735]

  [5.34844]
  + // `cursor.len()`).
• replacement in sanakirja-core/src/btree/del.rs at line 359
  [5.35589]→[5.35589:35660](∅→∅)
  − // deleting at an internal node (i.e. if cursor.pointer ==
  [5.35589]

  [5.35660]
  + // deleting at an internal node (i.e. if cursor.len ==
• replacement in sanakirja-core/src/btree/del.rs at line 361
  [5.35718]→[5.2145:2185](∅→∅)
  − if cursor.pointer() == p0 {
  [5.35718]

  [5.5364]
  + if cursor.len() + 1 == p0 {
• replacement in sanakirja-core/src/btree/del.rs at line 389
  [5.36543]→[5.5478:5540](∅→∅)
  − let split_key_is_k0 = if cursor.pointer() == p0 {
  [5.36543]

  [5.36581]
  + let split_key_is_k0 = if cursor.len() + 1 == p0 {
• replacement in sanakirja-core/src/btree/del.rs at line 409
  [5.6125]→[5.6125:6177](∅→∅)
  − assert!(cursor.pointer() < p0);
  [5.6125]

  [5.11938]
  + assert!(cursor.len() + 1 < p0);
• replacement in sanakirja-core/src/btree/del.rs at line 420
  [5.20503]→[5.2227:2310](∅→∅)
  − if cursor.pointer() + 1 >= cursor.first_rc_level && !split_key_is_k0 {
  [5.37212]

  [5.37710]
  + if cursor.len() + 2 >= cursor.first_rc_len && !split_key_is_k0 {
• replacement in sanakirja-core/src/btree/del.rs at line 428
  [5.110]→[5.6377:6445](∅→∅)
  − // Free the page(s) at level `cursor.pointer() + 1` if it isn't
  [5.37905]

  [5.6445]
  + // Free the page(s) at level `cursor.len() + 1` if it isn't
• replacement in sanakirja-core/src/btree/del.rs at line 431
  [5.110]→[5.2311:2361](∅→∅),[5.6539]→[5.2311:2361](∅→∅),[5.37905]→[5.2311:2361](∅→∅),[5.2361]→[5.6540:6584](∅→∅)
  − if cursor.pointer() < cursor.first_rc_level {

  − free[cursor.pointer() + 1] = freed;
  [5.6539]

  [5.62825]
  + if cursor.len() + 1 < cursor.first_rc_len {

  + free[cursor.len() + 1] = freed;
• replacement in sanakirja-core/src/btree/del.rs at line 452
  [5.63098]→[4.7937:8090](∅→∅)
  − let mut left = P::left_child(unsafe { m.page.as_page() }, &c0);

  − while let Some((k, v, r)) = P::next(txn, unsafe { m.page.as_page() }, &mut c0) {
  [5.63098]

  [5.9970]
  + let mut left = P::left_child(m.page.as_page(), &c0);

  + while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c0) {
• replacement in sanakirja-core/src/btree/del.rs at line 478
  [5.10639]→[4.8091:8173](∅→∅)
  − if let Some((k, v, r)) = P::next(txn, unsafe { m.page.as_page() }, &mut c1) {
  [5.10639]

  [5.10710]
  + if let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1) {
• replacement in sanakirja-core/src/btree/del.rs at line 487
  [5.10942]→[4.8174:8259](∅→∅)
  − while let Some((k, v, r)) = P::next(txn, unsafe { m.page.as_page() }, &mut c1) {
  [5.10942]

  [5.11016]
  + while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1) {
• replacement in sanakirja-core/src/btree/cursor.rs at line 20
  [5.64601]→[5.64601:64743](∅→∅),[5.64743]→[5.13695:13781](∅→∅)
  − // of a B tree below the root has at least 4 elements, the arity is at

  − // least 5, except for the root. Since 5^23 is the smallest power of 5

  − // larger than 2^52, the maximum depth is 24.

  − pub(crate) const N_CURSORS: usize = 24;
  [5.64601]

  [5.64882]
  + // of a B tree below the root has at least 2 elements (because each

  + // page is at least half-full, and elements are at most 1/4th of a

  + // page), the arity is at least 3, except for the root. Since 3^33 is

  + // the smallest power of 3 larger than 2^52, the maximum depth is 33.

  + pub(crate) const N_CURSORS: usize = 33;
• replacement in sanakirja-core/src/btree/cursor.rs at line 32
  [5.2653]→[5.65137:65168](∅→∅),[5.24741]→[5.65137:65168](∅→∅),[5.65137]→[5.65137:65168](∅→∅),[5.65168]→[5.2654:2674](∅→∅)
  − pub first_rc_level: usize,

  − pointer: usize,
  [5.2653]

  [5.65192]
  + pub first_rc_len: usize,

  + len: usize,
• edit in sanakirja-core/src/btree/cursor.rs at line 38
  [5.10907]

  [5.13800]
  + // Looking forward to getting array initialisation stabilised :)
• edit in sanakirja-core/src/btree/cursor.rs at line 40
  [5.13826]

  [5.13826]
  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),

  + core::mem::MaybeUninit::uninit(),
• replacement in sanakirja-core/src/btree/cursor.rs at line 81
  [5.65572]→[5.65572:65611](∅→∅),[5.65611]→[5.647:671](∅→∅)
  − first_rc_level: N_CURSORS,

  − pointer: 0,
  [5.65572]

  [5.11045]
  + first_rc_len: N_CURSORS,

  + len: 1,
• replacement in sanakirja-core/src/btree/cursor.rs at line 87
  [5.1841]→[5.3484:3566](∅→∅),[5.7419]→[5.3484:3566](∅→∅),[5.3484]→[5.3484:3566](∅→∅)
  − self.pointer += 1;

  − self.stack[self.pointer] = MaybeUninit::new(p)
  [5.7419]

  [5.65645]
  + self.stack[self.len] = MaybeUninit::new(p);

  + self.len += 1;
• edit in sanakirja-core/src/btree/cursor.rs at line 90
  [5.65651]→[5.3567:3568](∅→∅),[5.3568]→[5.7420:7484](∅→∅),[5.1909]→[5.3625:3688](∅→∅),[5.7484]→[5.3625:3688](∅→∅),[5.3625]→[5.3625:3688](∅→∅),[5.3688]→[5.3688:3694](∅→∅)
  −

  − pub(super) fn last(&mut self) -> &mut PageCursor<K, V, P> {

  − unsafe { &mut *self.stack[self.pointer].as_mut_ptr() }

  − }
• replacement in sanakirja-core/src/btree/cursor.rs at line 94
  [5.1972]→[5.65821:65876](∅→∅),[5.7544]→[5.65821:65876](∅→∅),[5.25007]→[5.65821:65876](∅→∅),[5.65821]→[5.65821:65876](∅→∅)
  − unsafe { &*self.stack[self.pointer].as_ptr() }
  [5.7544]

  [5.65876]
  + assert!(self.len > 0);

  + unsafe { &*self.stack[self.len - 1].as_ptr() }
• replacement in sanakirja-core/src/btree/cursor.rs at line 98
  [5.65883]→[5.7545:7589](∅→∅),[5.2020]→[5.3732:3753](∅→∅),[5.7589]→[5.3732:3753](∅→∅),[5.3732]→[5.3732:3753](∅→∅)
  − pub(super) fn pointer(&self) -> usize {

  − self.pointer
  [5.65883]

  [5.3753]
  + pub(super) fn len(&self) -> usize {

  + self.len
• replacement in sanakirja-core/src/btree/cursor.rs at line 102
  [5.3760]→[5.7590:7625](∅→∅),[5.2059]→[5.672:707](∅→∅),[5.7625]→[5.672:707](∅→∅),[5.3788]→[5.672:707](∅→∅),[5.707]→[5.3788:3814](∅→∅),[5.3788]→[5.3788:3814](∅→∅)
  − pub(super) fn pop(&mut self) {

  − assert!(self.pointer > 0);

  − self.pointer -= 1
  [5.3760]

  [5.3814]
  + pub(super) fn pop(&mut self) -> Option<PageCursor<K, V, P>> {

  + if self.len > 0 {

  + self.len -= 1;

  + let result = core::mem::replace(&mut self.stack[self.len], MaybeUninit::uninit());

  + Some(unsafe { result.assume_init() })

  + } else {

  + None

  + }
• replacement in sanakirja-core/src/btree/cursor.rs at line 113
  [5.2134]→[5.33974:34037](∅→∅),[5.7697]→[5.33974:34037](∅→∅),[5.25072]→[5.33974:34037](∅→∅),[5.33974]→[5.33974:34037](∅→∅)
  − unsafe { &mut *self.stack[self.pointer].as_mut_ptr() }
  [5.7697]

  [5.34037]
  + assert!(self.len > 0);

  + unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() }
• replacement in sanakirja-core/src/btree/cursor.rs at line 126
  [5.7738]→[5.7738:7764](∅→∅)
  − self.pointer = 0;
  [5.7738]

  [5.7764]
  + self.len = 1;
• replacement in sanakirja-core/src/btree/cursor.rs at line 132
  [5.66237]→[5.2507:2548](∅→∅),[5.2548]→[5.757:810](∅→∅),[5.34163]→[5.2548:2648](∅→∅),[5.810]→[5.2548:2648](∅→∅),[5.1601]→[5.2548:2648](∅→∅),[5.2548]→[5.2548:2648](∅→∅),[5.2648]→[5.15041:15168](∅→∅),[5.15168]→[5.66450:66501](∅→∅),[5.1748]→[5.66450:66501](∅→∅),[5.66450]→[5.66450:66501](∅→∅)
  − while self.pointer < N_CURSORS {

  − debug!("set cursor {:?}", self.pointer);

  − let current = unsafe { &mut *self.stack.get_unchecked_mut(self.pointer).as_mut_ptr() };

  − // let page = current.page;

  − if self.first_rc_level >= N_CURSORS && txn.rc(current.page.offset)? >= 2 {

  − self.first_rc_level = self.pointer
  [5.66237]

  [5.66501]
  + while self.len < N_CURSORS {

  + debug!("set cursor {:?}", self.len);

  + let current = unsafe { &mut *self.stack.get_unchecked_mut(self.len - 1).as_mut_ptr() };

  + if self.first_rc_len >= N_CURSORS && txn.rc(current.page.offset)? >= 2 {

  + self.first_rc_len = self.len
• replacement in sanakirja-core/src/btree/cursor.rs at line 141
  [5.66731]→[4.8260:8407](∅→∅)
  − if let Ok((kk, vv, _)) =

  − P::set_cursor(txn, unsafe { current.page.as_page() }, cursor, k, v)

  − {
  [5.66731]

  [5.66814]
  + if let Ok((kk, vv, _)) = P::set_cursor(txn, current.page.as_page(), cursor, k, v) {
• replacement in sanakirja-core/src/btree/cursor.rs at line 146
  [5.66973]→[5.66973:67027](∅→∅)
  − last_matching_page = self.pointer
  [5.66973]

  [5.848]
  + last_matching_page = self.len
• replacement in sanakirja-core/src/btree/cursor.rs at line 153
  [5.67059]→[4.8408:8494](∅→∅)
  − let next_page = P::left_child(unsafe { current.page.as_page() }, cursor);
  [5.67059]

  [5.67163]
  + let next_page = P::left_child(current.page.as_page(), cursor);
• replacement in sanakirja-core/src/btree/cursor.rs at line 165
  [5.34799]→[5.67513:67560](∅→∅),[5.1017]→[5.67513:67560](∅→∅),[5.67513]→[5.67513:67560](∅→∅)
  − self.pointer = last_matching_page;
  [5.1017]

  [5.67560]
  + self.len = last_matching_page;
• replacement in sanakirja-core/src/btree/cursor.rs at line 177
  [5.67886]→[5.11312:11427](∅→∅)
  − assert_eq!(self.pointer, 0);

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

  [5.15527]
  + self.len = 1;

  + let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
• replacement in sanakirja-core/src/btree/cursor.rs at line 181
  [5.67901]→[5.67901:67983](∅→∅),[5.67983]→[5.11493:11535](∅→∅),[5.11535]→[5.67983:68121](∅→∅),[5.67983]→[5.67983:68121](∅→∅)
  − let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };

  − debug!("{:?}", current.page);

  − if self.first_rc_level >= N_CURSORS && txn.rc(current.page.offset)? >= 2 {

  − self.first_rc_level = self.pointer
  [5.67901]

  [5.68121]
  + let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };

  + if self.first_rc_len >= N_CURSORS && txn.rc(current.page.offset)? >= 2 {

  + self.first_rc_len = self.len
• replacement in sanakirja-core/src/btree/cursor.rs at line 185
  [5.68135]→[5.11536:11589](∅→∅),[5.11589]→[4.8495:8621](∅→∅)
  − debug!("cursor = {:?}", current.cursor);

  − let (k, v, r) =

  − P::current(txn, unsafe { current.page.as_page() }, &mut current.cursor).unwrap();
  [5.68135]

  [5.68404]
  + 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 187
  [5.68443]→[5.11689:11744](∅→∅)
  − debug!("k {:?} v {:?} r = {:?}", k, v, r);
• replacement in sanakirja-core/src/btree/cursor.rs at line 214
  [5.68948]→[5.1185:1233](∅→∅),[5.1233]→[5.0:82](∅→∅),[5.68948]→[5.0:82](∅→∅)
  − debug!("next: {:?}", self.pointer);

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

  [5.15636]
  + debug!("next: {:?}", self.len);

  + let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
• replacement in sanakirja-core/src/btree/cursor.rs at line 217
  [5.15681]→[4.8622:8717](∅→∅)
  − let left = P::right_child(unsafe { current.page.as_page() }, &current.cursor);
  [5.15681]

  [5.13357]
  + let left = P::right_child(current.page.as_page(), &current.cursor);
• replacement in sanakirja-core/src/btree/cursor.rs at line 227
  [5.12618]→[4.8718:8846](∅→∅)
  − } else if let Some((k, v, r)) =

  − P::current(txn, unsafe { current.page.as_page() }, &current.cursor)
  [5.12618]

  [5.8172]
  + } else if let Some((k, v, r)) = P::current(txn, current.page.as_page(), &current.cursor)
• replacement in sanakirja-core/src/btree/cursor.rs at line 238
  [5.13077]→[5.13077:13146](∅→∅)
  − } else if self.pointer > 0 {

  − self.pop();
  [5.13077]

  [5.664]
  + } else if self.len > 1 {

  + self.len -= 1
• replacement in sanakirja-core/src/btree/cursor.rs at line 249
  [5.13321]→[5.13321:13403](∅→∅)
  − let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };
  [5.13321]

  [5.8286]
  + let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
• replacement in sanakirja-core/src/btree/cursor.rs at line 252
  [5.8347]→[5.8347:8406](∅→∅)
  − self.pointer, current.page, current.cursor
  [5.8347]

  [5.8406]
  + self.len, current.page, current.cursor
• replacement in sanakirja-core/src/btree/cursor.rs at line 256
  [5.614]→[4.8847:8941](∅→∅)
  − let left = P::left_child(unsafe { current.page.as_page() }, &current.cursor);
  [5.614]

  [5.2606]
  + let left = P::left_child(current.page.as_page(), &current.cursor);
• replacement in sanakirja-core/src/btree/cursor.rs at line 266
  [5.13856]→[4.8942:9070](∅→∅)
  − } else if let Some((k, v, _)) =

  − P::current(txn, unsafe { current.page.as_page() }, &current.cursor)
  [5.13856]

  [5.8523]
  + } else if let Some((k, v, _)) = P::current(txn, current.page.as_page(), &current.cursor)
• replacement in sanakirja-core/src/btree/cursor.rs at line 269
  [5.668]→[4.9071:9162](∅→∅)
  − let l = P::left_child(unsafe { current.page.as_page() }, &current.cursor);
  [5.668]

  [5.14115]
  + let l = P::left_child(current.page.as_page(), &current.cursor);
• replacement in sanakirja-core/src/btree/cursor.rs at line 280
  [5.8579]→[5.14372:14413](∅→∅),[5.14372]→[5.14372:14413](∅→∅)
  − } else if self.pointer > 0 {
  [5.8579]

  [5.669]
  + } else if self.len > 1 {
• replacement in sanakirja-core/src/btree/cursor.rs at line 282
  [5.700]→[5.14413:14441](∅→∅),[5.14413]→[5.14413:14441](∅→∅),[5.14441]→[5.2982:3068](∅→∅)
  − self.pop();

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

  [5.13573]
  + self.len -= 1;

  + let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
• replacement in sanakirja/src/tests.rs at line 199
  [5.724]→[5.11554:11608](∅→∅)
  − crate::debug::debug(&txn, &[&db], "debug", true);
  [5.724]

  [5.11608]
  + crate::debug::debug(&txn, &[&db, &db2], "debug", true);
• edit in sanakirja/src/tests.rs at line 202
  [5.772]

  [5.11640]
  + crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
• replacement in sanakirja/src/tests.rs at line 227
  [5.25993]→[5.25993:26016](∅→∅)
  − let n = 20 as u64;
  [5.25993]

  [5.6021]
  + let n = 19 as u64;
• edit in sanakirja/src/tests.rs at line 239
  [5.6386]

  [5.1460]
  + crate::debug::debug(&txn, &[&db, &db2], "debug0", true);
• edit in sanakirja/src/tests.rs at line 248
  [5.6527]

  [5.6527]
  + crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
• edit in sanakirja/src/tests.rs at line 264
  [5.7121]

  [5.7121]
  + debug!("{:?}", *k);
• replacement in sanakirja/src/tests.rs at line 349
  [5.15485]→[5.15485:15543](∅→∅)
  − let mut c = P::cursor_first(p.as_page());
  [5.15485]

  [5.8297]
  + let mut c = P::cursor_first(&p);
• replacement in sanakirja/src/tests.rs at line 699
  [5.15822]→[5.15822:15874](∅→∅)
  − let cursor = P::cursor_first(pp.as_page());
  [5.15822]

  [5.15874]
  + let cursor = P::cursor_first(&pp);
• replacement in sanakirja/src/debug.rs at line 28
  [5.663]→[5.18042:18218](∅→∅)
  − print_page::<T, K, V, PP>(

  − t,

  − &mut h,

  − &mut buf,

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

  − recurse,

  − );
  [5.663]

  [5.746]
  + print_page::<T, K, V, PP>(t, &mut h, &mut buf, &t.load_page(db.db).unwrap(), recurse);
• replacement in sanakirja/src/debug.rs at line 42
  [5.1032]→[5.1032:1046](∅→∅)
  − p: &Page,
  [5.1032]

  [5.1046]
  + p: &CowPage,
• replacement in sanakirja/src/debug.rs at line 69
  [5.1743]→[5.1743:1831](∅→∅)
  − print_page::<T, K, V, P>(txn, pages, buf, &p.as_page(), print_children)
  [5.1743]

  [5.1831]
  + print_page::<T, K, V, P>(txn, pages, buf, &p, print_children)
• replacement in sanakirja/src/debug.rs at line 85
  [5.2136]→[5.2136:2150](∅→∅)
  − p: &Page,
  [5.2136]

  [5.2150]
  + p: &CowPage,
• replacement in sanakirja/src/debug.rs at line 89
  [5.2191]→[5.18219:18261](∅→∅)
  − let mut cursor = P::cursor_first(*p);
  [5.2191]

  [5.2233]
  + let mut cursor = P::cursor_first(p);
• replacement in sanakirja/src/debug.rs at line 91
  [5.2252]→[5.2252:2292](∅→∅)
  − let l = P::left_child(*p, &cursor);
  [5.2252]

  [5.2292]
  + let l = P::left_child(p.as_page(), &cursor);
• replacement in sanakirja/src/debug.rs at line 99
  [5.2481]→[2.0:68](∅→∅)
  − while let Some((key, val, r)) = P::next(txn, *p, &mut cursor) {
  [5.2481]

  [5.2547]
  + while let Some((key, val, r)) = P::next(txn, p.as_page(), &mut cursor) {
• edit in sanakirja/Cargo.toml at line 27
  [5.6555]

  [5.5524]
  + uuid = { version = "*", features = [ "v4" ] }