Formatting, debugging, etc.

[?]

Feb 3, 2021, 6:42 PM

6UVFCERMGSGNRWCVC3GWO5HWV6MSWE433DXBJVC7KRPP6LLJLCSQC

Dependencies

[2] H3FVSQIQ Unsized pages
[3] S4V4QZ5C Debugging reference-counting for put
[4] NQBEOCFO Tests cleanup
[5] OTWDDJE7 Trait/type cleanup
[6] WS4ZQM4R Debugging, tests, etc.
[7] EHJFNMB2 Debugging
[8] EAAYH6BQ Debugging put
[9] X3QVVQIS More debugging (del seems to work now)
[10] QEUTVAZ4 Splitting btree::page
[11] ONES3V46 reference counting works for put
[12] 6DMPXOAT More debugging
[13] UAQX27N4 Tests
[14] OP6SVMOD Resetting history
[15] DV4A2LR7 Double-inserts (rebalancing near an internal deletion)
[16] PXF3R6SV Improving test coverage for btree::cursor
[17] YWFYZNLZ Cleanup + inter-process concurrency
[18] FMN7X4J2 Micro-improvements, now noticeably faster than std::collections::BTreeMap

Change contents

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

[2.1352]→[3.467:468](∅→∅),[3.467]→[3.467:468](∅→∅)
replacement in sanakirja-core/src/lib.rs at line 93

[3.469]→[3.1495:1496](∅→∅),[3.1495]→[3.1495:1496](∅→∅),[3.1496]→[2.1353:1476](∅→∅)

