Trait/type cleanup

[?]

Feb 3, 2021, 8:24 AM

OTWDDJE7TTE73D6BGF4ZN6BH2NFUFLPME2VJ3CPALH463UGWLEIQC

Dependencies

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

Change contents

replacement in sanakirja-core/src/lib.rs at line 4

[3.119]→[3.119:148](∅→∅)

pub trait Representable<T> {

[3.119]

[3.148]

pub trait Representable {
replacement in sanakirja-core/src/lib.rs at line 11

[3.444]→[3.0:65](∅→∅)

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

[3.444]

[3.505]

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

[3.761]

[3.761]

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

[3.809]→[3.809:851](∅→∅)

impl<T> Representable<T> for $t {

[3.809]

[3.851]

impl Representable for $t {
replacement in sanakirja-core/src/lib.rs at line 32

[3.1154]→[3.66:138](∅→∅)

fn compare(&self, _: &T, b: &Self) -> core::cmp::Ordering {

[3.1154]

[3.138]

fn compare<T>(&self, _: &T, b: &Self) -> core::cmp::Ordering {
edit in sanakirja-core/src/lib.rs at line 38

[3.1364]

[3.1364]

unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
&*(p as *const Self)
}
edit in sanakirja-core/src/lib.rs at line 50

[3.1476]

[3.1476]

direct_repr!(u32);
direct_repr!(i32);
edit in sanakirja-core/src/lib.rs at line 53

[3.1495]

[3.1495]

direct_repr!(i64);
replacement in sanakirja-core/src/lib.rs at line 57

[3.1496]→[3.17:144](∅→∅),[3.144]→[3.1615:1641](∅→∅),[3.1615]→[3.1615:1641](∅→∅)

unsafe fn read<T, K: Representable<T>, V: Representable<T>>(p: *const u8) -> (*const K, *const V) {
let k = p as *const K;
let s = K::size(&*k);

[3.1496]

[3.1641]

unsafe fn read<T, K: Representable, V: Representable>(txn: &T, k: *const u8) -> (*const u8, *const u8) {
let s = K::size(K::from_raw_ptr(txn, k));
replacement in sanakirja-core/src/lib.rs at line 62

[3.1725]→[3.145:168](∅→∅)

(k, v as *const V)

[3.1725]

[3.1746]

(k, v)
replacement in sanakirja-core/src/lib.rs at line 65

[3.1749]→[3.1749:1833](∅→∅)

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

[3.1749]

[3.1833]

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

[3.1972]→[3.169:260](∅→∅)

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

[3.1972]

[3.2061]

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

[3.146]→[3.4119:4213](∅→∅),[3.4119]→[3.4119:4213](∅→∅)

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

[3.146]

[3.4213]

pub fn put<T: AllocPage, K: Representable, V: Representable, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core/src/btree/put.rs at line 20

[3.4230]→[3.0:30](∅→∅)

db: &mut Db_<T, K, V, P>,

[3.4230]

[3.4259]

db: &mut Db_<K, V, P>,
replacement in sanakirja-core/src/btree/put.rs at line 52

[3.4963]→[3.4963:5061](∅→∅)

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

[3.4963]

[3.5061]

fn put_cascade<T: AllocPage, K: Representable, V: Representable, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core/src/btree/put.rs at line 54

[3.5078]→[3.5078:5115](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.5078]

[3.5115]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/put.rs at line 125

[3.7489]→[3.7489:7566](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreePage<T, K, V>,

[3.7489]

[3.7566]

K: Representable,
V: Representable,
P: BTreePage<K, V>,
replacement in sanakirja-core/src/btree/put.rs at line 130

[3.7586]→[3.7586:7623](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.7586]

[3.7623]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/put.rs at line 156

[3.8332]→[3.1126:1200](∅→∅)

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

[3.8332]

[3.8397]

while let Some((k, v, r)) = P::next(txn, cur.page.as_page(), &mut c) {
edit in sanakirja-core/src/btree/page.rs at line 20

[3.8770]→[3.29:78](∅→∅),[3.78]→[3.8812:8867](∅→∅),[3.8812]→[3.8812:8867](∅→∅)

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(C)]
struct Tuple<K, V> {
k: K,
v: V,
}
replacement in sanakirja-core/src/btree/page.rs at line 21

[3.304]→[3.304:491](∅→∅)

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

[3.304]

[3.9832]

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 37

[3.10101]→[3.10101:10157](∅→∅)

fn size(m: &ModifiedPage<T, K, V, Self>) -> usize {

[3.10101]

[3.1548]

fn size(m: &ModifiedPage<K, V, Self>) -> usize {
replacement in sanakirja-core/src/btree/page.rs at line 42

[3.10292]→[3.10292:10355](∅→∅)

if fixed_size::<T, K, V>().is_some() && m.c1.is_leaf {

[3.10292]

[3.10355]

if fixed_size::<K, V>().is_some() && m.c1.is_leaf {
replacement in sanakirja-core/src/btree/page.rs at line 57

[3.10717]→[3.10717:10772](∅→∅)

if fixed_size::<T, K, V>().is_none() {

[3.10717]

[3.612]

if fixed_size::<K, V>().is_none() {
replacement in sanakirja-core/src/btree/page.rs at line 73

[3.10923]→[3.10923:10939](∅→∅)

fn put<'a>(

[3.10923]

[3.10939]

fn put<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 91

[3.11472]→[3.1062:1082](∅→∅)

fn replace<'a>(

[3.11472]

[3.1082]

fn replace<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 107

[3.1520]→[3.11472:11498](∅→∅),[3.11472]→[3.11472:11498](∅→∅)

fn update_left_child(

[3.1520]

[3.11498]

fn update_left_child<T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 128

[3.254]→[3.2293:2360](∅→∅),[3.2293]→[3.2293:2360](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

[3.254]

[3.255]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut new);
replacement in sanakirja-core/src/btree/page.rs at line 134

[3.2458]→[3.2458:2535](∅→∅)

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

[3.2458]

[3.2535]

clone::<K, V, Internal>(page.as_page(), &mut new, s, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 147

[3.12564]→[3.2661:2758](∅→∅)

fn del(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> {
replacement in sanakirja-core/src/btree/page.rs at line 157

[3.1770]→[3.1770:1833](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.1770]

[3.1833]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 167

[3.2344]→[3.2344:2410](∅→∅)

let size = entry_size::<T, K, V>(kv_ptr);

[3.2344]

[3.2410]

let size = entry_size::<K, V>(kv_ptr);
replacement in sanakirja-core/src/btree/page.rs at line 175

[3.2749]→[3.2749:2898](∅→∅)

let size = entry_size::<T, K, V>(kv_ptr);
core::ptr::copy(ptr.offset(1), ptr, (&*hdr).n() as usize - c.cur);

[3.2749]

[3.2898]

let size = entry_size::<K, V>(kv_ptr);
core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur);
replacement in sanakirja-core/src/btree/page.rs at line 193

[3.4499]→[3.4499:4570](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

[3.4499]

[3.14729]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut new);
replacement in sanakirja-core/src/btree/page.rs at line 198

[3.14967]→[3.4647:4811](∅→∅)

clone::<T, K, V, Leaf>(page.as_page(), &mut new, s0, &mut n);
clone::<T, K, V, Leaf>(page.as_page(), &mut new, s1, &mut n);

[3.14967]

[3.15111]

clone::<K, V, Leaf>(page.as_page(), &mut new, s0, &mut n);
clone::<K, V, Leaf>(page.as_page(), &mut new, s1, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 204

[3.15347]→[3.4892:4978](∅→∅)

clone::<T, K, V, Internal>(page.as_page(), &mut new, s0, &mut n);

[3.15347]

[3.15423]

clone::<K, V, Internal>(page.as_page(), &mut new, s0, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 207

[3.15539]→[3.4979:5065](∅→∅)

clone::<T, K, V, Internal>(page.as_page(), &mut new, s1, &mut n);

[3.15539]

[3.15615]

clone::<K, V, Internal>(page.as_page(), &mut new, s1, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 214

[3.15688]→[3.15688:15719](∅→∅)

fn merge_or_rebalance<'a>(

[3.15688]

[3.15719]

fn merge_or_rebalance<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 216

[3.15740]→[3.5066:5109](∅→∅)

m: &mut Concat<'a, T, K, V, Self>,

[3.15740]

[3.15779]

m: &mut Concat<'a, K, V, Self>,
replacement in sanakirja-core/src/btree/page.rs at line 220

[3.15906]→[3.15906:15961](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.15906]

[3.15961]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 225

[3.16104]→[3.5110:5170](∅→∅)

2 + alloc_size::<T, K, V>(m.mid.0, m.mid.1)

[3.16104]

[3.16179]

2 + alloc_size::<K, V>(m.mid.0, m.mid.1)
replacement in sanakirja-core/src/btree/page.rs at line 228

[3.16210]→[3.5171:5227](∅→∅)

8 + alloc_size::<T, K, V>(m.mid.0, m.mid.1)

[3.16210]

[3.16281]

8 + alloc_size::<K, V>(m.mid.0, m.mid.1)
replacement in sanakirja-core/src/btree/page.rs at line 243

[3.5447]→[3.5447:5514](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

[3.5447]

[3.16691]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut new);
replacement in sanakirja-core/src/btree/page.rs at line 246

[3.16755]→[3.5515:5571](∅→∅)

merge::<_, _, _, Leaf>(&mut new, m)

[3.16755]

[3.16806]

merge::<_, _, _, Leaf>(txn, &mut new, m)
replacement in sanakirja-core/src/btree/page.rs at line 248

[3.16831]→[3.5572:5632](∅→∅)

merge::<_, _, _, Internal>(&mut new, m)

[3.16831]

[3.16886]

merge::<_, _, _, Internal>(txn, &mut new, m)
replacement in sanakirja-core/src/btree/page.rs at line 306

[3.18476]→[3.18476:18562](∅→∅)

impl<T: LoadPage, K: Representable<T>, V: Representable<T>> super::BTreePage<T, K, V>

[3.18476]

[3.18562]

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

[3.19408]→[3.3778:3815](∅→∅)

unsafe fn unchecked_current<'a>(

[3.19408]

[3.3815]

unsafe fn unchecked_current<'a, T: LoadPage>(
txn: &T,
replacement in sanakirja-core/src/btree/page.rs at line 340

[3.19528]→[3.19528:19593](∅→∅)

let off = if let Some(f) = fixed_size::<T, K, V>() {

[3.19528]

[3.19593]

let off = if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 347

[3.19851]→[3.7355:7461](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));
(&*k, &*v, 0)

[3.19851]

[3.19944]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
(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 351

[3.7555]→[3.7555:7682](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().add((off & 0xfff) as usize));
(&*k, &*v, off & !0xfff)

[3.7555]

[3.20159]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
(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 357

[3.7817]→[3.20299:20354](∅→∅),[3.20299]→[3.20299:20354](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.7817]

[3.20354]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 372

[3.20851]→[3.20851:20910](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.20851]

[3.20910]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 375

[3.20957]→[3.4023:4106](∅→∅)

2 + entry_size::<T, K, V>(page.data.as_ptr().add(u16::from_le(

[3.20957]

[3.4106]

2 + entry_size::<K, V>(page.data.as_ptr().add(u16::from_le(
replacement in sanakirja-core/src/btree/page.rs at line 381

[3.21236]→[3.8229:8295](∅→∅)

8 + entry_size::<T, K, V>(page.data.as_ptr().add(

[3.21236]

[3.4224]

8 + entry_size::<K, V>(page.data.as_ptr().add(
replacement in sanakirja-core/src/btree/page.rs at line 420

[3.22153]→[3.22153:22176](∅→∅)

fn set_cursor<'a>(

[3.22153]

[3.22176]

fn set_cursor<'a, T: LoadPage>(
replacement in sanakirja-core/src/btree/page.rs at line 434

[3.24688]→[3.24688:24765](∅→∅)

let off = if let Some(f) = fixed_size::<T, K, V>() {

[3.24688]

[3.24765]

let off = if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page.rs at line 443

[3.25150]→[3.9219:9267](∅→∅)

Ok(Leaf::kv(page, off))

[3.25150]

[3.25199]

Ok(Leaf::kv(txn, page, off))
replacement in sanakirja-core/src/btree/page.rs at line 447

[3.4628]→[3.9370:9455](∅→∅),[3.9370]→[3.9370:9455](∅→∅)

Ok(Internal::kv(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 472

[3.25881]→[3.25881:25961](∅→∅)

fn fixed_size<T, K: Representable<T>, V: Representable<T>>() -> Option<usize> {

[3.25881]

[3.25961]

fn fixed_size<K: Representable, V: Representable>() -> Option<usize> {
replacement in sanakirja-core/src/btree/page.rs at line 482

[3.26193]→[3.9545:9608](∅→∅)

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

[3.9543]

[3.9608]

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

[3.9834]→[3.9834:9881](∅→∅)

if fixed_size::<T, K, V>().is_some() {

[3.9834]

[3.9881]

if fixed_size::<K, V>().is_some() {
replacement in sanakirja-core/src/btree/page.rs at line 516

[3.10787]→[3.10787:10878](∅→∅),[3.10878]→[3.4861:4979](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().offset(off as isize));
match (&*k).compare(txn, k0) {
Ordering::Equal => (&*v).compare(txn, v0),

[3.10787]

[3.4979]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().offset(off as isize));
let k = K::from_raw_ptr(txn, k as *const u8);
match k.compare(txn, k0) {
Ordering::Equal => {
let v = V::from_raw_ptr(txn, v as *const u8);
v.compare(txn, v0)
},
replacement in sanakirja-core/src/btree/page.rs at line 529

[3.11097]→[3.11097:11188](∅→∅),[3.11188]→[3.5038:5081](∅→∅)

let (k, _) = read::<T, K, V>(page.data.as_ptr().offset(off as isize));
(&*k).compare(txn, k0)

[3.11097]

[3.11242]

let (k, _) = read::<T, K, V>(txn, page.data.as_ptr().offset(off as isize));
let k = K::from_raw_ptr(txn, k);
k.compare(txn, k0)
replacement in sanakirja-core/src/btree/page.rs at line 543

[3.11540]→[3.11540:11635](∅→∅),[3.11635]→[3.5224:5334](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().offset(off as isize & 0xfff));
match (&*k).compare(txn, k0) {
Ordering::Equal => (&*v).compare(txn, v0),

[3.11540]

[3.5334]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().offset(off as isize & 0xfff));
let k = K::from_raw_ptr(txn, k);
match k.compare(txn, k0) {
Ordering::Equal => {
let v = V::from_raw_ptr(txn, v);
v.compare(txn, v0)
},
replacement in sanakirja-core/src/btree/page.rs at line 556

[3.11842]→[3.11842:11937](∅→∅),[3.11937]→[3.5385:5424](∅→∅)

let (k, _) = read::<T, K, V>(page.data.as_ptr().offset(off as isize & 0xfff));
(&*k).compare(txn, k0)

[3.11842]

[3.11987]

let (k, _) = read::<T, K, V>(txn, page.data.as_ptr().offset(off as isize & 0xfff));
let k = K::from_raw_ptr(txn, k);
k.compare(txn, k0)
replacement in sanakirja-core/src/btree/page.rs at line 572

[3.8349]→[3.8349:8473](∅→∅)

T: LoadPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.8349]

[3.8473]

T: LoadPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page.rs at line 576

[3.8487]→[3.8487:8490](∅→∅)

>(

[3.8487]

[3.20093]

>(
txn: &T,
replacement in sanakirja-core/src/btree/page.rs at line 579

[3.20116]→[3.34732:34779](∅→∅),[3.34732]→[3.34732:34779](∅→∅)

m: &mut ModifiedPage<T, K, V, Page<K, V>>,

[3.20116]

[3.34779]

m: &mut ModifiedPage<K, V, Page<K, V>>,
replacement in sanakirja-core/src/btree/page.rs at line 584

[3.20184]→[3.20184:20315](∅→∅)

while let Some((k, v, r)) = <Page<K, V>>::next(m.page.as_page(), &mut m.c0) {
alloc::<_, _, _, L>(new, k, v, l, r, n);

[3.20184]

[3.35024]

while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c0) {
alloc::<_, _, L>(new, k, v, l, r, n);
replacement in sanakirja-core/src/btree/page.rs at line 590

[3.8532]→[3.8532:8644](∅→∅)

alloc::<_, _, _, L>(new, k, v, 0, 0, n);
alloc::<_, _, _, L>(new, k2, v2, m.l, m.r, n);

[3.8532]

[3.8644]

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

[3.8661]→[3.8661:8718](∅→∅)

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

[3.8661]

[3.8718]

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

[3.35214]→[3.20372:20454](∅→∅)

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

[3.35214]

[3.35287]

while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.page.as_page(), &mut m.c1) {
replacement in sanakirja-core/src/btree/page.rs at line 604

[3.35371]→[3.20455:20504](∅→∅)

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 610

[3.8746]→[3.8746:8870](∅→∅)

T: LoadPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.8746]

[3.8870]

T: LoadPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page.rs at line 614

[3.8884]→[3.8884:8887](∅→∅)

>(

[3.8884]

[3.20505]

>(
txn: &T,
replacement in sanakirja-core/src/btree/page.rs at line 617

[3.20528]→[3.35549:35590](∅→∅),[3.35549]→[3.35549:35590](∅→∅)

m: &mut Concat<T, K, V, Page<K, V>>,

[3.20528]

[3.35590]

m: &mut Concat<K, V, Page<K, V>>,
replacement in sanakirja-core/src/btree/page.rs at line 621

[3.35673]→[3.20529:20589](∅→∅)

modify::<_, _, _, L>(new, &mut m.modified, &mut n);

[3.35673]

[3.20589]

modify::<_, _, _, L>(txn, new, &mut m.modified, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 624

[3.20723]→[3.20723:20936](∅→∅)

alloc::<_, _, _, L>(new, &*m.mid.0, &*m.mid.1, 0, l, &mut n);
while let Some((k, v, r)) = <Page<K, V>>::next(m.other.as_page(), &mut rc) {
alloc::<_, _, _, L>(new, k, v, 0, r, &mut n);

[3.20723]

[3.36058]

alloc::<_, _, L>(new, m.mid.0, m.mid.1, 0, l, &mut n);
while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
alloc::<_, _, L>(new, k, v, 0, r, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 631

[3.21075]→[3.21075:21218](∅→∅)

while let Some((k, v, r)) = <Page<K, V>>::next(m.other.as_page(), &mut rc) {
alloc::<_, _, _, L>(new, k, v, l, r, &mut n);

[3.21075]

[3.36340]

while let Some((k, v, r)) = <Page<K, V>>::next(txn, m.other.as_page(), &mut rc) {
alloc::<_, _, L>(new, k, v, l, r, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 635

[3.36369]→[3.21219:21349](∅→∅)

alloc::<_, _, _, L>(new, &*m.mid.0, &*m.mid.1, 0, 0, &mut n);
modify::<_, _, _, L>(new, &mut m.modified, &mut n);

[3.36369]

[3.36499]

alloc::<_, _, L>(new, m.mid.0, m.mid.1, 0, 0, &mut n);
modify::<_, _, _, L>(txn, new, &mut m.modified, &mut n);
replacement in sanakirja-core/src/btree/page.rs at line 641

[3.38647]→[3.22462:22527](∅→∅)

fn clone<T, K: Representable<T>, V: Representable<T>, L: Alloc>(

[3.36872]

[3.38741]

fn clone<K: Representable, V: Representable, L: Alloc>(
replacement in sanakirja-core/src/btree/page.rs at line 654

[3.22697]→[3.22697:22756](∅→∅)

let size = entry_size::<T, K, V>(ptr);

[3.22697]

[3.22756]

let size = entry_size::<K, V>(ptr);
replacement in sanakirja-core/src/btree/page.rs at line 666

[3.39419]→[3.39419:39476](∅→∅)

let size = fixed_size::<T, K, V>().unwrap();

[3.39419]

[3.39476]

let size = fixed_size::<K, V>().unwrap();
replacement in sanakirja-core/src/btree/page.rs at line 685

[3.39991]→[3.23621:23686](∅→∅)

fn alloc<T, K: Representable<T>, V: Representable<T>, L: Alloc>(

[3.39991]

[3.23686]

fn alloc<K: Representable, V: Representable, L: Alloc>(
replacement in sanakirja-core/src/btree/page.rs at line 694

[3.40209]→[3.23710:23773](∅→∅)

let off_new = L::alloc_insert::<T, K, V>(new, n, size, r);

[3.40209]

[3.23773]

let off_new = L::alloc_insert::<K, V>(new, n, size, r);
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 6

[3.469]→[3.469:594](∅→∅)

T: AllocPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.469]

[3.594]

T: AllocPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 12

[3.628]→[3.628:673](∅→∅)

m: &mut Concat<'a, T, K, V, Page<K, V>>,

[3.628]

[3.673]

m: &mut Concat<'a, K, V, Page<K, V>>,
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 19

[3.946]→[3.946:1034](∅→∅)

let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(m.other.as_page(), &rc) };

[3.946]

[3.1034]

let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &rc) };
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 49

[3.1795]→[3.1795:1868](∅→∅)

alloc::<T, K, V, L>(&mut new_left, m.mid.0, m.mid.1, 0, rl, &mut n);

[3.1795]

[3.1868]

alloc::<K, V, L>(&mut new_left, m.mid.0, m.mid.1, 0, rl, &mut n);
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 52

[3.1916]→[3.1916:1976](∅→∅)

let (new_right, k, v) = match fixed_size::<T, K, V>() {

[3.1916]

[3.1976]

let (new_right, k, v) = match fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 106

[3.3910]→[3.3910:4035](∅→∅)

T: AllocPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.3910]

[3.4035]

T: AllocPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 112

[3.4069]→[3.4069:4114](∅→∅)

m: &mut Concat<'a, T, K, V, Page<K, V>>,

[3.4069]

[3.4114]

m: &mut Concat<'a, K, V, Page<K, V>>,
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 117

[3.4290]→[3.4290:4381](∅→∅)

let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(m.other.as_page(), &lc) };

[3.4290]

[3.4381]

let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &lc) };
replacement in sanakirja-core/src/btree/page/put.rs at line 5

[3.5972]→[3.5972:6097](∅→∅)

T: AllocPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.5972]

[3.6097]

T: AllocPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page/put.rs at line 34

[3.6835]→[3.6835:6967](∅→∅)

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

[3.6835]

[3.6967]

alloc::<_, _, L>(&mut page, k0, v0, 0, 0, &mut n);
alloc::<_, _, L>(&mut page, k1, v1, l, r, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 37

[3.6984]→[3.6984:7050](∅→∅)

alloc::<_, _, _, L>(&mut page, k0, v0, l, r, &mut n);

[3.6984]

[3.7050]

alloc::<_, _, L>(&mut page, k0, v0, l, r, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 43

[3.7239]→[3.7239:7302](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut new);

[3.7239]

[3.7302]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut new);
replacement in sanakirja-core/src/btree/page/put.rs at line 48

[3.7500]→[3.7500:7567](∅→∅)

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

[3.7500]

[3.7567]

clone::<K, V, L>(page.as_page(), &mut new, s0, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 50

[3.7606]→[3.7606:7736](∅→∅)

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

[3.7606]

[3.7736]

alloc::<_, _, L>(&mut new, k0, v0, 0, 0, &mut n);
alloc::<_, _, L>(&mut new, k1, v1, l, r, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 53

[3.7753]→[3.7753:7818](∅→∅)

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

[3.7753]

[3.7818]

alloc::<_, _, L>(&mut new, k0, v0, l, r, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 55

[3.7828]→[3.7828:7895](∅→∅)

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

[3.7828]

[3.7895]

clone::<K, V, L>(page.as_page(), &mut new, s1, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 64

[3.8085]→[3.8085:8136](∅→∅)

if let Some(s) = fixed_size::<T, K, V>() {

[3.8085]

[3.8136]

if let Some(s) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/put.rs at line 75

[3.8399]→[3.8399:8524](∅→∅)

T: AllocPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.8399]

[3.8524]

T: AllocPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page/put.rs at line 106

[3.9266]→[3.9266:9337](∅→∅)

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

[3.9266]

[3.9337]

let (k, v, r) = L::kv(txn, page.as_page(), s1a.first::<T, K, V>());
replacement in sanakirja-core/src/btree/page/put.rs at line 126

[3.10119]→[3.10119:10191](∅→∅)

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

[3.10119]

[3.10191]

clone::<K, V, L>(page.as_page(), &mut left, s0, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 133

[3.10420]→[3.10420:10485](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut right);

[3.10420]

[3.10485]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut right);
replacement in sanakirja-core/src/btree/page/put.rs at line 138

[3.10668]→[3.10668:10883](∅→∅)

clone::<T, K, V, L>(page.as_page(), &mut right, s1a, &mut n);
alloc::<T, K, V, L>(&mut right, k0, v0, l, r, &mut n);
clone::<T, K, V, L>(page.as_page(), &mut right, s1b, &mut n);

[3.10668]

[3.10883]

clone::<K, V, L>(page.as_page(), &mut right, s1a, &mut n);
alloc::<K, V, L>(&mut right, k0, v0, l, r, &mut n);
clone::<K, V, L>(page.as_page(), &mut right, s1b, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 147

[3.11212]→[3.11212:11285](∅→∅)

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

[3.11212]

[3.11285]

clone::<K, V, L>(page.as_page(), &mut right, s1, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 158

[3.11481]→[3.11481:11545](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut left);

[3.11481]

[3.11545]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut left);
replacement in sanakirja-core/src/btree/page/put.rs at line 164

[3.11764]→[3.11764:11964](∅→∅)

clone::<T, K, V, L>(page.as_page(), &mut left, s0a, &mut n);
alloc::<T, K, V, L>(&mut left, k0, v0, l, r, &mut n);
clone::<T, K, V, L>(page.as_page(), &mut left, s0b, &mut n);

[3.11764]

[3.11964]

clone::<K, V, L>(page.as_page(), &mut left, s0a, &mut n);
alloc::<K, V, L>(&mut left, k0, v0, l, r, &mut n);
clone::<K, V, L>(page.as_page(), &mut left, s0b, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 172

[3.12114]→[3.12114:12206](∅→∅)

if let Some((k, v)) = L::truncate_left::<T, K, V>(&mut right, k as usize + 1) {

[3.12114]

[3.12206]

if let Some((k, v)) = L::truncate_left::<T, K, V>(txn, &mut right, k as usize + 1) {
replacement in sanakirja-core/src/btree/page/put.rs at line 174

[3.12231]→[3.12231:12307](∅→∅)

split_key = &*k;
split_value = &*v;

[3.12231]

[3.12307]

split_key = K::from_raw_ptr(txn, k as *const u8);
split_value = V::from_raw_ptr(txn, v as *const u8);
replacement in sanakirja-core/src/btree/page/put.rs at line 181

[3.12418]→[3.12418:12487](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut right);

[3.12418]

[3.12487]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut right);
replacement in sanakirja-core/src/btree/page/put.rs at line 184

[3.12573]→[3.12573:12646](∅→∅)

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

[3.12573]

[3.12646]

clone::<K, V, L>(page.as_page(), &mut right, s1, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 199

[3.12878]→[3.968:1005](∅→∅),[3.1005]→[3.12914:13002](∅→∅),[3.12914]→[3.12914:13002](∅→∅)

T: AllocPage + core::fmt::Debug,
K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.12878]

[3.13002]

T: AllocPage,
K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/page/put.rs at line 217

[3.13291]→[3.13291:13351](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut left);

[3.13291]

[3.13351]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut left);
replacement in sanakirja-core/src/btree/page/put.rs at line 220

[3.13391]→[3.13391:13451](∅→∅)

<Page<K, V> as BTreeMutPage<T, K, V>>::init(&mut left);

[3.13391]

[3.13451]

<Page<K, V> as BTreeMutPage<K, V>>::init(&mut left);
replacement in sanakirja-core/src/btree/page/put.rs at line 225

[3.13560]→[3.13560:13599](∅→∅)

let mut split = core::ptr::null();

[3.13560]

[3.13599]

let mut split = (core::ptr::null(), core::ptr::null());
replacement in sanakirja-core/src/btree/page/put.rs at line 241

[3.13999]→[3.13999:14079](∅→∅)

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

[3.13999]

[3.14079]

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

[3.14190]→[3.14190:14241](∅→∅)

split = ptr as *const Tuple<K, V>;

[3.14190]

[3.14241]

split = read::<T, K, V>(txn, ptr);
replacement in sanakirja-core/src/btree/page/put.rs at line 261

[3.14733]→[3.14733:14807](∅→∅)

alloc::<T, K, V, L>(current_page, k0, v0, 0, l0, &mut n);

[3.14733]

[3.14807]

alloc::<K, V, L>(current_page, k0, v0, 0, l0, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 263

[3.14881]→[3.14881:14955](∅→∅)

alloc::<T, K, V, L>(current_page, k1, v1, 0, r0, &mut n);

[3.14881]

[3.14955]

alloc::<K, V, L>(current_page, k1, v1, 0, r0, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 267

[3.15074]→[3.15074:15149](∅→∅)

alloc::<T, K, V, L>(current_page, k0, v0, l0, r0, &mut n);

[3.15074]

[3.15149]

alloc::<K, V, L>(current_page, k0, v0, l0, r0, &mut n);
replacement in sanakirja-core/src/btree/page/put.rs at line 273

[3.15277]→[3.15277:15344](∅→∅)

assert!(!split.is_null());
let split = unsafe { &*split };

[3.15277]

[3.15344]

assert!(!split.0.is_null());
replacement in sanakirja-core/src/btree/page/put.rs at line 275

[3.15364]→[3.15364:15424](∅→∅)

split_key: &split.k,
split_value: &split.v,

[3.15364]

[3.15424]

split_key: unsafe { K::from_raw_ptr(txn, split.0) },
split_value: unsafe { V::from_raw_ptr(txn, split.1) },
replacement in sanakirja-core/src/btree/page/alloc.rs at line 4

[3.17273]→[3.17273:17546](∅→∅)

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

[3.17273]

[3.17546]

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;
replacement in sanakirja-core/src/btree/page/alloc.rs at line 10

[3.17650]→[3.17650:17717](∅→∅)

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

[3.17650]

[3.17717]

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

[3.17803]→[3.17803:17869](∅→∅)

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

[3.17803]

[3.17869]

fn alloc_insert<K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 25

[3.18160]→[3.18160:18230](∅→∅)

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

[3.18160]

[3.18230]

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

[3.18297]→[3.18297:18357](∅→∅)

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

[3.18297]

[3.18357]

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

[3.19245]→[3.19245:19330](∅→∅)

pub fn first<T, K: Representable<T>, V: Representable<T>>(&self) -> (u64, u16) {

[3.19245]

[3.19330]

pub fn first<T, K: Representable, V: Representable>(&self) -> (u64, u16) {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 63

[3.19432]→[3.19432:19493](∅→∅)

let size = fixed_size::<T, K, V>().unwrap();

[3.19432]

[3.19493]

let size = fixed_size::<K, V>().unwrap();
replacement in sanakirja-core/src/btree/page/alloc.rs at line 76

[3.19755]→[3.19755:19878](∅→∅)

fn extra_size<T, K: Representable<T>, V: Representable<T>>() -> usize {
if fixed_size::<T, K, V>().is_some() {

[3.19755]

[3.19878]

fn extra_size<T, K: Representable, V: Representable>() -> usize {
if fixed_size::<K, V>().is_some() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 83

[3.19939]→[3.19939:20089](∅→∅)

fn can_alloc<T, K: Representable<T>, V: Representable<T>>(hdr: &Header, size: usize) -> bool {
if let Some(f) = fixed_size::<T, K, V>() {

[3.19939]

[3.20089]

fn can_alloc<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 92

[3.20377]→[3.20377:20525](∅→∅)

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

[3.20377]

[3.20525]

fn can_compact<T, K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
if fixed_size::<K, V>().is_some() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 102

[3.20842]→[3.20842:20909](∅→∅)

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

[3.20842]

[3.20909]

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

[3.21047]→[3.21047:21098](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.21047]

[3.21098]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 138

[3.22218]→[3.22218:22256](∅→∅)

Some(read::<T, K, V>(

[3.22218]

[3.22256]

let (k, v) = read::<T, K, V>(
txn,
replacement in sanakirja-core/src/btree/page/alloc.rs at line 141

[3.22330]→[3.22330:22349](∅→∅)

))

[3.22330]

[3.22349]

);
Some((K::from_raw_ptr(txn, k), V::from_raw_ptr(txn, v)))
replacement in sanakirja-core/src/btree/page/alloc.rs at line 159

[3.22907]→[3.22907:23002](∅→∅)

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

[3.22907]

[3.23002]

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

[3.23462]→[3.23462:23528](∅→∅)

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

[3.23462]

[3.23528]

fn alloc_insert<K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 182

[3.23632]→[3.23632:23683](∅→∅)

if let Some(f) = fixed_size::<T, K, V>() {

[3.23632]

[3.23683]

if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 226

[3.25230]→[3.25230:25300](∅→∅)

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

[3.25230]

[3.25300]

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

[3.25400]→[3.25400:25447](∅→∅)

if fixed_size::<T, K, V>().is_some() {

[3.25400]

[3.25447]

if fixed_size::<K, V>().is_some() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 241

[3.25752]→[3.25752:25812](∅→∅)

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

[3.25752]

[3.25812]

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

[3.25917]→[3.25917:26023](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));
(&*k, &*v, 0)

[3.25917]

[3.26023]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
(K::from_raw_ptr(txn, k), V::from_raw_ptr(txn, v), 0)
replacement in sanakirja-core/src/btree/page/alloc.rs at line 254

[3.26068]→[3.26068:26144](∅→∅)

fn extra_size<T, K: Representable<T>, V: Representable<T>>() -> usize {

[3.26068]

[3.26144]

fn extra_size<T, K: Representable, V: Representable>() -> usize {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 257

[3.26160]→[3.26160:26259](∅→∅)

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

[3.26160]

[3.26259]

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

[3.26346]→[3.26346:26447](∅→∅)

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

[3.26346]

[3.26447]

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

[3.26533]→[3.26533:26600](∅→∅)

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

[3.26533]

[3.26600]

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

[3.27048]→[3.27048:27110](∅→∅)

let size = if let Some(f) = fixed_size::<T, K, V>() {

[3.27048]

[3.27110]

let size = if let Some(f) = fixed_size::<K, V>() {
replacement in sanakirja-core/src/btree/page/alloc.rs at line 290

[3.27479]→[3.27479:27574](∅→∅)

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

[3.27479]

[3.27574]

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

[3.28075]→[3.28075:28141](∅→∅)

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

[3.28075]

[3.28141]

fn alloc_insert<K: Representable, V: Representable>(
replacement in sanakirja-core/src/btree/page/alloc.rs at line 346

[3.29294]→[3.29294:29364](∅→∅)

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

[3.29294]

[3.29364]

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

[3.29672]→[3.29672:29732](∅→∅)

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

[3.29672]

[3.29732]

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

[3.29837]→[3.29837:29943](∅→∅)

let (k, v) = read::<T, K, V>(page.data.as_ptr().add(off as usize));
(&*k, &*v, r)

[3.29837]

[3.29943]

let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
(K::from_raw_ptr(txn, k), V::from_raw_ptr(txn, v), r)
replacement in sanakirja-core/src/btree/mod.rs at line 27

[3.46099]→[3.46099:46176](∅→∅)

pub trait BTreePage<T: LoadPage, K: Representable<T>, V: Representable<T>> {

[3.46099]

[3.46176]

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
#[repr(C)]
pub struct Tuple<K, V> {
k: K,
v: V,
}

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

[3.28406]→[3.28406:28545](∅→∅)

fn next<'b>(p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {
if let Some((k, v, r)) = Self::current(p, c) {

[3.28406]

[3.28545]

fn next<'b, T: LoadPage>(txn: &T, p: Page<'b>, c: &mut Self::Cursor) -> Option<(&'b K, &'b V, u64)> {
if let Some((k, v, r)) = Self::current(txn, p, c) {
replacement in sanakirja-core/src/btree/mod.rs at line 47

[3.46676]→[3.28643:28727](∅→∅)

fn prev<'b>(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 49

[3.28762]→[3.28762:28794](∅→∅)

Self::current(p, c)

[3.28762]

[3.28794]

Self::current(txn, p, c)
replacement in sanakirja-core/src/btree/mod.rs at line 56

[3.28958]→[3.28958:29132](∅→∅)

unsafe fn unchecked_current<'a>(p: Page<'a>, c: &Self::Cursor) -> (&'a K, &'a V, u64);
fn current<'a>(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 62

[3.29154]→[3.29154:29206](∅→∅)

Some(Self::unchecked_current(p, c))

[3.29154]

[3.29206]

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

[3.29462]→[3.47284:47307](∅→∅),[3.47284]→[3.47284:47307](∅→∅)

fn set_cursor<'a>(

[3.29462]

[3.47307]

fn set_cursor<'a, T: LoadPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 84

[3.47651]→[3.47651:47728](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreePage<T, K, V>,

[3.47651]

[3.47728]

K: Representable,
V: Representable,
P: BTreePage<K, V>,
edit in sanakirja-core/src/btree/mod.rs at line 89

[3.47755]

[3.29660]

txn: &'a T,
replacement in sanakirja-core/src/btree/mod.rs at line 96

[3.47817]→[3.47817:47916](∅→∅)

K: Representable<T> + 'a,
V: Representable<T> + 'a,
P: BTreePage<T, K, V>,

[3.47817]

[3.47916]

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

[3.48058]→[3.48058:48103](∅→∅)

P::next(self.page, &mut self.cursor)

[3.48058]

[3.48103]

P::next(self.txn, self.page, &mut self.cursor)
replacement in sanakirja-core/src/btree/mod.rs at line 107

[3.48112]→[3.48112:48223](∅→∅)

pub trait BTreeMutPage<T: AllocPage, K: Representable<T>, V: Representable<T>>:
BTreePage<T, K, V> + Sized

[3.48112]

[3.48223]

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

[3.29786]→[3.48282:48298](∅→∅),[3.48282]→[3.48282:48298](∅→∅)

fn put<'a>(

[3.29786]

[3.48298]

fn put<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 124

[3.48501]→[3.48501:48527](∅→∅)

fn update_left_child(

[3.48501]

[3.48527]

fn update_left_child<T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 132

[3.48665]→[3.29835:29930](∅→∅)

fn del(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 134

[3.48758]→[3.48758:48778](∅→∅)

fn replace<'a>(

[3.48758]

[3.48778]

fn replace<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 146

[3.49208]→[3.29955:29990](∅→∅)

fn merge_or_rebalance<'a, 'b>(

[3.49208]

[3.49239]

fn merge_or_rebalance<'a, 'b, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 148

[3.49260]→[3.29991:30037](∅→∅)

m: &'b mut Concat<'a, T, K, V, Self>,

[3.49260]

[3.49299]

m: &'b mut Concat<'a, K, V, Self>,
replacement in sanakirja-core/src/btree/mod.rs at line 151

[3.49344]→[3.49344:49363](∅→∅)

fn modify<'a>(

[3.49344]

[3.49363]

fn modify<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 153

[3.49384]→[3.30038:30087](∅→∅)

m: &mut ModifiedPage<'a, T, K, V, Self>,

[3.49384]

[3.49429]

m: &mut ModifiedPage<'a, K, V, Self>,
replacement in sanakirja-core/src/btree/mod.rs at line 182

[3.50146]→[3.50146:50201](∅→∅)

fn size(m: &ModifiedPage<T, K, V, Self>) -> usize;

[3.50146]

[3.50201]

fn size(m: &ModifiedPage<K, V, Self>) -> usize;
replacement in sanakirja-core/src/btree/mod.rs at line 186

[3.3885]→[3.50204:50267](∅→∅),[3.50204]→[3.50204:50267](∅→∅)

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

[3.3885]

[3.50267]

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

[3.30667]→[3.50582:50676](∅→∅),[3.50582]→[3.50582:50676](∅→∅)

T: LoadPage,
K: Representable<T>,
V: Representable<T>,
P: BTreePage<T, K, V>,

[3.30667]

[3.50676]

K: Representable,
V: Representable,
P: BTreePage<K, V>,
replacement in sanakirja-core/src/btree/mod.rs at line 227

[3.51195]→[3.30735:30855](∅→∅)

impl<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>
ModifiedPage<'a, T, K, V, P>

[3.51195]

[3.51307]

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

[3.51677]→[3.51677:51777](∅→∅)

pub struct Concat<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>

[3.51677]

[3.51777]

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

[3.31062]→[3.31062:31110](∅→∅)

pub modified: ModifiedPage<'a, T, K, V, P>,

[3.31062]

[3.31110]

pub modified: ModifiedPage<'a, K, V, P>,
replacement in sanakirja-core/src/btree/mod.rs at line 255

[3.52016]→[3.31:126](∅→∅)

pub struct Db_<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>> {

[3.52016]

[3.31135]

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

[3.31156]→[3.52128:52185](∅→∅),[3.52128]→[3.52128:52185](∅→∅)

pub marker: core::marker::PhantomData<(T, K, V, P)>,

[3.31156]

[3.52185]

pub marker: core::marker::PhantomData<(K, V, P)>,
replacement in sanakirja-core/src/btree/mod.rs at line 260

[3.52188]→[3.127:182](∅→∅)

pub type Db<T, K, V> = Db_<T, K, V, page::Page<K, V>>;

[3.52188]

[3.182]

pub type Db<K, V> = Db_<K, V, page::Page<K, V>>;
replacement in sanakirja-core/src/btree/mod.rs at line 264

[3.52224]→[3.52224:52304](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreeMutPage<T, K, V>,

[3.52224]

[3.52304]

K: Representable,
V: Representable,
P: BTreeMutPage<K, V>,
replacement in sanakirja-core/src/btree/mod.rs at line 269

[3.52324]→[3.203:244](∅→∅)

) -> Result<Db_<T, K, V, P>, T::Error> {

[3.52324]

[3.31157]

) -> Result<Db_<K, V, P>, T::Error> {
replacement in sanakirja-core/src/btree/mod.rs at line 280

[3.314]→[3.314:402](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.314]

[3.402]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/mod.rs at line 284

[3.422]→[3.422:478](∅→∅)

) -> Result<Db_<T, K, V, page::Page<K, V>>, T::Error> {

[3.422]

[3.478]

) -> Result<Db_<K, V, page::Page<K, V>>, T::Error> {
replacement in sanakirja-core/src/btree/mod.rs at line 290

[3.3921]→[3.3921:4001](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreeMutPage<T, K, V>,

[3.3921]

[3.4001]

K: Representable,
V: Representable,
P: BTreeMutPage<K, V>,
replacement in sanakirja-core/src/btree/mod.rs at line 295

[3.4021]→[3.519:586](∅→∅)

db: &Db_<T, K, V, P>,
) -> Result<Db_<T, K, V, P>, T::Error> {

[3.4021]

[3.4086]

db: &Db_<K, V, P>,
) -> Result<Db_<K, V, P>, T::Error> {
replacement in sanakirja-core/src/btree/mod.rs at line 306

[3.657]→[3.657:745](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,

[3.657]

[3.745]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
replacement in sanakirja-core/src/btree/mod.rs at line 310

[3.765]→[3.765:824](∅→∅)

db: &Db<T, K, V>,
) -> Result<Db<T, K, V>, T::Error> {

[3.765]

[3.824]

db: &Db<K, V>,
) -> Result<Db<K, V>, T::Error> {
replacement in sanakirja-core/src/btree/mod.rs at line 316

[3.408]→[3.408:502](∅→∅)

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

[3.408]

[3.502]

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

[3.518]→[3.847:873](∅→∅)

db: &Db_<T, K, V, P>,

[3.518]

[3.543]

db: &Db_<K, V, P>,
replacement in sanakirja-core/src/btree/mod.rs at line 333

[3.1107]→[3.1107:1185](∅→∅)

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

[3.1107]

[3.1185]

} else if let Some((k, v, _)) = P::current(txn, page.as_page(), &cursor) {
replacement in sanakirja-core/src/btree/del.rs at line 21

[3.31281]→[3.31281:31369](∅→∅),[3.31369]→[3.53347:53396](∅→∅),[3.53347]→[3.53347:53396](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.31281]

[3.53396]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 26

[3.53416]→[3.874:904](∅→∅)

db: &mut Db_<T, K, V, P>,

[3.53416]

[3.53445]

db: &mut Db_<K, V, P>,
replacement in sanakirja-core/src/btree/del.rs at line 40

[3.31418]→[3.31418:31506](∅→∅),[3.31506]→[3.53804:53853](∅→∅),[3.53804]→[3.53804:53853](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.31418]

[3.53853]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 45

[3.53873]→[3.905:935](∅→∅),[3.935]→[3.53902:53939](∅→∅),[3.53902]→[3.53902:53939](∅→∅)

db: &mut Db_<T, K, V, P>,
cursor: &mut Cursor<T, K, V, P>,

[3.53873]

[3.53939]

db: &mut Db_<K, V, P>,
cursor: &mut Cursor<K, V, P>,
edit in sanakirja-core/src/btree/del.rs at line 50

[3.53999]

[3.30598]

// If p0 < cursor.first_rc_level, the page containing the deleted
// element is not shared with another table. Therefore, the RC of
// the pages referenced by the deleted element needs to be
// decreased.
if p0 < cursor.first_rc_level {
unsafe {
let cur = cursor.current();
let (delk, delv, _) =
P::unchecked_current(txn, cur.page.as_page(), cur.cursor.as_ref().unwrap());
for o in delk.page_offsets().chain(delv.page_offsets()) {
txn.incr_rc(o)?;
}
}
}
replacement in sanakirja-core/src/btree/del.rs at line 65

[3.30668]→[3.30668:30693](∅→∅)

// "replacement" is.

[3.30668]

[3.54094]

// "replacement" element is.
replacement in sanakirja-core/src/btree/del.rs at line 69

[3.30765]→[3.30765:30874](∅→∅)

// (k0, v0) if we're in an internal node.
let (mut last_op, k0, v0) = leaf_delete(txn, cursor, p0)?;

[3.30765]

[3.55545]

// (k0, v0) if the deletion happens in an internal node (`(k0,
// v0)` is uninitialized else).
let mut k0 = MaybeUninit::uninit();
let mut v0 = MaybeUninit::uninit();
let (mut last_op, k0v0) = leaf_delete(txn, cursor, p0, &mut k0, &mut v0)?;
replacement in sanakirja-core/src/btree/del.rs at line 77

[3.55587]→[3.55587:55653](∅→∅)

// Then, climb up the stack, and perform the lazy operations.

[3.55587]

[3.55653]

// Then, climb up the stack, performing the operations lazily.
replacement in sanakirja-core/src/btree/del.rs at line 80

[3.55709]→[3.55709:55759](∅→∅),[3.55759]→[3.30875:30945](∅→∅)

// Compute the need for merge/rebalancing
let mut concat = concat(txn, cursor, p0, &k0, &v0, last_op)?;

[3.55709]

[3.30945]

// Prepare a plan for merging the current modified page (that
// page is at level cursor.pointer + 1) with one of its
// neighbours.
//
// This is a little bit convoluted, but we do have to get up
// one level in order to fetch the right or left sibling of
// the modified page.
let mut concat = concat(txn, cursor, p0, k0v0, last_op)?;
edit in sanakirja-core/src/btree/del.rs at line 90

[3.30986]

[3.4202]

// Execute the plan, resulting in one of four different
// outcomes.
edit in sanakirja-core/src/btree/del.rs at line 95

[3.7002]

[3.30987]

// Prepare a description (`last_op`) of the page modification
// to be performed at the current level (i.e. at level
// `cursor.pointer`).
replacement in sanakirja-core/src/btree/del.rs at line 100

[3.31025]→[3.31025:31108](∅→∅)

last_op = handle_merge(txn, cursor, p0, &k0, &v0, mil, merge, &mut free)?;

[3.31025]

[3.59562]

last_op = handle_merge(txn, cursor, p0, k0v0, mil, merge, &mut free)?;
replacement in sanakirja-core/src/btree/del.rs at line 104

[3.32228]→[3.59597:59685](∅→∅),[3.59597]→[3.59597:59685](∅→∅),[3.59685]→[3.4326:4366](∅→∅),[3.4366]→[3.31109:31283](∅→∅),[3.31283]→[3.59685:59732](∅→∅),[3.4366]→[3.59685:59732](∅→∅),[3.59685]→[3.59685:59732](∅→∅),[3.59732]→[3.31284:31367](∅→∅),[3.31367]→[3.60764:60770](∅→∅),[3.60764]→[3.60764:60770](∅→∅)

// The root was merged or rebalanced.
if let Some(d) = last_op.single_child() {
debug!("single child {:?}", d);
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 = txn.load_page(d)?
} else {
update_root(txn, db, last_op, &k0, cursor.first_rc_level <= 1, &mut free)?
}

[3.32228]

[3.60770]

// The last operation was on the root (i.e. at level 1), and that
// operation still needs to be executed.
update_root(txn, db, last_op, k0v0, cursor.first_rc_level <= 1, &mut free)?;

// Finally, free all the freed pages, now that we don't need to
// read them anymore.
replacement in sanakirja-core/src/btree/del.rs at line 127

[3.61149]→[3.61149:61248](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.61149]

[3.61248]

K: Representable,
V: Representable,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 132

[3.61268]→[3.61268:61305](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.61268]

[3.61305]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/del.rs at line 157

[3.31607]→[3.31607:31744](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.31607]

[3.31744]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
P: BTreeMutPage<K, V> + core::fmt::Debug + 'a,
replacement in sanakirja-core/src/btree/del.rs at line 162

[3.31764]→[3.31764:31801](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.31764]

[3.31801]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/del.rs at line 164

[3.31816]→[3.31816:31983](∅→∅)

) -> Result<(ModifiedPage<'a, T, K, V, P>, MaybeUninit<K>, MaybeUninit<V>), T::Error> {
let ref mut curs0 = unsafe { cursor.stack[cursor.pointer].assume_init() };

[3.31816]

[3.31983]

k0: &'a mut MaybeUninit<K>,
v0: &'a mut MaybeUninit<V>,
) -> Result<(ModifiedPage<'a, K, V, P>, Option<(&'a K, &'a V)>), T::Error> {
let curs0 = unsafe { &mut *cursor.stack[cursor.pointer].as_mut_ptr() };
edit in sanakirja-core/src/btree/del.rs at line 169

[3.32069]→[3.32069:32220](∅→∅)

if cursor.pointer == cursor.first_rc_level {
debug!("decr_rc");
txn.decr_rc(curs0.page.offset)?;
debug!("/decr_rc");
}
replacement in sanakirja-core/src/btree/del.rs at line 173

[3.32388]→[3.32388:32527](∅→∅)

while let Some((k, v, _)) = P::next(curs0.page.as_page(), &mut c0)
.or_else(|| P::next(curs0.page.as_page(), &mut c1))

[3.32388]

[3.32527]

while let Some((k, v, _)) = P::next(txn, curs0.page.as_page(), &mut c0)
.or_else(|| P::next(txn, curs0.page.as_page(), &mut c1))
replacement in sanakirja-core/src/btree/del.rs at line 181

[3.32664]→[3.32664:32790](∅→∅)

debug!("pointer = {:?}", cursor.pointer);
let mut k0 = MaybeUninit::uninit();
let mut v0 = MaybeUninit::uninit();

[3.32664]

[3.32790]

let mut deleted = None;
replacement in sanakirja-core/src/btree/del.rs at line 185

[3.32883]→[3.32883:32960](∅→∅)

let (k, v, _) = P::unchecked_current(curs0.page.as_page(), &c0);

[3.32883]

[3.32960]

let (k, v, _) = P::unchecked_current(txn, curs0.page.as_page(), &c0);
replacement in sanakirja-core/src/btree/del.rs at line 191

[3.33162]→[3.33162:33296](∅→∅)

core::ptr::copy_nonoverlapping(k, k0.as_mut_ptr(), 1);
core::ptr::copy_nonoverlapping(v, v0.as_mut_ptr(), 1);

[3.33162]

[3.33296]

if K::SIZE.is_some() && V::SIZE.is_some() {
core::ptr::copy_nonoverlapping(k, k0.as_mut_ptr(), 1);
core::ptr::copy_nonoverlapping(v, v0.as_mut_ptr(), 1);
deleted = Some((&*k0.as_ptr(), &*v0.as_ptr()))
} else {
deleted = Some((k, v))
}
replacement in sanakirja-core/src/btree/del.rs at line 212

[3.33591]→[3.33591:33615](∅→∅)

k0,
v0,

[3.33591]

[3.33615]

deleted,
replacement in sanakirja-core/src/btree/del.rs at line 219

[3.61838]→[3.61838:61937](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.61838]

[3.61937]

K: Representable,
V: Representable,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 224

[3.61957]→[3.33623:33660](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.61957]

[3.33660]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/del.rs at line 226

[3.33675]→[3.33675:33725](∅→∅),[3.33725]→[3.32658:32701](∅→∅),[3.8727]→[3.32658:32701](∅→∅),[3.32658]→[3.32658:32701](∅→∅),[3.32701]→[3.62088:62136](∅→∅),[3.62088]→[3.62088:62136](∅→∅)

k0: &MaybeUninit<K>,
v0: &MaybeUninit<V>,
last_op: ModifiedPage<'a, T, K, V, P>,
) -> Result<Concat<'a, T, K, V, P>, T::Error> {

[3.33675]

[3.33726]

k0v0: Option<(&'a K, &'a V)>,
last_op: ModifiedPage<'a, K, V, P>,
) -> Result<Concat<'a, K, V, P>, T::Error> {
replacement in sanakirja-core/src/btree/del.rs at line 233

[3.33809]→[3.32778:32853](∅→∅),[3.8764]→[3.32778:32853](∅→∅),[3.32778]→[3.32778:32853](∅→∅),[3.32953]→[3.62426:62477](∅→∅),[3.62426]→[3.62426:62477](∅→∅),[3.62477]→[3.33810:33870](∅→∅),[3.33870]→[3.62502:62564](∅→∅),[3.33034]→[3.62502:62564](∅→∅),[3.8792]→[3.62502:62564](∅→∅),[3.62502]→[3.62502:62564](∅→∅)

let other = txn.load_page(P::left_child(curs.page.as_page(), c))?;
Ok(Concat {
modified: last_op,
mid: unsafe { (&*k0.as_ptr(), &*v0.as_ptr()) },
other,
mod_is_left: false,
})

[3.33809]

[3.62564]

if let Some((k0, v0)) = k0v0 {
let other = txn.load_page(P::left_child(curs.page.as_page(), c))?;
Ok(Concat {
modified: last_op,
mid: (k0, v0),
other,
mod_is_left: false,
})
} else {
unreachable!()
}
replacement in sanakirja-core/src/btree/del.rs at line 246

[3.33071]→[3.33071:33149](∅→∅)

let (k, v, r) = if let Some(x) = P::current(curs.page.as_page(), c) {

[3.33071]

[3.8793]

let (k, v, r) = if let Some(x) = P::current(txn, curs.page.as_page(), c) {
replacement in sanakirja-core/src/btree/del.rs at line 252

[3.33213]→[3.33213:33283](∅→∅)

let (k, v, _) = P::prev(curs.page.as_page(), c).unwrap();

[3.33213]

[3.33283]

let (k, v, _) = P::prev(txn, curs.page.as_page(), c).unwrap();
replacement in sanakirja-core/src/btree/del.rs at line 270

[3.34015]→[3.34015:34114](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.34015]

[3.34114]

K: Representable,
V: Representable,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 275

[3.34134]→[3.34134:34171](∅→∅)

cursor: &mut Cursor<T, K, V, P>,

[3.34134]

[3.34171]

cursor: &mut Cursor<K, V, P>,
replacement in sanakirja-core/src/btree/del.rs at line 277

[3.34186]→[3.34186:34236](∅→∅)

k0: &MaybeUninit<K>,
v0: &MaybeUninit<V>,

[3.34186]

[3.34236]

k0v0: Option<(&'a K, &'a V)>,
replacement in sanakirja-core/src/btree/del.rs at line 281

[3.34325]→[3.34325:34379](∅→∅)

) -> Result<ModifiedPage<'a, T, K, V, P>, T::Error> {

[3.34325]

[3.34379]

) -> Result<ModifiedPage<'a, K, V, P>, T::Error> {
replacement in sanakirja-core/src/btree/del.rs at line 324

[3.35756]→[3.35756:35835](∅→∅)

last_op.ins = unsafe { Some((&*k0.as_ptr(), &*v0.as_ptr())) };

[3.35756]

[3.35835]

last_op.ins = k0v0;
replacement in sanakirja-core/src/btree/del.rs at line 351

[3.36738]→[3.36738:36817](∅→∅)

last_op.ins = unsafe { Some((&*k0.as_ptr(), &*v0.as_ptr())) };

[3.36738]

[3.36817]

last_op.ins = k0v0;
replacement in sanakirja-core/src/btree/del.rs at line 368

[3.37595]→[3.37595:37696](∅→∅)

if cursor.pointer + 1 >= cursor.first_rc_level && (split_key as *const K) != k0.as_ptr()

[3.37595]

[3.37696]

let split_key_is_k0 = if let Some((k0, _)) = k0v0 {
(k0 as *const K) == (split_key as *const K)
} else {
false
};
if cursor.pointer + 1 >= cursor.first_rc_level && !split_key_is_k0
edit in sanakirja-core/src/btree/del.rs at line 384

[3.37991]→[3.37991:38149](∅→∅)

} else {
if cursor.pointer == cursor.first_rc_level {
txn.decr_rc(last_op.page.offset)?;
}
modify_rc(txn, &last_op)?;
edit in sanakirja-core/src/btree/del.rs at line 385

[3.62831]

[3.38150]

modify_rc(txn, &last_op, cursor.pointer, cursor.first_rc_level)?;
edit in sanakirja-core/src/btree/del.rs at line 389

[3.62834]

[3.62834]

// This function modifies the reference counts of references of the
// modified page, which is the page *about to be* modified.
//
// This function is always called when `m` is an internal node.
replacement in sanakirja-core/src/btree/del.rs at line 395

[3.62877]→[3.62877:62954](∅→∅)

K: Representable<T>,
V: Representable<T>,
P: BTreePage<T, K, V>,

[3.62877]

[3.62954]

K: Representable,
V: Representable,
P: BTreePage<K, V>,
replacement in sanakirja-core/src/btree/del.rs at line 400

[3.62974]→[3.62974:63008](∅→∅)

m: &ModifiedPage<T, K, V, P>,

[3.62974]

[3.63008]

m: &ModifiedPage<K, V, P>,
p: usize,
first_rc_level: usize,
edit in sanakirja-core/src/btree/del.rs at line 404

[3.63036]

[3.63036]

if p == first_rc_level {
txn.decr_rc(m.page.offset)?;
}
replacement in sanakirja-core/src/btree/del.rs at line 411

[3.33576]→[3.33576:33645](∅→∅),[3.33645]→[3.63206:63295](∅→∅),[3.63206]→[3.63206:63295](∅→∅)

while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c0) {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;

[3.33576]

[3.63295]

assert_ne!(left, 0);
if p >= first_rc_level {
while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c0) {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;
}
assert_ne!(left, 0);
txn.incr_rc(left)?;
left = r;
edit in sanakirja-core/src/btree/del.rs at line 421

[3.63305]→[3.63305:63351](∅→∅)

txn.incr_rc(left)?;
left = r;
replacement in sanakirja-core/src/btree/del.rs at line 422

[3.63357]→[3.63357:63379](∅→∅),[3.63379]→[3.33646:33695](∅→∅),[3.33695]→[3.63419:63460](∅→∅),[3.63419]→[3.63419:63460](∅→∅)

if m.skip_first {
P::move_next(m.page.as_page(), &mut c1);
} else {
txn.incr_rc(left)?;

[3.63357]

[3.63460]

// The insertions come from pages strictly below the page at
// cursor.pointer, so if `incr_ins`, we increment them here,
// except the replacement, already incremented in `leaf_delete`
// above
if p + 1 >= first_rc_level {
if let Some((k, v)) = m.ins {
// If this is the replacement, it has already been
// incremented in `leaf_delete`, so we don't need to
// increment it again.
if m.skip_first {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;
}
}
if let Some((k, v)) = m.ins2 {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;
}
}
}
replacement in sanakirja-core/src/btree/del.rs at line 443

[3.63466]→[3.33696:33765](∅→∅),[3.33765]→[3.63526:63615](∅→∅),[3.63526]→[3.63526:63615](∅→∅)

while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c1) {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;

[3.63466]

[3.63615]

if p >= first_rc_level {
if m.skip_first {
P::move_next(m.page.as_page(), &mut c1);
}
// If we are not updating the left child of c1's first
// element, increment that left child.
if m.l == 0 {
assert_ne!(left, 0);
txn.incr_rc(left)?;
}

// Moving on to the first non-deleted element of `c1`: if we
// are not updating the right child of the first element,
// increment that right child's RC.
if let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1) {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;
}
if m.r == 0 {
assert_ne!(r, 0);
txn.incr_rc(r)?;
}
}
// Finally, increment the RCs of all other elements in `c1`.
while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1) {
for o in k.page_offsets().chain(v.page_offsets()) {
txn.incr_rc(o)?;
}
if r != 0 {
assert_ne!(r, 0);
txn.incr_rc(r)?;
}
edit in sanakirja-core/src/btree/del.rs at line 476

[3.63625]→[3.63625:63650](∅→∅)

txn.incr_rc(r)?;
edit in sanakirja-core/src/btree/del.rs at line 481

[3.38203]→[3.38203:38211](∅→∅)

'a,
replacement in sanakirja-core/src/btree/del.rs at line 482

[3.38259]→[3.38259:38396](∅→∅)

K: Representable<T> + core::fmt::Debug,
V: Representable<T> + core::fmt::Debug,
P: BTreeMutPage<T, K, V> + core::fmt::Debug,

[3.38259]

[3.38396]

K: Representable + core::fmt::Debug,
V: Representable + core::fmt::Debug,
P: BTreeMutPage<K, V> + core::fmt::Debug,
replacement in sanakirja-core/src/btree/del.rs at line 487

[3.38416]→[3.38416:38514](∅→∅)

db: &mut Db_<T, K, V, P>,
mut last_op: ModifiedPage<T, K, V, P>,
k0: &MaybeUninit<K>,

[3.38416]

[3.38514]

db: &mut Db_<K, V, P>,
mut last_op: ModifiedPage<K, V, P>,
k0v0: Option<(&K, &V)>,
edit in sanakirja-core/src/btree/del.rs at line 493

[3.38597]

[3.38597]

if let Some(d) = last_op.single_child() {
// If the root had only one element, and the last operation
// was a merge, this decreases the depth of the tree.
debug!("single child {:?}", d);
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 = txn.load_page(d)?;
return Ok(())
}

// Else, we execute the last operation
replacement in sanakirja-core/src/btree/del.rs at line 535

[3.39331]→[3.39331:39396](∅→∅)

if is_rc && (split_key as *const K) != k0.as_ptr() {

[3.39331]

[3.39396]

let split_key_is_k0 = if let Some((k0, _)) = k0v0 {
(k0 as *const K) == (split_key as *const K)
} else {
false
};
if is_rc && !split_key_is_k0 {
replacement in sanakirja-core/src/btree/cursor.rs at line 7

[3.63799]→[3.63799:63899](∅→∅)

pub struct PageCursor<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>

[3.63799]

[3.63899]

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

[3.63959]→[3.63959:64079](∅→∅)

impl<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>> Clone
for PageCursor<T, K, V, P>

[3.63959]

[3.64079]

impl<K: Representable, V: Representable, P: BTreePage<K, V>> Clone
for PageCursor<K, V, P>
replacement in sanakirja-core/src/btree/cursor.rs at line 23

[3.64220]→[3.64220:64339](∅→∅)

impl<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>> Copy
for PageCursor<T, K, V, P>

[3.64220]

[3.64339]

impl<K: Representable, V: Representable, P: BTreePage<K, V>> Copy
for PageCursor<K, V, P>
replacement in sanakirja-core/src/btree/cursor.rs at line 41

[3.64963]→[3.64963:65137](∅→∅)

pub struct Cursor<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>> {
pub stack: [core::mem::MaybeUninit<PageCursor<T, K, V, P>>; N_CURSORS],

[3.64963]

[3.65137]

pub struct Cursor<K: Representable, V: Representable, P: BTreePage<K, V>> {
pub stack: [core::mem::MaybeUninit<PageCursor<K, V, P>>; N_CURSORS],
replacement in sanakirja-core/src/btree/cursor.rs at line 47

[3.65195]→[3.65195:65305](∅→∅)

impl<'a, T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>
Cursor<T, K, V, P>

[3.65195]

[3.65305]

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

[3.65307]→[3.936:983](∅→∅)

pub fn new(db: &Db_<T, K, V, P>) -> Self {

[3.65307]

[3.65353]

pub fn new(db: &Db_<K, V, P>) -> Self {
replacement in sanakirja-core/src/btree/cursor.rs at line 64

[3.65654]→[3.33823:33906](∅→∅),[3.33906]→[3.65741:65764](∅→∅),[3.65741]→[3.65741:65764](∅→∅)

impl<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>
Cursor<T, K, V, P>

[3.65654]

[3.65764]

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

[3.65766]→[3.65766:65821](∅→∅)

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

[3.65766]

[3.65821]

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

[3.65883]→[3.33907:33974](∅→∅)

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

[3.65883]

[3.33974]

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

[3.34044]→[3.34044:34064](∅→∅)

pub fn set<'a>(

[3.34044]

[3.65899]

pub fn set<'a, T: LoadPage>(
replacement in sanakirja-core/src/btree/cursor.rs at line 122

[3.67642]→[3.34851:34944](∅→∅)

pub fn set_last<'a>(&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 135

[3.68320]→[3.35025:35118](∅→∅)

let (k, v, r) = unsafe { P::unchecked_current(current.page.as_page(), cursor) };

[3.68320]

[3.68404]

let (k, v, r) = unsafe { P::unchecked_current(txn, current.page.as_page(), cursor) };
replacement in sanakirja-core/src/btree/cursor.rs at line 150

[3.68806]→[3.35219:35253](∅→∅)

pub fn next<'a, L: LoadPage>(

[3.68806]

[3.68836]

pub fn next<'a, T: LoadPage>(
replacement in sanakirja-core/src/btree/cursor.rs at line 152

[3.68855]→[3.68855:68879](∅→∅),[3.68879]→[3.35254:35300](∅→∅)

txn: &'a mut L,
) -> Result<Option<(&K, &V)>, L::Error> {

[3.68855]

[3.68933]

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

[3.286]→[3.286:364](∅→∅)

if let Some((k, v, r)) = P::next(current.page.as_page(), c) {

[3.286]

[3.364]

if let Some((k, v, r)) = P::next(txn, current.page.as_page(), c) {
replacement in sanakirja/src/tests.rs at line 12

[3.305]→[3.305:359](∅→∅)

struct A<T>([u64; 100], std::marker::PhantomData<T>);

[3.305]

[3.359]

struct A([u64; 100]);
replacement in sanakirja/src/tests.rs at line 14

[3.360]→[3.360:395](∅→∅)

impl<T> std::fmt::Debug for A<T> {

[3.360]

[3.395]

impl std::fmt::Debug for A {
replacement in sanakirja/src/tests.rs at line 21

[3.522]→[3.522:813](∅→∅),[3.813]→[3.39589:39677](∅→∅),[3.39677]→[3.897:978](∅→∅),[3.897]→[3.897:978](∅→∅)

impl<T> Representable<T> for A<T> {
type PageOffsets = core::iter::Empty<u64>;
fn page_offsets(&self) -> Self::PageOffsets {
core::iter::empty()
}
const ALIGN: usize = core::mem::align_of::<Self>();
const SIZE: Option<usize> = Some(core::mem::size_of::<Self>());
fn compare(&self, _: &T, b: &Self) -> std::cmp::Ordering {
self.0.cmp(&b.0)
}
fn size(&self) -> usize {
core::mem::size_of::<Self>()
}
}

[3.522]

[3.978]

direct_repr!(A);
edit in sanakirja/src/tests.rs at line 23

[3.979]→[3.984:1018](∅→∅),[3.1018]→[3.1024:1025](∅→∅),[3.1024]→[3.1024:1025](∅→∅)

type T<'a> = MutTxn<&'a Env, ()>;
replacement in sanakirja/src/tests.rs at line 28

[3.1193]→[3.1072:1150](∅→∅)

let mut db = create_db::<MutTxn<&Env, ()>, u64, A<T>>(&mut txn).unwrap();

[3.1193]

[3.1288]

let mut db = create_db::<MutTxn<&Env, ()>, u64, A>(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 38

[3.1610]→[3.1610:1673](∅→∅)

let a = A([i * i * i; 100], std::marker::PhantomData);

[3.1610]

[3.1673]

let a = A([i * i * i; 100]);
replacement in sanakirja/src/tests.rs at line 54

[3.1199]→[3.2289:2340](∅→∅),[3.2289]→[3.2289:2340](∅→∅)

let a = A([0; 100], std::marker::PhantomData);

[3.1199]

[3.2340]

let a = A([0; 100]);
replacement in sanakirja/src/tests.rs at line 65

[3.2679]→[3.2679:2741](∅→∅)

let a = A([i0 * i0 * i0; 100], std::marker::PhantomData);

[3.2679]

[3.2741]

let a = A([i0 * i0 * i0; 100]);
replacement in sanakirja/src/tests.rs at line 84

[3.4478]→[3.1253:1316](∅→∅)

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

[3.4478]

[3.4544]

let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 101

[3.5162]→[3.1370:1433](∅→∅)

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

[3.5162]

[3.5228]

let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 132

[3.9094]→[3.1487:1550](∅→∅)

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

[3.9094]

[3.9160]

let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 151

[3.5886]→[3.1604:1667](∅→∅),[3.1667]→[3.9953:9979](∅→∅),[3.5952]→[3.9953:9979](∅→∅)

let mut db: Db<_, u64, ()> = create_db(&mut txn).unwrap();
let n = 2_000 as u64;

[3.5886]

[3.6021]

let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
let n = 20 as u64;
edit in sanakirja/src/tests.rs at line 154

[3.6074]

[3.6074]

let a = A([0; 100]);
replacement in sanakirja/src/tests.rs at line 156

[3.6098]→[3.6098:6152](∅→∅)

if put(&mut txn, &mut db, &i, &()).unwrap() {

[3.6098]

[3.6152]

if put(&mut txn, &mut db, &i, &a).unwrap() {
edit in sanakirja/src/tests.rs at line 164

[3.6386]→[2.93:119](∅→∅)

debug!("==========");
replacement in sanakirja/src/tests.rs at line 165

[3.6410]→[3.6410:6464](∅→∅)

if put(&mut txn, &mut db, &i, &()).unwrap() {

[3.6410]

[3.6464]

if put(&mut txn, &mut db, &i, &a).unwrap() {
replacement in sanakirja/src/tests.rs at line 180

[3.6899]→[3.6899:6953](∅→∅)

curs.set(&txn, Some((&500, Some(&())))).unwrap();

[3.6899]

[3.6953]

curs.set(&txn, Some((&500, Some(&a)))).unwrap();
replacement in sanakirja/src/tests.rs at line 193

[2.225]→[2.225:247](∅→∅),[2.247]→[3.10075:10125](∅→∅),[3.10075]→[3.10075:10125](∅→∅)

unimplemented!();
del(&mut txn, &mut db, &1019, None).unwrap();

[2.225]

[2.248]

debug!("==============");
del(&mut txn, &mut db, &11, None).unwrap();
debug!("free_owned_pages = {:?}", txn.free_owned_pages);
crate::debug::debug(&txn, &[&db, &db2], "debug1", true);
replacement in sanakirja/src/tests.rs at line 199

[2.277]→[2.277:306](∅→∅)

for i in 0..0 { // 512 {

[2.277]

[3.10238]

for i in 0..1 {
replacement in sanakirja/src/tests.rs at line 203

[2.357]→[3.2040:2068](∅→∅),[3.2040]→[3.2040:2068](∅→∅),[3.2068]→[3.10501:10552](∅→∅),[3.10501]→[3.10501:10552](∅→∅),[3.10552]→[3.2069:2077](∅→∅)

/*for i in 1530..1531 {
del(&mut txn, &mut db, &i, None).unwrap();
}*/

[2.357]

[3.10651]

// for i in 1530..1531 {
// del(&mut txn, &mut db, &i, None).unwrap();
// }
edit in sanakirja/src/tests.rs at line 214

[3.2239]

[3.2239]

let mut err = 0;
replacement in sanakirja/src/tests.rs at line 218

[3.2329]→[3.2329:2385](∅→∅)

assert_eq!(txn.rc(*p).unwrap(), *r as u64);

[3.2329]

[3.2385]

if txn.rc(*p).unwrap() != *r as u64 {
error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
err += 1;
}
replacement in sanakirja/src/tests.rs at line 223

[3.2402]→[3.2402:2450](∅→∅)

assert_eq!(txn.rc(*p).unwrap(), 0);

[3.2402]

[3.2450]

if txn.rc(*p).unwrap() != 0 {
error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
err += 1;
}
edit in sanakirja/src/tests.rs at line 229

[3.2466]

[3.7378]

assert_eq!(err, 0);
replacement in sanakirja/src/tests.rs at line 237

[3.7597]→[3.7597:7693](∅→∅)

let mut curs: btree::cursor::Cursor<T, _, _, B> = btree::cursor::Cursor::new(&db_free);

[3.7597]

[3.7693]

let mut curs: btree::cursor::Cursor<_, _, B> = btree::cursor::Cursor::new(&db_free);
replacement in sanakirja/src/tests.rs at line 246

[3.7872]→[3.7872:7963](∅→∅)

fn add_refs<T: LoadPage, K: Representable<T>, V: Representable<T>, P: BTreePage<T, K, V>>(

[3.7872]

[3.7963]

fn add_refs<T: LoadPage, K: Representable, V: Representable, P: BTreePage<K, V>>(
replacement in sanakirja/src/tests.rs at line 248

[3.7976]→[3.1668:1694](∅→∅)

db: &Db_<T, K, V, P>,

[3.7976]

[3.8001]

db: &Db_<K, V, P>,
edit in sanakirja/src/tests.rs at line 251

[3.8067]

[3.8067]

debug!("------ add_refs {:?}", db.db.offset);
edit in sanakirja/src/tests.rs at line 254

[3.8138]

[3.8138]

debug!("-- p = {:?}", p);
edit in sanakirja/src/tests.rs at line 260

[3.8353]

[3.8353]

debug!("l = {:?}", l);
replacement in sanakirja/src/tests.rs at line 263

[3.8431]→[3.8431:8510](∅→∅)

while let Some((_, _, r)) = P::next(p.as_page(), &mut c) {

[3.8431]

[3.8510]

while let Some((_, _, r)) = P::next(txn, p.as_page(), &mut c) {
debug!("r = {:?}", r);
edit in sanakirja/src/tests.rs at line 270

[3.8658]

[3.8658]

debug!("already there");
replacement in sanakirja/src/tests.rs at line 295

[3.2381]→[3.2381:2444](∅→∅)

let db: Db<_, u64, ()> = txn.root_db(0).unwrap().unwrap();

[3.2381]

[3.2444]

let db: Db<u64, ()> = txn.root_db(0).unwrap().unwrap();
replacement in sanakirja/src/environment/muttxn.rs at line 18

[3.1320]→[3.2775:2817](∅→∅)

rc: Option<btree::Db<Self, u64, ()>>,

[3.1320]

[3.80470]

rc: Option<btree::Db<u64, ()>>,
replacement in sanakirja/src/environment/muttxn.rs at line 142

[3.84183]→[3.3366:3434](∅→∅)

let mut free_db: btree::Db<Self, u64, ()> = btree::Db {

[3.84183]

[3.84279]

let mut free_db: btree::Db<u64, ()> = btree::Db {
replacement in sanakirja/src/environment/muttxn.rs at line 219

[3.86537]→[3.4034:4093](∅→∅)

let mut db: btree::Db<Self, u64, ()> = btree::Db {

[3.86537]

[3.86624]

let mut db: btree::Db<u64, ()> = btree::Db {
replacement in sanakirja/src/environment/muttxn.rs at line 389

[3.4458]→[3.4458:4522](∅→∅)

K: Representable<Self>,
V: Representable<Self>,

[3.4458]

[3.4522]

K: Representable,
V: Representable,
replacement in sanakirja/src/environment/muttxn.rs at line 394

[3.4562]→[3.4562:4634](∅→∅)

) -> Result<Option<sanakirja_core::btree::Db<Self, K, V>>, Error> {

[3.4562]

[3.4634]

) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Error> {
replacement in sanakirja/src/environment/mod.rs at line 424

[3.6186]→[3.6186:6250](∅→∅)

K: Representable<Self>,
V: Representable<Self>,

[3.6186]

[3.6250]

K: Representable,
V: Representable,
replacement in sanakirja/src/environment/mod.rs at line 429

[3.6290]→[3.6290:6367](∅→∅)

) -> Result<Option<sanakirja_core::btree::Db<Self, K, V>>, Self::Error>;

[3.6290]

[3.6367]

) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Self::Error>;