pmeunier/sanakirja-1.0 - Change LSQ6V7M66TEGLJ7QBLRVDX4E7UKJTDQTEXZOS3KGPGFKVXNLPKBQC

Cleanup + docs

Created by pmeunier on February 13, 2021

LSQ6V7M66TEGLJ7QBLRVDX4E7UKJTDQTEXZOS3KGPGFKVXNLPKBQC

Dependencies

In channels

main

Change contents

Insertion in sanakirja-core/src/lib.rs at line 1 [5.91]
[5.91]
[6.0]
```
#![no_std]
```

Replacement in sanakirja-core/src/lib.rs at line 5 [5.91]

B:BD[6.140] → [6.140:255]

//! memory-mapped files, but if that environment is threatened, might
//! seek refuge in lower-level environments.

[6.140]

[6.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.91]
∅:D[6.1317] → [5.92:103]
B:BD[5.91] → [5.92:103]
```
#![no_std]
```
[6.1317]
[5.103]

Insertion in sanakirja-core/src/lib.rs at line 31 [5.91]

[7.1]

/// There's a hard-coded assumption that pages have 4K bytes. This is
/// true for normal memory pages on almost all platforms.

Insertion in sanakirja-core/src/lib.rs at line 35 [5.91]
[5.119]
[8.0]
```
/// Types that can be stored on disk.
```

Deletion in sanakirja-core/src/lib.rs at line 37 [5.91]

∅:D[8.44] → [5.148:444]

∅:D[9.26] → [5.148:444]

B:BD[5.148] → [5.148:444]

B:BD[5.444] → [7.37:115]

∅:D[10.65] → [5.505:506]

∅:D[7.115] → [5.505:506]

∅:D[9.95] → [5.505:506]

