pijul/sanakirja - Change 73Z2UB3JGRLFNFORE7D64O4IHIFSZASD4G4FLJ4FJLHANT75MGIAC

Cleanup + comments

Created by pmeunier on February 11, 2021

73Z2UB3JGRLFNFORE7D64O4IHIFSZASD4G4FLJ4FJLHANT75MGIAC

Dependencies

In channels

main

Change contents

Insertion in sanakirja-core/src/btree/put.rs at line 38 [6.3448]
[4.50]
[5.45]
```
        false,
```
Insertion in sanakirja-core/src/btree/put.rs at line 88 [6.3448]
[4.190]
[5.137]
```
                        false,
```
Insertion in sanakirja-core/src/btree/put.rs at line 106 [6.3448]
[6.5879]
[5.175]
```
                        false,
```
Replacement in sanakirja-core/src/btree/put.rs at line 174 [6.3448]
B:BD[5.330] → [5.330:380]
```
        P::move_next(cur.page.as_page(), &mut c);
```
[5.330]
[7.1067]
```
        P::move_next(&mut c);
```

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 31 [8.2014]

B:BD[8.2648] → [8.2648:2747]

    fn clean(page: &mut MutPage) {
        let hdr = header_mut(page);
        hdr.clean();
    }

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 36 [8.2014]

B:BD[9.147] → [9.147:236]

    unsafe fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V) {
        (&*s.0, &*s.1)

[9.147]

[9.236]

    fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V) {
        unsafe { (&*s.0, &*s.1) }

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 40 [8.2014]

∅:D[9.243] → [8.2747:3112]

B:BD[8.2747] → [8.2747:3112]

B:BD[8.3112] → [2.0:62]

∅:D[2.62] → [8.3170:3213]

B:BD[8.3170] → [8.3170:3213]

B:BD[8.3213] → [2.63:129]

∅:D[2.129] → [8.3275:3289]

B:BD[8.3275] → [8.3275:3289]

B:BD[8.3607] → [8.3607:3641]

    fn size(m: &ModifiedPage<K, V, Self>) -> usize {
        let mut occupied = {
            let hdr = header(m.page.as_page());
            (hdr.left_page() & 0xfff) as usize
        };
        occupied += HDR;
        if m.skip_first {
            occupied -= Self::current_size(m.page.as_page(), &m.c1) as usize;
        }
        if let Some((k, v)) = m.ins {
            occupied += 8 + crate::alloc_size(k, v) as usize;
            if let Some((k, v)) = m.ins2 {
                occupied += 8 + crate::alloc_size(k, v) as usize;
            }
        }
        occupied
    }

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 44 [8.2014]
[8.3738]
[10.0]
```
        replace: bool,
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 58 [8.2014]
B:BD[3.107] → [3.107:130]
```
                false,
```
[3.107]
[3.130]
```
                replace,
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 71 [8.2014]
B:BD[3.388] → [3.388:411]
```
                false,
```
[3.388]
[3.411]
```
                replace,
```

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 80 [8.2014]

B:BD[8.4130] → [8.4130:4415]

B:BD[8.4415] → [3.558:716]

    }
    fn replace<'a, T: AllocPage>(
        txn: &mut T,
        page: CowPage,
        mutable: bool,
        c: &Self::Cursor,
        k0: &'a K,
        v0: &'a V,
        k1v1: Option<(&'a K, &'a V)>,
        l: u64,
        r: u64,
    ) -> Result<Put<'a, K, V>, T::Error> {
        assert!(c.cur >= 0);
        assert!(!c.is_leaf);
        put::put::<_, _, _, Internal>(txn, page, mutable, true, c.cur as usize, k0, v0, k1v1, l, r)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 196 [8.2014]
