pijul/sanakirja - Change SYURNHHL3P22ZAERTML4YW3DYLATHY5ALZH4GL5NF3LENDSKL2NQC

Adding the `put_mut` and `set_left_child` methods

Created by pmeunier on March 9, 2021

SYURNHHL3P22ZAERTML4YW3DYLATHY5ALZH4GL5NF3LENDSKL2NQC

Dependencies

In channels

main

Change contents

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 341 [3.2014]

[3.4585]

[4.9840]

    unsafe fn put_mut(
        page: &mut MutPage,
        c: &Self::Cursor,
        k0: &K,
        v0: &V,
        r: u64,
    ) {
        let mut n = c.cur;
        if r == 0 {
            Leaf::alloc_write(page, k0, v0, 0, r, &mut n);
        } else {
            Internal::alloc_write(page, k0, v0, 0, r, &mut n);
        }
    }
    unsafe fn set_left_child(
        page: &mut MutPage,
        c: &Self::Cursor,
        l: u64
    ) {
        let off = (page.0.data.add(HDR) as *mut u64).offset(c.cur - 1);
        *off = (l | (u64::from_le(*off) & 0xfff)).to_le();
    }

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

[5.11472]

[6.10883]

    unsafe fn put_mut(
        page: &mut MutPage,
        c: &Self::Cursor,
        k0: &K,
        v0: &V,
        r: u64,
    ) {
        use super::page_unsized::AllocWrite;
        let mut n = c.cur;
        if r == 0 {
            Leaf::alloc_write(page, k0, v0, 0, r, &mut n);
        } else {
            Internal::alloc_write(page, k0, v0, 0, r, &mut n);
        }
    }
    unsafe fn set_left_child(
        page: &mut MutPage,
        c: &Self::Cursor,
        l: u64
    ) {
        let off = (page.0.data.add(HDR) as *mut u64).offset(c.cur - 1);
        *off = (l | (u64::from_le(*off) & 0xfff)).to_le();
    }

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

[5.48501]

[7.11013]

    /// Add an entry to `page`, at position `c`. Does not check
    /// whether there is enough space to do so. This method is mostly
    /// useful for cloning pages.
    #[allow(unused_variables)]
    unsafe fn put_mut(
        page: &mut MutPage,
        c: &Self::Cursor,
        k0: &K,
        v0: &V,
        r: u64,
    ) {
        unimplemented!()
    }
    #[allow(unused_variables)]
    unsafe fn set_left_child(
        page: &mut MutPage,
        c: &Self::Cursor,
        l: u64
    ) {
        unimplemented!()
    }

Replacement in sanakirja/src/tests.rs at line 341 [9.11]

∅:D[8.14949] → [9.2983:3039]

B:BD[9.2983] → [9.2983:3039]

    let (k, _) = curs.set_last(&txn).unwrap().unwrap();

[8.14949]

[9.3039]

    curs.set_last(&txn).unwrap();
    let (k, _) = curs.prev(&txn).unwrap().unwrap();

Replacement in sanakirja/src/tests.rs at line 391 [9.11]

∅:D[8.15017] → [9.5592:5650]

B:BD[9.5592] → [9.5592:5650]

    let (&nn, _) = curs.set_last(&txn).unwrap().unwrap();

[8.15017]

[10.1518]

    curs.set_last(&txn).unwrap();
    let (&nn, _) = curs.prev(&txn).unwrap().unwrap();

Replacement in sanakirja/src/tests.rs at line 413 [9.11]

B:BD[11.507] → [11.507:560]

    assert!(curs.set_last(&txn).unwrap().is_none());

[11.507]

[9.5674]

    curs.set_last(&txn).unwrap();
    assert!(curs.next(&txn).unwrap().is_none());

Replacement in sanakirja/src/tests.rs at line 440 [9.11]

B:BD[12.382] → [12.382:443]

B:BD[12.443] → [13.103:122]

    let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
    let n = 20u64;

[12.382]

[13.122]

    let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
    let n = 200u64;

Replacement in sanakirja/src/tests.rs at line 445 [9.11]

B:BD[14.10883] → [14.10883:10932]

        put(&mut txn, &mut db, &i, &i).unwrap();

[14.10883]

[14.10932]

        let a = A([i; 100]);
        put(&mut txn, &mut db, &i, &a).unwrap();

Replacement in sanakirja/src/tests.rs at line 451 [9.11]
B:BD[14.10997] → [15.3723:3771]
```
    let _db2 = fork_db(&mut txn, &db).unwrap();
```
[14.10997]
[14.11044]
```
    let db2 = fork_db(&mut txn, &db).unwrap();
```
Insertion in sanakirja/src/tests.rs at line 453 [9.11]
[14.11092]
[14.11092]
```
    debug(&txn, &[&db, &db2], "debug0", true);
```

Replacement in sanakirja/src/lib.rs at line 108 [5.79574]

B:BD[13.6634] → [13.6634:6717]

pub use sanakirja_core::{btree, direct_repr, LoadPage, Storable, UnsizedStorable};

[13.6634]

[16.312]

pub use sanakirja_core::{btree, direct_repr, LoadPage, AllocPage, Storable, UnsizedStorable, MutPage, CowPage, Page};

Insertion in sanakirja/src/environment/muttxn.rs at line 413 [5.80166]
[13.17561]
[13.17561]
```
            debug!("free_for_all {:?}", i);
```

Replacement in sanakirja/src/environment/muttxn.rs at line 492 [5.80166]

B:BD[5.89127] → [2.20030:20082]

            debug!("incr rc {:?} {:?}", off, rc+1);

[5.89127]

[13.19176]

            debug!("incr rc 0x{:x} {:?}", off, rc+1);

Insertion in sanakirja/src/environment/mod.rs at line 589 [5.91606]

[8.18025]

        }
    }
}
impl<E: Borrow<Env>> Txn<E> {
    /// A "raw" version of the `root_db` method, useful to store
    /// things other than databases.
    pub fn root(&self, n: usize) -> u64 {
        assert!(n <= (4096 - GLOBAL_HEADER_SIZE) / 8);
        unsafe {
            let env = self.env.borrow();
            let maps = env.mmaps.lock();
            *(maps[0]
              .ptr
              .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
              as *mut u64)

Deletion in sanakirja/src/debug.rs at line 100 [17.11]
B:BD[17.2481] → [2.20722:20773]
```
    debug!("CURSOR: {:?} {:?}", p.offset, cursor);
```