Debugging after plugging this into Pijul

[?]

Feb 9, 2021, 8:13 PM

XEU2QVLCHPYOOD4TQIPEEVYOVSFMKFPLJYWEJYXYJAZ7S54KWDZAC

Dependencies

[2] SO25TWFL A few features for integrating it into Pijul
[3] LROAI3NB Two iterators (convenience functions), along with tests to move cursors (put and del still destroy cursors though)
[4] DV4A2LR7 Double-inserts (rebalancing near an internal deletion)
[5] 7WJNSPEW Using the same definition of the "occupied" field uniform everywhere
[6] 6DMPXOAT More debugging
[7] WS4ZQM4R Debugging, tests, etc.
[8] EHJFNMB2 Debugging
[9] OTWDDJE7 Trait/type cleanup
[10] EAAYH6BQ Debugging put
[11] H3FVSQIQ Unsized pages
[12] OP6SVMOD Resetting history
[13] KM3JAFGP Adding a test for next/prev
[14] YWFYZNLZ Cleanup + inter-process concurrency
[15] UUUVNC4D Debugging/cleanup around cursors
[16] S4V4QZ5C Debugging reference-counting for put
[17] YXKP4AIW New file locks, with multiple sets of free pages
[18] OFINGD26 implementing prev() on cursors (+ some cleanup)
[19] W26CFMAQ Improving safety of cursors
[20] 6UVFCERM Formatting, debugging, etc.
[21] KMT3MF5N Drop a database
[22] G4JEQLLX Debugging synchronisation
[23] X3QVVQIS More debugging (del seems to work now)
[24] QEUTVAZ4 Splitting btree::page
[25] KX3WVNZW Testing/debugging "rebalance causes split of the root"
[26] AOX2XQIS Actually, with the correct functions, Unsized pages are always slower than Sized pages (especially for writing)
[27] 6DCQHIFP Minor changes after benchmarking
[28] NQBEOCFO Tests cleanup
[29] UAQX27N4 Tests
[30] PXF3R6SV Improving test coverage for btree::cursor

Change contents

edit in sanakirja-core/src/lib.rs at line 3

[4.118]

[4.118]

pub const PAGE_SIZE: usize = 4096;
replacement in sanakirja-core/src/lib.rs at line 13

[4.444]→[4.27:95](∅→∅)

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

[4.444]

[4.505]

fn compare<T: LoadPage>(&self, txn: &T, b: &Self) -> core::cmp::Ordering;
replacement in sanakirja-core/src/lib.rs at line 23

[2.64]→[4.96:166](∅→∅),[4.761]→[4.96:166](∅→∅)

unsafe fn from_raw_ptr<'a, T>(txn: &T, p: *const u8) -> &'a Self;

[2.64]

[2.65]

unsafe fn from_raw_ptr<'a, T: LoadPage>(txn: &T, p: *const u8) -> &'a Self;
replacement in sanakirja-core/src/lib.rs at line 94

[4.469]→[4.0:73](∅→∅)

unsafe fn read<T, K: Representable + ?Sized, V: Representable + ?Sized>(

[4.469]

[4.73]

unsafe fn read<T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(
edit in sanakirja-core/src/lib.rs at line 129

[4.2494]→[4.283:315](∅→∅)

const PAGE_SIZE: usize = 4096;
edit in sanakirja-core/src/lib.rs at line 147

[4.2555]

[4.504]

/// The layout of pages is as follows: the LSB of the first byte is
/// "dirty".
replacement in sanakirja-core/src/lib.rs at line 154

[4.2606]→[4.2606:2723](∅→∅)

unsafe {
let d = *self.0.data.offset(8);
*self.0.data.offset(8) = d & (!1)
}

[4.2606]

[4.2723]

unsafe { *self.0.data &= 0xfe }
edit in sanakirja-core/src/btree/put.rs at line 47

[4.136]→[4.45:78](∅→∅),[4.4780]→[4.45:78](∅→∅)

debug!("free = {:?}", free);
edit in sanakirja-core/src/btree/page_unsized.rs at line 8

[4.2101]

[4.2128]

pub(in super::super) mod header;
replacement in sanakirja-core/src/btree/page_unsized.rs at line 10

[4.2143]→[4.1028:1080](∅→∅)

use super::page::header::{header, header_mut, HDR};

[4.2143]

[4.2143]

use header::*;
edit in sanakirja-core/src/btree/page_unsized.rs at line 13

[4.2162]→[4.2162:2194](∅→∅)

const PAGE_SIZE: usize = 4096;
replacement in sanakirja-core/src/btree/page_unsized.rs at line 94

[4.4469]→[4.4469:4578](∅→∅)

let new = Self::del(txn, page, c, l)?;
Self::put(txn, new.0, mutable, c, k0, v0, k1v1, l, r)

[4.4469]

[4.4578]

let new = Self::del(txn, page, mutable, c, l)?;
Self::put(txn, new.0, true, c, k0, v0, k1v1, l, r)
edit in sanakirja-core/src/btree/page_unsized.rs at line 134

[4.1267]

[3.25]

mutable: bool,
replacement in sanakirja-core/src/btree/page_unsized.rs at line 139

[4.710]→[4.6155:6199](∅→∅),[4.6155]→[4.6155:6199](∅→∅)

if Self::is_dirty(page.as_page()) {

[4.710]

[4.6199]

if mutable && Self::is_dirty(page.as_page()) {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 259

[4.10975]→[4.10975:11065](∅→∅)

page: Self::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?,

[4.10975]

[4.11065]

page: Self::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?,
replacement in sanakirja-core/src/btree/page_unsized.rs at line 314

[4.1691]→[4.1691:1827](∅→∅)

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

[4.1691]

[4.1827]

let off = {
u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16))
as usize
};
replacement in sanakirja-core/src/btree/page_unsized.rs at line 341

[4.13392]→[4.2632:2734](∅→∅),[4.2734]→[4.13485:13510](∅→∅),[4.13485]→[4.13485:13510](∅→∅)

(u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)
as usize

[4.13392]

[4.13510]

(u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64))
& 0xfff) as usize
replacement in sanakirja-core/src/btree/page_unsized.rs at line 353