B:BD[8.8955] → [8.8955:9003]
```
        let mod_size = Self::size(&m.modified);
```
[8.8955]
[8.9003]
```
        let mod_size = size::<K, V>(&m.modified);
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 210 [8.2014]

B:BD[8.9489] → [8.9489:9722]

            unsafe {
                if m.modified.c0.is_leaf {
                    merge::<_, _, _, Leaf>(txn, &mut new, m)
                } else {
                    merge::<_, _, _, Internal>(txn, &mut new, m)
                }

[8.9489]

[8.9722]

            if m.modified.c0.is_leaf {
                merge::<_, _, _, Leaf>(txn, &mut new, m)
            } else {
                merge::<_, _, _, Internal>(txn, &mut new, m)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 236 [8.2014]
B:BD[8.10547] → [8.10547:10596]
```
                return Ok(Op::Put(Self::replace(
```
[8.10547]
[8.10596]
```
                return Ok(Op::Put(Self::put(
```
Insertion in sanakirja-core/src/btree/page_unsized.rs at line 240 [8.2014]
[8.10698]
[8.10698]
```
                    true,
```

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 275 [8.2014]

[8.11586]

[11.1341]

fn size<K: Representable + ?Sized, V: Representable + ?Sized>(
    m: &ModifiedPage<K, V, Page<K, V>>,
) -> usize {
    let mut total = {
        let hdr = header(m.page.as_page());
        (hdr.left_page() & 0xfff) as usize
    };
    total += HDR;
    let extra = if m.c1.is_leaf { 2 } else { 8 };
    if let Some((k, v)) = m.ins {
        total += extra + crate::alloc_size(k, v) as usize;
        if let Some((k, v)) = m.ins2 {
            total += extra + crate::alloc_size(k, v) as usize;
        }
    }
    if m.skip_first {
        total -= <Page<K, V> as BTreePage<K, V>>::current_size(m.page.as_page(), &m.c1) as usize;
    }
    total
}

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 347 [8.2014]

B:BD[8.13149] → [8.13149:13283]

B:BD[8.13283] → [5.2530:2631]

∅:D[5.2631] → [8.13375:13392]

B:BD[8.13375] → [8.13375:13392]

B:BD[8.13392] → [12.1085:1212]

∅:D[12.1212] → [8.13510:13527]

B:BD[8.13510] → [8.13510:13527]

    unsafe fn unchecked_current_ptr(page: crate::Page, c: &Self::Cursor) -> *const u8 {
        page.data.as_ptr().add(if c.is_leaf {
            u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16)) as usize
        } else {
            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64))
                & 0xfff) as usize
        })
    }

[8.13149]

[8.13527]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 355 [8.2014]
B:BD[8.14150] → [8.14150:14219]
```
    fn move_next(_page: crate::Page, c: &mut Self::Cursor) -> bool {
```
[8.14150]
[5.2920]
```
    fn move_next(c: &mut Self::Cursor) -> bool {
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 363 [8.2014]
B:BD[8.14340] → [8.14340:14409]
```
    fn move_prev(_page: crate::Page, c: &mut Self::Cursor) -> bool {
```
[8.14340]
[8.14409]
```
    fn move_prev(c: &mut Self::Cursor) -> bool {
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 430 [8.2014]

B:BD[8.16285] → [8.16285:16369]

    fn split_at(_: crate::Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {

[8.16285]

[8.16369]

    /// Split a cursor, returning two cursors `(a, b)` where b is the
    /// same as `c`, and `a` is a cursor running from the first
    /// element of the page to `c` (excluding `c`).
    fn split_at(c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 547 [8.2014]
B:BD[8.18973] → [8.18973:18991]
```
unsafe fn modify<
```
[8.18973]
[8.18991]
```
fn modify<
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 585 [8.2014]
B:BD[8.20059] → [8.20059:20076]
```
unsafe fn merge<
```
[8.20059]
[8.20076]
```
fn merge<
```
Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 25 [8.22926]
∅:D[3.1976] → [13.129:197]
B:BD[8.23777] → [13.129:197]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::replace(
```
[3.1976]
[8.23842]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
```
Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 29 [8.22926]
[8.23920]
[8.23920]
```
            true,
```

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

B:BD[3.2188] → [3.2188:2321]

    if let Put::Ok(Ok { page, freed }) =
        <Page<K, V>>::put(txn, new_left.0, true, &lc, m.mid.0, m.mid.1, None, 0, rl)?
    {

[3.2188]

[3.2321]

    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
        txn, new_left.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
    )? {

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 116 [8.22926]
∅:D[3.2697] → [13.1156:1224]
B:BD[8.25893] → [13.1156:1224]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::replace(
```
[3.2697]
[8.25958]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
```
Insertion in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 120 [8.22926]
[8.26036]
[8.26036]
```
            true,
```

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

B:BD[3.2850] → [3.2850:2985]

    if let Put::Ok(Ok { page, freed }) =
        <Page<K, V>>::put(txn, new_right.0, true, &rc, m.mid.0, m.mid.1, None, r0, rl)?
    {

[3.2850]

[3.2985]

    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
        txn,
        new_right.0,
        true,
        false,
        &rc,
        m.mid.0,
        m.mid.1,
        None,
        r0,
        rl,
    )? {

Deletion in sanakirja-core/src/btree/page_unsized/header.rs at line 63 [14.15503]
B:BD[14.16833] → [14.16833:16926]
```
    }
    pub fn clean(&mut self) {
        self.n = (u16::from_le(self.n) & 0xfff).to_le()
```

Insertion in sanakirja-core/src/btree/page.rs at line 29 [6.8623]

[9.554]

[6.8769]


impl<K: Representable, V: Representable> super::BTreePage<K, V> for Page<K, V> {
    fn is_dirty(page: crate::Page) -> bool {
        header(page).is_dirty()
    }
    type Cursor = PageCursor;
    fn is_empty(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur >= c.total as isize
    }
    fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur < 0
    }
    fn cursor_before(p: crate::Page) -> Self::Cursor {
        PageCursor::new(p, -1)
    }
    fn cursor_after(p: crate::Page) -> Self::Cursor {
        PageCursor::after(p)
    }
    fn current<'a, T: LoadPage>(
        txn: &T,
        page: crate::Page<'a>,
        c: &Self::Cursor,
    ) -> Option<(&'a K, &'a V, u64)> {
        if c.cur < 0 || c.cur >= c.total as isize {
            None
        } else if c.is_leaf {
            let f = tuple_size::<K, V>();
            let off = {
                let al = K::ALIGN.max(V::ALIGN);
                let hdr = (HDR + al - 1) & !(al - 1);
                hdr + c.cur as usize * f
            };
            unsafe {
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    0,
                ))
            }
        } else {
            unsafe {
                let off =
                    u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize));
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    off & !0xfff,
                ))
            }
        }
    }
    fn current_size(page: crate::Page, c: &Self::Cursor) -> usize {
        assert!(c.cur >= 0 && c.cur < c.total as isize);
        unsafe {
            if c.is_leaf {
                tuple_size::<K, V>()
            } else {
                8 + entry_size::<K, V>(page.data.as_ptr().add(
                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize))
                        & 0xfff) as usize,
                ))
            }
        }
    }
    fn move_next(c: &mut Self::Cursor) -> bool {
        if c.cur < c.total as isize {
            c.cur += 1;
            true
        } else {
            false
        }
    }
    fn move_prev(c: &mut Self::Cursor) -> bool {
        if c.cur > 0 {
            c.cur -= 1;
            true
        } else {
            c.cur = -1;
            false
        }
    }
    fn left_child(page: crate::Page, c: &Self::Cursor) -> u64 {
        assert!(c.cur >= 0);
        if c.is_leaf {
            0
        } else {
            let off =
                unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
            u64::from_le(off) & !0xfff
        }
    }
    fn right_child(page: crate::Page, c: &Self::Cursor) -> u64 {
        assert!(c.cur < c.total as isize);
        if c.is_leaf {
            0
        } else {
            let off =
                unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
            u64::from_le(off) & !0xfff
        }
    }
    fn set_cursor<'a, T: LoadPage>(
        txn: &T,
        page: crate::Page,
        c: &mut PageCursor,
        k0: &K,
        v0: Option<&V>,
    ) -> Result<(&'a K, &'a V, u64), usize> {
        unsafe {
            let lookup = lookup(txn, page, c, k0, v0);
            let result;
            c.cur = match lookup {
                Ok(n) => {
                    result = if c.is_leaf {
                        let f = tuple_size::<K, V>();
                        let off = {
                            let al = K::ALIGN.max(V::ALIGN);
                            let hdr_size = (HDR + al - 1) & !(al - 1);
                            (0, (hdr_size + f * n) as u16)
                        };
                        Ok(Leaf::kv(txn, page, off))
                    } else {
                        let off =
                            u64::from_le(*(page.data.as_ptr().add(HDR + n * 8) as *const u64));
                        Ok(Internal::kv(
                            txn,
                            page,
                            (off & !0xfff, (off & 0xfff) as u16),
                        ))
                    };
                    n as isize
                }
                Err(n) => {
                    result = Err(n);
                    n as isize
                }
            };
            result
        }
    }

Insertion in sanakirja-core/src/btree/page.rs at line 178 [6.8623]

[6.8770]

[11.5036]

    fn split_at(c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {
        (
            PageCursor {
                cur: 0,
                total: c.cur.max(0) as usize,
                is_leaf: c.is_leaf,
            },
            *c,
        )
    }
}

Deletion in sanakirja-core/src/btree/page.rs at line 197 [6.8623]
B:BD[6.9933] → [7.1422:1457]
B:BD[7.1457] → [9.610:672]
```
    fn clean(page: &mut MutPage) {
        <super::page_unsized::Page<K, V>>::clean(page)
    }
```

Replacement in sanakirja-core/src/btree/page.rs at line 208 [6.8623]

B:BD[6.10101] → [9.1088:1219]

    unsafe fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V) {
        (core::mem::transmute(&s.0), core::mem::transmute(&s.1))

[6.10101]

[9.1219]

    fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V) {
        unsafe { (core::mem::transmute(&s.0), core::mem::transmute(&s.1)) }

Deletion in sanakirja-core/src/btree/page.rs at line 212 [6.8623]

∅:D[9.1226] → [15.1354:1407]

B:BD[6.10101] → [15.1354:1407]

B:BD[15.1407] → [2.130:156]

∅:D[2.156] → [7.1577:1625]

B:BD[7.1577] → [7.1577:1625]

∅:D[7.1625] → [6.10234:10292]

B:BD[6.10234] → [6.10234:10292]

B:BD[6.10292] → [8.44417:44443]

∅:D[8.44443] → [6.10355:10400]

∅:D[15.1468] → [6.10355:10400]

B:BD[6.10355] → [6.10355:10400]

B:BD[6.10400] → [2.157:206]

∅:D[2.206] → [6.10452:10469]

B:BD[6.10452] → [6.10452:10469]

B:BD[6.10469] → [2.207:232]

∅:D[2.232] → [6.10497:10508]

B:BD[6.10497] → [6.10497:10508]

B:BD[7.1740] → [16.79:117]

B:BD[16.117] → [2.233:354]

∅:D[2.354] → [17.492:535]

B:BD[7.1799] → [17.492:535]

B:BD[17.535] → [2.355:422]

∅:D[2.422] → [6.10875:10899]

B:BD[6.10875] → [6.10875:10899]

B:BD[6.10899] → [2.423:548]

∅:D[2.548] → [6.10916:10923]

B:BD[6.10916] → [6.10916:10923]

    fn size(m: &ModifiedPage<K, V, Self>) -> usize {
        let mut total = {
            let hdr = header(m.page.as_page());
            (hdr.left_page() & 0xfff) as usize
        };
        if m.c1.is_leaf {
            let al = K::ALIGN.max(V::ALIGN);
            total += (HDR + al - 1) & (!al - 1);
        } else {
            total += HDR
        };
        if let Some((k, v)) = m.ins {
            let extra = if m.c1.is_leaf { 8 } else { 0 };
            total += extra + crate::alloc_size(k, v) as usize;
            if let Some((k, v)) = m.ins2 {
                total += extra + crate::alloc_size(k, v) as usize;
            }
        }
        if m.skip_first {
            total -= Self::current_size(m.page.as_page(), &m.c1) as usize;
        }
        total
    }

Insertion in sanakirja-core/src/btree/page.rs at line 216 [6.8623]
[6.11010]
[10.970]
```
        replace: bool,
```
Replacement in sanakirja-core/src/btree/page.rs at line 230 [6.8623]
B:BD[3.5731] → [3.5731:5754]
```
                false,
```
[3.5731]
[3.5754]
```
                replace,
```
Replacement in sanakirja-core/src/btree/page.rs at line 243 [6.8623]
B:BD[3.6012] → [3.6012:6035]
```
                false,
```
[3.6012]
[3.6035]
```
                replace,
```

Deletion in sanakirja-core/src/btree/page.rs at line 254 [6.8623]

B:BD[6.11472] → [15.1553:1587]

∅:D[15.1587] → [17.1082:1326]

B:BD[17.1082] → [17.1082:1326]

B:BD[17.1326] → [3.6182:6608]

∅:D[3.6608] → [17.1513:1520]

∅:D[12.3402] → [17.1513:1520]

B:BD[17.1513] → [17.1513:1520]

    fn replace<'a, T: AllocPage>(
        txn: &mut T,
        page: CowPage,
        mutable: bool,
        c: &Self::Cursor,
        k0: &'a K,
        v0: &'a V,
        k1v1: Option<(&'a K, &'a V)>,
        l: u64,
        r: u64,
    ) -> Result<Put<'a, K, V>, T::Error> {
        if r == 0 {
            put::put::<_, _, _, Leaf>(txn, page, mutable, true, c.cur as usize, k0, v0, k1v1, 0, 0)
        } else {
            put::put::<_, _, _, Internal>(
                txn,
                page,
                mutable,
                true,
                c.cur as usize,
                k0,
                v0,
                k1v1,
                l,
                r,
            )
        }
    }