B:BD[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;

Insertion in sanakirja-core/src/lib.rs at line 41 [5.91]

[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

Insertion in sanakirja-core/src/lib.rs at line 48 [5.91]

[5.732]

[11.0]


    /// If `Self::SIZE.is_some()`, this must return the same
    /// value. The default implementation is `Self;:SIZE.unwrap()`.

Insertion in sanakirja-core/src/lib.rs at line 54 [5.91]

[11.64]

[7.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]`).

Insertion in sanakirja-core/src/lib.rs at line 59 [5.91]

[7.196]

[11.65]


    /// Read the size from an on-page entry. If `Self::SIZE.is_some()`
    /// this must be the same value.

Insertion in sanakirja-core/src/lib.rs at line 65 [5.91]

[11.150]

[12.50]


    /// Write to a page. Must not overwrite the allocated size, but
    /// this isn't checkde (which is why it's unsafe).

Insertion in sanakirja-core/src/lib.rs at line 69 [5.91]

[12.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.91]
∅:D[7.280] → [13.73:86]
B:BD[13.73] → [13.73:86]
```
    txn: &T,
```
[7.280]
[13.86]
```
    _txn: &T,
```
Replacement in sanakirja-core/src/lib.rs at line 154 [5.91]
∅:D[12.1476] → [9.575:621]
∅:D[13.134] → [9.575:621]
B:BD[9.575] → [9.575:621]
```
    let s = K::size(K::from_raw_ptr(txn, k));
```
[13.134]
[5.1641]
```
    let s = K::onpage_size(k);
```
Replacement in sanakirja-core/src/lib.rs at line 179 [5.91]
B:BD[5.2399] → [6.1478:1508]
∅:D[6.1508] → [5.2399:2429]
B:BD[5.2399] → [5.2399:2429]
```
/// Representation of a page.
#[derive(Debug, Clone, Copy)]
```
[5.2399]
[14.261]
```
/// Representation of a mutable or shared page.
#[derive(Debug)]
#[repr(C)]
```
Insertion in sanakirja-core/src/lib.rs at line 188 [5.91]
[5.2524]
[14.316]
```
#[repr(C)]
```
Replacement in sanakirja-core/src/lib.rs at line 195 [5.91]
B:BD[14.412] → [4.0:43]
```
    pub unsafe fn as_page(&self) -> Page {
```
[14.412]
[6.1509]
```
    pub fn as_page(&self) -> Page {
```

Replacement in sanakirja-core/src/lib.rs at line 197 [5.91]

B:BD[6.1524] → [4.44:103]

            data: &*(self.data as *const [u8; PAGE_SIZE]),

[6.1524]

[6.1594]

            data: unsafe { &*(self.data as *const [u8; PAGE_SIZE]) },

Replacement in sanakirja-core/src/btree/put.rs at line 31 [5.3448]

∅:D[15.475] → [5.4449:4485]

∅:D[14.674] → [5.4449:4485]

B:BD[5.4449] → [5.4449:4485]

    let ref cur = cursor.current();

[15.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.3448]
B:BD[5.4538] → [16.0:50]
```
        cursor.pointer() < cursor.first_rc_level,
```
[5.4538]
[17.0]
```
        is_owned,
```
Deletion in sanakirja-core/src/btree/put.rs at line 65 [5.3448]
B:BD[5.4718] → [15.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.3448]
B:BD[15.1695] → [15.1695:1696]
[15.1695]
[15.1696]
```
                debug!("Want to split the root");
```

Replacement in sanakirja-core/src/btree/put.rs at line 105 [5.3448]

∅:D[15.1770] → [16.81:123]

B:BD[16.81] → [16.81:123]

B:BD[16.123] → [15.1771:1911]

∅:D[15.1911] → [8.79:113]

B:BD[16.123] → [8.79:113]

∅:D[16.123] → [18.70:118]

∅:D[8.113] → [18.70:118]

B:BD[18.70] → [18.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();

[15.1770]

[18.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.3448]

B:BD[18.215] → [16.124:190]

                        cursor.pointer() < cursor.first_rc_level,

[18.215]

[17.16]

                        is_owned,

Replacement in sanakirja-core/src/btree/put.rs at line 124 [5.3448]

B:BD[18.532] → [15.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.

[18.532]

[14.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.3448]

∅:D[15.2656] → [16.221:263]

B:BD[16.221] → [16.221:263]

                if cursor.pointer() > 0 {

[15.2656]

[15.2657]

                let is_owned = cursor.len() < cursor.first_rc_len;
                if let Some(curs) = cursor.pop() {

Deletion in sanakirja-core/src/btree/put.rs at line 162 [5.3448]
∅:D[15.2729] → [8.114:148]
B:BD[16.263] → [8.114:148]
∅:D[16.263] → [18.573:626]
∅:D[8.148] → [18.573:626]
B:BD[18.573] → [18.573:626]
```
                    cursor.pop();
                    let ref curs = cursor.current();
```

Replacement in sanakirja-core/src/btree/put.rs at line 165 [5.3448]

B:BD[18.746] → [16.264:330]

                        cursor.pointer() < cursor.first_rc_level,

[18.746]

[19.233]

                        is_owned,

Replacement in sanakirja-core/src/btree/put.rs at line 191 [5.3448]
B:BD[13.1017] → [16.358:408]
```
    if cursor.pointer() < cursor.first_rc_level {
```
[5.7700]
[15.2893]
```
    if cursor.len() < cursor.first_rc_len {
```
Replacement in sanakirja-core/src/btree/put.rs at line 195 [5.3448]
∅:D[15.3053] → [16.409:449]
B:BD[5.7814] → [16.409:449]
```
        free[cursor.pointer()] = freed;
```
[15.3053]
[5.7852]
```
        free[cursor.len()] = freed;
```
Replacement in sanakirja-core/src/btree/put.rs at line 199 [5.3448]
∅:D[15.3172] → [16.450:505]
∅:D[8.227] → [16.450:505]
B:BD[20.92] → [16.450:505]
```
        if cursor.pointer() == cursor.first_rc_level {
```
[15.3172]
[5.7918]
```
        if cursor.len() == cursor.first_rc_len {
```
Replacement in sanakirja-core/src/btree/put.rs at line 201 [5.3448]
B:BD[5.7958] → [16.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.3448]

B:BD[6.2136] → [4.104:173]

        let left = P::left_child(unsafe { cur.page.as_page() }, &c);

[6.2136]

[15.3668]

        let left = P::left_child(cur.page.as_page(), &c);

Replacement in sanakirja-core/src/btree/put.rs at line 220 [5.3448]

B:BD[15.3887] → [4.174:264]

        while let Some((k, v, r)) = P::next(txn, unsafe { cur.page.as_page() }, &mut c) {

[15.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 [12.2014]

B:BD[12.5268] → [4.265:341]

            let l = header(unsafe { page.as_page() }).left_page() & !0xfff;

[12.5268]

[12.5333]

            let l = header(page.as_page()).left_page() & !0xfff;

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 100 [12.2014]

B:BD[12.5411] → [4.342:421]

            let s = Internal::offset_slice::<K, V>(unsafe { page.as_page() });

[12.5411]

[12.5479]

            let s = Internal::offset_slice::<K, V>(page.as_page());

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 102 [12.2014]

B:BD[12.5506] → [4.422:507]

            clone::<K, V, Internal>(unsafe { page.as_page() }, &mut new, s, &mut n);

[12.5506]

[6.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 [12.2014]
B:BD[12.8658] → [12.8658:8698]
```
        m: &mut Concat<'a, K, V, Self>,
```
[12.8658]
[12.8698]
```
        m: Concat<'a, K, V, Self>,
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 198 [12.2014]

B:BD[12.9028] → [4.508:568]

            let hdr = header(unsafe { m.other.as_page() });

[12.9028]

[12.9077]

            let hdr = header(m.other.as_page());

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 210 [12.2014]

[12.9489]

[17.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]
            };

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 220 [12.2014]

B:BD[12.9736] → [6.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 [12.2014]
B:BD[12.10070] → [12.10070:10145]
```
                freed: [m.modified.page.offset | b0, m.other.offset | b1],
```
[12.10070]
[12.10145]
```
                freed,
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 227 [12.2014]

B:BD[6.2466] → [4.569:657]

        let first_size = <Page<K, V>>::current_size(unsafe { m.other.as_page() }, &rc);

[6.2466]

[12.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 [12.2014]
B:BD[17.722] → [4.658:713]
```
        let hdr = header(unsafe { m.page.as_page() });
```
[17.722]
[17.766]
```
        let hdr = header(m.page.as_page());
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 286 [12.2014]

B:BD[17.1117] → [4.714:835]

        total -= <Page<K, V> as BTreePage<K, V>>::current_size(unsafe { m.page.as_page() }, &m.c1)
            as usize;

[17.1117]

[17.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 [12.2014]

B:BD[12.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) {

[12.19262]

[12.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 [12.2014]

B:BD[12.19817] → [4.1013:1111]

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

[12.19817]

[12.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 [12.2014]
B:BD[12.20250] → [12.20250:20288]
```
    m: &mut Concat<K, V, Page<K, V>>,
```
[12.20250]
[12.20288]
```
    mut m: Concat<K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 590 [12.2014]

B:BD[6.2962] → [4.1112:1189]

        let l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

[6.2962]

[12.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 [12.2014]

B:BD[12.20596] → [4.1190:1291]

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

[12.20596]

[12.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 [12.2014]

B:BD[6.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) {

[6.3014]

[12.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 [12.22926]
B:BD[12.23132] → [12.23132:23174]
```
    m: &mut Concat<'a, K, V, Page<K, V>>,
```
[12.23132]
[12.23174]
```
    m: Concat<'a, K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 19 [12.22926]

B:BD[6.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();

[6.3065]

[12.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)) };

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 27 [12.22926]
[21.1976]
[17.1615]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 41 [12.22926]

B:BD[22.225] → [4.1642:1727]

∅:D[4.1727] → [22.299:387]

B:BD[22.299] → [22.299:387]

                let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                    1
                } else {
                    0
                };

[22.225]

[22.387]

                let b = if is_dirty { 1 } else { 0 };

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 49 [12.22926]
[12.24156]
[21.1977]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 58 [12.22926]

B:BD[22.812] → [4.1728:1809]

∅:D[21.2108] → [22.877:949]

∅:D[4.1809] → [22.877:949]

B:BD[22.877] → [22.877:949]

            let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                1
            } else {
                0
            };

[22.812]

[22.949]

            let b = if is_dirty { 1 } else { 0 };

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 63 [12.22926]

B:BD[21.2129] → [6.3066:3116]

∅:D[6.3116] → [17.1699:1759]

B:BD[21.2188] → [17.1699:1759]

    let lc = PageCursor::after(&m.modified.page);
    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(

[21.2129]

[17.1759]

    let lc = PageCursor::after(&new_left.0);
    let new_left = if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 67 [12.22926]
∅:D[17.1842] → [21.2321:2375]
B:BD[21.2321] → [21.2321:2375]
```
        assert_eq!(page.0.offset, new_left.0.offset);
```
Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 68 [12.22926]
[21.2405]
[22.1018]
```
        page
```

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 73 [12.22926]

[12.24372]

[21.2406]

    let b = {
        let hdr = &*header(m.other.as_page());
        if hdr.is_dirty() {
            1
        } else {
            0
        }
    };

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 82 [12.22926]
B:BD[21.2497] → [21.2497:2587]
```
    let (k, v): (&K, &V) = unsafe { (core::mem::transmute(k), core::mem::transmute(v)) };
```
Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 83 [12.22926]
B:BD[21.2606] → [4.1810:1868]
∅:D[4.1868] → [12.24670:24722]
B:BD[12.24670] → [12.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 [12.22926]
B:BD[12.25161] → [12.25161:25203]
```
    m: &mut Concat<'a, K, V, Page<K, V>>,
```
[12.25161]
[12.25203]
```
    m: Concat<'a, K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 107 [12.22926]

B:BD[12.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();

[12.25320]

[12.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 [12.22926]

B:BD[6.3175] → [4.2033:2115]

    let rl = <Page<K, V>>::left_child(unsafe { m.modified.page.as_page() }, &rc);

[6.3175]

[12.25655]

    let rl = <Page<K, V>>::left_child(m.modified.page.as_page(), &rc);

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 117 [12.22926]
[21.2697]
[17.1843]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 131 [12.22926]

B:BD[22.1252] → [4.2116:2201]

∅:D[4.2201] → [22.1326:1414]

B:BD[22.1326] → [22.1326:1414]

                let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                    1
                } else {
                    0
                };

[22.1252]

[22.1414]

                let b = if is_dirty { 1 } else { 0 };

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 139 [12.22926]
[12.26272]
[21.2698]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 148 [12.22926]

B:BD[22.1533] → [4.2202:2283]

∅:D[21.2829] → [22.1599:1671]

∅:D[4.2283] → [22.1599:1671]

B:BD[22.1599] → [22.1599:1671]

            let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                1
            } else {
                0
            };

[22.1533]

[22.1671]

            let b = if is_dirty { 1 } else { 0 };

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 153 [12.22926]

B:BD[21.2850] → [6.3176:3234]

    if let Put::Ok(Ok { freed, .. }) = <Page<K, V>>::put(

[21.2850]

[17.1987]

    let new_right = if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 166 [12.22926]
[21.3070]
[12.26515]
```
        page
```

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 171 [12.22926]

[12.26559]

[21.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
        }
    };

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 183 [12.22926]
B:BD[21.3180] → [4.2284:2342]
∅:D[4.2342] → [12.26712:26764]
B:BD[12.26712] → [12.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 [12.22926]

B:BD[12.26893] → [12.26893:26989]

        k: unsafe { core::mem::transmute(k0) },
        v: unsafe { core::mem::transmute(v0) },

[12.26893]

[23.42]

        k,
        v,

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 30 [12.27023]

B:BD[21.3328] → [4.2343:2437]

        let cur_size = Internal::current_size::<K, V>(unsafe { page.as_page() }, u as isize);

[21.3328]

[21.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 [12.27023]
B:BD[21.3495] → [4.2438:2487]
```
    let hdr = header(unsafe { page.as_page() });
```
[21.3495]
[12.27583]
```
    let hdr = header(page.as_page());
```

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 38 [12.27023]

B:BD[12.27674] → [4.2488:2574]

    if mutable && is_dirty && L::can_alloc(header(unsafe { page.as_page() }), size) {

[12.27674]

[12.27757]

    if mutable && is_dirty && L::can_alloc(header(page.as_page()), size) {

Insertion in sanakirja-core/src/btree/page_unsized/put.rs at line 43 [12.27023]

[21.3556]

            let p = page.0.data;
            let hdr = header_mut(&mut page);

Deletion in sanakirja-core/src/btree/page_unsized/put.rs at line 47 [12.27023]
B:BD[21.3614] → [21.3614:3651]
```
                let p = page.0.data;
```
Deletion in sanakirja-core/src/btree/page_unsized/put.rs at line 52 [12.27023]
B:BD[21.3967] → [3.0:49]
```
                let hdr = header_mut(&mut page);
```

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 68 [12.27023]

B:BD[12.28439] → [4.2575:2643]

        let s = L::offset_slice::<K, V>(unsafe { page.as_page() });

[12.28439]

[12.28496]

        let s = L::offset_slice::<K, V>(page.as_page());

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 72 [12.27023]

B:BD[12.28566] → [4.2644:2719]

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

[12.28566]

[12.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 [12.27023]

B:BD[12.28882] → [4.2720:2795]

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

[12.28882]

[24.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 [12.27023]

B:BD[12.29136] → [4.2796:3023]

        return split_unsized::<_, _, _, L>(
            txn,
            unsafe { page.as_page() },
            replace,
            u,
            k0,
            v0,
            k1v1,
            l,
            r,
        );

[12.29136]

[12.29224]

        return split_unsized::<_, _, _, L>(txn, page.as_page(), replace, u, k0, v0, k1v1, l, r);

Insertion in sanakirja-core/src/btree/page.rs at line 14 [5.8623]

[25.95]

[12.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.

Deletion in sanakirja-core/src/btree/page.rs at line 26 [5.8623]

B:BD[5.8683] → [26.279:494]

B:BD[26.494] → [26.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.8623]

B:BD[17.2954] → [17.2954:2996]

            let f = tuple_size::<K, V>();

[17.2954]

[17.2996]

            let f = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page.rs at line 87 [5.8623]

B:BD[17.4139] → [17.4139:4176]

                tuple_size::<K, V>()

[17.4139]

[17.4176]

                core::mem::size_of::<Tuple<K, V>>()

Replacement in sanakirja-core/src/btree/page.rs at line 146 [5.8623]

B:BD[17.5875] → [17.5875:5929]

                        let f = tuple_size::<K, V>();

[17.5875]

[17.5929]

                        let f = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page.rs at line 264 [5.8623]

B:BD[9.1693] → [4.3024:3100]

            let l = header(unsafe { page.as_page() }).left_page() & !0xfff;

[9.1693]

[27.320]

            let l = header(page.as_page()).left_page() & !0xfff;

Replacement in sanakirja-core/src/btree/page.rs at line 267 [5.8623]

B:BD[25.328] → [4.3101:3183]

            let s = Internal::offset_slice::<T, K, V>(unsafe { page.as_page() });

[25.328]

[14.2431]

            let s = Internal::offset_slice::<T, K, V>(page.as_page());

Replacement in sanakirja-core/src/btree/page.rs at line 269 [5.8623]

B:BD[14.2458] → [4.3184:3269]

            clone::<K, V, Internal>(unsafe { page.as_page() }, &mut new, s, &mut n);

[14.2458]

[6.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.8623]

B:BD[10.1693] → [26.1439:1485]

                let f = tuple_size::<K, V>();

[10.1693]

                let f = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page.rs at line 359 [5.8623]
B:BD[5.15740] → [9.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.8623]

B:BD[5.15906] → [26.1486:1528]

            let f = tuple_size::<K, V>();

[5.15906]

[12.45058]

            let f = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page.rs at line 372 [5.8623]

B:BD[14.5253] → [4.3270:3330]

            let hdr = header(unsafe { m.other.as_page() });

[14.5253]

[5.16415]

            let hdr = header(m.other.as_page());

Insertion in sanakirja-core/src/btree/page.rs at line 380 [5.8623]

[9.2861]

[17.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]
            };

Deletion in sanakirja-core/src/btree/page.rs at line 390 [5.8623]

B:BD[5.16918] → [6.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.8623]

B:BD[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.8623]

B:BD[6.3947] → [4.3331:3419]

        let first_size = <Page<K, V>>::current_size(unsafe { m.other.as_page() }, &rc);

[6.3947]

[10.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.8623]
B:BD[17.7721] → [4.3420:3475]
```
        let hdr = header(unsafe { m.page.as_page() });
```
[17.7721]
[17.7765]
```
        let hdr = header(m.page.as_page());
```

Replacement in sanakirja-core/src/btree/page.rs at line 459 [5.8623]

B:BD[17.8236] → [4.3476:3597]

        total -= <Page<K, V> as BTreePage<K, V>>::current_size(unsafe { m.page.as_page() }, &m.c1)
            as usize;

[17.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.8623]

B:BD[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]

[9.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.8623]

B:BD[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.8623]
B:BD[14.20528] → [9.6103:6141]
```
    m: &mut Concat<K, V, Page<K, V>>,
```
[14.20528]
[5.35590]
```
    mut m: Concat<K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page.rs at line 620 [5.8623]

B:BD[6.5784] → [4.3874:3951]

        let l = <Page<K, V>>::left_child(unsafe { m.other.as_page() }, &rc);

[6.5784]

[9.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.8623]

B:BD[9.6271] → [4.3952:4053]

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

[9.6271]

[9.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.8623]

B:BD[6.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) {

[6.5836]

[9.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.8623]

B:BD[5.39419] → [26.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 [25.387]
B:BD[25.628] → [9.7080:7122]
```
    m: &mut Concat<'a, K, V, Page<K, V>>,
```
[25.628]
[25.673]
```
    m: Concat<'a, K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 18 [25.387]

B:BD[6.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();

[6.5887]

[25.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 [25.387]

B:BD[25.1209] → [25.1209:1271]

    let mut new_left = if let Some((k, v)) = m.modified.ins {

[25.1209]

[17.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 [25.387]

B:BD[22.2040] → [4.4404:4489]

∅:D[4.4489] → [22.2114:2202]

B:BD[22.2114] → [22.2114:2202]

                let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                    1
                } else {
                    0
                };

[22.2040]

[22.2202]

                let b = if is_dirty { 1 } else { 0 };

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 46 [25.387]
[25.1650]
[21.7894]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 55 [25.387]

B:BD[21.7977] → [4.4490:4571]

∅:D[4.4571] → [21.8047:8119]

B:BD[21.8047] → [21.8047:8119]

            let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                1
            } else {
                0
            };

[21.7977]

[21.8119]

            let b = if is_dirty { 1 } else { 0 };

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 60 [25.387]

B:BD[25.1736] → [6.5888:5938]

∅:D[6.5938] → [17.8453:8513]

B:BD[28.1491] → [17.8453:8513]

    let lc = PageCursor::after(&m.modified.page);
    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(

[25.1736]

[17.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 [25.387]

∅:D[17.8596] → [22.2525:2548]

B:BD[22.2525] → [22.2525:2548]

B:BD[22.2548] → [4.4572:4648]

∅:D[4.4648] → [22.2613:2754]

B:BD[22.2613] → [22.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

[17.8596]

[22.2754]

        assert_eq!(freed, 0);
        page

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 70 [25.387]

B:BD[22.2798] → [4.4649:4707]

∅:D[4.4707] → [26.1754:1788]

B:BD[25.1916] → [26.1754:1788]

    let right_hdr = header(unsafe { m.other.as_page() });
    let f = tuple_size::<K, V>();

[22.2798]

[12.46209]

    let right_hdr = header(m.other.as_page());
    let f = core::mem::size_of::<Tuple<K, V>>();

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 100 [25.387]

[12.47398]

[21.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 [25.387]

B:BD[21.8290] → [4.4708:4770]

∅:D[4.4770] → [21.8341:8432]

B:BD[21.8341] → [21.8341:8432]

            let hdr = &*header(unsafe { m.other.as_page() });
            let b = if hdr.is_dirty() { 1 } else { 0 };
            freed_[1] = freed | b;

[21.8290]

[12.47416]

            freed_[1] = freed | if is_dirty { 1 } else { 0 };

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 108 [25.387]
B:BD[12.47426] → [21.8433:8509]
```
        unsafe { (page, core::mem::transmute(k), core::mem::transmute(v)) }
```
[12.47426]
[25.3471]
```
        (page, k, v)
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 113 [25.387]

B:BD[25.3752] → [25.3752:3846]

        k: unsafe { core::mem::transmute(k) },
        v: unsafe { core::mem::transmute(v) },

[25.3752]

[23.84]

        k,
        v,

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 128 [25.387]
B:BD[25.4069] → [9.7447:7489]
```
    m: &mut Concat<'a, K, V, Page<K, V>>,
```
[25.4069]
[25.4114]
```
    m: Concat<'a, K, V, Page<K, V>>,
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 132 [25.387]

B:BD[25.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();

[25.4231]

[25.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 [25.387]

B:BD[6.5997] → [4.4928:5010]

    let rl = <Page<K, V>>::left_child(unsafe { m.modified.page.as_page() }, &rc);

[6.5997]

[25.4561]

    let rl = <Page<K, V>>::left_child(m.modified.page.as_page(), &rc);

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 142 [25.387]
[21.8569]
[17.8597]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 155 [25.387]

B:BD[25.5094] → [4.5011:5092]

∅:D[4.5092] → [22.3032:3104]

B:BD[22.3032] → [22.3032:3104]

            let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                1
            } else {
                0
            };

[25.5094]

[22.3104]

            let b = if is_dirty { 1 } else { 0 };

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 162 [25.387]
[25.5178]
[21.8570]
```
        let is_dirty = m.modified.page.is_dirty();
```

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 171 [25.387]

B:BD[22.3205] → [4.5093:5174]

∅:D[21.8701] → [22.3271:3343]

∅:D[4.5174] → [22.3271:3343]

B:BD[22.3271] → [22.3271:3343]

            let b = if header(unsafe { m.modified.page.as_page() }).is_dirty() {
                1
            } else {
                0
            };

[22.3205]

[22.3343]

            let b = if is_dirty { 1 } else { 0 };

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 176 [25.387]

B:BD[21.8722] → [17.8681:8741]

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

[21.8722]

[17.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 [25.387]
B:BD[21.8887] → [21.8887:8942]
```
        assert_eq!(new_right.0.offset, page.0.offset);
```
[21.8887]
[25.5421]
```
        page
```

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 194 [25.387]

[25.5465]

[21.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 [25.387]

B:BD[21.9052] → [4.5175:5233]

∅:D[4.5233] → [25.5618:5670]

B:BD[25.5618] → [25.5618:5670]

B:BD[25.5670] → [21.9053:9083]

        let hdr = &*header(unsafe { m.other.as_page() });
        let b = if hdr.is_dirty() { 1 } else { 0 };
        freed_[1] = freed | b

[21.9052]

[25.5708]

        freed_[1] = freed | if is_dirty { 1 } else { 0 }

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 205 [25.387]

B:BD[25.5799] → [25.5799:5895]

        k: unsafe { core::mem::transmute(k0) },
        v: unsafe { core::mem::transmute(v0) },

[25.5799]

[23.126]

        k,
        v,

Replacement in sanakirja-core/src/btree/page/put.rs at line 27 [25.5929]
B:BD[25.6458] → [4.5234:5283]
```
    let hdr = header(unsafe { page.as_page() });
```
[25.6458]
[25.6496]
```
    let hdr = header(page.as_page());
```

Replacement in sanakirja-core/src/btree/page/put.rs at line 29 [25.5929]

B:BD[25.6531] → [4.5284:5378]

    if mutable && is_dirty && L::can_alloc::<K, V>(header(unsafe { page.as_page() }), size) {

[25.6531]

[21.9104]

    if mutable && is_dirty && L::can_alloc::<K, V>(header(page.as_page()), size) {

Insertion in sanakirja-core/src/btree/page/put.rs at line 31 [25.5929]
[21.9142]
[25.6764]
```
        let p = page.0.data;
        let hdr = header_mut(&mut page);
```
Deletion in sanakirja-core/src/btree/page/put.rs at line 37 [25.5929]
B:BD[21.9222] → [21.9222:9259]
```
                let p = page.0.data;
```
Deletion in sanakirja-core/src/btree/page/put.rs at line 42 [25.5929]
B:BD[21.9575] → [21.9575:9624]
```
                let hdr = header_mut(&mut page);
```

Replacement in sanakirja-core/src/btree/page/put.rs at line 58 [25.5929]

B:BD[25.7370] → [4.5379:5450]

        let s = L::offset_slice::<T, K, V>(unsafe { page.as_page() });

[25.7370]

[25.7430]

        let s = L::offset_slice::<T, K, V>(page.as_page());

Replacement in sanakirja-core/src/btree/page/put.rs at line 62 [25.5929]

B:BD[25.7500] → [4.5451:5526]

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

[25.7500]

[21.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 [25.5929]

B:BD[21.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);

[21.9871]

[21.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 [25.5929]
B:BD[25.8085] → [26.1789:1827]
```
        let s = tuple_size::<K, V>();
```
[25.8060]
[12.47480]
```
        let s = core::mem::size_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page/put.rs at line 106 [25.5929]
B:BD[25.8738] → [4.5716:5765]
```
    let hdr = header(unsafe { page.as_page() });
```
[25.8738]
[25.8776]
```
    let hdr = header(page.as_page());
```

Replacement in sanakirja-core/src/btree/page/put.rs at line 113 [25.5929]

B:BD[25.8894] → [4.5766:5833]

    let s = L::offset_slice::<T, K, V>(unsafe { page.as_page() });

[25.8894]

[25.8950]

    let s = L::offset_slice::<T, K, V>(page.as_page());

Replacement in sanakirja-core/src/btree/page/put.rs at line 120 [25.5929]

B:BD[25.9266] → [4.5834:5921]

        let (k, v, r) = L::kv(txn, unsafe { page.as_page() }, s1a.first::<T, K, V>());

[25.9266]

[25.9449]

        let (k, v, r) = L::kv(txn, page.as_page(), s1a.first::<T, K, V>());

Insertion in sanakirja-core/src/btree/page/put.rs at line 125 [25.5929]

[25.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 [25.5929]

B:BD[25.10119] → [4.5922:6002]

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

[25.10119]

[25.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 [25.5929]

B:BD[25.10249] → [25.10249:10420]

B:BD[25.10420] → [9.8555:8617]

∅:D[9.8617] → [25.10485:10668]

B:BD[25.10485] → [25.10485:10668]

B:BD[25.10668] → [4.6003:6085]

∅:D[4.6085] → [9.8689:8753]

B:BD[9.8689] → [9.8689:8753]

B:BD[9.8753] → [4.6086:6168]

∅:D[4.6168] → [25.10883:10900]

∅:D[9.8824] → [25.10883:10900]

B:BD[25.10883] → [25.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 {

[25.10249]

[25.10900]


        if u == k as usize {

Deletion in sanakirja-core/src/btree/page/put.rs at line 163 [25.5929]
B:BD[25.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 [25.5929]

B:BD[25.11605] → [4.6251:6324]

        let ll = header(unsafe { page.as_page() }).left_page() & !0xfff;

[25.11605]

[25.11667]

        let ll = header(page.as_page()).left_page() & !0xfff;

Replacement in sanakirja-core/src/btree/page/put.rs at line 178 [25.5929]

B:BD[25.11764] → [4.6325:6402]

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

[25.11764]

[9.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 [25.5929]

B:BD[9.9083] → [4.6403:6480]

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

[9.9083]

[25.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 [25.5929]

B:BD[25.12573] → [4.6481:6562]

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

[25.12573]

[25.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 [25.17232]

B:BD[25.19432] → [26.1828:1877]

                let size = tuple_size::<K, V>();

[25.19432]

[25.19493]

                let size = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 76 [25.17232]
B:BD[13.6547] → [26.1878:1916]
```
        let f = tuple_size::<K, V>();
```
[13.6547]
[12.47719]
```
        let f = core::mem::size_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 100 [25.17232]
B:BD[25.21047] → [26.1917:1955]
```
        let f = tuple_size::<K, V>();
```
[25.21047]
[12.48138]
```
        let f = core::mem::size_of::<Tuple<K, V>>();
```

Insertion in sanakirja-core/src/btree/page/alloc.rs at line 107 [25.17232]

[12.48345]

[13.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 [25.17232]
B:BD[25.23632] → [26.1956:1994]
```
        let f = tuple_size::<K, V>();
```
[25.23632]
[13.7284]
```
        let f = core::mem::size_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 222 [25.17232]
B:BD[25.27048] → [26.1995:2033]
```
        let f = tuple_size::<K, V>();
```
[25.27048]
[13.7767]
```
        let f = core::mem::size_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/mod.rs at line 216 [5.45735]
B:BD[5.49260] → [9.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.45735]

B:BD[6.6429] → [4.6563:6663]

        if let Ok((kk, vv, _)) = P::set_cursor(txn, unsafe { page.as_page() }, &mut cursor, k, v) {

[6.6429]

[27.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.45735]

B:BD[27.1107] → [4.6664:6758]

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

[27.1107]

[15.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.45735]

B:BD[15.4800] → [4.6759:6834]

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

[15.4800]

[27.1399]

        let next_page = P::left_child(page.as_page(), &cursor);

Insertion in sanakirja-core/src/btree/mod.rs at line 456 [5.45735]

[6.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.45735]

B:BD[15.5321] → [4.6835:6934]

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

[15.5321]

[29.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.45735]

B:BD[29.2490] → [4.6935:7018]

                let r = P::left_child(unsafe { cur.page.as_page() }, &cur.cursor);

[29.2490]

[29.2562]

                let r = P::left_child(cur.page.as_page(), &cur.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 43 [5.52511]
B:BD[5.53969] → [16.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.52511]
∅:D[6.7959] → [9.16416:16452]
B:BD[9.16416] → [9.16416:16452]
```
    if p0 < cursor.first_rc_level {
```
[6.7959]
[19.9636]
```
    if p0 < cursor.first_rc_len {
```

Replacement in sanakirja-core/src/btree/del.rs at line 56 [5.52511]

B:BD[9.16509] → [4.7019:7100]

            P::current(txn, unsafe { cur.page.as_page() }, &cur.cursor).unwrap()

[9.16509]

[16.1183]

            P::current(txn, cur.page.as_page(), &cur.cursor).unwrap()

Replacement in sanakirja-core/src/btree/del.rs at line 66 [5.52511]

B:BD[6.7994] → [4.7101:7185]

    let mut left_page = P::right_child(unsafe { cur.page.as_page() }, &cur.cursor);

[6.7994]

[6.8067]

    let mut left_page = P::right_child(cur.page.as_page(), &cur.cursor);

Insertion in sanakirja-core/src/btree/del.rs at line 68 [5.52511]

[6.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.52511]

B:BD[6.8182] → [4.7186:7255]

        left_page = P::left_child(unsafe { page.as_page() }, &curs);

[6.8182]

[6.8240]

        left_page = P::left_child(page.as_page(), &curs);

Insertion in sanakirja-core/src/btree/del.rs at line 76 [5.52511]
[6.8302]
[30.6150]
```
    let leaf_is_shared = cursor.len() >= cursor.first_rc_len;
```
Replacement in sanakirja-core/src/btree/del.rs at line 86 [5.52511]
B:BD[6.8473] → [6.8473:8524]
```
    if cursor.pointer() >= cursor.first_rc_level {
```
[6.8473]
[6.8524]
```
    if leaf_is_shared {
```

Replacement in sanakirja-core/src/btree/del.rs at line 92 [5.52511]

B:BD[5.55587] → [9.17067:17134]

B:BD[16.1308] → [16.1308:1341]

B:BD[16.1341] → [8.386:408]

∅:D[16.1341] → [9.17136:17471]

∅:D[8.408] → [9.17136:17471]

B:BD[9.17136] → [9.17136:17471]

B:BD[9.17471] → [26.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]

[9.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.52511]

B:BD[9.17539] → [9.17539:17603]

B:BD[9.17603] → [23.848:1078]

∅:D[23.1078] → [31.4202:4264]

∅:D[25.30986] → [31.4202:4264]

∅:D[30.6963] → [31.4202:4264]

∅:D[9.17624] → [31.4202:4264]

B:BD[14.32226] → [31.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)?;

[9.17539]

[9.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.52511]

B:BD[9.17626] → [9.17626:17696]

B:BD[9.17696] → [23.1079:1200]

∅:D[23.1200] → [25.30987:31025]

∅:D[9.17789] → [25.30987:31025]

B:BD[30.7002] → [25.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;

[9.17626]

[26.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.52511]

B:BD[6.8769] → [6.8769:8824]

        if cursor.pointer() >= cursor.first_rc_level {

[6.8769]

[6.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.52511]

B:BD[14.32228] → [9.17870:17985]

B:BD[9.17985] → [6.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;

[14.32228]

[6.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.52511]

B:BD[26.2827] → [16.1527:1674]

    let is_rc = cursor.pointer() >= cursor.first_rc_level;
    let del_at_internal = p0 < cursor.pointer();
    let ref mut curs0 = cursor.last();

[26.2827]

[17.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.52511]

B:BD[6.9352] → [4.7256:7344]

        let (k, v, _) = P::current(txn, unsafe { curs0.page.as_page() }, &c1).unwrap();

[6.9352]

[16.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.52511]
B:BD[5.61790] → [23.2008:2068]
```
/// From a cursor at level `p = cursor.pointer()`, form the
```
[5.61790]
[23.2068]
```
/// From a cursor at level `p = cursor.len()`, form the
```

Replacement in sanakirja-core/src/btree/del.rs at line 211 [5.52511]

B:BD[9.19536] → [16.2053:2083]

B:BD[16.2083] → [23.2201:2243]

    let p = cursor.pointer();
    let rc_level = cursor.first_rc_level;

[9.19536]

[25.33754]

    let p = cursor.len();
    let rc_level = cursor.first_rc_len;

Replacement in sanakirja-core/src/btree/del.rs at line 224 [5.52511]

B:BD[23.2697] → [4.7345:7442]

        let other = txn.load_page(P::left_child(unsafe { curs.page.as_page() }, &curs.cursor))?;

[23.2697]

[23.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.52511]

B:BD[23.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)
        };

[23.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.52511]
B:BD[23.4516] → [23.4516:4539]
```
/// cursor.pointer()`.
```
[23.4516]
[25.33961]
```
/// cursor.len()`.
```

Replacement in sanakirja-core/src/btree/del.rs at line 298 [5.52511]

B:BD[9.20246] → [16.2084:2144]

    let mutable = cursor.pointer() < cursor.first_rc_level;

[9.20246]

[25.34437]

    let mutable = cursor.len() < cursor.first_rc_len;

Replacement in sanakirja-core/src/btree/del.rs at line 300 [5.52511]

B:BD[25.34461] → [25.34461:34502]

        let curs = cursor.current_mut();

[25.34461]

[17.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.52511]

B:BD[23.4610] → [23.4610:4679]

    // level `cursor.pointer() + 1`, and build the modification plan

[23.4610]

[23.4679]

    // level `cursor.len() + 1`, and build the modification plan

Replacement in sanakirja-core/src/btree/del.rs at line 319 [5.52511]
B:BD[23.4735] → [23.4735:4763]
```
    // `cursor.pointer()`).
```
[23.4735]
[25.34844]
```
    // `cursor.len()`).
```

Replacement in sanakirja-core/src/btree/del.rs at line 359 [5.52511]

B:BD[25.35589] → [25.35589:35660]

            // deleting at an internal node (i.e. if cursor.pointer ==

[25.35589]

[25.35660]

            // deleting at an internal node (i.e. if cursor.len ==

Replacement in sanakirja-core/src/btree/del.rs at line 361 [5.52511]
B:BD[25.35718] → [16.2145:2185]
```
            if cursor.pointer() == p0 {
```
[25.35718]
[23.5364]
```
            if cursor.len() + 1 == p0 {
```

Replacement in sanakirja-core/src/btree/del.rs at line 389 [5.52511]

B:BD[25.36543] → [23.5478:5540]

            let split_key_is_k0 = if cursor.pointer() == p0 {

[25.36543]

[25.36581]

            let split_key_is_k0 = if cursor.len() + 1 == p0 {

Replacement in sanakirja-core/src/btree/del.rs at line 409 [5.52511]

B:BD[23.6125] → [23.6125:6177]

                    assert!(cursor.pointer() < p0);

[23.6125]

[17.11938]

                    assert!(cursor.len() + 1 < p0);

Replacement in sanakirja-core/src/btree/del.rs at line 420 [5.52511]

B:BD[9.20503] → [16.2227:2310]

            if cursor.pointer() + 1 >= cursor.first_rc_level && !split_key_is_k0 {

[25.37212]

[25.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.52511]

B:BD[32.110] → [23.6377:6445]

    // Free the page(s) at level `cursor.pointer() + 1` if it isn't

[25.37905]

[23.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.52511]
∅:D[32.110] → [16.2311:2361]
∅:D[23.6539] → [16.2311:2361]
B:BD[25.37905] → [16.2311:2361]
B:BD[16.2361] → [23.6540:6584]
```
    if cursor.pointer() < cursor.first_rc_level {
        free[cursor.pointer() + 1] = freed;
```
[23.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.52511]

B:BD[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]

[6.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.52511]

B:BD[6.10639] → [4.8091:8173]

    if let Some((k, v, r)) = P::next(txn, unsafe { m.page.as_page() }, &mut c1) {

[6.10639]

[6.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.52511]

B:BD[6.10942] → [4.8174:8259]

    while let Some((k, v, r)) = P::next(txn, unsafe { m.page.as_page() }, &mut c1) {

[6.10942]

[6.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.63682]

B:BD[5.64601] → [5.64601:64743]

B:BD[5.64743] → [6.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.63682]
∅:D[16.2653] → [5.65137:65168]
∅:D[9.24741] → [5.65137:65168]
B:BD[5.65137] → [5.65137:65168]
B:BD[5.65168] → [16.2654:2674]
```
    pub first_rc_level: usize,
    pointer: usize,
```
[16.2653]
[5.65192]
```
    pub first_rc_len: usize,
    len: usize,
```
Insertion in sanakirja-core/src/btree/cursor.rs at line 38 [5.63682]
[19.10907]
[6.13800]
```
        // Looking forward to getting array initialisation stabilised :)
```

Insertion in sanakirja-core/src/btree/cursor.rs at line 40 [5.63682]

[6.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.63682]

B:BD[5.65572] → [5.65572:65611]

B:BD[5.65611] → [8.647:671]

            first_rc_level: N_CURSORS,
            pointer: 0,

[5.65572]

[19.11045]

            first_rc_len: N_CURSORS,
            len: 1,

Replacement in sanakirja-core/src/btree/cursor.rs at line 87 [5.63682]

∅:D[28.1841] → [16.3484:3566]

∅:D[7.7419] → [16.3484:3566]

B:BD[16.3484] → [16.3484:3566]

        self.pointer += 1;
        self.stack[self.pointer] = MaybeUninit::new(p)

[7.7419]

[5.65645]

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

Deletion in sanakirja-core/src/btree/cursor.rs at line 90 [5.63682]
B:BD[5.65651] → [16.3567:3568]
B:BD[16.3568] → [7.7420:7484]
∅:D[28.1909] → [16.3625:3688]
∅:D[7.7484] → [16.3625:3688]
B:BD[16.3625] → [16.3625:3688]
B:BD[16.3688] → [16.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.63682]
∅:D[28.1972] → [5.65821:65876]
∅:D[7.7544] → [5.65821:65876]
∅:D[9.25007] → [5.65821:65876]
B:BD[5.65821] → [5.65821:65876]
```
        unsafe { &*self.stack[self.pointer].as_ptr() }
```
[7.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.63682]
B:BD[5.65883] → [7.7545:7589]
∅:D[28.2020] → [16.3732:3753]
∅:D[7.7589] → [16.3732:3753]
B:BD[16.3732] → [16.3732:3753]
```
    pub(super) fn pointer(&self) -> usize {
        self.pointer
```
[5.65883]
[16.3753]
```
    pub(super) fn len(&self) -> usize {
        self.len
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 102 [5.63682]

B:BD[16.3760] → [7.7590:7625]

∅:D[28.2059] → [8.672:707]

∅:D[7.7625] → [8.672:707]

B:BD[16.3788] → [8.672:707]

∅:D[8.707] → [16.3788:3814]

B:BD[16.3788] → [16.3788:3814]

    pub(super) fn pop(&mut self) {
        assert!(self.pointer > 0);
        self.pointer -= 1

[16.3760]

[16.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.63682]
∅:D[28.2134] → [14.33974:34037]
∅:D[7.7697] → [14.33974:34037]
∅:D[9.25072] → [14.33974:34037]
B:BD[14.33974] → [14.33974:34037]
```
        unsafe { &mut *self.stack[self.pointer].as_mut_ptr() }
```
[7.7697]
[14.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.63682]
B:BD[7.7738] → [7.7738:7764]
```
        self.pointer = 0;
```
[7.7738]
[7.7764]
```
        self.len = 1;
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 132 [5.63682]

B:BD[5.66237] → [18.2507:2548]

B:BD[18.2548] → [8.757:810]

∅:D[14.34163] → [18.2548:2648]

∅:D[8.810] → [18.2548:2648]

∅:D[27.1601] → [18.2548:2648]

B:BD[18.2548] → [18.2548:2648]

B:BD[18.2648] → [6.15041:15168]

∅:D[6.15168] → [5.66450:66501]

∅:D[27.1748] → [5.66450:66501]

B:BD[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.63682]

B:BD[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.63682]

B:BD[5.66973] → [5.66973:67027]

                    last_matching_page = self.pointer

[5.66973]

[8.848]

                    last_matching_page = self.len

Replacement in sanakirja-core/src/btree/cursor.rs at line 153 [5.63682]

B:BD[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.63682]
∅:D[14.34799] → [5.67513:67560]
∅:D[8.1017] → [5.67513:67560]
B:BD[5.67513] → [5.67513:67560]
```
            self.pointer = last_matching_page;
```
[8.1017]
[5.67560]
```
            self.len = last_matching_page;
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 177 [5.63682]

B:BD[5.67886] → [19.11312:11427]

        assert_eq!(self.pointer, 0);
        let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };

[5.67886]

[6.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.63682]

B:BD[5.67901] → [5.67901:67983]

B:BD[5.67983] → [19.11493:11535]

∅:D[19.11535] → [5.67983:68121]

B:BD[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.63682]

B:BD[5.68135] → [19.11536:11589]

B:BD[19.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();

Deletion in sanakirja-core/src/btree/cursor.rs at line 187 [5.63682]
B:BD[5.68443] → [19.11689:11744]
```
            debug!("k {:?} v {:?} r = {:?}", k, v, r);
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 214 [5.63682]

B:BD[5.68948] → [8.1185:1233]

∅:D[8.1233] → [33.0:82]

B:BD[5.68948] → [33.0:82]

            debug!("next: {:?}", self.pointer);
            let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };

[5.68948]

[6.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.63682]

B:BD[6.15681] → [4.8622:8717]

                let left = P::right_child(unsafe { current.page.as_page() }, &current.cursor);

[6.15681]

[17.13357]

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

Replacement in sanakirja-core/src/btree/cursor.rs at line 227 [5.63682]

B:BD[19.12618] → [4.8718:8846]

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

[19.12618]

[7.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.63682]

B:BD[19.13077] → [19.13077:13146]

            } else if self.pointer > 0 {
                self.pop();

[19.13077]

[33.664]

            } else if self.len > 1 {
                self.len -= 1

Replacement in sanakirja-core/src/btree/cursor.rs at line 249 [5.63682]

B:BD[19.13321] → [19.13321:13403]

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

[19.13321]

[7.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.63682]

B:BD[7.8347] → [7.8347:8406]

                self.pointer, current.page, current.cursor

[7.8347]

[7.8406]

                self.len, current.page, current.cursor

Replacement in sanakirja-core/src/btree/cursor.rs at line 256 [5.63682]

B:BD[34.614] → [4.8847:8941]

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

[34.614]

[28.2606]

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

Replacement in sanakirja-core/src/btree/cursor.rs at line 266 [5.63682]

B:BD[19.13856] → [4.8942:9070]

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

[19.13856]

[7.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.63682]

B:BD[34.668] → [4.9071:9162]

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

[34.668]

[19.14115]

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

Replacement in sanakirja-core/src/btree/cursor.rs at line 280 [5.63682]
∅:D[7.8579] → [19.14372:14413]
B:BD[19.14372] → [19.14372:14413]
```
            } else if self.pointer > 0 {
```
[7.8579]
[34.669]
```
            } else if self.len > 1 {
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 282 [5.63682]

∅:D[34.700] → [19.14413:14441]

B:BD[19.14413] → [19.14413:14441]

B:BD[19.14441] → [28.2982:3068]

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

[34.700]

[17.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 [36.11]

B:BD[35.724] → [21.11554:11608]

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

[35.724]

[21.11608]

    crate::debug::debug(&txn, &[&db, &db2], "debug", true);

Insertion in sanakirja/src/tests.rs at line 202 [36.11]
[35.772]
[21.11640]
```
    crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
```
Replacement in sanakirja/src/tests.rs at line 227 [36.11]
B:BD[9.25993] → [9.25993:26016]
```
    let n = 20 as u64;
```
[9.25993]
[36.6021]
```
    let n = 19 as u64;
```
Insertion in sanakirja/src/tests.rs at line 239 [36.11]
[36.6386]
[8.1460]
```
    crate::debug::debug(&txn, &[&db, &db2], "debug0", true);
```
Insertion in sanakirja/src/tests.rs at line 248 [36.11]
[36.6527]
[36.6527]
```
    crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
```
Insertion in sanakirja/src/tests.rs at line 264 [36.11]
[36.7121]
[36.7121]
```
        debug!("{:?}", *k);
```

Replacement in sanakirja/src/tests.rs at line 349 [36.11]

B:BD[19.15485] → [19.15485:15543]

                let mut c = P::cursor_first(p.as_page());

[19.15485]

[36.8297]

                let mut c = P::cursor_first(&p);

Replacement in sanakirja/src/tests.rs at line 699 [36.11]
B:BD[19.15822] → [19.15822:15874]
```
        let cursor = P::cursor_first(pp.as_page());
```
[19.15822]
[19.15874]
```
        let cursor = P::cursor_first(&pp);
```

Replacement in sanakirja/src/debug.rs at line 28 [37.11]

B:BD[37.663] → [19.18042:18218]

        print_page::<T, K, V, PP>(
            t,
            &mut h,
            &mut buf,
            &t.load_page(db.db).unwrap().as_page(),
            recurse,
        );

[37.663]

[37.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 [37.11]
B:BD[37.1032] → [37.1032:1046]
```
    p: &Page,
```
[37.1032]
[37.1046]
```
    p: &CowPage,
```

Replacement in sanakirja/src/debug.rs at line 69 [37.11]

B:BD[37.1743] → [37.1743:1831]

                print_page::<T, K, V, P>(txn, pages, buf, &p.as_page(), print_children)

[37.1743]

[37.1831]

                print_page::<T, K, V, P>(txn, pages, buf, &p, print_children)

Replacement in sanakirja/src/debug.rs at line 85 [37.11]
B:BD[37.2136] → [37.2136:2150]
```
    p: &Page,
```
[37.2136]
[37.2150]
```
    p: &CowPage,
```
Replacement in sanakirja/src/debug.rs at line 89 [37.11]
B:BD[37.2191] → [19.18219:18261]
```
    let mut cursor = P::cursor_first(*p);
```
[37.2191]
[37.2233]
```
    let mut cursor = P::cursor_first(p);
```
Replacement in sanakirja/src/debug.rs at line 91 [37.11]
B:BD[37.2252] → [37.2252:2292]
```
    let l = P::left_child(*p, &cursor);
```
[37.2252]
[37.2292]
```
    let l = P::left_child(p.as_page(), &cursor);
```

Replacement in sanakirja/src/debug.rs at line 99 [37.11]

B:BD[37.2481] → [2.0:68]

    while let Some((key, val, r)) = P::next(txn, *p, &mut cursor) {

[37.2481]

[37.2547]

    while let Some((key, val, r)) = P::next(txn, p.as_page(), &mut cursor) {

Insertion in sanakirja/Cargo.toml at line 27 [5.108411]
[38.6555]
[22.5524]
```
uuid = { version = "*", features = [ "v4" ] }
```

Cleanup + docs

Dependencies

In channels

Change contents

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

Replacement in sanakirja-core/src/lib.rs at line 5 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 28 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 31 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 35 [5.91]

Deletion in sanakirja-core/src/lib.rs at line 37 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 41 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 48 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 54 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 59 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 65 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 69 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 151 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 154 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 179 [5.91]

Insertion in sanakirja-core/src/lib.rs at line 188 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 195 [5.91]

Replacement in sanakirja-core/src/lib.rs at line 197 [5.91]

Replacement in sanakirja-core/src/btree/put.rs at line 31 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 40 [5.3448]

Deletion in sanakirja-core/src/btree/put.rs at line 65 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 103 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 105 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 114 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 124 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 159 [5.3448]

Deletion in sanakirja-core/src/btree/put.rs at line 162 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 165 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 191 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 195 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 199 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 201 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 213 [5.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 220 [5.3448]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 97 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 100 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 102 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 188 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 198 [12.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 210 [12.2014]

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 220 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 222 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 227 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 274 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 286 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 550 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 566 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 584 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 590 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 592 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 597 [12.2014]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 12 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 19 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 27 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 41 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 49 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 58 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 63 [12.22926]

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 67 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 68 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 73 [12.22926]

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 82 [12.22926]

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 83 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 103 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 107 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 112 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 117 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 131 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 139 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 148 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 153 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 166 [12.22926]

Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 171 [12.22926]

Deletion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 183 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 188 [12.22926]

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 30 [12.27023]