[4.13967]→[4.2816:2919](∅→∅),[4.2919]→[4.14067:14101](∅→∅),[4.14067]→[4.14067:14101](∅→∅)

(u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur)) & 0xfff)
as usize,

[4.13967]

[4.14101]

(u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur))
& 0xfff) as usize,
replacement in sanakirja-core/src/btree/page_unsized.rs at line 381

[4.14642]→[4.3014:3120](∅→∅)

let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };

[4.14642]

[4.14739]

let off =
unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
replacement in sanakirja-core/src/btree/page_unsized.rs at line 446

[4.16540]→[4.16540:16615](∅→∅)

unsafe fn lookup<T, K: Representable + ?Sized, V: Representable + ?Sized>(

[4.16540]

[4.16615]

unsafe fn lookup<T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 513

[3.304]→[4.3377:3472](∅→∅),[4.18917]→[4.3377:3472](∅→∅)

pub(in super) cur: isize,
pub(in super) total: usize,
pub(in super) is_leaf: bool,

[3.304]

[4.3472]

pub(super) cur: isize,
pub(super) total: usize,
pub(super) is_leaf: bool,
replacement in sanakirja-core/src/btree/page_unsized.rs at line 519

[3.323]→[3.323:386](∅→∅)

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

[3.323]

[4.3554]

pub(super) fn new(p: crate::Page, cur: isize) -> Self {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 528

[4.3747]→[3.409:462](∅→∅)

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

[4.3747]

[4.3802]

pub(super) fn after(p: crate::Page) -> Self {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 537

[4.3997]→[3.485:537](∅→∅)

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

[4.3997]

[4.4051]

pub(super) fn last(p: crate::Page) -> Self {
edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 1

[4.22926]

[4.22927]

use super::header::header;
edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 3

[4.22941]→[4.2301:2341](∅→∅)

use crate::btree::page::header::header;
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 49

[4.24156]→[4.24156:24235](∅→∅)

<Page<K, V>>::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?

[4.24156]

[4.24235]

<Page<K, V>>::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 76

[4.24432]→[4.24432:24486](∅→∅)

<Page<K, V>>::del(txn, m.other, &rc, r)?,

[4.24432]

[4.24486]

<Page<K, V>>::del(txn, m.other, m.other_is_mutable, &rc, r)?,
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 141

[4.26272]→[4.26272:26351](∅→∅)

<Page<K, V>>::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?

[4.26272]

[4.26351]

<Page<K, V>>::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 165

[4.26559]→[4.26559:26620](∅→∅)

let new_left = <Page<K, V>>::del(txn, m.other, &lc, 0)?;

[4.26559]

[4.26620]

let new_left = <Page<K, V>>::del(txn, m.other, m.other_is_mutable, &lc, 0)?;
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 1

[4.27023]→[4.2342:2401](∅→∅)

use super::super::page::header::{header, header_mut, HDR};

[4.27023]

[4.27024]

use super::header::{header, header_mut, HDR};
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 51

[4.28669]→[4.28669:28793](∅→∅)

alloc::<_, _, L>(&mut new, k0, v0, 0, 0, &mut n);
alloc::<_, _, L>(&mut new, k1, v1, l, r, &mut n);

[4.28669]

[4.28793]

alloc::<_, _, L>(&mut new, k0, v0, 0, l, &mut n);
alloc::<_, _, L>(&mut new, k1, v1, 0, r, &mut n);
file move: header.rs (-xw-x--x--) → header.rs (-xw-x--x--)

[4.22910]

[4.15503]
edit in sanakirja-core/src/btree/page_unsized/header.rs at line 1

[4.15503]

[4.15504]

use crate::PAGE_SIZE;
edit in sanakirja-core/src/btree/page_unsized/header.rs at line 6

[4.15552]

[4.15552]

data: u16,
edit in sanakirja-core/src/btree/page_unsized/header.rs at line 8

[4.15564]→[4.15564:15579](∅→∅)

data: u16,
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 14

[4.15659]→[4.15659:15744](∅→∅)

self.n = (1u16).to_le(); // dirty page
self.data = 4096_u16.to_le();

[4.15659]

[4.15744]

self.data = (((PAGE_SIZE as u16) << 1) | 1).to_le();
self.n = 0;
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 21

[4.15830]→[4.15830:15864](∅→∅)

u16::from_le(self.n) >> 4

[4.15830]

[4.15864]

u16::from_le(self.n)
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 25

[4.15909]→[4.15909:15999](∅→∅)

let dirty = u16::from_le(self.n) & 1;
self.n = ((n << 4) | dirty).to_le()

[4.15909]

[4.15999]

self.n = n.to_le();
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 29

[4.16043]→[4.16043:16081](∅→∅)

u16::from_le(self.n) & 1 != 0

[4.16043]

[4.16081]

u16::from_le(self.data) & 1 != 0
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 41

[4.16289]→[4.16289:16321](∅→∅)

u16::from_le(self.data)

[4.16289]

[4.16321]

u16::from_le(self.data) >> 1
replacement in sanakirja-core/src/btree/page_unsized/header.rs at line 45

[4.16369]→[4.16369:16399](∅→∅)

self.data = d.to_le()

[4.16369]

[4.16399]

let dirty = u16::from_le(self.data) & 1;
self.data = ((d << 1) | dirty).to_le()
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 1

[4.33822]→[4.2877:2944](∅→∅)

use super::super::page::header::{header, header_mut, Header, HDR};

[4.33822]

[4.33823]

use super::header::{header, header_mut, Header, HDR};
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 29

[4.35011]→[4.35011:35083](∅→∅)

fn kv<'a, T, K: Representable + ?Sized, V: Representable + ?Sized>(

[4.35011]

[4.35083]

fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 82

[4.3623]→[4.3623:3643](∅→∅)

<= 4096

[4.3623]

[4.36463]

<= PAGE_SIZE
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 162

[4.39262]→[4.39262:39334](∅→∅)

fn kv<'a, T, K: Representable + ?Sized, V: Representable + ?Sized>(

[4.39262]

[4.39334]

fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 196

[4.4566]→[4.4566:4586](∅→∅)

<= 4096

[4.4566]

[4.40203]

<= PAGE_SIZE
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 291

[4.43370]→[4.43370:43442](∅→∅)

fn kv<'a, T, K: Representable + ?Sized, V: Representable + ?Sized>(

[4.43370]

[4.43442]

fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(
edit in sanakirja-core/src/btree/page.rs at line 8

[4.34]→[4.5002:5035](∅→∅)

pub(in super::super) mod header;
replacement in sanakirja-core/src/btree/page.rs at line 10

[4.76]→[4.76:94](∅→∅)

use rebalance::*;

[4.76]

[3.928]

use super::page_unsized::header;
edit in sanakirja-core/src/btree/page.rs at line 12

[3.969]

[4.94]

use rebalance::*;
edit in sanakirja-core/src/btree/page.rs at line 14

[4.95]→[4.8651:8682](∅→∅),[4.8651]→[4.8651:8682](∅→∅),[4.8682]→[4.44312:44313](∅→∅)

const PAGE_SIZE: usize = 4096;
replacement in sanakirja-core/src/btree/page.rs at line 111

[4.1404]→[4.1404:1513](∅→∅)

let new = Self::del(txn, page, c, l)?;
Self::put(txn, new.0, mutable, c, k0, v0, k1v1, l, r)

[4.1380]

[4.1513]

let new = Self::del(txn, page, mutable, c, l)?;
Self::put(txn, new.0, true, c, k0, v0, k1v1, l, r)
edit in sanakirja-core/src/btree/page.rs at line 150

[4.5238]

[3.995]

mutable: bool,
replacement in sanakirja-core/src/btree/page.rs at line 155

[4.5196]→[4.2759:2803](∅→∅),[4.12692]→[4.2759:2803](∅→∅)

if Self::is_dirty(page.as_page()) {

[4.5196]

[4.2803]

if mutable && Self::is_dirty(page.as_page()) {
replacement in sanakirja-core/src/btree/page.rs at line 273

[4.3740]→[4.6338:6428](∅→∅),[4.6338]→[4.6338:6428](∅→∅)

page: Self::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?,

[4.3740]

[4.6428]

page: Self::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?,
replacement in sanakirja-core/src/btree/page.rs at line 345

[4.6625]→[4.6625:6731](∅→∅)

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

[4.6625]

[4.6731]

let off =
u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize));
replacement in sanakirja-core/src/btree/page.rs at line 364

[4.20628]→[4.7133:7235](∅→∅),[4.7235]→[4.3997:4022](∅→∅),[4.3997]→[4.3997:4022](∅→∅)

(u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)
as usize

[4.20628]

[4.20721]

(u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64))
& 0xfff) as usize
replacement in sanakirja-core/src/btree/page.rs at line 375

[4.3817]→[4.7294:7403](∅→∅),[4.7403]→[4.4324:4358](∅→∅),[4.4324]→[4.4324:4358](∅→∅)

(u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize)) & 0xfff)
as usize,

[4.3817]

[4.21394]

(u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize))
& 0xfff) as usize,
replacement in sanakirja-core/src/btree/page.rs at line 403