unsafe fn read<T, K: Representable + ?Sized, V: Representable + ?Sized>(txn: &T, k: *const u8) -> (*const u8, *const u8) {

[3.469]

[3.575]

unsafe fn read<T, K: Representable + ?Sized, V: Representable + ?Sized>(
txn: &T,
k: *const u8,
) -> (*const u8, *const u8) {
replacement in sanakirja-core/src/lib.rs at line 104

[3.1749]→[2.1477:1566](∅→∅)

fn alloc_size<K: Representable+?Sized, V: Representable+?Sized>(k: &K, v: &V) -> usize {

[3.1749]

[3.1833]

fn alloc_size<K: Representable + ?Sized, V: Representable + ?Sized>(k: &K, v: &V) -> usize {
replacement in sanakirja-core/src/lib.rs at line 110

[3.1972]→[2.1567:1663](∅→∅)

unsafe fn entry_size<K: Representable+?Sized, V: Representable+?Sized>(k: *const u8) -> usize {

[3.1972]

[2.1663]

unsafe fn entry_size<K: Representable + ?Sized, V: Representable + ?Sized>(k: *const u8) -> usize {
replacement in sanakirja-core/src/btree/put.rs at line 18

[3.146]→[2.1733:1832](∅→∅)

pub fn put<T: AllocPage, K: Representable+?Sized, V: Representable+?Sized, P: BTreeMutPage<K, V>>(

[3.146]

[3.4213]

pub fn put<
T: AllocPage,
K: Representable + ?Sized + core::fmt::Debug,
V: Representable + ?Sized + core::fmt::Debug,
P: BTreeMutPage<K, V>,
>(
replacement in sanakirja-core/src/btree/put.rs at line 57

[3.4963]→[2.1833:1936](∅→∅)

fn put_cascade<T: AllocPage, K: Representable+?Sized, V: Representable+?Sized, P: BTreeMutPage<K, V>>(

[3.4963]

[3.5061]

fn put_cascade<
T: AllocPage,
K: Representable + ?Sized + core::fmt::Debug,
V: Representable + ?Sized + core::fmt::Debug,
P: BTreeMutPage<K, V>,
>(
edit in sanakirja-core/src/btree/put.rs at line 96

[3.5684]

[3.832]

debug!("split root {:?} {:?}", split_key, split_value);
debug!("{:?} {:?}", left, right);
replacement in sanakirja-core/src/btree/put.rs at line 137

[3.7489]→[2.1937:1995](∅→∅)

K: Representable+?Sized,
V: Representable+?Sized,

[3.7489]

[3.1076]

K: Representable + ?Sized,
V: Representable + ?Sized,
replacement in sanakirja-core/src/btree/put.rs at line 147

[3.7700]→[3.530:651](∅→∅)

debug!("incr_descendants {:?} {:?} {:?} {:?}", cursor.current().page, freed, cursor.pointer, cursor.first_rc_level);

[3.7700]

[3.7700]

debug!(
"incr_descendants {:?} {:?} {:?} {:?}",
cursor.current().page,
freed,
cursor.pointer,
cursor.first_rc_level
);
edit in sanakirja-core/src/btree/page_unsized.rs at line 5

[2.2067]→[2.2067:2076](∅→∅)

mod put;
edit in sanakirja-core/src/btree/page_unsized.rs at line 6

[2.2087]

[2.2087]

mod put;
edit in sanakirja-core/src/btree/page_unsized.rs at line 8

[2.2101]→[2.2101:2128](∅→∅)

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

[2.2143]

[2.2143]

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

[2.2334]→[2.2334:2438](∅→∅)

K: Representable+?Sized + core::fmt::Debug,
V: Representable+?Sized + core::fmt::Debug,

[2.2334]

[2.2438]

K: Representable + ?Sized + core::fmt::Debug,
V: Representable + ?Sized + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page_unsized.rs at line 140

[2.5967]→[2.5967:6078](∅→∅)

fn del<T: AllocPage>(txn: &mut T, page: crate::CowPage, c: &Cursor, l: u64) -> Result<MutPage, T::Error> {

[2.5967]

[2.6078]

fn del<T: AllocPage>(
txn: &mut T,
page: crate::CowPage,
c: &Cursor,
l: u64,
) -> Result<MutPage, T::Error> {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 289

[2.11586]→[2.11586:11689](∅→∅)

impl<K: Representable + ?Sized, V: Representable + ?Sized> super::BTreePage<K, V>
for Page<K, V>
{

[2.11586]

[2.11689]

impl<K: Representable + ?Sized, V: Representable + ?Sized> super::BTreePage<K, V> for Page<K, V> {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 321

[2.12513]→[2.12513:12648](∅→∅)

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

[2.12513]

[2.12648]

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

[2.12733]→[2.12733:12825](∅→∅)

(K::from_raw_ptr(txn, k as *const u8), V::from_raw_ptr(txn, v as *const u8), 0)

[2.12733]

[2.12825]

(
K::from_raw_ptr(txn, k as *const u8),
V::from_raw_ptr(txn, v as *const u8),
0,
)
replacement in sanakirja-core/src/btree/page_unsized.rs at line 332

[2.13030]→[2.13030:13133](∅→∅)

(K::from_raw_ptr(txn, k as *const u8), V::from_raw_ptr(txn, v as *const u8), off & !0xfff)

[2.13030]

[2.13133]

(
K::from_raw_ptr(txn, k as *const u8),
V::from_raw_ptr(txn, v as *const u8),
off & !0xfff,
)
replacement in sanakirja-core/src/btree/page_unsized.rs at line 352

[2.13792]→[2.13792:13883](∅→∅)

)
as usize))

[2.13792]

[2.13883]

) as usize))
replacement in sanakirja-core/src/btree/page_unsized.rs at line 416

[2.15976]→[2.15976:16066](∅→∅)

Ok(Internal::kv(txn, page, (off & !0xfff, (off & 0xfff) as u16)))

[2.15976]

[2.16066]

Ok(Internal::kv(
txn,
page,
(off & !0xfff, (off & 0xfff) as u16),
))
replacement in sanakirja-core/src/btree/page_unsized.rs at line 469

[2.17449]→[2.17449:17472](∅→∅)

},

[2.17449]

[2.17472]

}
replacement in sanakirja-core/src/btree/page_unsized.rs at line 495

[2.18451]→[2.18451:18474](∅→∅)

},

[2.18451]

[2.18474]

}
replacement in sanakirja-core/src/btree/page_unsized.rs at line 522

[2.19122]→[2.19122:19129](∅→∅)

>(

[2.19122]

[2.19129]

>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 550

[2.19988]→[2.19988:20035](∅→∅)

alloc::< _, _, L>(new, k, v, l, r, n);

[2.19988]

[2.20035]

alloc::<_, _, L>(new, k, v, l, r, n);
replacement in sanakirja-core/src/btree/page_unsized.rs at line 560

[2.20207]→[2.20207:20214](∅→∅)

>(

[2.20207]

[2.20214]

>(
edit in sanakirja-core/src/btree/page_unsized.rs at line 586

[2.21213]→[2.21213:21214](∅→∅)
replacement in sanakirja-core/src/btree/page_unsized.rs at line 604

[2.21935]→[2.21935:22022](∅→∅)

let off_new = L::alloc::<K, V>(hdr, size, K::ALIGN.max(V::ALIGN));

[2.21935]

[2.22022]

let off_new = L::alloc(hdr, size, K::ALIGN.max(V::ALIGN));
file deletion: header.rs (-xw-x--x--)

[2.22910]→[2.32081:32092](∅→∅),[2.32092]→[2.32093:32093](∅→∅)

#[derive(Debug)]
#[repr(C)]
pub struct Header {
n: u16,
data: u16,
crc: u32,
left_page: u64,
}

impl Header {
pub fn init(&mut self) {
self.n = (1u16).to_le(); // dirty page
self.data = 4096_u16.to_le();
self.crc = 0;
self.left_page = 0;
}

pub fn n(&self) -> u16 {
u16::from_le(self.n) >> 4
}

pub fn set_n(&mut self, n: u16) {
let dirty = u16::from_le(self.n) & 1;
self.n = ((n << 4) | dirty).to_le()
}

pub fn is_dirty(&self) -> bool {
u16::from_le(self.n) & 1 != 0
}

pub fn left_page(&self) -> u64 {
u64::from_le(self.left_page)
}

pub fn set_left_page(&mut self, l: u64) {
self.left_page = l.to_le()
}

pub fn data(&self) -> u16 {
u16::from_le(self.data)
}

pub fn set_data(&mut self, d: u16) {
self.data = d.to_le()
}

pub fn decr(&mut self, s: usize) {
self.left_page = (self.left_page() - s as u64).to_le();
}

pub fn set_occupied(&mut self, size: u64) {
self.left_page = ((self.left_page() & !0xfff) | size).to_le()
}

pub fn incr(&mut self, s: usize) {
self.left_page = (self.left_page() + s as u64).to_le();
}

pub fn is_leaf(&self) -> bool {
u64::from_le(self.left_page) <= 0xfff
}

pub fn clean(&mut self) {
self.n = (u16::from_le(self.n) & 0xfff).to_le()
}
}

pub const HDR: usize = core::mem::size_of::<Header>();

pub fn header<'a>(page: crate::Page<'a>) -> &'a Header {
unsafe { &*(page.data.as_ptr() as *const Header) }
}

pub fn header_mut(page: &mut crate::MutPage) -> &mut Header {
unsafe { &mut *(page.0.data as *mut Header) }
}
edit in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 2

[2.22941]

[2.22941]

use crate::btree::page::header::header;
edit in sanakirja-core/src/btree/page_unsized/put.rs at line 1

[2.27023]

[2.27024]

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

[2.27674]→[2.27674:27757](∅→∅)

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

[2.27674]

[2.27757]

if mutable && is_dirty && L::can_alloc(header(page.as_page()), size) {
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 41

[2.28178]→[2.28178:28228](∅→∅)

} else if L::can_compact::<K, V>(hdr, size) {

[2.28178]

[2.28228]

} else if L::can_compact(hdr, size) {
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 113

[2.30434]→[2.30434:30508](∅→∅)

let size = entry_size::<K, V>(ptr) + L::extra_size::<K, V>();

[2.30434]

[2.30508]

let size = entry_size::<K, V>(ptr) + L::extra_size();
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 122

[2.30812]→[2.30812:30916](∅→∅)

let off_new = L::alloc::<K, V>(header_mut(current_page), size, K::ALIGN.max(V::ALIGN));

[2.30812]

[2.30916]

let off_new = L::alloc(header_mut(current_page), size, K::ALIGN.max(V::ALIGN));
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 135

[2.31343]→[2.31343:31414](∅→∅)

total += alloc_size(k0, v0) + L::extra_size::<K, V>();

[2.31343]

[2.31414]

total += alloc_size(k0, v0) + L::extra_size();
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 137

[2.31485]→[2.31485:31556](∅→∅)

total += alloc_size(k1, v1) + L::extra_size::<K, V>();

[2.31485]

[2.31556]

total += alloc_size(k1, v1) + L::extra_size();
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 140

[2.31649]→[2.31649:31720](∅→∅)

total += alloc_size(k0, v0) + L::extra_size::<K, V>();

[2.31649]

[2.31720]

total += alloc_size(k0, v0) + L::extra_size();
edit in sanakirja-core/src/btree/page_unsized/alloc.rs at line 1

[2.33822]

[2.33823]

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

[2.33863]→[2.33863:34279](∅→∅)

fn extra_size<K: Representable + ?Sized, V: Representable + ?Sized>() -> usize;
fn can_alloc<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool;
fn can_compact<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool;
fn alloc<K: Representable+?Sized, V: Representable+?Sized>(hdr: &mut Header, size: usize, align: usize) -> u16;

[2.33863]

[2.34279]

fn extra_size() -> usize;
fn can_alloc(hdr: &Header, size: usize) -> bool;
fn can_compact(hdr: &Header, size: usize) -> bool;
fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16;
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 61

[2.35860]→[2.35860:35945](∅→∅)

fn extra_size<K: Representable + ?Sized, V: Representable + ?Sized>() -> usize {

[2.35860]

[2.35945]

fn extra_size() -> usize {
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 64

[2.35961]→[2.35961:36212](∅→∅)

fn can_alloc<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool {
debug!("can_alloc: {:?} {:?} {:?}", hdr.n(), size, hdr.data());
HDR + (hdr.n() as usize) * 2 + 2 + size <= hdr.data() as usize

[2.35961]

[2.36212]

fn can_alloc(hdr: &Header, size: usize) -> bool {
(HDR as usize) + (hdr.n() as usize) * 2 + 2 + size < hdr.data() as usize
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 67

[2.36218]→[2.36218:36463](∅→∅)

fn can_compact<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool {
debug!("can_compact: {:?} {:?}", hdr.left_page(), size);
HDR + ((hdr.left_page() & 0xfff) as usize) + 2 + size <= 4096

[2.36218]

[2.36463]

fn can_compact(hdr: &Header, size: usize) -> bool {
debug!(
"can_compact, internal: {:?} {:?} {:?}",
HDR,
hdr.left_page() & 0xfff,
size
);
(HDR as usize) + (hdr.n() as usize) * 2 + ((hdr.left_page() & 0xfff) as usize) + 2 + size
<= 4096
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 91

[2.36943]→[2.36943:37081](∅→∅)

let deleted_offsets = unsafe {
core::slice::from_raw_parts(page.0.data.add(HDR) as *const u16, n as usize)
};

[2.36943]

[2.37081]

let deleted_offsets =
unsafe { core::slice::from_raw_parts(page.0.data.add(HDR) as *const u16, n as usize) };
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 95

[2.37149]→[2.37149:37278](∅→∅)

.map(|&off| {
2 + unsafe { entry_size::<K, V>(page.0.data.add(off as usize)) } as u64
})

[2.37149]

[2.37278]

.map(|&off| 2 + unsafe { entry_size::<K, V>(page.0.data.add(off as usize)) } as u64)
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 102

[2.37431]→[2.37431:37719](∅→∅)

fn alloc<K: Representable+?Sized, V: Representable+?Sized>(hdr: &mut Header, size: usize, align: usize) -> u16 {
debug!("alloc = {:?} {:?}", hdr.data(), size);
let mut data = hdr.data() - size as u16;
data &= !((align - 1) as u16);
hdr.set_data(data);

[2.37431]

[2.37719]

fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {
assert_eq!(size % align, 0);
let data = hdr.data();
hdr.set_data(data - size as u16);
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 107

[2.37751]→[2.37751:37817](∅→∅)

hdr.incr(size + Self::extra_size::<K, V>());
data

[2.37751]

[2.37817]

hdr.incr(size);
data - size as u16
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 120

[2.38113]→[2.38113:38191](∅→∅)

Self::alloc::<K, V>(&mut *hdr, size, K::ALIGN.max(V::ALIGN)),

[2.38113]

[2.38191]

Self::alloc(&mut *hdr, size, K::ALIGN.max(V::ALIGN)),
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 167

[2.39652]→[2.39652:39737](∅→∅)

fn extra_size<K: Representable + ?Sized, V: Representable + ?Sized>() -> usize {

[2.39652]

[2.39737]

fn extra_size() -> usize {
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 170

[2.39753]→[2.39753:39861](∅→∅)

fn can_alloc<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool {

[2.39753]

[2.39861]

fn can_alloc(hdr: &Header, size: usize) -> bool {
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 173

[2.39948]→[2.39948:40203](∅→∅)

fn can_compact<K: Representable + ?Sized, V: Representable + ?Sized>(hdr: &Header, size: usize) -> bool {
debug!("can_compact: {:?} {:?}", hdr.left_page(), size);
(HDR as usize) + ((hdr.left_page() & 0xfff) as usize) + 8 + size < 4096

[2.39948]

[2.40203]

fn can_compact(hdr: &Header, size: usize) -> bool {
debug!(
"can_compact, internal: {:?} {:?} {:?}",
HDR,
hdr.left_page() & 0xfff,
size
);
(HDR as usize) + (hdr.n() as usize) * 8 + ((hdr.left_page() & 0xfff) as usize) + 8 + size
<= 4096
edit in sanakirja-core/src/btree/page_unsized/alloc.rs at line 183

[2.40209]

[2.40209]
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 208

[2.41045]→[2.41045:41186](∅→∅)

.map(|&off| {
8 + unsafe { entry_size::<K, V>(page.0.data.add(off as usize)) } as u64
})

[2.41045]

[2.41186]

.map(|&off| 8 + unsafe { entry_size::<K, V>(page.0.data.add(off as usize)) } as u64)
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 217

[2.41410]→[2.41410:41643](∅→∅)

fn alloc<K: Representable+?Sized, V: Representable+?Sized>(hdr: &mut Header, size: usize, align: usize) -> u16 {
let mut data = hdr.data() - size as u16;
data -= data % (align as u16);
hdr.set_data(data);

[2.41410]

[2.41643]

fn alloc(hdr: &mut Header, size: usize, align: usize) -> u16 {
assert_eq!(size % align, 0);
let data = hdr.data();
hdr.set_data(data - size as u16);
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 222

[2.41675]→[2.41675:41741](∅→∅)

hdr.incr(size + Self::extra_size::<K, V>());
data

[2.41675]

[2.41741]

hdr.incr(size);
data - size as u16
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 235

[2.42037]→[2.42037:42115](∅→∅)

Self::alloc::<K, V>(&mut *hdr, size, K::ALIGN.max(V::ALIGN)),

[2.42037]

[2.42115]

Self::alloc(&mut *hdr, size, K::ALIGN.max(V::ALIGN)),
edit in sanakirja-core/src/btree/page.rs at line 5

[3.8651]→[3.0:9](∅→∅)

mod put;
edit in sanakirja-core/src/btree/page.rs at line 6

[3.20]

[3.20]

mod put;
replacement in sanakirja-core/src/btree/page.rs at line 8

[3.34]→[3.34:46](∅→∅)

mod header;

[3.34]

[3.46]

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

[3.9723]→[3.298:304](∅→∅),[3.304]→[3.1216:1353](∅→∅)

impl<
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
> super::BTreeMutPage<K, V> for Page<K, V>

[3.8770]

[3.9832]

impl<K: Representable + core::fmt::Debug, V: Representable + core::fmt::Debug>
super::BTreeMutPage<K, V> for Page<K, V>
replacement in sanakirja-core/src/btree/page.rs at line 146

[3.12564]→[3.1769:1880](∅→∅)

fn del<T: AllocPage>(txn: &mut T, page: crate::CowPage, c: &Cursor, l: u64) -> Result<MutPage, T::Error> {

[3.12564]

[3.148]

fn del<T: AllocPage>(
txn: &mut T,
page: crate::CowPage,
c: &Cursor,
l: u64,
) -> Result<MutPage, T::Error> {
edit in sanakirja-core/src/btree/page.rs at line 159

[3.1693]

[3.1693]

let f = core::mem::size_of::<Tuple<K, V>>();
edit in sanakirja-core/src/btree/page.rs at line 162

[3.1770]→[2.44608:44673](∅→∅)

let f = core::mem::size_of::<Tuple<K, V>>();
edit in sanakirja-core/src/btree/page.rs at line 170

[3.2635]→[3.2635:2749](∅→∅),[3.2749]→[3.2006:2065](∅→∅)

let off = (u64::from_le(*ptr) & 0xfff) as usize;
let kv_ptr = p.add(off);
let size = entry_size::<K, V>(kv_ptr);
replacement in sanakirja-core/src/btree/page.rs at line 171

[3.2148]→[3.2898:2942](∅→∅),[3.2898]→[3.2898:2942](∅→∅)

(&mut *hdr).decr(size);

[3.2148]

[3.2942]

(&mut *hdr).decr(f);
replacement in sanakirja-core/src/btree/page.rs at line 297

[3.18476]→[3.2990:3054](∅→∅),[3.3054]→[3.18562:18583](∅→∅),[3.18562]→[3.18562:18583](∅→∅)

impl<K: Representable, V: Representable> super::BTreePage<K, V>
for Page<K, V>
{

[3.18476]

[3.18583]

impl<K: Representable, V: Representable> super::BTreePage<K, V> for Page<K, V> {
replacement in sanakirja-core/src/btree/page.rs at line 336

[3.3271]→[3.3271:3363](∅→∅)

(K::from_raw_ptr(txn, k as *const u8), V::from_raw_ptr(txn, v as *const u8), 0)

[3.3271]

[3.19944]

(
K::from_raw_ptr(txn, k as *const u8),
V::from_raw_ptr(txn, v as *const u8),
0,
)
replacement in sanakirja-core/src/btree/page.rs at line 344

[3.3459]→[3.3459:3562](∅→∅)

(K::from_raw_ptr(txn, k as *const u8), V::from_raw_ptr(txn, v as *const u8), off & !0xfff)

[3.3459]

[3.20159]

(
K::from_raw_ptr(txn, k as *const u8),
V::from_raw_ptr(txn, v as *const u8),
off & !0xfff,
)
replacement in sanakirja-core/src/btree/page.rs at line 430

[3.4628]→[3.3984:4074](∅→∅)

Ok(Internal::kv(txn, page, (off & !0xfff, (off & 0xfff) as u16)))

[3.4628]

[3.25407]

Ok(Internal::kv(
txn,
page,
(off & !0xfff, (off & 0xfff) as u16),
))
replacement in sanakirja-core/src/btree/page.rs at line 498

[3.5175]→[3.5175:5198](∅→∅)

},

[3.5175]

[3.5334]

}
replacement in sanakirja-core/src/btree/page.rs at line 525

[3.8487]→[3.5484:5491](∅→∅)

>(

[3.8487]

[3.5491]

>(
replacement in sanakirja-core/src/btree/page.rs at line 553

[3.35371]→[3.5934:5981](∅→∅)

alloc::< _, _, L>(new, k, v, l, r, n);

[3.35371]

[3.35425]

alloc::<_, _, L>(new, k, v, l, r, n);
replacement in sanakirja-core/src/btree/page.rs at line 563

[3.8884]→[3.6082:6089](∅→∅)

>(

[3.8884]

[3.6089]

>(
edit in sanakirja-core/src/btree/page.rs at line 589

[3.21692]→[3.36871:36872](∅→∅),[3.36871]→[3.36871:36872](∅→∅)
edit in sanakirja-core/src/btree/page.rs at line 643

[3.6978]

[3.23773]

debug!("off_new = {:?}", off_new);
replacement in sanakirja-core/src/btree/page/put.rs at line 29

[3.6587]→[3.6587:6673](∅→∅)

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

[3.6587]

[3.6673]

if mutable && is_dirty && L::can_alloc::<K, V>(header(page.as_page()), size) {
replacement in sanakirja-core/src/btree/page/put.rs at line 40

[3.7103]→[3.7103:7156](∅→∅)

} else if L::can_compact::<T, K, V>(hdr, size) {

[3.7103]

[3.7156]

} else if L::can_compact::<K, V>(hdr, size) {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 4

[3.17273]→[3.10313:10568](∅→∅)

fn extra_size<T, K: Representable, V: Representable>() -> usize;
fn can_alloc<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;
fn can_compact<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;

[3.17273]

[3.17546]

fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;
fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;
replacement in sanakirja-core/src/btree/page/alloc.rs at line 75

[3.19755]→[3.10982:11052](∅→∅),[3.11052]→[2.47655:47665](∅→∅),[2.47665]→[3.19933:19939](∅→∅),[3.19933]→[3.19933:19939](∅→∅),[3.19939]→[3.11097:11190](∅→∅)

fn extra_size<T, K: Representable, V: Representable>() -> usize {
0
}
fn can_alloc<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[3.19755]

[2.47666]

fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
edit in sanakirja-core/src/btree/page/alloc.rs at line 78

[2.47760]

[2.47760]

assert_eq!(size % al, 0);
replacement in sanakirja-core/src/btree/page/alloc.rs at line 80

[2.47814]→[2.47814:47888](∅→∅)

header_size + (hdr.n() as usize) * f + size < hdr.data() as usize

[2.47814]

[3.20371]

header_size + (hdr.n() as usize) * f + size <= PAGE_SIZE
replacement in sanakirja-core/src/btree/page/alloc.rs at line 82

[3.20377]→[3.11239:11334](∅→∅)

fn can_compact<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[3.20377]

[2.47889]

fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
edit in sanakirja-core/src/btree/page/alloc.rs at line 84

[2.47930]

[2.47930]

assert_eq!(size % al, 0);
replacement in sanakirja-core/src/btree/page/alloc.rs at line 86

[2.47984]→[2.47984:48084](∅→∅)

header_size + ((hdr.left_page() & 0xfff) as usize) + size
< hdr.data() as usize

[2.47984]

[3.20836]

debug!(
"can_compact, leaf: {:?} {:?} {:?}",
header_size,
hdr.left_page() & 0xfff,
size
);
header_size + ((hdr.left_page() & 0xfff) as usize) + size <= PAGE_SIZE
replacement in sanakirja-core/src/btree/page/alloc.rs at line 107

[2.48345]→[2.48345:48459](∅→∅)

let mut swap: core::mem::MaybeUninit<Tuple<K, V>> =
core::mem::MaybeUninit::uninit();

[2.48345]

[2.48459]

let mut swap: core::mem::MaybeUninit<Tuple<K, V>> = core::mem::MaybeUninit::uninit();
replacement in sanakirja-core/src/btree/page/alloc.rs at line 129

[2.49146]→[2.49146:49294](∅→∅)

let (k, v) = read::<T, K, V>(
txn,
page.0.data.add(hdr_size + (hdr_n as usize - n) * f),
);

[2.49146]

[2.49294]

let (k, v) = read::<T, K, V>(txn, page.0.data.add(hdr_size + (hdr_n as usize - n) * f));
replacement in sanakirja-core/src/btree/page/alloc.rs at line 134

[3.23271]→[3.23271:23387](∅→∅)

let mut data = hdr.data() - size as u16;
data &= !((align - 1) as u16);
hdr.set_data(data);

[3.23271]

[3.23387]

assert_eq!(size % align, 0);
replacement in sanakirja-core/src/btree/page/alloc.rs at line 137

[3.23443]→[3.23443:23456](∅→∅)

data

[3.23443]

[3.23456]

0
replacement in sanakirja-core/src/btree/page/alloc.rs at line 142

[3.23578]→[2.49364:49386](∅→∅)

_size: usize,

[3.23578]

[3.23599]

size: usize,
edit in sanakirja-core/src/btree/page/alloc.rs at line 146

[2.49440]

[2.49440]

assert_eq!(f, size);
replacement in sanakirja-core/src/btree/page/alloc.rs at line 191

[3.26068]→[3.12206:12276](∅→∅),[3.12276]→[3.26144:26160](∅→∅),[3.26144]→[3.26144:26160](∅→∅),[3.26160]→[3.12277:12370](∅→∅)

fn extra_size<T, K: Representable, V: Representable>() -> usize {
8
}
fn can_alloc<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[3.26068]

[3.26259]

fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 194

[3.26346]→[3.12371:12466](∅→∅),[3.12466]→[3.26447:26527](∅→∅),[3.26447]→[3.26447:26527](∅→∅)

fn can_compact<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
(HDR as usize) + ((hdr.left_page() & 0xfff) as usize) + 8 + size < 4096

[3.26346]

[3.26527]

fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
debug!(
"can_compact, internal: {:?} {:?} {:?}",
HDR,
hdr.left_page() & 0xfff,
size
);
(HDR as usize) + (hdr.n() as usize) * 8 + ((hdr.left_page() & 0xfff) as usize) + 8 + size
<= 4096
replacement in sanakirja-core/src/btree/page/alloc.rs at line 220

[2.50098]→[2.50098:50119](∅→∅),[2.50119]→[3.27110:27162](∅→∅),[3.12606]→[3.27110:27162](∅→∅),[3.27110]→[3.27110:27162](∅→∅),[3.27616]→[3.27616:27627](∅→∅)

let size = {
((8 + f) * (hdr_n as usize - n)) as u64
};

[2.50098]

[3.27627]

let size = { ((8 + f) * (hdr_n as usize - n)) as u64 };
replacement in sanakirja-core/src/btree/page/alloc.rs at line 228

[3.27884]→[3.27884:28000](∅→∅)

let mut data = hdr.data() - size as u16;
data -= data % (align as u16);
hdr.set_data(data);

[3.27884]

[3.28000]

assert_eq!(size % align, 0);
let data = hdr.data();
hdr.set_data(data - size as u16);
replacement in sanakirja-core/src/btree/page/alloc.rs at line 233

[3.28056]→[3.28056:28069](∅→∅)

data

[3.28056]

[3.28069]

data - size as u16
replacement in sanakirja-core/src/btree/mod.rs at line 28

[3.46099]→[2.50185:50264](∅→∅)

pub trait BTreePage<K: Representable+?Sized, V: Representable+?Sized>: Sized {

[3.46099]

[3.46176]

pub trait BTreePage<K: Representable + ?Sized, V: Representable + ?Sized>: Sized {
replacement in sanakirja-core/src/btree/mod.rs at line 33

[3.28406]→[3.13214:13320](∅→∅)

fn next<'b, T: LoadPage>(txn: &T, p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {

[3.28406]

[3.13320]

fn next<'b, T: LoadPage>(
txn: &T,
p: Page<'b>,
c: &mut Self::Cursor,
) -> Option<(&'b K, &'b V, u64)> {
replacement in sanakirja-core/src/btree/mod.rs at line 45

[3.46676]→[3.13381:13487](∅→∅)

fn prev<'b, T: LoadPage>(txn: &T, p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {

[3.46676]

[3.28727]

fn prev<'b, T: LoadPage>(
txn: &T,
p: Page<'b>,
c: &mut Self::Cursor,
) -> Option<(&'b K, &'b V, u64)> {
replacement in sanakirja-core/src/btree/mod.rs at line 58

[3.28958]→[3.13526:13744](∅→∅)

unsafe fn unchecked_current<'a, T: LoadPage>(txn: &T, p: Page<'a>, c: &Self::Cursor) -> (&'a K, &'a V, u64);
fn current<'a, T: LoadPage>(txn: &T, p: Page<'a>, c: &Self::Cursor) -> Option<(&'a K, &'a V, u64)> {

[3.28958]

[3.46909]

unsafe fn unchecked_current<'a, T: LoadPage>(
txn: &T,
p: Page<'a>,
c: &Self::Cursor,
) -> (&'a K, &'a V, u64);
fn current<'a, T: LoadPage>(
txn: &T,
p: Page<'a>,
c: &Self::Cursor,
) -> Option<(&'a K, &'a V, u64)> {
replacement in sanakirja-core/src/btree/mod.rs at line 71

[3.46977]→[3.29133:29154](∅→∅),[3.29154]→[3.13745:13802](∅→∅),[3.13802]→[3.29206:29220](∅→∅),[3.29206]→[3.29206:29220](∅→∅)

unsafe {
Some(Self::unchecked_current(txn, p, c))
}

[3.46977]

[3.47025]

unsafe { Some(Self::unchecked_current(txn, p, c)) }
replacement in sanakirja-core/src/btree/mod.rs at line 84

[3.47415]→[3.29484:29531](∅→∅)

) -> Result<(&'a K, &'a V, u64), usize>;

[3.47415]

[3.29531]

) -> Result<(&'a K, &'a V, u64), usize>;
replacement in sanakirja-core/src/btree/mod.rs at line 92

[3.47651]→[2.50265:50323](∅→∅)

K: Representable+?Sized,
V: Representable+?Sized,

[3.47651]

[3.13884]

K: Representable + ?Sized,
V: Representable + ?Sized,
replacement in sanakirja-core/src/btree/mod.rs at line 104

[3.47817]→[2.50324:50400](∅→∅)

K: Representable+?Sized + 'a,
V: Representable+?Sized + 'a,

[3.47817]

[3.13988]

K: Representable + ?Sized + 'a,
V: Representable + ?Sized + 'a,
replacement in sanakirja-core/src/btree/mod.rs at line 115

[3.48112]→[2.50401:50475](∅→∅)

pub trait BTreeMutPage<K: Representable+?Sized, V: Representable+?Sized>:

[3.48112]

[2.50475]

pub trait BTreeMutPage<K: Representable + ?Sized, V: Representable + ?Sized>:
replacement in sanakirja-core/src/btree/mod.rs at line 140

[3.48665]→[3.14234:14343](∅→∅)

fn del<T: AllocPage>(txn: &mut T, page: CowPage, c: &Self::Cursor, l: u64) -> Result<MutPage, T::Error>;

[3.48665]

[3.48757]

fn del<T: AllocPage>(
txn: &mut T,
page: CowPage,
c: &Self::Cursor,
l: u64,
) -> Result<MutPage, T::Error>;
replacement in sanakirja-core/src/btree/mod.rs at line 186

[3.5700]→[3.3763:3853](∅→∅),[3.3763]→[3.3763:3853](∅→∅)

Ok(Put::Ok(Self::update_left_child(txn, m.page, m.mutable, &m.c1, m.l)?))

[3.5700]

[3.5701]

Ok(Put::Ok(Self::update_left_child(
txn, m.page, m.mutable, &m.c1, m.l,
)?))
replacement in sanakirja-core/src/btree/mod.rs at line 192

[3.5825]→[3.5825:5913](∅→∅)

Ok(Put::Ok(Self::update_left_child(txn, m.page, m.mutable, &c1, m.r)?))

[3.5825]

[3.3853]

Ok(Put::Ok(Self::update_left_child(
txn, m.page, m.mutable, &c1, m.r,
)?))
replacement in sanakirja-core/src/btree/mod.rs at line 203

[3.3885]→[2.50496:50567](∅→∅)

pub enum Op<'a, T, K: Representable+?Sized, V: Representable+?Sized> {

[3.3885]

[3.50267]

pub enum Op<'a, T, K: Representable + ?Sized, V: Representable + ?Sized> {
replacement in sanakirja-core/src/btree/mod.rs at line 221

[3.50582]→[3.30655:30667](∅→∅),[3.30667]→[2.50568:50626](∅→∅)

'a,
K: Representable+?Sized,
V: Representable+?Sized,

[3.50582]

[3.14709]

'a,
K: Representable + ?Sized,
V: Representable + ?Sized,
replacement in sanakirja-core/src/btree/mod.rs at line 244

[3.51195]→[2.50627:50706](∅→∅)

impl<'a, K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>>

[3.51195]

[3.14799]

impl<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>>
replacement in sanakirja-core/src/btree/mod.rs at line 252

[3.51481]→[3.30913:31032](∅→∅)

if P::is_empty(self.page.as_page(), &self.c0) && self.ins.is_none() && P::is_empty(self.page.as_page(), &c1) {

[3.51481]

[3.51582]

if P::is_empty(self.page.as_page(), &self.c0)
&& self.ins.is_none()
&& P::is_empty(self.page.as_page(), &c1)
{
replacement in sanakirja-core/src/btree/mod.rs at line 264

[3.51677]→[2.50707:50799](∅→∅),[2.50799]→[3.51777:51779](∅→∅),[3.14908]→[3.51777:51779](∅→∅),[3.51777]→[3.51777:51779](∅→∅)

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

[3.51677]

[3.31033]

pub struct Concat<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {
replacement in sanakirja-core/src/btree/mod.rs at line 274

[3.52016]→[2.50800:50887](∅→∅)

pub struct Db_<K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>> {

[3.52016]

[3.31135]

pub struct Db_<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {
replacement in sanakirja-core/src/btree/mod.rs at line 285

[3.52224]→[2.51012:51070](∅→∅)

K: Representable+?Sized,
V: Representable+?Sized,

[3.52224]

[3.15178]

K: Representable + ?Sized,
V: Representable + ?Sized,
replacement in sanakirja-core/src/btree/mod.rs at line 313

[3.3921]→[2.51186:51244](∅→∅)

K: Representable+?Sized,
V: Representable+?Sized,

[3.3921]

[3.15426]

K: Representable + ?Sized,
V: Representable + ?Sized,
replacement in sanakirja-core/src/btree/mod.rs at line 340

[3.407]→[3.407:408](∅→∅),[3.408]→[2.51360:51459](∅→∅)

pub fn get<'a, T: LoadPage, K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>>(

[3.407]

[3.502]

pub fn get<
'a,
T: LoadPage,
K: Representable + ?Sized,
V: Representable + ?Sized,
P: BTreePage<K, V>,
>(
replacement in sanakirja-core/src/btree/mod.rs at line 364

[3.15846]→[3.1185:1325](∅→∅),[3.1185]→[3.1185:1325](∅→∅)

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

[3.15846]

[3.1325]

unsafe { last_match = Some((core::mem::transmute(k), core::mem::transmute(v))) }
edit in sanakirja-core/src/btree/del.rs at line 80

[3.55709]→[3.17135:17136](∅→∅)
replacement in sanakirja-core/src/btree/del.rs at line 105

[3.17985]→[3.17985:18066](∅→∅)

update_root(txn, db, last_op, k0v0, cursor.first_rc_level <= 1, &mut free)?;

[3.17985]

[3.18066]

update_root(
txn,
db,
last_op,
k0v0,
cursor.first_rc_level <= 1,
&mut free,
)?;
replacement in sanakirja-core/src/btree/del.rs at line 379

[3.20503]→[3.20503:20582](∅→∅),[3.20582]→[3.37696:37710](∅→∅),[3.37696]→[3.37696:37710](∅→∅)

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

[3.20503]

[3.37710]

if cursor.pointer + 1 >= cursor.first_rc_level && !split_key_is_k0 {
replacement in sanakirja-core/src/btree/del.rs at line 398

[3.20849]→[3.62834:62877](∅→∅),[3.62834]→[3.62834:62877](∅→∅),[3.62877]→[3.20850:20918](∅→∅),[3.20918]→[3.62954:62957](∅→∅),[3.62954]→[3.62954:62957](∅→∅)

fn modify_rc<
T: AllocPage + LoadPage,
K: Representable,
V: Representable,
P: BTreePage<K, V>,
>(

[3.20849]

[3.62957]

fn modify_rc<T: AllocPage + LoadPage, K: Representable, V: Representable, P: BTreePage<K, V>>(
edit in sanakirja-core/src/btree/del.rs at line 493

[3.38597]→[3.23597:23598](∅→∅)
replacement in sanakirja-core/src/btree/del.rs at line 503

[3.24023]→[3.24023:24045](∅→∅)

return Ok(())

[3.24023]

[3.24045]

return Ok(());
replacement in sanakirja-core/src/btree/cursor.rs at line 2

[3.63697]→[3.33766:33798](∅→∅)

use crate::{LoadPage, CowPage};

[3.63697]

[3.63726]

use crate::{CowPage, LoadPage};
replacement in sanakirja-core/src/btree/cursor.rs at line 7

[3.63799]→[2.51460:51552](∅→∅),[2.51552]→[3.63899:63901](∅→∅),[3.24400]→[3.63899:63901](∅→∅),[3.63899]→[3.63899:63901](∅→∅)

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

[3.63799]

[3.33799]

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

[3.63959]→[2.51553:51634](∅→∅)

impl<K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>> Clone

[3.63959]

[3.24468]

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Clone
replacement in sanakirja-core/src/btree/cursor.rs at line 22

[3.64220]→[2.51635:51715](∅→∅)

impl<K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>> Copy

[3.64220]

[3.24563]

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Copy
replacement in sanakirja-core/src/btree/cursor.rs at line 40

[3.64963]→[2.51716:51806](∅→∅)

pub struct Cursor<K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>> {

[3.64963]

[3.24668]

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

[3.65195]→[2.51807:51886](∅→∅),[2.51886]→[3.24807:24827](∅→∅),[3.24807]→[3.24807:24827](∅→∅),[3.24827]→[3.65305:65307](∅→∅),[3.65305]→[3.65305:65307](∅→∅)

impl<'a, K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>>
Cursor<K, V, P>
{

[3.65195]

[3.24828]

impl<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {
replacement in sanakirja-core/src/btree/cursor.rs at line 61

[3.65654]→[2.51887:51962](∅→∅),[2.51962]→[3.24934:24954](∅→∅),[3.24934]→[3.24934:24954](∅→∅),[3.24954]→[3.65764:65766](∅→∅),[3.65764]→[3.65764:65766](∅→∅)

impl<K: Representable+?Sized, V: Representable+?Sized, P: BTreePage<K, V>>
Cursor<K, V, P>
{

[3.65654]

[3.24955]

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {
replacement in sanakirja-core/src/btree/cursor.rs at line 117

[3.67642]→[3.25107:25213](∅→∅)

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

[3.67642]

[3.67731]

pub fn set_last<'a, 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 148

[3.68806]→[3.25313:25347](∅→∅),[3.35253]→[3.68836:68855](∅→∅),[3.25347]→[3.68836:68855](∅→∅),[3.68836]→[3.68836:68855](∅→∅),[3.68855]→[3.25348:25418](∅→∅)

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

[3.68806]

[3.68933]

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

[3.70713]→[3.450:501](∅→∅)

return Ok(Some((& *k, & *v)));

[3.70713]

[3.501]

return Ok(Some((&*k, &*v)));
replacement in sanakirja/src/tests.rs at line 55

[3.25713]→[3.2340:2389](∅→∅),[3.2340]→[3.2340:2389](∅→∅)

put(&mut txn, &mut db, &(m/2), &a).unwrap();

[3.25713]

[3.2389]

put(&mut txn, &mut db, &(m / 2), &a).unwrap();
edit in sanakirja/src/tests.rs at line 124

[3.5676]→[3.8887:8888](∅→∅)
edit in sanakirja/src/tests.rs at line 125

[3.8889]→[3.5676:5677](∅→∅),[3.5676]→[3.5676:5677](∅→∅)
edit in sanakirja/src/tests.rs at line 169

[3.6528]→[3.120:121](∅→∅)
replacement in sanakirja/src/tests.rs at line 273

[3.1696]→[3.1696:1726](∅→∅)

#[cfg(target_family="unix")]

[3.1696]

[3.1726]

#[cfg(target_family = "unix")]
edit in sanakirja/src/tests.rs at line 299

[2.52088]→[2.52088:52089](∅→∅)
edit in sanakirja/src/tests.rs at line 300

[2.52154]

[2.52154]

type P<K, V> = sanakirja_core::btree::page::Page<K, V>;
edit in sanakirja/src/tests.rs at line 321

[2.52818]

#[test]
fn sized_vs_unsized() {
env_logger::try_init().unwrap_or(());
let env = Env::new_anon(409_600_000, 1).unwrap();
let mut txn = Env::mut_txn_begin(&env).unwrap();

let now = std::time::SystemTime::now();
let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
let n = 22_014u64;
for i in 0..n {
debug!("=================== {:?}", i);
put(&mut txn, &mut db, &i, &i).unwrap();
}
debug!("===========================");
crate::debug::debug(&txn, &[&db], "debug0", true);
put(&mut txn, &mut db, &n, &n).unwrap();
crate::debug::debug(&txn, &[&db], "debug", true);
println!("sized: {:?}", now.elapsed());
let mut refs = BTreeMap::new();
add_refs(&txn, &db, &mut refs).unwrap();
let mut n = 0;
for (p, r) in refs.iter() {
if *r >= 2 {
error!("{:?} referenced twice", p);
n += 1
}
}
assert_eq!(n, 0);
/*
let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, UP<u64, u64>>(&mut txn).unwrap();
let now = std::time::SystemTime::now();
let n = 100_000u64;
for i in 0..n {
put(&mut txn, &mut db, &i, &i).unwrap();
}
println!("unsized: {:?}", now.elapsed());
*/
}
replacement in sanakirja/src/environment/muttxn.rs at line 394

[3.4442]→[3.4442:4458](∅→∅),[3.4458]→[3.27591:27643](∅→∅),[3.27643]→[3.4522:4529](∅→∅),[3.4522]→[3.4522:4529](∅→∅)

fn root_db<
K: Representable,
V: Representable,
>(

[3.4442]

[3.4529]

fn root_db<K: Representable, V: Representable>(
replacement in sanakirja/src/environment/muttxn.rs at line 412

[3.5081]→[3.5081:5180](∅→∅)

*(maps[0].ptr.add(*root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n) as *mut u64)

[3.5081]

[3.5180]

*(maps[0]
.ptr
.add(*root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
as *mut u64)
replacement in sanakirja/src/environment/mod.rs at line 423

[3.6170]→[3.6170:6186](∅→∅),[3.6186]→[3.27711:27763](∅→∅),[3.27763]→[3.6250:6257](∅→∅),[3.6250]→[3.6250:6257](∅→∅)

fn root_db<
K: Representable,
V: Representable,
>(

[3.6170]

[3.6257]

fn root_db<K: Representable, V: Representable>(