Replacement in sanakirja-core/src/btree/page.rs at line 375 [6.8623]
B:BD[6.16292] → [17.2976:3024]
```
        let mod_size = Self::size(&m.modified);
```
[6.16292]
[7.5228]
```
        let mod_size = size::<K, V>(&m.modified);
```

Replacement in sanakirja-core/src/btree/page.rs at line 385 [6.8623]

∅:D[7.5514] → [6.16691:16755]

∅:D[15.2861] → [6.16691:16755]

B:BD[6.16691] → [6.16691:16755]

B:BD[6.16755] → [15.2862:2923]

∅:D[7.5571] → [6.16806:16831]

∅:D[15.2923] → [6.16806:16831]

B:BD[6.16806] → [6.16806:16831]

B:BD[6.16831] → [15.2924:2989]

∅:D[7.5632] → [6.16886:16904]

∅:D[15.2989] → [6.16886:16904]

B:BD[6.16886] → [6.16886:16904]

            unsafe {
                if m.modified.c0.is_leaf {
                    merge::<_, _, _, Leaf>(txn, &mut new, m)
                } else {
                    merge::<_, _, _, Internal>(txn, &mut new, m)
                }

[15.2861]

[6.16904]

            if m.modified.c0.is_leaf {
                merge::<_, _, _, Leaf>(txn, &mut new, m)
            } else {
                merge::<_, _, _, Internal>(txn, &mut new, m)

Replacement in sanakirja-core/src/btree/page.rs at line 411 [6.8623]

B:BD[17.3536] → [17.3536:3585]

                return Ok(Op::Put(Self::replace(

[17.3536]

[7.6024]

                return Ok(Op::Put(Self::put(

Insertion in sanakirja-core/src/btree/page.rs at line 415 [6.8623]
[7.6126]
[7.6126]
```
                    true,
```

Replacement in sanakirja-core/src/btree/page.rs at line 450 [6.8623]

B:BD[6.18476] → [11.5416:5497]

∅:D[11.5497] → [6.18583:18628]

B:BD[6.18583] → [6.18583:18628]

B:BD[6.18628] → [7.6646:6678]

∅:D[7.6678] → [6.18726:18733]

B:BD[6.18726] → [6.18726:18733]

B:BD[6.18733] → [7.6679:6739]

B:BD[7.6739] → [5.5688:5806]

∅:D[5.5806] → [6.18819:18825]

B:BD[6.18819] → [6.18819:18825]

B:BD[6.18825] → [10.1077:1107]

∅:D[10.1107] → [5.5807:5862]

B:BD[6.18851] → [5.5807:5862]

B:BD[5.5862] → [10.1108:1139]

∅:D[5.5889] → [6.19108:19114]

∅:D[10.1139] → [6.19108:19114]

B:BD[6.19108] → [6.19108:19114]

B:BD[6.19114] → [5.5890:5944]

B:BD[5.5944] → [10.1140:1169]

∅:D[5.5969] → [6.19402:19408]

∅:D[10.1169] → [6.19402:19408]

B:BD[6.19402] → [6.19402:19408]

B:BD[6.19408] → [5.5970:6003]

∅:D[5.6003] → [15.3105:3122]

B:BD[15.3105] → [15.3105:3122]

∅:D[15.3122] → [17.3815:3872]

B:BD[17.3815] → [17.3815:3872]

B:BD[17.3872] → [5.6004:6142]

∅:D[5.6142] → [9.1529:1571]

B:BD[6.19528] → [9.1529:1571]

∅:D[9.1571] → [8.45226:45250]

B:BD[8.45226] → [8.45226:45250]

∅:D[8.45250] → [6.19593:19696]

∅:D[15.3185] → [6.19593:19696]

B:BD[6.19593] → [6.19593:19696]

B:BD[6.19696] → [5.6143:6184]

∅:D[5.6184] → [6.19836:19851]

∅:D[7.7354] → [6.19836:19851]

B:BD[6.19836] → [6.19836:19851]

B:BD[5.6226] → [5.6226:6336]

B:BD[5.6408] → [5.6408:6603]

∅:D[5.6603] → [6.19944:19961]

∅:D[7.7461] → [6.19944:19961]

∅:D[11.5653] → [6.19944:19961]

∅:D[15.3363] → [6.19944:19961]

B:BD[6.19944] → [6.19944:19961]

B:BD[6.19961] → [5.6604:6625]

B:BD[5.6625] → [12.3737:3863]

∅:D[12.3863] → [5.6731:7036]

B:BD[5.6731] → [5.6731:7036]

impl<K: Representable, V: Representable> super::BTreePage<K, V> for Page<K, V> {
    fn is_dirty(page: crate::Page) -> bool {
        header(page).is_dirty()
    }
    fn is_empty(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur >= c.total as isize
    }
    fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur < 0
    }
    type Cursor = PageCursor;
    fn cursor_before(p: crate::Page) -> Self::Cursor {
        PageCursor::new(p, -1)
    }
    fn cursor_after(p: crate::Page) -> Self::Cursor {
        PageCursor::after(p)
    }
    fn current<'a, T: LoadPage>(
        txn: &T,
        page: crate::Page<'a>,
        c: &Self::Cursor,
    ) -> Option<(&'a K, &'a V, u64)> {
        if c.cur < 0 || c.cur >= c.total as isize {
            None
        } else if c.is_leaf {
            let f = tuple_size::<K, V>();
            let off = {
                let al = K::ALIGN.max(V::ALIGN);
                let hdr = (HDR + al - 1) & !(al - 1);
                hdr + c.cur as usize * f
            };
            unsafe {
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    0,
                ))
            }
        } else {
            unsafe {
                let off =
                    u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize));
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    off & !0xfff,
                ))
            }

[6.18476]

[6.20159]

fn size<K: Representable, V: Representable>(m: &ModifiedPage<K, V, Page<K, V>>) -> usize {
    let mut total = {
        let hdr = header(m.page.as_page());
        (hdr.left_page() & 0xfff) as usize
    };
    if m.c1.is_leaf {
        let al = K::ALIGN.max(V::ALIGN);
        total += (HDR + al - 1) & (!al - 1);
    } else {
        total += HDR
    };
    if let Some((k, v)) = m.ins {
        let extra = if m.c1.is_leaf { 0 } else { 8 };
        total += extra + crate::alloc_size(k, v) as usize;
        if let Some((k, v)) = m.ins2 {
            total += extra + crate::alloc_size(k, v) as usize;

Replacement in sanakirja-core/src/btree/page.rs at line 468 [6.8623]

B:BD[6.20175] → [7.7683:7771]

B:BD[7.7771] → [5.7037:7094]

∅:D[5.7094] → [7.7771:7817]

B:BD[7.7771] → [7.7771:7817]

B:BD[7.7817] → [9.1572:1614]

∅:D[9.1614] → [8.45308:45403]

B:BD[8.45308] → [8.45308:45403]

B:BD[8.45403] → [5.7095:7132]

∅:D[5.7132] → [6.20611:20628]

∅:D[8.45431] → [6.20611:20628]

B:BD[6.20611] → [6.20611:20628]

B:BD[6.20628] → [12.3864:3991]

∅:D[17.4022] → [6.20721:20738]

∅:D[7.8017] → [6.20721:20738]

∅:D[12.3991] → [6.20721:20738]

B:BD[6.20721] → [6.20721:20738]

B:BD[6.20738] → [7.8018:8086]

B:BD[7.8086] → [5.7236:7293]

∅:D[5.7293] → [6.20807:20851]

∅:D[7.8086] → [6.20807:20851]

B:BD[6.20807] → [6.20807:20851]

B:BD[6.20851] → [9.1615:1652]

∅:D[8.45484] → [6.21215:21236]

∅:D[9.1652] → [6.21215:21236]

B:BD[6.21215] → [6.21215:21236]

B:BD[6.21236] → [15.3754:3817]

B:BD[15.3817] → [12.3992:4135]

∅:D[17.4358] → [6.21394:21443]

∅:D[7.8405] → [6.21394:21443]

∅:D[12.4135] → [6.21394:21443]

B:BD[6.21394] → [6.21394:21443]

B:BD[6.21443] → [7.8406:8475]

B:BD[7.8475] → [5.7404:7442]

∅:D[5.7442] → [6.21542:21634]

B:BD[6.21542] → [6.21542:21634]

B:BD[6.21634] → [7.8476:8626]

B:BD[7.8626] → [5.7443:7467]

∅:D[5.7467] → [7.8626:8724]

B:BD[7.8626] → [7.8626:8724]

B:BD[7.8724] → [5.7468:7497]

∅:D[5.7497] → [6.21699:21753]

∅:D[7.8724] → [6.21699:21753]

B:BD[6.21699] → [6.21699:21753]

B:BD[6.21753] → [12.4136:4258]

∅:D[5.7604] → [6.21841:21896]

∅:D[7.8822] → [6.21841:21896]

∅:D[12.4258] → [6.21841:21896]

B:BD[6.21841] → [6.21841:21896]

B:BD[6.21896] → [7.8823:8888]

B:BD[7.8888] → [5.7605:7648]

∅:D[5.7648] → [6.21962:22016]

∅:D[7.8888] → [6.21962:22016]

B:BD[6.21962] → [6.21962:22016]

B:BD[6.22016] → [12.4259:4378]

∅:D[5.7752] → [6.22098:22153]

∅:D[7.8980] → [6.22098:22153]

∅:D[12.4378] → [6.22098:22153]

B:BD[6.22098] → [6.22098:22153]

B:BD[6.22153] → [15.3818:3854]

∅:D[15.3854] → [6.22176:22193]

B:BD[6.22176] → [6.22176:22193]

B:BD[6.22193] → [7.8981:9008]

B:BD[7.9008] → [10.1170:1198]

∅:D[10.1198] → [6.22245:22285]

B:BD[6.22245] → [6.22245:22285]

B:BD[6.22285] → [7.9009:9055]

∅:D[7.9055] → [6.22339:22356]

B:BD[6.22339] → [6.22339:22356]

B:BD[6.22356] → [7.9056:9111]

∅:D[7.9111] → [6.22435:22459]

∅:D[16.709] → [6.22435:22459]

B:BD[6.22435] → [6.22435:22459]

B:BD[6.24582] → [6.24582:24688]

B:BD[6.24688] → [9.1653:1707]

∅:D[9.1707] → [8.45554:45590]

B:BD[8.45554] → [8.45554:45590]

∅:D[8.45590] → [6.24765:24956]

∅:D[15.3929] → [6.24765:24956]

B:BD[6.24765] → [6.24765:24956]

B:BD[6.25123] → [6.25123:25150]

B:BD[6.25150] → [15.3930:3983]

∅:D[7.9267] → [6.25199:25228]

∅:D[15.3983] → [6.25199:25228]

B:BD[6.25199] → [6.25199:25228]

B:BD[6.25228] → [17.4498:4628]

B:BD[17.4628] → [11.5821:6022]

∅:D[7.9455] → [6.25407:25430]

∅:D[11.6022] → [6.25407:25430]

∅:D[15.4074] → [6.25407:25430]

B:BD[6.25407] → [6.25407:25430]

B:BD[6.25430] → [5.7753:7784]

∅:D[5.7784] → [6.25452:25535]

B:BD[6.25452] → [6.25452:25535]

B:BD[6.25535] → [5.7785:7816]

∅:D[5.7816] → [6.25557:25625]

B:BD[6.25557] → [6.25557:25625]

B:BD[6.25625] → [7.9456:9541]

∅:D[7.9541] → [6.25710:25720]

B:BD[6.25710] → [6.25710:25720]

B:BD[6.25720] → [10.1199:1224]

∅:D[10.1224] → [6.25741:25765]

B:BD[6.25741] → [6.25741:25765]

B:BD[6.25765] → [5.7817:7863]

∅:D[5.7863] → [6.25795:25872]

B:BD[6.25795] → [6.25795:25872]

    unsafe fn unchecked_current_ptr(page: crate::Page, c: &Self::Cursor) -> *const u8 {
        assert!(c.cur >= 0 && c.cur < c.total as isize);
        page.data.as_ptr().add(if c.is_leaf {
            let f = tuple_size::<K, V>();
            let al = K::ALIGN.max(V::ALIGN);
            let hdr = (HDR + al - 1) & !(al - 1);
            hdr + c.cur as usize * f
        } else {
            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64))
                & 0xfff) as usize
        })
    }
    fn current_size(page: crate::Page, c: &Self::Cursor) -> usize {
        assert!(c.cur >= 0 && c.cur < c.total as isize);
        unsafe {
            if c.is_leaf {
                tuple_size::<K, V>()
            } else {
                8 + entry_size::<K, V>(page.data.as_ptr().add(
                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize))
                        & 0xfff) as usize,
                ))
            }
        }
    }
    fn move_next(_page: crate::Page, c: &mut Self::Cursor) -> bool {
        if c.cur < c.total as isize {
            c.cur += 1;
            true
        } else {
            false
        }
    }
    fn move_prev(_page: crate::Page, c: &mut Self::Cursor) -> bool {
        if c.cur > 0 {
            c.cur -= 1;
            true
        } else {
            c.cur = -1;
            false
        }
    }
    fn left_child(page: crate::Page, c: &Self::Cursor) -> u64 {
        assert!(c.cur >= 0);
        if c.is_leaf {
            0
        } else {
            let off =
                unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
            u64::from_le(off) & !0xfff
        }
    }
    fn right_child(page: crate::Page, c: &Self::Cursor) -> u64 {
        assert!(c.cur < c.total as isize);
        if c.is_leaf {
            0
        } else {
            let off =
                unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
            u64::from_le(off) & !0xfff
        }
    }
    fn set_cursor<'a, T: LoadPage>(
        txn: &T,
        page: crate::Page,
        c: &mut PageCursor,
        k0: &K,
        v0: Option<&V>,
    ) -> Result<(&'a K, &'a V, u64), usize> {
        unsafe {
            let lookup = lookup(txn, page, c, k0, v0);
            let result;
            c.cur = match lookup {
                Ok(n) => {
                    result = if c.is_leaf {
                        let f = tuple_size::<K, V>();
                        let off = {
                            let al = K::ALIGN.max(V::ALIGN);
                            let hdr_size = (HDR + al - 1) & !(al - 1);
                            (0, (hdr_size + f * n) as u16)
                        };
                        Ok(Leaf::kv(txn, page, off))
                    } else {
                        let off =
                            u64::from_le(*(page.data.as_ptr().add(HDR + n * 8) as *const u64));
                        Ok(Internal::kv(
                            txn,
                            page,
                            (off & !0xfff, (off & 0xfff) as u16),
                        ))
                    };
                    n as isize
                }
                Err(n) => {
                    result = Err(n);
                    n as isize
                }
            };
            result
        }
    }
    fn split_at(_: crate::Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor) {
        (
            PageCursor {
                cur: 0,
                total: c.cur.max(0) as usize,
                is_leaf: c.is_leaf,
            },
            *c,
        )

[6.20175]

[6.26184]

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

Insertion in sanakirja-core/src/btree/page.rs at line 471 [6.8623]
[6.26190]
[6.26190]
```
    total
```
Replacement in sanakirja-core/src/btree/page.rs at line 545 [6.8623]
B:BD[6.34631] → [17.8331:8349]
```
unsafe fn modify<
```
[7.12021]
[15.5384]
```
fn modify<
```
Replacement in sanakirja-core/src/btree/page.rs at line 582 [6.8623]
B:BD[6.35449] → [17.8729:8746]
```
unsafe fn merge<
```
[6.35449]
[15.5982]
```
fn merge<
```

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

B:BD[14.1271] → [13.1944:2012]

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

[14.1271]

[14.1336]

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

Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 28 [14.387]
[14.1414]
[14.1414]
```
            true,
```

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

∅:D[5.8171] → [13.2392:2525]

∅:D[10.1491] → [13.2392:2525]

B:BD[13.2392] → [13.2392:2525]

    if let Put::Ok(Ok { page, freed }) =
        <Page<K, V>>::put(txn, new_left.0, true, &lc, m.mid.0, m.mid.1, None, 0, rl)?
    {

[10.1491]

[13.2525]

    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
        txn, new_left.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
    )? {

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 153 [14.387]
∅:D[3.8569] → [13.2893:2961]
B:BD[14.4799] → [13.2893:2961]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::replace(
```
[3.8569]
[14.4864]
```
        if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
```
Insertion in sanakirja-core/src/btree/page/rebalance.rs at line 157 [14.387]
[14.4942]
[14.4942]
```
            true,
```

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

B:BD[3.8722] → [3.8722:8857]

    if let Put::Ok(Ok { page, freed }) =
        <Page<K, V>>::put(txn, new_right.0, true, &rc, m.mid.0, m.mid.1, None, r0, rl)?
    {

[3.8722]

[3.8857]

    if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
        txn,
        new_right.0,
        true,
        false,
        &rc,
        m.mid.0,
        m.mid.1,
        None,
        r0,
        rl,
    )? {

Deletion in sanakirja-core/src/btree/mod.rs at line 31 [6.45735]
∅:D[8.50264] → [6.46176:46226]
∅:D[11.8054] → [6.46176:46226]
∅:D[15.13213] → [6.46176:46226]
B:BD[6.46176] → [6.46176:46226]
```
    type Cursor: Clone + Copy + core::fmt::Debug;
```

Insertion in sanakirja-core/src/btree/mod.rs at line 32 [6.45735]

[6.46263]

[5.8428]


    type Cursor: Clone + Copy + core::fmt::Debug;
    /// Whether this cursor is at the end of the page.
    fn is_empty(p: Page, c: &Self::Cursor) -> bool;
    /// Whether this cursor is strictly before the first element.
    fn is_init(p: Page, c: &Self::Cursor) -> bool;

Insertion in sanakirja-core/src/btree/mod.rs at line 44 [6.45735]

[5.8568]


    /// Returns a cursor set to the first element of the page
    /// (i.e. 0). If the page is empty, the returned cursor might be
    /// empty.

Replacement in sanakirja-core/src/btree/mod.rs at line 51 [6.45735]
B:BD[5.8699] → [5.8699:8735]
```
        Self::move_next(p, &mut c);
```
[5.8699]
[5.8735]
```
        Self::move_next(&mut c);
```
Insertion in sanakirja-core/src/btree/mod.rs at line 55 [6.45735]
[5.8791]
[5.8791]

Insertion in sanakirja-core/src/btree/mod.rs at line 59 [6.45735]

[5.8929]


    /// Returns a cursor set to the last element of the page. If the
    /// cursor is empty, this is the same as `cursor_before`.

Replacement in sanakirja-core/src/btree/mod.rs at line 64 [6.45735]
B:BD[5.9018] → [5.9018:9054]
```
        Self::move_prev(p, &mut c);
```
[5.9018]
[5.9054]
```
        Self::move_prev(&mut c);
```

Insertion in sanakirja-core/src/btree/mod.rs at line 67 [6.45735]

[5.9070]

[11.8055]


    /// Return the element currently pointed to by the cursor (if the
    /// cursor is not before or after the elements of the page), and
    /// move the cursor to the next element.

Replacement in sanakirja-core/src/btree/mod.rs at line 77 [6.45735]
∅:D[15.13380] → [7.28545:28580]
B:BD[7.28545] → [7.28545:28580]
```
            Self::move_next(p, c);
```
[15.13380]
[7.28580]
```
            Self::move_next(c);
```

Insertion in sanakirja-core/src/btree/mod.rs at line 83 [6.45735]

[6.46676]

[11.8193]


    /// Move the cursor to the previous element, and return that
    /// element. In that sense, this is not the symmetric of `next`.

Replacement in sanakirja-core/src/btree/mod.rs at line 91 [6.45735]
∅:D[11.8330] → [7.28727:28762]
∅:D[15.13487] → [7.28727:28762]
B:BD[7.28727] → [7.28727:28762]
```
        if Self::move_prev(p, c) {
```
[11.8330]
[15.13488]
```
        if Self::move_prev(c) {
```

Replacement in sanakirja-core/src/btree/mod.rs at line 97 [6.45735]

B:BD[7.28844] → [7.28844:28958]

    fn move_next(p: Page, c: &mut Self::Cursor) -> bool;
    fn move_prev(p: Page, c: &mut Self::Cursor) -> bool;

[7.28844]

[11.8475]


    /// Move the cursor to the next position. Returns whether the
    /// cursor was actually moved (i.e. `true` if and only if the
    /// cursor isn't at the end of the page already).
    fn move_next(c: &mut Self::Cursor) -> bool;
    /// Move the cursor to the previous position. Returns whether the
    /// cursor was actually moved (i.e. `true` if and only if the
    /// cursor isn't strictly before the page).
    fn move_prev(c: &mut Self::Cursor) -> bool;
    /// Returns the current element, if the cursor is pointing at one.

Replacement in sanakirja-core/src/btree/mod.rs at line 114 [6.45735]
∅:D[5.9109] → [7.29221:29298]
B:BD[6.47041] → [7.29221:29298]
```
    unsafe fn unchecked_current_ptr(p: Page, c: &Self::Cursor) -> *const u8;
```
[5.9109]
[7.29298]
```
    /// Returns the size of the entry pointed to by the cursor.
```
Insertion in sanakirja-core/src/btree/mod.rs at line 117 [6.45735]
[7.29355]
[7.29355]
```
    /// Returns the left child of the entry pointed to by the cursor.
```
Insertion in sanakirja-core/src/btree/mod.rs at line 120 [6.45735]
[7.29408]
[7.29408]
```
    /// Returns the right child of the entry pointed to by the cursor.
```

Insertion in sanakirja-core/src/btree/mod.rs at line 123 [6.45735]

[7.29462]

[15.13803]


    /// Sets the cursor to the last element less than or equal to `k0`
    /// if `v0.is_none()`, and to `(k0, v0)` if `v0.is_some()`.

Replacement in sanakirja-core/src/btree/mod.rs at line 133 [6.45735]

∅:D[11.8722] → [7.29531:29659]

B:BD[7.29531] → [7.29531:29659]

B:BD[7.29659] → [5.9110:9161]

    fn split_at(p: Page, c: &Self::Cursor) -> (Self::Cursor, Self::Cursor);
    fn is_empty(p: Page, c: &Self::Cursor) -> bool;
    fn is_init(p: Page, c: &Self::Cursor) -> bool;

[11.8722]

[6.47598]

    fn split_at(c: &Self::Cursor) -> (Self::Cursor, Self::Cursor);

Insertion in sanakirja-core/src/btree/mod.rs at line 165 [6.45735]
[6.48225]
[7.29719]
```
    /// Initialise a page.
```

Replacement in sanakirja-core/src/btree/mod.rs at line 167 [6.45735]

B:BD[7.29752] → [7.29752:29786]

    fn clean(page: &mut MutPage);

[7.29752]

[15.14162]


    /// Add an entry to the page, possibly splitting the page in the
    /// process.

Insertion in sanakirja-core/src/btree/mod.rs at line 174 [6.45735]
[6.48362]
[6.48362]
```
        replace: bool,
```

Insertion in sanakirja-core/src/btree/mod.rs at line 183 [6.45735]

[6.48501]

[15.14193]

    /// Update the left child of the position pointed to by the
    /// cursor.

Insertion in sanakirja-core/src/btree/mod.rs at line 194 [6.45735]

[9.2050]


    /// Save a leaf entry as a replacement, when we delete at an
    /// internal node. This can be a pointer to the leaf if the leaf
    /// isn't mutated, or the actual value, or something else.

Replacement in sanakirja-core/src/btree/mod.rs at line 200 [6.45735]

B:BD[9.2112] → [9.2112:2177]

    unsafe fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V);

[9.2112]

[9.2177]

    /// Recover the saved value.
    fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V);

Insertion in sanakirja-core/src/btree/mod.rs at line 203 [6.45735]

[9.2178]

[11.8946]

    /// Delete an entry on the page, returning the resuting page along
    /// with the offset of the freed page (or 0 if no page was freed,
    /// i.e. if `page` is mutable).

Replacement in sanakirja-core/src/btree/mod.rs at line 214 [6.45735]
B:BD[6.48758] → [15.14344:14378]
∅:D[15.14378] → [6.48778:48799]
B:BD[6.48778] → [6.48778:48799]
B:BD[6.48799] → [7.29931:29954]
∅:D[7.29954] → [6.48819:48906]
B:BD[6.48819] → [6.48819:48906]
B:BD[6.48906] → [17.13913:13951]
∅:D[17.13951] → [6.48906:48938]
B:BD[6.48906] → [6.48906:48938]
B:BD[6.48938] → [17.13952:13994]
∅:D[17.13994] → [6.49207:49208]
B:BD[6.49207] → [6.49207:49208]
```
    fn replace<'a, T: AllocPage>(
        txn: &mut T,
        page: CowPage,
        mutable: bool,
        c: &Self::Cursor,
        k0: &'a K,
        v0: &'a V,
        k1v1: Option<(&'a K, &'a V)>,
        l: u64,
        r: u64,
    ) -> Result<Put<'a, K, V>, T::Error>;
```
[6.48758]
[15.14379]
```
    /// Merge, rebalance or update a concatenation.
```

Deletion in sanakirja-core/src/btree/mod.rs at line 219 [6.45735]

B:BD[6.49343] → [6.49343:49344]

B:BD[6.49344] → [15.14473:14506]

∅:D[15.14506] → [6.49363:49384]

B:BD[6.49363] → [6.49363:49384]

B:BD[6.49384] → [15.14507:14553]

∅:D[7.30087] → [6.49429:49472]

∅:D[15.14553] → [6.49429:49472]

B:BD[6.49429] → [6.49429:49472]

B:BD[6.49472] → [3.10307:10342]

∅:D[3.10342] → [16.5469:5507]

B:BD[6.49472] → [16.5469:5507]

∅:D[16.5507] → [7.30129:30159]

B:BD[7.30129] → [7.30129:30159]

B:BD[7.30159] → [17.13995:14080]

∅:D[17.14080] → [6.49773:49794]

∅:D[7.30238] → [6.49773:49794]

∅:D[16.5589] → [6.49773:49794]

B:BD[6.49773] → [6.49773:49794]

B:BD[6.49794] → [17.14081:14162]

∅:D[17.14162] → [6.50115:50129]

∅:D[7.30314] → [6.50115:50129]

∅:D[16.5667] → [6.50115:50129]

B:BD[6.50115] → [6.50115:50129]

B:BD[6.50129] → [7.30315:30332]

B:BD[7.30332] → [18.3391:3421]

B:BD[18.3421] → [3.10343:10475]

∅:D[3.10475] → [16.5668:5700]

B:BD[18.3742] → [16.5668:5700]

B:BD[16.5700] → [11.9095:9224]

∅:D[11.9224] → [16.5701:5825]

B:BD[18.3853] → [16.5701:5825]

B:BD[16.5825] → [11.9225:9352]

∅:D[16.5913] → [18.3853:3867]

∅:D[11.9352] → [18.3853:3867]

B:BD[18.3853] → [18.3853:3867]

∅:D[7.30617] → [6.50129:50146]

∅:D[18.3867] → [6.50129:50146]

B:BD[6.50129] → [6.50129:50146]

B:BD[6.50146] → [15.14554:14606]


    fn modify<'a, T: AllocPage>(
        txn: &mut T,
        m: &mut ModifiedPage<'a, K, V, Self>,
    ) -> Result<Put<'a, K, V>, T::Error> {
        debug!("modify: {:?}", m);
        if let Some((k, v)) = m.ins {
            if m.skip_first {
                Self::replace(txn, m.page, m.mutable, &m.c1, k, v, m.ins2, m.l, m.r)
            } else {
                Self::put(txn, m.page, m.mutable, &m.c1, k, v, m.ins2, m.l, m.r)
            }
        } else {
            if m.skip_first {
                let (page, freed) = Self::del(txn, m.page, m.mutable, &m.c1, m.l)?;
                Ok(Put::Ok(Ok { freed, page }))
            } else if m.l > 0 {
                Ok(Put::Ok(Self::update_left_child(
                    txn, m.page, m.mutable, &m.c1, m.l,
                )?))
            } else {
                let mut c1 = m.c1.clone();
                Self::move_next(m.page.as_page(), &mut c1);
                Ok(Put::Ok(Self::update_left_child(
                    txn, m.page, m.mutable, &c1, m.r,
                )?))
            }
        }
    }
    fn size(m: &ModifiedPage<K, V, Self>) -> usize;

Replacement in sanakirja-core/src/btree/mod.rs at line 270 [6.45735]
B:BD[6.51424] → [7.30856:30912]
```
            P::move_next(self.page.as_page(), &mut c1);
```
[6.51424]
[6.51471]
```
            P::move_next(&mut c1);
```

Replacement in sanakirja-core/src/btree/del.rs at line 179 [6.52511]

B:BD[5.9929] → [5.9929:9998]

    let (c0, c1) = P::split_at(curs0.page.as_page(), &curs0.cursor);

[5.9929]

[19.1714]

    let (c0, c1) = P::split_at(&curs0.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 234 [6.52511]

B:BD[19.2423] → [19.2423:2496]

        let (k0, v0) = unsafe { P::from_saved(k0v0.as_ref().unwrap()) };

[19.2423]

[19.2496]

        let (k0, v0) = P::from_saved(k0v0.as_ref().unwrap());

Replacement in sanakirja-core/src/btree/del.rs at line 306 [6.52511]

B:BD[14.34502] → [5.10499:10570]

        let (c0, c1) = P::split_at(curs.page.as_page(), &curs.cursor);

[14.34502]

[14.34609]

        let (c0, c1) = P::split_at(&curs.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 368 [6.52511]

B:BD[9.3208] → [9.3208:3280]

                    last_op.ins = Some(unsafe { P::from_saved(k0v0) });

[9.3208]

[9.3280]

                    last_op.ins = Some(P::from_saved(k0v0));

Replacement in sanakirja-core/src/btree/del.rs at line 397 [6.52511]

B:BD[9.3342] → [9.3342:3414]

                    last_op.ins = Some(unsafe { P::from_saved(k0v0) });

[9.3342]

[9.3414]

                    last_op.ins = Some(P::from_saved(k0v0));

Replacement in sanakirja-core/src/btree/del.rs at line 413 [6.52511]

B:BD[19.6177] → [19.6177:6243]

                    let (k0, _) = unsafe { P::from_saved(k0v0) };

[19.6177]

[19.6243]

                    let (k0, _) = P::from_saved(k0v0);

Replacement in sanakirja-core/src/btree/del.rs at line 477 [6.52511]
B:BD[15.22255] → [15.22255:22308]
```
            P::move_next(m.page.as_page(), &mut c1);
```
[15.22255]
[15.22308]
```
            P::move_next(&mut c1);
```
Replacement in sanakirja-core/src/btree/del.rs at line 554 [6.52511]
∅:D[19.7364] → [14.38633:38675]
B:BD[14.38633] → [14.38633:38675]
```
    match P::modify(txn, &mut last_op)? {
```
[19.7364]
[19.7365]
```
    match modify::<_, K, V, P>(txn, &mut last_op)? {
```

Replacement in sanakirja-core/src/btree/del.rs at line 570 [6.52511]

B:BD[5.10686] → [5.10686:10738]

B:BD[5.10738] → [19.7633:7713]

            P::move_next(page.0.as_page(), &mut c);
            P::put(txn, page.0, true, &c, k, v, None, l.0.offset, r.0.offset)?;

[5.10686]

[9.3820]

            P::move_next(&mut c);
            P::put(
                txn, page.0, true, false, &c, k, v, None, l.0.offset, r.0.offset,
            )?;

Replacement in sanakirja-core/src/btree/del.rs at line 575 [6.52511]

B:BD[9.3885] → [9.3885:3947]

                let (k0, _) = unsafe { P::from_saved(k0v0) };

[9.3885]

[19.7714]

                let (k0, _) = P::from_saved(k0v0);

Insertion in sanakirja-core/src/btree/del.rs at line 590 [6.52511]

[6.63669]


/// Apply the modifications to a page.
fn modify<
    'a,
    T: AllocPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreeMutPage<K, V>,
>(
    txn: &mut T,
    m: &mut ModifiedPage<'a, K, V, P>,
) -> Result<Put<'a, K, V>, T::Error> {
    debug!("modify: {:?}", m);
    if let Some((k, v)) = m.ins {
        P::put(
            txn,
            m.page,
            m.mutable,
            m.skip_first,
            &m.c1,
            k,
            v,
            m.ins2,
            m.l,
            m.r,
        )
    } else {
        if m.skip_first {
            let (page, freed) = P::del(txn, m.page, m.mutable, &m.c1, m.l)?;
            Ok(Put::Ok(Ok { freed, page }))
        } else if m.l > 0 {
            Ok(Put::Ok(P::update_left_child(
                txn, m.page, m.mutable, &m.c1, m.l,
            )?))
        } else {
            let mut c1 = m.c1.clone();
            P::move_next(&mut c1);
            Ok(Put::Ok(P::update_left_child(
                txn, m.page, m.mutable, &c1, m.r,
            )?))
        }
    }
}

Replacement in sanakirja-core/src/btree/cursor.rs at line 200 [6.63682]

B:BD[20.84] → [10.2293:2368]

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

[20.84]

[10.2368]

                P::move_next(&mut current.cursor);

Replacement in sanakirja-core/src/btree/cursor.rs at line 211 [6.63682]

∅:D[12.8186] → [10.2447:2522]

B:BD[5.12721] → [10.2447:2522]

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

[12.8186]

[5.12796]

                P::move_next(&mut current.cursor);

Replacement in sanakirja-core/src/btree/cursor.rs at line 246 [6.63682]

B:BD[10.2716] → [10.2716:2795]

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

[10.2716]

[5.13838]

                    P::move_prev(&mut current.cursor);

Replacement in sanakirja-core/src/btree/cursor.rs at line 259 [6.63682]

B:BD[10.2902] → [10.2902:2981]

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

[10.2902]

[6.70713]

                    P::move_prev(&mut current.cursor);

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

B:BD[10.3068] → [10.3068:3143]

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

[10.3068]

[5.14441]

                P::move_prev(&mut current.cursor);

Cleanup + comments

Dependencies

In channels

Change contents

Insertion in sanakirja-core/src/btree/put.rs at line 38 [6.3448]

Insertion in sanakirja-core/src/btree/put.rs at line 88 [6.3448]

Insertion in sanakirja-core/src/btree/put.rs at line 106 [6.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 174 [6.3448]

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 31 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 36 [8.2014]

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 40 [8.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 44 [8.2014]

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

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 71 [8.2014]

Deletion in sanakirja-core/src/btree/page_unsized.rs at line 80 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 196 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 210 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 236 [8.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 240 [8.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 275 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 347 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 355 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 363 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 430 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 547 [8.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 585 [8.2014]

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

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

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

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

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

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

Deletion in sanakirja-core/src/btree/page_unsized/header.rs at line 63 [14.15503]

Insertion in sanakirja-core/src/btree/page.rs at line 29 [6.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 178 [6.8623]

Deletion in sanakirja-core/src/btree/page.rs at line 197 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 208 [6.8623]

Deletion in sanakirja-core/src/btree/page.rs at line 212 [6.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 216 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 230 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 243 [6.8623]

Deletion in sanakirja-core/src/btree/page.rs at line 254 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 375 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 385 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 411 [6.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 415 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 450 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 468 [6.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 471 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 545 [6.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 582 [6.8623]

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

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

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

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

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

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

Deletion in sanakirja-core/src/btree/mod.rs at line 31 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 32 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 44 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 51 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 55 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 59 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 64 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 67 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 77 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 83 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 91 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 97 [6.45735]

Replacement in sanakirja-core/src/btree/mod.rs at line 114 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 117 [6.45735]

Insertion in sanakirja-core/src/btree/mod.rs at line 120 [6.45735]