[4.21753]→[4.7498:7604](∅→∅)

let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };

[4.21753]

[4.21841]

let off =
unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };
replacement in sanakirja-core/src/btree/page.rs at line 413

[4.22016]→[4.7649:7752](∅→∅)

let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };

[4.22016]

[4.22098]

let off =
unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
replacement in sanakirja-core/src/btree/page.rs at line 470

[4.9543]→[4.49:111](∅→∅)

fn leaf_linear_search<T, K: Representable, V: Representable>(

[4.9543]

[4.111]

fn leaf_linear_search<T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page.rs at line 486

[4.429]→[4.429:486](∅→∅)

unsafe fn lookup<T, K: Representable, V: Representable>(

[4.429]

[4.9608]

unsafe fn lookup<T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 48

[4.1650]→[4.1650:1729](∅→∅)

<Page<K, V>>::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?

[4.1650]

[4.1729]

<Page<K, V>>::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 105

[4.3306]→[4.3306:3364](∅→∅)

<Page<K, V>>::del(txn, m.other, &rc, r)?,

[4.3306]

[4.3364]

<Page<K, V>>::del(txn, m.other, m.other_is_mutable, &rc, r)?,
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 169

[4.5178]→[4.5178:5257](∅→∅)

<Page<K, V>>::del(txn, m.modified.page, &m.modified.c1, m.modified.l)?

[4.5178]

[4.5257]

<Page<K, V>>::del(
txn,
m.modified.page,
m.modified.mutable,
&m.modified.c1,
m.modified.l,
)?
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 193

[4.5465]→[4.5465:5526](∅→∅)

let new_left = <Page<K, V>>::del(txn, m.other, &lc, 0)?;

[4.5465]

[4.5526]

let new_left = <Page<K, V>>::del(txn, m.other, m.other_is_mutable, &lc, 0)?;
replacement in sanakirja-core/src/btree/page/alloc.rs at line 9

[4.17650]→[4.10569:10630](∅→∅)

fn truncate_left<T, K: Representable, V: Representable>(

[4.17650]

[4.10630]

fn truncate_left<T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 24

[4.18160]→[4.10706:10770](∅→∅)

fn offset_slice<'a, T, K: Representable, V: Representable>(

[4.18160]

[4.18230]

fn offset_slice<'a, T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 27

[4.18297]→[4.10771:10825](∅→∅)

fn kv<'a, T, K: Representable, V: Representable>(

[4.18297]

[4.10825]

fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 94

[4.20842]→[4.11379:11440](∅→∅)

fn truncate_left<T, K: Representable, V: Representable>(

[4.20842]

[4.11440]

fn truncate_left<T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 172

[4.25230]→[4.11872:11936](∅→∅)

fn offset_slice<'a, T, K: Representable, V: Representable>(

[4.25230]

[4.25300]

fn offset_slice<'a, T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 178

[4.25752]→[4.11982:12036](∅→∅)

fn kv<'a, T, K: Representable, V: Representable>(

[4.25752]

[4.12036]

fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 202

[4.7746]→[4.7746:7766](∅→∅)

<= 4096

[4.7746]

[4.26527]

<= PAGE_SIZE
replacement in sanakirja-core/src/btree/page/alloc.rs at line 284

[4.29672]→[4.12823:12877](∅→∅)

fn kv<'a, T, K: Representable, V: Representable>(

[4.29672]

[4.12877]

fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/mod.rs at line 3

[4.45766]→[3.1611:1668](∅→∅)

pub use cursor::{Cursor, iter, rev_iter, Iter, RevIter};

[4.45766]

[4.45766]

pub use cursor::{iter, rev_iter, Cursor, Iter, RevIter};
edit in sanakirja-core/src/btree/mod.rs at line 157

[4.9016]

[4.9016]

mutable: bool,
replacement in sanakirja-core/src/btree/mod.rs at line 191

[4.3421]→[4.3421:3485](∅→∅)

let page = Self::del(txn, m.page, &m.c1, m.l)?;

[4.3421]

[4.3485]

let page = Self::del(txn, m.page, m.mutable, &m.c1, m.l)?;
edit in sanakirja-core/src/btree/mod.rs at line 267

[4.51481]

[4.9584]

debug!(
"single_child: {:?} {:?} {:?} {:?}",
self.page, self.c0, c1, self.ins
);
edit in sanakirja-core/src/btree/mod.rs at line 290

[4.51996]

[4.51996]

pub other_is_mutable: bool,
replacement in sanakirja-core/src/btree/del.rs at line 148

[4.32574]→[4.1427:1460](∅→∅),[4.1460]→[4.61708:61726](∅→∅),[4.61708]→[4.61708:61726](∅→∅),[4.61726]→[4.9867:9893](∅→∅),[4.9893]→[4.61758:61770](∅→∅),[4.61758]→[4.61758:61770](∅→∅)

cursor.push(PageCursor {
page,
cursor: curs,
});

[4.32574]

[4.61770]

cursor.push(PageCursor { page, cursor: curs });
edit in sanakirja-core/src/btree/del.rs at line 224

[4.2083]

[4.33754]

let rc_l = cursor.first_rc_level;
edit in sanakirja-core/src/btree/del.rs at line 231

[4.10242]

[4.19655]

let other_is_rced = if p > rc_l {
true
} else {
txn.rc(other.offset)? >= 2
};
edit in sanakirja-core/src/btree/del.rs at line 241

[4.19804]

[4.19804]

other_is_mutable: !other_is_rced,
edit in sanakirja-core/src/btree/del.rs at line 260

[4.62688]

[4.62688]

let other_is_rced = if p > rc_l {
true
} else {
txn.rc(other.offset)? >= 2
};
edit in sanakirja-core/src/btree/del.rs at line 270

[4.33518]

[4.62814]

other_is_mutable: !other_is_rced,
replacement in sanakirja-core/src/btree/del.rs at line 507

[4.23774]→[4.23774:23863](∅→∅),[4.23863]→[4.1458:1511](∅→∅)

debug!("single child {:?}", d);
if P::is_dirty(last_op.page.as_page()) {
txn.decr_rc_owned(last_op.page.offset)?;

[4.23774]

[4.23915]

//
// We don't do this if the table is empty, in order to be
// consistent with put and drop.
debug!("single child {:?} {:?}", d, is_rc);
if d > 0 {
if !is_rc {
if P::is_dirty(last_op.page.as_page()) {
txn.decr_rc_owned(last_op.page.offset)?;
} else {
txn.decr_rc(last_op.page.offset)?;
}
}
db.db = d;
replacement in sanakirja-core/src/btree/del.rs at line 521

[4.23932]→[4.1512:1559](∅→∅)

txn.decr_rc(last_op.page.offset)?;

[4.23932]

[4.23978]

// The page becomes empty.
let page = P::del(txn, last_op.page, last_op.mutable, &last_op.c1, d)?;
if page.0.offset != last_op.page.offset && !is_rc {
if P::is_dirty(last_op.page.as_page()) {
txn.decr_rc_owned(last_op.page.offset)?;
} else {
txn.decr_rc(last_op.page.offset)?;
}
}
db.db = page.0.offset
edit in sanakirja-core/src/btree/del.rs at line 532

[4.23988]→[4.10571:10590](∅→∅)

db.db = d;
replacement in sanakirja-core/src/btree/cursor.rs at line 7

[4.63799]→[3.1669:1777](∅→∅)

pub(in super) struct PageCursor<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[4.63799]

[4.33799]

pub(super) struct PageCursor<
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
> {
replacement in sanakirja-core/src/btree/cursor.rs at line 67

[4.3431]→[3.1778:1841](∅→∅)

pub(in super) fn push(&mut self, p: PageCursor<K, V, P>) {

[4.3431]

[4.3484]

pub(super) fn push(&mut self, p: PageCursor<K, V, P>) {
replacement in sanakirja-core/src/btree/cursor.rs at line 72

[4.3568]→[3.1842:1909](∅→∅)

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

[4.3568]

[4.3625]

pub(super) fn last(&mut self) -> &mut PageCursor<K, V, P> {
replacement in sanakirja-core/src/btree/cursor.rs at line 78

[4.11210]→[3.1910:1972](∅→∅)

pub(in super) fn current(&self) -> &PageCursor<K, V, P> {

[4.11210]

[4.65821]

pub(super) fn current(&self) -> &PageCursor<K, V, P> {
replacement in sanakirja-core/src/btree/cursor.rs at line 82

[4.65883]→[3.1973:2020](∅→∅)

pub(in super) fn pointer(&self) -> usize {

[4.65883]

[4.3732]

pub(super) fn pointer(&self) -> usize {
replacement in sanakirja-core/src/btree/cursor.rs at line 86

[4.3760]→[3.2021:2059](∅→∅)

pub(in super) fn pop(&mut self) {

[4.3760]

[4.672]

pub(super) fn pop(&mut self) {
replacement in sanakirja-core/src/btree/cursor.rs at line 91

[4.3821]→[3.2060:2134](∅→∅)

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

[4.3821]

[4.33974]

pub(super) fn current_mut(&mut self) -> &mut PageCursor<K, V, P> {
edit in sanakirja-core/src/btree/cursor.rs at line 102

[4.66162]

[4.708]

// Start back from the bottom.
self.pointer = 0;
let init = unsafe { &mut *self.stack[0].as_mut_ptr() };
init.cursor = P::cursor_before(init.page.as_page());
edit in sanakirja-core/src/btree/cursor.rs at line 129

[4.67045]

[4.67045]

} else {
*cursor = P::cursor_first(page.as_page());
edit in sanakirja-core/src/btree/cursor.rs at line 189

[4.3619]→[3.2135:2136](∅→∅)
replacement in sanakirja-core/src/btree/cursor.rs at line 193

[3.2292]→[4.11964:12059](∅→∅),[4.3619]→[4.11964:12059](∅→∅)

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

[3.2292]

[4.1156]

pub fn next<T: LoadPage>(&mut self, txn: &'a T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
replacement in sanakirja-core/src/btree/cursor.rs at line 209

[4.12618]→[4.12618:12721](∅→∅)

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

[4.12618]

[3.2447]

} 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 228

[4.13211]→[4.13211:13306](∅→∅)

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

[4.13211]

[4.457]

pub fn prev<T: LoadPage>(&mut self, txn: &'a T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
replacement in sanakirja-core/src/btree/cursor.rs at line 232

[4.13403]→[4.491:580](∅→∅)

debug!("prev = {:?} {:?} {:?}" ,self.pointer, current.page, current.cursor);

[4.13403]

[4.13403]

debug!(
"prev = {:?} {:?} {:?}",
self.pointer, current.page, current.cursor
);
replacement in sanakirja-core/src/btree/cursor.rs at line 248

[4.13856]→[4.13856:13959](∅→∅)

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

[4.13856]

[4.615]

} 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 261

[4.70731]→[4.14331:14372](∅→∅)

return Ok(Some((k, v,)))

[4.70731]

[4.14372]

return Ok(Some((k, v)));
replacement in sanakirja-core/src/btree/cursor.rs at line 274

[4.14497]→[3.3147:3256](∅→∅)

pub struct Iter<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[4.14497]

[3.3256]

pub struct Iter<
'a,
T: LoadPage,
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
> {
replacement in sanakirja-core/src/btree/cursor.rs at line 288

[3.3379]→[3.3379:3416](∅→∅)

origin: Option<(&K, Option<&V>)>

[3.3379]

[3.3416]

origin: Option<(&K, Option<&V>)>,
replacement in sanakirja-core/src/btree/cursor.rs at line 290

[3.3460]→[3.3460:3554](∅→∅)

where T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V> {

[3.3460]

[3.3554]

where
T: LoadPage,
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
{
replacement in sanakirja-core/src/btree/cursor.rs at line 298

[3.3628]→[3.3628:3678](∅→∅)

Ok(Iter {
cursor,
txn,
})

[3.3628]

[4.70761]

Ok(Iter { cursor, txn })
replacement in sanakirja-core/src/btree/cursor.rs at line 301

[3.3680]→[3.3680:3827](∅→∅)

impl<'a, T: LoadPage, K: Representable + ?Sized + 'a, V: Representable + ?Sized + 'a, P: BTreePage<K, V> + 'a> Iterator for Iter<'a, T, K, V, P> {

[3.3680]

[3.3827]

impl<
'a,
T: LoadPage,
K: Representable + ?Sized + 'a,
V: Representable + ?Sized + 'a,
P: BTreePage<K, V> + 'a,
> Iterator for Iter<'a, T, K, V, P>
{
replacement in sanakirja-core/src/btree/cursor.rs at line 315

[3.3980]→[3.3980:4092](∅→∅)

pub struct RevIter<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[3.3980]

[3.4092]

pub struct RevIter<
'a,
T: LoadPage,
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
> {
replacement in sanakirja-core/src/btree/cursor.rs at line 329

[3.4219]→[3.4219:4256](∅→∅)

origin: Option<(&K, Option<&V>)>

[3.4219]

[3.4256]

origin: Option<(&K, Option<&V>)>,
replacement in sanakirja-core/src/btree/cursor.rs at line 331

[3.4303]→[3.4303:4397](∅→∅)

where T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V> {

[3.4303]

[3.4397]

where
T: LoadPage,
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
{
replacement in sanakirja-core/src/btree/cursor.rs at line 339

[3.4471]→[3.4471:4524](∅→∅)

Ok(RevIter {
cursor,
txn,
})

[3.4471]

[3.4524]

Ok(RevIter { cursor, txn })
replacement in sanakirja-core/src/btree/cursor.rs at line 342

[3.4527]→[3.4527:4677](∅→∅)

impl<'a, T: LoadPage, K: Representable + ?Sized + 'a, V: Representable + ?Sized + 'a, P: BTreePage<K, V> + 'a> Iterator for RevIter<'a, T, K, V, P> {

[3.4527]

[3.4677]

impl<
'a,
T: LoadPage,
K: Representable + ?Sized + 'a,
V: Representable + ?Sized + 'a,
P: BTreePage<K, V> + 'a,
> Iterator for RevIter<'a, T, K, V, P>
{
replacement in sanakirja/src/tests.rs at line 213

[4.277]→[4.26407:26427](∅→∅)

for i in 0..1 {

[4.277]

[4.10238]

for i in 0..15 {
replacement in sanakirja/src/tests.rs at line 216

[4.2077]→[4.10651:10652](∅→∅),[4.26520]→[4.10651:10652](∅→∅),[4.7217]→[4.10651:10652](∅→∅)

[4.10295]

[4.358]

crate::debug::debug(&txn, &[&db, &db2], "debug2", true);
for i in n / 2..n {
del(&mut txn, &mut db, &i, None).unwrap();
}
replacement in sanakirja/src/tests.rs at line 221

[4.392]→[4.392:452](∅→∅)

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

[4.392]

[4.2188]

crate::debug::debug(&txn, &[&db, &db2], "debug3", true);
edit in sanakirja/src/tests.rs at line 441

[4.1074]→[4.15758:15768](∅→∅)

#[ignore]
replacement in sanakirja/src/tests.rs at line 444

[4.1148]→[4.3620:3640](∅→∅),[4.3640]→[4.1169:1200](∅→∅),[4.1169]→[4.1169:1200](∅→∅)

for i in 1..8 {
let n = i * 1_000_000;

[4.1148]

[4.1200]

for i in 1..3 {
let n = i * 128; // _000_000;
let mut times = [0f64; 12];
let mut test = Vec::with_capacity(n);
let mut rng = rand::thread_rng();
for _ in 0..n {
use rand::Rng;
test.push((rng.gen(), rng.gen()))
}
/*
edit in sanakirja/src/tests.rs at line 462

[4.1554]→[4.1554:1590](∅→∅)

let mut times = [0f64; 12];
edit in sanakirja/src/tests.rs at line 463

[4.1591]→[4.1591:1786](∅→∅)

let mut test = Vec::with_capacity(n);
let mut rng = rand::thread_rng();
for _ in 0..n {
use rand::Rng;
test.push((rng.gen(), rng.gen()))
}
replacement in sanakirja/src/tests.rs at line 473

[4.2227]→[4.2227:2228](∅→∅)

[4.2227]

[4.2228]

*/
edit in sanakirja/src/tests.rs at line 481

[4.2592]

[4.2592]

crate::debug::debug(&txn, &[&db], "debug", true);
edit in sanakirja/src/tests.rs at line 489

[4.2880]

[4.2880]

/*
edit in sanakirja/src/tests.rs at line 501

[4.3310]

[4.3310]

*/
replacement in sanakirja/src/tests.rs at line 537

[4.4566]→[4.4566:4567](∅→∅)

[4.4566]

[4.4567]

/*
edit in sanakirja/src/tests.rs at line 560

[4.5485]

[4.3641]

*/
replacement in sanakirja/src/tests.rs at line 794

[3.5382]→[3.5382:5416](∅→∅)

let (k, v) = kv.unwrap();

[3.5382]

[3.5416]

let (k, _v) = kv.unwrap();
replacement in sanakirja/src/tests.rs at line 800

[3.5579]→[3.5579:5613](∅→∅)

let (k, v) = kv.unwrap();

[3.5579]

[3.5613]

let (k, _v) = kv.unwrap();
edit in sanakirja/src/tests.rs at line 803

[3.5671]

[4.1757]

}

let mut it = btree::rev_iter(&txn, &db, Some((&100, None))).unwrap();
let (k, _v) = it.next().unwrap().unwrap();
assert_eq!(*k, 99);

let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
for i in 0..100 {
debug!("i = {:?}", i);
let (&k, v) = cursor.set(&txn, Some((&i, None))).unwrap().unwrap();
debug!("kv = {:?} {:?}", k, v);
assert_eq!(i, k);
let (&k1, v1) = cursor.next(&txn).unwrap().unwrap();
debug!("next = {:?} {:?}", k1, v1);
assert_eq!(i, k1);
}

let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
for i in 0..100 {
debug!("i = {:?}", i);
let (&k, v) = cursor.set(&txn, Some((&i, None))).unwrap().unwrap();
debug!("kv = {:?} {:?}", k, v);
assert_eq!(i, k);
let (&k1, v1) = cursor.prev(&txn).unwrap().unwrap();
debug!("prev = {:?} {:?}", k1, v1);
assert_eq!(i, k1);
}
}

#[test]
pub fn fork_del() {
env_logger::try_init().unwrap_or(());
let env = Env::new_anon(409600000, 1).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();
let mut db: Db<u64, A> = create_db(&mut txn).unwrap();

let n = 6 as u64;
let mut values = Vec::with_capacity(n as usize);
let a = A([0; 100]);
for i in 0..n {
if put(&mut txn, &mut db, &i, &a).unwrap() {
values.push(i);
}
}
crate::debug::debug(&txn, &[&db], "debug0", true);

let db2 = fork_db(&mut txn, &db).unwrap();
del(&mut txn, &mut db, &1, None).unwrap();

crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
/*
let mut refs = BTreeMap::new();
add_refs(&txn, &db, &mut refs).unwrap();
add_refs(&txn, &db2, &mut refs).unwrap();
// add_refs(&txn, &db3, &mut refs).unwrap();
let mut err = 0;
for (p, r) in refs.iter() {
println!("{:?} {:?}", p, r);
if *r >= 2 {
if txn.rc(*p).unwrap() != *r as u64 {
error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
err += 1;
}
} else {
if txn.rc(*p).unwrap() != 0 {
error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
err += 1;
}
}
edit in sanakirja/src/tests.rs at line 873

[4.1763]

[4.5521]

assert_eq!(err, 0);
txn.commit().unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();
check_free(&mut txn, &refs);
debug!("{:?}", refs);
*/
edit in sanakirja/src/environment/muttxn.rs at line 116

[4.83523]

[4.83523]

};
let length = if header.length == 0 {
(PAGE_SIZE as u64) * (header.n_roots as u64)
} else {
header.length
replacement in sanakirja/src/environment/muttxn.rs at line 126

[4.83631]→[4.83631:83822](∅→∅)

length: if header.length == 0 {
(PAGE_SIZE as u64) * (header.n_roots as u64)
} else {
header.length
},

[4.83631]

[4.83822]

length,
replacement in sanakirja/src/environment/muttxn.rs at line 167

[4.3894]→[4.3894:3918](∅→∅)

*rr = r

[4.3894]

[4.3918]

if r > 0 {
*rr = r
}
edit in sanakirja/src/environment/muttxn.rs at line 205

[4.86200]

[4.86200]

debug!("FREEING OWNED PAGE {:?}", offset);
edit in sanakirja/src/environment/muttxn.rs at line 210

[4.86294]

[4.86294]

debug!("FREEING PAGE {:?}", offset);
edit in sanakirja/src/environment/muttxn.rs at line 242

[4.37584]

[4.37584]

debug!("free owned pop {:?}", offset);
edit in sanakirja/src/environment/muttxn.rs at line 251

[4.37871]

[4.37871]

debug!("free pages pop {:?}", offset);
replacement in sanakirja/src/environment/mod.rs at line 23

[4.91834]→[4.91834:91876](∅→∅)

pub(crate) const PAGE_SIZE: usize = 4096;

[4.91834]

[4.91876]

pub use sanakirja_core::PAGE_SIZE;
pub(crate) const PAGE_SIZEU64: u64 = PAGE_SIZE as u64;
replacement in sanakirja/src/environment/mod.rs at line 133

[4.95626]→[4.95626:95666](∅→∅)

std::cmp::max(length, 4096)

[4.95626]

[4.95666]

std::cmp::max(length, PAGE_SIZEU64)
replacement in sanakirja/src/environment/mod.rs at line 135

[4.95677]→[4.5850:5896](∅→∅)

let length = (length + 4095) & !4095;

[4.95677]

[4.95726]

let length = (length + PAGE_SIZEU64 - 1) & !(PAGE_SIZEU64 - 1);
replacement in sanakirja/src/environment/mod.rs at line 268

[4.4230]→[4.5981:6048](∅→∅)

let length = (std::cmp::max(length, 4096) + 4095) & !4095;

[4.4230]

[4.102110]

let length =
(std::cmp::max(length, PAGE_SIZEU64) + (PAGE_SIZEU64 - 1)) & !(PAGE_SIZEU64 - 1);
replacement in sanakirja/src/environment/mod.rs at line 278

[4.4432]→[4.6049:6116](∅→∅)

let length = (std::cmp::max(length, 4096) + 4095) & !4095;

[4.4432]

[4.102542]

let length =
(std::cmp::max(length, PAGE_SIZEU64) + (PAGE_SIZEU64 - 1)) & !(PAGE_SIZEU64 - 1);