replacement in sanakirja-core-async/src/lib.rs at line 36
[8.1982]→[8.1982:2012](∅→∅) − use async_trait::async_trait;
edit in sanakirja-core-async/src/lib.rs at line 38
+
+ mod slice;
+ pub use slice::*;
replacement in sanakirja-core-async/src/lib.rs at line 49
[8.2395]→[8.2395:2417](∅→∅) replacement in sanakirja-core-async/src/lib.rs at line 53
[8.2589]→[8.2589:2647](∅→∅) − fn compare(&self, _b: &Self) -> core::cmp::Ordering {
+ async fn compare<T: LoadPage>(&self, _txn: &T, _b: &Self) -> core::cmp::Ordering {
replacement in sanakirja-core-async/src/lib.rs at line 63
[8.2979]→[8.2979:3057](∅→∅) − async fn drop<T: AllocPage>(&self, txn: &mut T) -> Result<(), T::Error> {
+ async unsafe fn drop<T: AllocPage>(&self, txn: &mut T) -> Result<(), T::Error> {
edit in sanakirja-core-async/src/lib.rs at line 83
+ #[async_trait::async_trait]
replacement in sanakirja-core-async/src/lib.rs at line 89
[8.3871]→[8.3871:3936](∅→∅) − fn compare(&self, b: &Self) -> core::cmp::Ordering {
+ async fn compare<T: LoadPage>(&self, _txn: &T, b: &Self) -> core::cmp::Ordering {
edit in sanakirja-core-async/src/lib.rs at line 93
+ #[async_trait::async_trait]
replacement in sanakirja-core-async/src/lib.rs at line 110
[8.4643]→[8.4643:4772](∅→∅) − unsafe fn write_to_page(&self, p: *mut u8) {
− core::ptr::copy_nonoverlapping(self, p as *mut Self, 1)
+ async unsafe fn write_to_page<T: AllocPage>(&self, _txn: &mut T, p: Mut<u8>) {
+ core::ptr::copy_nonoverlapping(self, p.0 as *mut Self, 1)
replacement in sanakirja-core-async/src/lib.rs at line 114
[8.4787]→[8.4787:4891](∅→∅) − unsafe fn from_raw_ptr<'a>(p: *const u8) -> &'a Self {
− &*(p as *const Self)
+ async unsafe fn from_raw_ptr<'a, T>(_: &T, p: Const<u8>) -> &'a Self {
+ &*(p.0 as *const Self)
edit in sanakirja-core-async/src/lib.rs at line 150
+
+ #[derive(Clone, Copy)]
+ pub struct Mut<T>(pub *mut T);
+
+ unsafe impl<T> Send for Mut<T> {}
+
+ impl<T> Mut<T> {
+ pub unsafe fn new(p: *mut T) -> Self {
+ Mut(p)
+ }
+
+ pub fn into_inner(self) -> *mut T {
+ self.0
+ }
+ }
+
+ #[derive(Clone, Copy)]
+ pub struct Const<T>(pub *const T);
+
+ unsafe impl<T> Send for Const<T> {}
+
+ impl<T> Const<T> {
+ pub unsafe fn new(p: *const T) -> Self {
+ Const(p)
+ }
+
+ pub fn into_inner(self) -> *const T {
+ self.0
+ }
+ }
edit in sanakirja-core-async/src/lib.rs at line 182
replacement in sanakirja-core-async/src/lib.rs at line 196
[8.6185]→[8.6185:6233](∅→∅) − unsafe fn write_to_page(&self, p: *mut u8);
+ async unsafe fn write_to_page<T: AllocPage>(&self, txn: &mut T, p: Mut<u8>);
replacement in sanakirja-core-async/src/lib.rs at line 198
[8.6234]→[8.6234:6292](∅→∅) − unsafe fn from_raw_ptr<'a>(p: *const u8) -> &'a Self;
+ async unsafe fn from_raw_ptr<'a, T>(_: &T, p: Const<u8>) -> &'a Self;
edit in sanakirja-core-async/src/lib.rs at line 201
replacement in sanakirja-core-async/src/lib.rs at line 207
[8.6460]→[8.6460:6517](∅→∅) − fn compare(&self, b: &Self) -> core::cmp::Ordering {
+ async fn compare<T: LoadPage>(&self, _txn: &T, b: &Self) -> core::cmp::Ordering {
edit in sanakirja-core-async/src/lib.rs at line 212
replacement in sanakirja-core-async/src/lib.rs at line 218
[8.6665]→[8.6665:6776](∅→∅) − unsafe fn from_raw_ptr<'a>(p: *const u8) -> &'a Self {
− let len = u16::from_le(*(p as *const u16));
+ async unsafe fn from_raw_ptr<'a, T>(_: &T, p: Const<u8>) -> &'a Self {
+ let len = u16::from_le(*(p.0 as *const u16));
replacement in sanakirja-core-async/src/lib.rs at line 222
[8.6841]→[8.6841:6901](∅→∅) − core::slice::from_raw_parts(p.add(2), len as usize)
+ core::slice::from_raw_parts(p.0.add(2), len as usize)
replacement in sanakirja-core-async/src/lib.rs at line 228
[8.7041]→[8.7041:7090](∅→∅) − unsafe fn write_to_page(&self, p: *mut u8) {
+ async unsafe fn write_to_page<T: AllocPage>(&self, _txn: &mut T, p: Mut<u8>) {
replacement in sanakirja-core-async/src/lib.rs at line 230
[8.7126]→[8.7126:7258](∅→∅) − *(p as *mut u16) = (self.len() as u16).to_le();
− core::ptr::copy_nonoverlapping(self.as_ptr(), p.add(2), self.len())
+ *(p.0 as *mut u16) = (self.len() as u16).to_le();
+ core::ptr::copy_nonoverlapping(self.as_ptr(), p.0.add(2), self.len())
replacement in sanakirja-core-async/src/lib.rs at line 303
[8.9328]→[8.9328:9464](∅→∅) − hasher.update(core::slice::from_raw_parts(
− self.data.add(8),
− PAGE_SIZE - 8,
− ));
+ hasher.update(core::slice::from_raw_parts(self.data.add(8), PAGE_SIZE - 8));
edit in sanakirja-core-async/src/lib.rs at line 334
+ #[cfg(not(feature = "crc32"))]
+ pub unsafe fn clear_dirty_(data: *mut u8) {
+ *data &= 0xfe
+ }
edit in sanakirja-core-async/src/lib.rs at line 339
+ #[cfg(feature = "crc32")]
+ pub unsafe fn clear_dirty_(data: *mut u8, hasher: &crc32fast::Hasher) {
+ *data &= 0xfe;
+ let crc = (data as *mut u32).add(1);
+ *crc = self.0.crc(hasher)
+ }
+
replacement in sanakirja-core-async/src/lib.rs at line 373
[8.10863]→[8.10863:10885](∅→∅) replacement in sanakirja-core-async/src/lib.rs at line 375
[8.10919]→[8.10919:10935](∅→∅) + type Error: core::fmt::Debug + Send;
+ /// Loading a page.
+ async unsafe fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>;
+
replacement in sanakirja-core-async/src/lib.rs at line 380
[8.10959]→[8.10959:11032](∅→∅) − async fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>;
+ async unsafe fn load_page_contiguous(
+ &self,
+ _off: u64,
+ _length: u64,
+ ) -> Result<CowPage, Self::Error> {
+ unimplemented!()
+ }
replacement in sanakirja-core-async/src/lib.rs at line 404
[8.11742]→[8.11742:11764](∅→∅) replacement in sanakirja-core-async/src/lib.rs at line 407
[8.11825]→[8.11825:11893](∅→∅) − async fn alloc_page(&mut self) -> Result<MutPage, Self::Error>;
+ async unsafe fn alloc_page(&mut self) -> Result<MutPage, Self::Error>;
+ /// Allocate a new page, and mark it as not requiring cleaning of the dirty bit.
+ async unsafe fn alloc_page_nodirty(&mut self) -> Result<MutPage, Self::Error> {
+ unimplemented!()
+ }
+ /// Allocate a new block.
+ async unsafe fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Self::Error>;
replacement in sanakirja-core-async/src/lib.rs at line 419
[8.12209]→[8.12209:12282](∅→∅) − async fn decr_rc(&mut self, off: u64) -> Result<usize, Self::Error>;
+ async unsafe fn decr_rc(&mut self, off: u64) -> Result<usize, Self::Error>;
replacement in sanakirja-core-async/src/lib.rs at line 424
[8.12518]→[8.12518:12597](∅→∅) − async fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Self::Error>;
+ async unsafe fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Self::Error>;
replacement in sanakirja-core-async/src/btree/put.rs at line 44
[8.23019]→[8.23019:23069](∅→∅) − let mut cursor = Cursor::new(txn, db).await?;
+ let mut cursor = unsafe { Cursor::new(txn, db).await? };
replacement in sanakirja-core-async/src/btree/put.rs at line 71
[8.23884]→[8.23884:23898](∅→∅) replacement in sanakirja-core-async/src/btree/put.rs at line 89
[8.24622]→[8.24622:24859](∅→∅) − db.db = put_cascade(txn, &mut cursor, put, &mut free).await?.0.offset;
− for f in &free[..p] {
− if *f & 1 != 0 {
− txn.decr_rc_owned((*f) ^ 1).await?;
− } else if *f > 0 {
− txn.decr_rc(*f).await?;
+ db.db = put_cascade(txn, &mut cursor, put, &mut free)
+ .await?
+ .0
+ .offset;
+ unsafe {
+ for f in &free[..p] {
+ if *f & 1 != 0 {
+ txn.decr_rc_owned((*f) ^ 1).await?;
+ } else if *f > 0 {
+ txn.decr_rc(*f).await?;
+ }
replacement in sanakirja-core-async/src/btree/put.rs at line 106
[8.24913]→[8.24913:24925](∅→∅) replacement in sanakirja-core-async/src/btree/put.rs at line 110
[8.24995]→[8.24995:25022](∅→∅) + P: BTreeMutPage<K, V> + Send,
replacement in sanakirja-core-async/src/btree/put.rs at line 150
[8.26593]→[8.26593:26623](∅→∅) replacement in sanakirja-core-async/src/btree/put.rs at line 156
[8.26836]→[8.26836:26893](∅→∅) − let mut p = txn.alloc_page().await?;
+ let mut p = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/put.rs at line 170
[8.27367]→[8.27367:27398](∅→∅) replacement in sanakirja-core-async/src/btree/put.rs at line 192
[8.28358]→[8.28358:28619](∅→∅) − put = Put::Ok(P::update_left_child(
− txn,
− curs.page,
− is_owned,
− &curs.cursor,
− page.0.offset,
− ).await?)
+ put = Put::Ok(
+ P::update_left_child(txn, curs.page, is_owned, &curs.cursor, page.0.offset)
+ .await?,
+ )
replacement in sanakirja-core-async/src/btree/put.rs at line 210
[8.28974]→[8.28974:28998](∅→∅) + P: BTreePage<K, V> + Send,
replacement in sanakirja-core-async/src/btree/put.rs at line 245
[8.30393]→[8.30393:30467](∅→∅) − while let Some((k, v, r)) = P::next(cur.page.as_page(), &mut c) {
+ while let Some((k, v, r)) = P::next(txn, cur.page.as_page(), &mut c).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 49
[8.32661]→[8.32661:32683](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 104
[8.34228]→[8.34228:34248](∅→∅) + async fn current<'a, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 115
[8.34591]→[8.34591:34672](∅→∅) − let (k, v) = read::<K, V>(page.data.as_ptr().add(off as usize));
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().add(off as usize));
+ (Const(k as *const u8), Const(v as *const u8))
+ };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 120
[8.34695]→[8.34695:34801](∅→∅) − K::from_raw_ptr(k as *const u8),
− V::from_raw_ptr(v as *const u8),
+ K::from_raw_ptr(txn, k).await,
+ V::from_raw_ptr(txn, v).await,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 129
[8.35022]→[8.35022:35113](∅→∅) − let (k, v) = read::<K, V>(page.data.as_ptr().add((off & 0xfff) as usize));
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().add((off & 0xfff) as usize));
+ (Const(k as *const u8), Const(v as *const u8))
+ };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 134
[8.35136]→[8.35136:35242](∅→∅) − K::from_raw_ptr(k as *const u8),
− V::from_raw_ptr(v as *const u8),
+ K::from_raw_ptr(txn, k).await,
+ V::from_raw_ptr(txn, v).await,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 160
[8.36039]→[8.36039:36142](∅→∅) − let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
+ let off =
+ unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 167
[8.36244]→[8.36244:36265](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 179
[8.36746]→[8.36746:36796](∅→∅) − match lookup(page, c, k0, v0).await {
+ match lookup(txn, page, c, k0, v0).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 185
[8.37028]→[8.37028:37189](∅→∅) − let (k, v) = read::<K, V>(page.data.as_ptr().add(off as usize));
− Ok((K::from_raw_ptr(k), V::from_raw_ptr(v), 0))
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().add(off as usize));
+ let k = Const(k as *const u8);
+ let v = Const(v as *const u8);
+ (k, v)
+ };
+ Ok((
+ K::from_raw_ptr(txn, k).await,
+ V::from_raw_ptr(txn, v).await,
+ 0,
+ ))
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 199
[8.37348]→[8.37348:37473](∅→∅) − let (k, v) =
− read::<K, V>(page.data.as_ptr().add(off as usize & 0xfff));
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().add(off as usize & 0xfff));
+ (Const(k as *const u8), Const(v as *const u8))
+ };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 204
[8.37502]→[8.37502:37598](∅→∅) − K::from_raw_ptr(k),
− V::from_raw_ptr(v),
+ K::from_raw_ptr(txn, k).await,
+ V::from_raw_ptr(txn, v).await,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 222
[8.38034]→[8.38034:38120](∅→∅) − async unsafe fn lookup<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(
+ async unsafe fn lookup<
+ 'a,
+ K: UnsizedStorable + ?Sized,
+ V: UnsizedStorable + ?Sized,
+ T: LoadPage,
+ >(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 238
[8.38341]→[8.38341:38380](∅→∅) − lookup_leaf(page, k0, v0, hdr)
+ lookup_leaf(txn, page, k0, v0, hdr).await
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 240
[8.38393]→[8.38393:38436](∅→∅) − lookup_internal(page, k0, v0, hdr)
+ lookup_internal(txn, page, k0, v0, hdr).await
+ }
+ }
+
+ async fn binary_search_by<'a, T, F, O>(s: &'a [T], mut f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a T) -> O,
+ O: core::future::Future<Output = Ordering>,
+ {
+ use Ordering::*;
+
+ let mut size = s.len();
+ let mut left = 0;
+ let mut right = size;
+ while left < right {
+ let mid = left + size / 2;
+
+ // SAFETY: the while condition means `size` is strictly positive, so
+ // `size/2 < size`. Thus `left + size/2 < left + size`, which
+ // coupled with the `left + size <= self.len()` invariant means
+ // we have `left + size/2 < self.len()`, and this is in-bounds.
+ let cmp = f(unsafe { s.get_unchecked(mid) }).await;
+
+ // The reason why we use if/else control flow rather than match
+ // is because match reorders comparison operations, which is perf sensitive.
+ // This is x86 asm for u8: https://rust.godbolt.org/z/8Y8Pra.
+ if cmp == Less {
+ left = mid + 1;
+ } else if cmp == Greater {
+ right = mid;
+ } else {
+ return Ok(mid);
+ }
+
+ size = right - left;
edit in sanakirja-core-async/src/btree/page_unsized.rs at line 276
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 279
[8.38445]→[8.38445:38534](∅→∅) − unsafe fn lookup_internal<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(
+ async unsafe fn lookup_internal<
+ 'a,
+ K: UnsizedStorable + ?Sized,
+ V: UnsizedStorable + ?Sized,
+ T: LoadPage,
+ >(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 291
[8.38647]→[8.38647:38772](∅→∅) − let s = core::slice::from_raw_parts(
− page.data.as_ptr().add(HDR) as *const u64,
− hdr.n() as usize,
− );
+ let s =
+ core::slice::from_raw_parts(page.data.as_ptr().add(HDR) as *const u64, hdr.n() as usize);
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 294
[8.38799]→[8.38799:38835](∅→∅) − s.binary_search_by(|&off| {
+ binary_search_by(s, |&off| async move {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 296
[8.38884]→[8.38884:39046](∅→∅) − let (k, v) = read::<K, V>(page.data.as_ptr().offset(off as isize & 0xfff));
− let k = K::from_raw_ptr(k);
− match k.compare(k0) {
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().offset(off as isize & 0xfff));
+ (Const(k), Const(v))
+ };
+ let k = K::from_raw_ptr(txn, k).await;
+ match k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 303
[8.39083]→[8.39083:39165](∅→∅) − let v = V::from_raw_ptr(v);
− v.compare(v0)
+ let v = V::from_raw_ptr(txn, v).await;
+ v.compare(txn, v0).await
edit in sanakirja-core-async/src/btree/page_unsized.rs at line 309
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 311
[8.39249]→[8.39249:39291](∅→∅) − match s.binary_search_by(|&off| {
+ match binary_search_by(s, |&off| async move {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 313
[8.39340]→[8.39340:39507](∅→∅) − let (k, _) = read::<K, V>(page.data.as_ptr().offset(off as isize & 0xfff));
− let k = K::from_raw_ptr(k);
− k.compare(k0)
− }) {
+ let k = Const(read::<K, V>(page.data.as_ptr().offset(off as isize & 0xfff)).0);
+ let k = K::from_raw_ptr(txn, k).await;
+ k.compare(txn, k0).await
+ })
+ .await
+ {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 323
[8.39657]→[8.39657:39914](∅→∅) − let off = u64::from_le(s[i-1]) & 0xfff;
− let (k, _) = read::<K, V>(page.data.as_ptr().offset(off as isize));
− let k = K::from_raw_ptr(k);
− if let Ordering::Equal = k.compare(k0) {
+ let off = u64::from_le(s[i - 1]) & 0xfff;
+ let k = Const(read::<K, V>(page.data.as_ptr().offset(off as isize)).0);
+ let k = K::from_raw_ptr(txn, k).await;
+ if let Ordering::Equal = k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 329
[8.39974]→[8.39974:40004](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 338
[8.40099]→[8.40099:40185](∅→∅) −
− unsafe fn lookup_leaf<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(
+ async unsafe fn lookup_leaf<
+ 'a,
+ K: UnsizedStorable + ?Sized,
+ V: UnsizedStorable + ?Sized,
+ T: LoadPage,
+ >(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 350
[8.40298]→[8.40298:40423](∅→∅) − let s = core::slice::from_raw_parts(
− page.data.as_ptr().add(HDR) as *const u16,
− hdr.n() as usize,
− );
+ let s =
+ core::slice::from_raw_parts(page.data.as_ptr().add(HDR) as *const u16, hdr.n() as usize);
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 353
[8.40450]→[8.40450:40486](∅→∅) − s.binary_search_by(|&off| {
+ binary_search_by(s, |&off| async move {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 355
[8.40527]→[8.40527:40694](∅→∅) − let (k, v) = read::<K, V>(page.data.as_ptr().offset(off as isize));
− let k = K::from_raw_ptr(k as *const u8);
− match k.compare(k0) {
+ let (k, v) = {
+ let (k, v) = read::<K, V>(page.data.as_ptr().offset(off as isize));
+ (Const(k as *const u8), Const(v as *const u8))
+ };
+ let k = K::from_raw_ptr(txn, k).await;
+ match k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 362
[8.40731]→[8.40731:40826](∅→∅) − let v = V::from_raw_ptr(v as *const u8);
− v.compare(v0)
+ let v = V::from_raw_ptr(txn, v).await;
+ v.compare(txn, v0).await
edit in sanakirja-core-async/src/btree/page_unsized.rs at line 368
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 370
[8.40910]→[8.40910:40952](∅→∅) − match s.binary_search_by(|&off| {
+ match binary_search_by(s, |&off| async move {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 372
[8.40993]→[8.40993:41152](∅→∅) − let (k, _) = read::<K, V>(page.data.as_ptr().offset(off as isize));
− let k = K::from_raw_ptr(k);
− k.compare(k0)
− }) {
+ let k = Const(read::<K, V>(page.data.as_ptr().offset(off as isize)).0);
+ let k = K::from_raw_ptr(txn, k).await;
+ k.compare(txn, k0).await
+ })
+ .await
+ {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 382
[8.41302]→[8.41302:41550](∅→∅) − let off = u16::from_le(s[i-1]);
− let (k, _) = read::<K, V>(page.data.as_ptr().offset(off as isize));
− let k = K::from_raw_ptr(k);
− if let Ordering::Equal = k.compare(k0){
+ let off = u16::from_le(s[i - 1]);
+ let k = Const(read::<K, V>(page.data.as_ptr().offset(off as isize)).0);
+ let k = K::from_raw_ptr(txn, k).await;
+ if let Ordering::Equal = k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 388
[8.41610]→[8.41610:41640](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 397
[8.41735]→[8.41735:41757](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 453
[8.43536]→[8.43536:43556](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 467
[8.43841]→[8.43841:43861](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 472
[8.43878]→[8.43878:43901](∅→∅) + async unsafe fn put_mut<T: AllocPage>(
+ txn: &mut T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 482
[8.44062]→[8.44062:44121](∅→∅) − Leaf::alloc_write(page, k0, v0, 0, r, &mut n);
+ Leaf::alloc_write(txn, page, k0, v0, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 484
[8.44138]→[8.44138:44201](∅→∅) − Internal::alloc_write(page, k0, v0, 0, r, &mut n);
+ Internal::alloc_write(txn, page, k0, v0, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 489
[8.44240]→[8.44240:44347](∅→∅) − unsafe fn set_left_child(
− page: &mut MutPage,
− c: &Self::Cursor,
− l: u64
− ) {
+ unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64) {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 511
[8.45084]→[8.45084:45135](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 595
[8.49089]→[8.49089:49140](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 686
[8.53302]→[8.53302:53707](∅→∅) − return Ok(Op::Put(Self::put(
− txn,
− m.modified.page,
− m.modified.mutable,
− m.modified.skip_first,
− &m.modified.c1,
− k,
− v,
− m.modified.ins2,
− m.modified.l,
− m.modified.r,
− ).await?));
+ return Ok(Op::Put(
+ Self::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ m.modified.skip_first,
+ &m.modified.c1,
+ k,
+ v,
+ m.modified.ins2,
+ m.modified.l,
+ m.modified.r,
+ )
+ .await?,
+ ));
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 709
[8.54030]→[8.54030:54056](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 719
[8.54366]→[8.54366:54612](∅→∅) − return Ok(Op::Put(Put::Ok(Self::update_left_child(
− txn,
− m.modified.page,
− m.modified.mutable,
− &c1,
− l,
− ).await?)));
+ return Ok(Op::Put(Put::Ok(
+ Self::update_left_child(txn, m.modified.page, m.modified.mutable, &c1, l)
+ .await?,
+ )));
edit in sanakirja-core-async/src/btree/page_unsized.rs at line 785
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 787
[8.56602]→[8.56602:56688](∅→∅) − fn alloc_write(new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize);
+ async fn alloc_write<T: AllocPage>(
+ txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ );
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 800
[8.56823]→[8.56823:56938](∅→∅) − fn modify<K: core::fmt::Debug + ?Sized, V: core::fmt::Debug + ?Sized, P: BTreeMutPage<K, V>, L: AllocWrite<K, V>>(
+ async fn modify<
+ 'a,
+ K: core::fmt::Debug + ?Sized,
+ V: core::fmt::Debug + ?Sized,
+ P: BTreeMutPage<K, V>,
+ L: AllocWrite<K, V>,
+ T: AllocPage,
+ >(
+ txn: &mut T,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 810
[8.56961]→[8.56961:56996](∅→∅) − m: &mut ModifiedPage<K, V, P>,
+ m: &mut ModifiedPage<'a, K, V, P>,
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 814
[8.57075]→[8.57075:57190](∅→∅) − while let Some((k, v, r)) = P::next(m.page.as_page(), &mut m.c0) {
− L::alloc_write(new, k, v, l, r, n);
+ while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut m.c0).await {
+ L::alloc_write(txn, new, k, v, l, r, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 821
[8.57308]→[8.57308:57410](∅→∅) − L::alloc_write(new, k, v, l, m.l, n);
− L::alloc_write(new, k2, v2, 0, m.r, n);
+ L::alloc_write(txn, new, k, v, l, m.l, n).await;
+ L::alloc_write(txn, new, k2, v2, 0, m.r, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 824
[8.57438]→[8.57438:57490](∅→∅) − L::alloc_write(new, k, v, m.l, m.r, n);
+ L::alloc_write(txn, new, k, v, m.l, m.r, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 826
[8.57507]→[8.57507:57557](∅→∅) − L::alloc_write(new, k, v, l, m.r, n);
+ L::alloc_write(txn, new, k, v, l, m.r, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 845
[8.58130]→[8.58130:58199](∅→∅) − while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c1) {
+ while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1).await {
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 847
[8.58219]→[8.58219:58268](∅→∅) − L::alloc_write(new, k, v, l, rr, n);
+ L::alloc_write(txn, new, k, v, l, rr, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 850
[8.58305]→[8.58305:58353](∅→∅) − L::alloc_write(new, k, v, l, r, n);
+ L::alloc_write(txn, new, k, v, l, r, n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 882
[8.59401]→[8.59401:59444](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 887
[8.59510]→[8.59510:59575](∅→∅) − modify::<_, _, _, L>(&mut new, &mut m.modified, &mut n);
+ modify::<_, _, _, L, _>(txn, &mut new, &mut m.modified, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 890
[8.59678]→[8.59678:59876](∅→∅) − L::alloc_write(&mut new, m.mid.0, m.mid.1, 0, l, &mut n);
− while let Some((k, v, r)) = P::next(m.other.as_page(), &mut rc) {
− L::alloc_write(&mut new, k, v, 0, r, &mut n);
+ L::alloc_write(txn, &mut new, m.mid.0, m.mid.1, 0, l, &mut n).await;
+ while let Some((k, v, r)) = P::next(txn, m.other.as_page(), &mut rc).await {
+ L::alloc_write(txn, &mut new, k, v, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 897
[8.60006]→[8.60006:60138](∅→∅) − while let Some((k, v, r)) = P::next(m.other.as_page(), &mut rc) {
− L::alloc_write(&mut new, k, v, l, r, &mut n);
+ while let Some((k, v, r)) = P::next(txn, m.other.as_page(), &mut rc).await {
+ L::alloc_write(txn, &mut new, k, v, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized.rs at line 901
[8.60167]→[8.60167:60298](∅→∅) − L::alloc_write(&mut new, m.mid.0, m.mid.1, 0, 0, &mut n);
− modify::<_, _, _, L>(&mut new, &mut m.modified, &mut n);
+ L::alloc_write(txn, &mut new, m.mid.0, m.mid.1, 0, 0, &mut n).await;
+ modify::<_, _, _, L, _>(txn, &mut new, &mut m.modified, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 22
[8.62669]→[8.62669:62745](∅→∅) − let (k, v, r) = <Page<K, V>>::current(m.other.as_page(), &rc).unwrap();
+ let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc)
+ .await
+ .unwrap();
replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 44
[8.63426]→[8.63426:63445](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 61
[8.64045]→[8.64045:64064](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 80
[8.64537]→[8.64537:64555](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 119
[8.65871]→[8.65871:65890](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 190
[8.68121]→[8.68121:68189](∅→∅) − let (k0, v0, r0) = P::current(m.other.as_page(), &lc).unwrap();
+ let (k0, v0, r0) = P::current(txn, m.other.as_page(), &lc).await.unwrap();
replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 208
[8.68705]→[8.68705:68724](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 238
[8.69582]→[8.69582:69601](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 254
[8.69969]→[8.69969:69987](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 271
[8.70741]→[8.70741:70760](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/rebalance.rs at line 296
[8.71381]→[8.71381:71400](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 77
[8.75850]→[8.75850:75972](∅→∅) − L::alloc_write(&mut page, k0, v0, 0, 0, &mut n);
− L::alloc_write(&mut page, k1, v1, l, r, &mut n);
+ L::alloc_write(txn, &mut page, k0, v0, 0, 0, &mut n).await;
+ L::alloc_write(txn, &mut page, k1, v1, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 80
[8.75989]→[8.75989:76050](∅→∅) − L::alloc_write(&mut page, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut page, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 88
[8.76384]→[8.76384:76431](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 104
[8.77016]→[8.77016:77136](∅→∅) − L::alloc_write(&mut new, k0, v0, 0, l, &mut n);
− L::alloc_write(&mut new, k1, v1, 0, r, &mut n);
+ L::alloc_write(txn, &mut new, k0, v0, 0, l, &mut n).await;
+ L::alloc_write(txn, &mut new, k1, v1, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 107
[8.77153]→[8.77153:77213](∅→∅) − L::alloc_write(&mut new, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut new, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 142
[8.78239]→[8.78239:78283](∅→∅) − let mut left = txn.alloc_page().await?;
+ let mut left = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 145
[8.78341]→[8.78341:78386](∅→∅) − let mut right = txn.alloc_page().await?;
+ let mut right = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 182
[8.80125]→[8.80125:80194](∅→∅) − L::alloc_write(current_page, k0, v0, 0, l0, &mut n);
+ L::alloc_write(txn, current_page, k0, v0, 0, l0, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 184
[8.80256]→[8.80256:80325](∅→∅) − L::alloc_write(current_page, k1, v1, 0, r0, &mut n);
+ L::alloc_write(txn, current_page, k1, v1, 0, r0, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 191
[8.80522]→[8.80522:80592](∅→∅) − L::alloc_write(current_page, k0, v0, l0, r0, &mut n);
+ L::alloc_write(txn, current_page, k0, v0, l0, r0, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 205
[8.81082]→[8.81082:81172](∅→∅) − let ptr = page.data.add(off);
− let size = entry_size::<K, V>(ptr);
+ let ptr = Const(page.data.add(off));
+ let size = entry_size::<K, V>(ptr.0);
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 215
[8.81610]→[8.81610:81730](∅→∅) − let (k, v) = read::<K, V>(ptr);
− split = Some((K::from_raw_ptr(k), V::from_raw_ptr(v)));
+ let (k, v) = {
+ let (k, v) = read::<K, V>(ptr.0);
+ (Const(k), Const(v))
+ };
+ split = Some((K::from_raw_ptr(txn, k).await, V::from_raw_ptr(txn, v).await));
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 250
[8.83055]→[8.83055:83080](∅→∅) replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 268
[8.83696]→[8.83696:83826](∅→∅) − L::alloc_write(current_page, k0, v0, 0, l0, &mut n);
− L::alloc_write(current_page, k1, v1, 0, r0, &mut n);
+ L::alloc_write(txn, current_page, k0, v0, 0, l0, &mut n).await;
+ L::alloc_write(txn, current_page, k1, v1, 0, r0, &mut n).await;
replacement in sanakirja-core-async/src/btree/page_unsized/put.rs at line 271
[8.83843]→[8.83843:83909](∅→∅) − L::alloc_write(current_page, k0, v0, l0, r0, &mut n);
+ L::alloc_write(txn, current_page, k0, v0, l0, r0, &mut n).await;
edit in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 180
replacement in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 182
[8.92606]→[8.92606:92749](∅→∅) − fn alloc_write(new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
− alloc_write::<K, V, Self>(new, k0, v0, l, r, n)
+ async fn alloc_write<T: AllocPage>(
+ txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
+ alloc_write::<K, V, Self, T>(txn, new, k0, v0, l, r, n).await
edit in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 198
replacement in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 200
[8.92954]→[8.92954:93097](∅→∅) − fn alloc_write(new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
− alloc_write::<K, V, Self>(new, k0, v0, l, r, n)
+ async fn alloc_write<T: AllocPage>(
+ txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
+ alloc_write::<K, V, Self, T>(txn, new, k0, v0, l, r, n).await
replacement in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 219
[8.93317]→[8.93317:93401](∅→∅) − fn alloc_write<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized, L: Alloc>(
+ async fn alloc_write<
+ K: UnsizedStorable + ?Sized,
+ V: UnsizedStorable + ?Sized,
+ L: Alloc,
+ T: AllocPage,
+ >(
+ txn: &mut T,
replacement in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 236
[8.93603]→[8.93603:93685](∅→∅) − let new_ptr = new.0.data.add(off_new);
− k0.write_to_page(new_ptr);
+ let new_ptr = Mut(new.0.data.add(off_new));
+ k0.write_to_page(txn, new_ptr).await;
replacement in sanakirja-core-async/src/btree/page_unsized/alloc.rs at line 239
[8.93713]→[8.93713:93818](∅→∅) − let v_ptr = new_ptr.add((ks + V::ALIGN - 1) & !(V::ALIGN - 1));
− v0.write_to_page(v_ptr);
+ let v_ptr = Mut(new_ptr.0.add((ks + V::ALIGN - 1) & !(V::ALIGN - 1)));
+ v0.write_to_page(txn, v_ptr).await;
replacement in sanakirja-core-async/src/btree/page.rs at line 102
[8.98819]→[8.98819:98841](∅→∅) replacement in sanakirja-core-async/src/btree/page.rs at line 157
[8.100315]→[8.100315:100335](∅→∅) + async fn current<'a, T: LoadPage>(
+ _txn: &T,
replacement in sanakirja-core-async/src/btree/page.rs at line 223
[8.103363]→[8.103363:103488](∅→∅) − let off =
− unsafe { *(page.data.as_ptr().offset((HDR as isize + c.cur * 8) - 8) as *const u64) };
+ let off = unsafe {
+ *(page.data.as_ptr().offset((HDR as isize + c.cur * 8) - 8) as *const u64)
+ };
replacement in sanakirja-core-async/src/btree/page.rs at line 241
[8.103966]→[8.103966:103987](∅→∅) replacement in sanakirja-core-async/src/btree/page.rs at line 253
[8.104468]→[8.104468:104518](∅→∅) − match lookup(page, c, k0, v0).await {
+ match lookup(txn, page, c, k0, v0).await {
replacement in sanakirja-core-async/src/btree/page.rs at line 281
[8.105601]→[8.105601:105623](∅→∅) replacement in sanakirja-core-async/src/btree/page.rs at line 336
[8.107692]→[8.107692:107795](∅→∅) − put::put::<_, _, _, Leaf>(txn, page, mutable, replace, c.cur as usize, k0, v0, 0, 0).await
+ put::put::<_, _, _, Leaf>(txn, page, mutable, replace, c.cur as usize, k0, v0, 0, 0)
+ .await
replacement in sanakirja-core-async/src/btree/page.rs at line 339
[8.107812]→[8.107812:107919](∅→∅) − put::put::<_, _, _, Internal>(txn, page, mutable, replace, c.cur as usize, k0, v0, l, r).await
+ put::put::<_, _, _, Internal>(txn, page, mutable, replace, c.cur as usize, k0, v0, l, r)
+ .await
replacement in sanakirja-core-async/src/btree/page.rs at line 344
[8.107936]→[8.107936:108026](∅→∅) − unsafe fn put_mut(page: &mut MutPage, c: &mut Self::Cursor, k0: &K, v0: &V, r: u64) {
+ async unsafe fn put_mut<T: AllocPage>(
+ txn: &mut T,
+ page: &mut MutPage,
+ c: &mut Self::Cursor,
+ k0: &K,
+ v0: &V,
+ r: u64,
+ ) {
replacement in sanakirja-core-async/src/btree/page.rs at line 355
[8.108118]→[8.108118:108177](∅→∅) − Leaf::alloc_write(page, k0, v0, 0, r, &mut n);
+ Leaf::alloc_write(txn, page, k0, v0, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page.rs at line 357
[8.108194]→[8.108194:108257](∅→∅) − Internal::alloc_write(page, k0, v0, 0, r, &mut n);
+ Internal::alloc_write(txn, page, k0, v0, 0, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page.rs at line 385
[8.109172]→[8.109172:109223](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page.rs at line 469
[8.112869]→[8.112869:112920](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page.rs at line 564
[8.117285]→[8.117285:117690](∅→∅) − return Ok(Op::Put(Self::put(
− txn,
− m.modified.page,
− m.modified.mutable,
− m.modified.skip_first,
− &m.modified.c1,
− k,
− v,
− m.modified.ins2,
− m.modified.l,
− m.modified.r,
− ).await?));
+ return Ok(Op::Put(
+ Self::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ m.modified.skip_first,
+ &m.modified.c1,
+ k,
+ v,
+ m.modified.ins2,
+ m.modified.l,
+ m.modified.r,
+ )
+ .await?,
+ ));
replacement in sanakirja-core-async/src/btree/page.rs at line 591
[8.118278]→[8.118278:118304](∅→∅) replacement in sanakirja-core-async/src/btree/page.rs at line 601
[8.118614]→[8.118614:118860](∅→∅) − return Ok(Op::Put(Put::Ok(Self::update_left_child(
− txn,
− m.modified.page,
− m.modified.mutable,
− &c1,
− l,
− ).await?)));
+ return Ok(Op::Put(Put::Ok(
+ Self::update_left_child(txn, m.modified.page, m.modified.mutable, &c1, l)
+ .await?,
+ )));
replacement in sanakirja-core-async/src/btree/page.rs at line 653
[8.120345]→[8.120345:120394](∅→∅) − fn leaf_linear_search<K: Storable, V: Storable>(
+ async fn leaf_linear_search<K: Storable, V: Storable, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page.rs at line 661
[8.120521]→[8.120521:120554](∅→∅) − match sm.k.compare(k0) {
+ match sm.k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page.rs at line 666
[8.120712]→[8.120712:120757](∅→∅) − match sm.v.compare(v0) {
+ match sm.v.compare(txn, v0).await {
replacement in sanakirja-core-async/src/btree/page.rs at line 682
[8.121188]→[8.121188:121222](∅→∅) − fn cmp<K: Storable, V: Storable>(
+ async fn cmp<K: Storable, V: Storable, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page.rs at line 697
[8.121554]→[8.121554:121676](∅→∅) − let tup = unsafe { &*(p.as_ptr().offset(off as isize & 0xfff) as *const Tuple<K, V>) };
− match tup.k.compare(k0) {
+ let (k, v) = unsafe {
+ let ptr = &*(p.as_ptr().offset(off as isize & 0xfff) as *const Tuple<K, V>);
+ (&ptr.k, &ptr.v)
+ };
+ match k.compare(txn, k0).await {
replacement in sanakirja-core-async/src/btree/page.rs at line 704
[8.121740]→[8.121740:121774](∅→∅) + v.compare(txn, v0).await
replacement in sanakirja-core-async/src/btree/page.rs at line 714
[8.121933]→[8.121933:121986](∅→∅) − unsafe fn internal_search<K: Storable, V: Storable>(
+ async unsafe fn internal_search<K: Storable, V: Storable, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page.rs at line 722
[8.122124]→[8.122124:122161](∅→∅) − match cmp(k0, v0, p, *off) {
+ match cmp(txn, k0, v0, p, *off).await {
replacement in sanakirja-core-async/src/btree/page.rs at line 733
[8.122449]→[8.122449:122503](∅→∅) − async unsafe fn lookup<'a, K: Storable, V: Storable>(
+ async unsafe fn lookup<'a, K: Storable, V: Storable, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/page.rs at line 750
[8.122984]→[8.122984:123022](∅→∅) − leaf_linear_search(k0, v0, s)
+ leaf_linear_search(txn, k0, v0, s).await
replacement in sanakirja-core-async/src/btree/page.rs at line 756
[8.123176]→[8.123176:123222](∅→∅) − internal_search(k0, v0, s, page.data)
+ internal_search(txn, k0, v0, s, page.data).await
replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 20
[8.126605]→[8.126605:126681](∅→∅) − let (k, v, r) = <Page<K, V>>::current(m.other.as_page(), &rc).unwrap();
+ let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc)
+ .await
+ .unwrap();
replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 42
[8.127358]→[8.127358:127377](∅→∅) replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 57
[8.127831]→[8.127831:127988](∅→∅) − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− ).await? {
+ if let Put::Ok(Ok { page, freed }) =
+ <Page<K, V>>::put(txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl).await?
+ {
replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 81
[8.128738]→[8.128738:128756](∅→∅) replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 91
[8.129121]→[8.129121:129278](∅→∅) − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− ).await? {
+ if let Put::Ok(Ok { page, freed }) =
+ <Page<K, V>>::put(txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl).await?
+ {
replacement in sanakirja-core-async/src/btree/page/rebalance.rs at line 110
[8.129925]→[8.129925:130041](∅→∅) − txn, m.modified.page, m.modified.mutable, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− ).await? {
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ false,
+ &lc,
+ m.mid.0,
+ m.mid.1,
+ None,
+ 0,
+ rl,
+ )
+ .await?
+ {
replacement in sanakirja-core-async/src/btree/page/put.rs at line 26
[8.134163]→[8.134163:134192](∅→∅) + let p = Mut(page.0.data);
replacement in sanakirja-core-async/src/btree/page/put.rs at line 36
[8.134610]→[8.134610:134677](∅→∅) − let ptr = p.add(HDR + n as usize * 8) as *mut u64;
+ let ptr = p.0.add(HDR + n as usize * 8) as *mut u64;
replacement in sanakirja-core-async/src/btree/page/put.rs at line 43
[8.134933]→[8.134933:134990](∅→∅) − L::alloc_write(&mut page, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut page, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page/put.rs at line 48
[8.135200]→[8.135200:135247](∅→∅) − let mut new = txn.alloc_page().await?;
+ let mut new = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page/put.rs at line 63
[8.135885]→[8.135885:135941](∅→∅) − L::alloc_write(&mut new, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut new, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page/put.rs at line 124
[8.137756]→[8.137756:137805](∅→∅) − let mut right = txn.alloc_page().await?;
+ let mut right = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page/put.rs at line 141
[8.138571]→[8.138571:138633](∅→∅) − L::alloc_write(&mut right, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut right, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page/put.rs at line 160
[8.139454]→[8.139454:139498](∅→∅) − left = txn.alloc_page().await?;
+ left = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page/put.rs at line 188
[8.140625]→[8.140625:140665](∅→∅) − left = txn.alloc_page().await?;
+ left = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/page/put.rs at line 197
[8.141067]→[8.141067:141124](∅→∅) − L::alloc_write(&mut left, k0, v0, l, r, &mut n);
+ L::alloc_write(txn, &mut left, k0, v0, l, r, &mut n).await;
replacement in sanakirja-core-async/src/btree/page/put.rs at line 217
[8.141829]→[8.141829:141874](∅→∅) − right = txn.alloc_page().await?;
+ right = unsafe { txn.alloc_page().await? };
edit in sanakirja-core-async/src/btree/page/alloc.rs at line 305
replacement in sanakirja-core-async/src/btree/page/alloc.rs at line 307
[8.154232]→[8.154232:154319](∅→∅) − fn alloc_write(new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
+ async fn alloc_write<T: AllocPage>(
+ _txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
edit in sanakirja-core-async/src/btree/page/alloc.rs at line 325
replacement in sanakirja-core-async/src/btree/page/alloc.rs at line 327
[8.154621]→[8.154621:154708](∅→∅) − fn alloc_write(new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
+ async fn alloc_write<T: AllocPage>(
+ _txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
edit in sanakirja-core-async/src/btree/page/alloc.rs at line 356
+ // We can't do the following, since K and V don't implement UnsizedStorable.
+ // k0.write_to_page(txn, Mut(&mut new_ptr.k as *mut u8)).await?;
+ // v0.write_to_page(txn, Mut(&mut new_ptr.v as *mut u8)).await?;
replacement in sanakirja-core-async/src/btree/mod.rs at line 26
[8.156490]→[8.156490:156512](∅→∅),
[8.156512]→[8.156512:156563](∅→∅) − #[async_trait(?Send)]
− pub trait BTreePage<K: ?Sized, V: ?Sized>: Sized {
+ #[async_trait]
+ pub trait BTreePage<K: ?Sized, V: ?Sized>: Sized + Send {
replacement in sanakirja-core-async/src/btree/mod.rs at line 64
[8.157872]→[8.157872:157889](∅→∅) + async fn next<'b, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/mod.rs at line 69
[8.157979]→[8.157979:158034](∅→∅) − if let Some((k, v, r)) = Self::current(p, c) {
+ if let Some((k, v, r)) = Self::current(txn, p, c).await {
replacement in sanakirja-core-async/src/btree/mod.rs at line 79
[8.158274]→[8.158274:158291](∅→∅) + async fn prev<'b, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/mod.rs at line 85
[8.158413]→[8.158413:158445](∅→∅) + Self::current(txn, p, c).await
replacement in sanakirja-core-async/src/btree/mod.rs at line 102
[8.159035]→[8.159035:159055](∅→∅) + async fn current<'a, T: LoadPage>(
+ txn: &T,
replacement in sanakirja-core-async/src/btree/mod.rs at line 122
[8.159831]→[8.159831:159851](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 137
[8.160340]→[8.160340:160357](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 141
[8.160380]→[8.160380:160500](∅→∅) − impl<'a, T: LoadPage, K: ?Sized + 'a, V: ?Sized + 'a, P: BTreePage<K, V>> Iterator
− for PageIterator<'a, T, K, V, P>
+ impl<'a, T: LoadPage, K: ?Sized + 'a, V: ?Sized + 'a, P: BTreePage<K, V>>
+ PageIterator<'a, T, K, V, P>
replacement in sanakirja-core-async/src/btree/mod.rs at line 144
[8.160502]→[8.160502:160631](∅→∅) − type Item = (&'a K, &'a V, u64);
− fn next(&mut self) -> Option<Self::Item> {
− P::next(self.page, &mut self.cursor)
+ pub async fn next(&mut self) -> Option<(&'a K, &'a V, u64)> {
+ P::next(self.txn, self.page, &mut self.cursor).await
replacement in sanakirja-core-async/src/btree/mod.rs at line 149
[8.160640]→[8.160640:160662](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 185
[8.162041]→[8.162041:162064](∅→∅) + async unsafe fn put_mut<T: AllocPage>(
+ txn: &mut T,
replacement in sanakirja-core-async/src/btree/mod.rs at line 195
[8.162209]→[8.162209:162315](∅→∅),
[8.162315]→[8.162315:162316](∅→∅) − unsafe fn set_left_child(
− page: &mut MutPage,
− c: &Self::Cursor,
− l: u64
− );
−
+ unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64);
replacement in sanakirja-core-async/src/btree/mod.rs at line 244
[8.163851]→[8.163851:163913](∅→∅) − unsafe impl<K, V, P: BTreePage<K, V>> Sync for Db_<K, V, P>{}
+ unsafe impl<K, V, P: BTreePage<K, V>> Sync for Db_<K, V, P> {}
replacement in sanakirja-core-async/src/btree/mod.rs at line 249
[8.163996]→[8.163996:164018](∅→∅),
[8.164018]→[8.164018:164121](∅→∅) − #[async_trait(?Send)]
− impl<K:Storable, V:Storable, P: BTreePage<K, V> + Send + core::fmt::Debug> Storable for Db_<K, V, P> {
+ #[async_trait]
+ impl<K: Storable, V: Storable, P: BTreePage<K, V> + core::fmt::Debug> Storable for Db_<K, V, P> {
replacement in sanakirja-core-async/src/btree/mod.rs at line 256
[8.164267]→[8.164267:164343](∅→∅) − async fn drop<T: AllocPage>(&self, t: &mut T) -> Result<(), T::Error> {
+ async unsafe fn drop<T: AllocPage>(&self, t: &mut T) -> Result<(), T::Error> {
replacement in sanakirja-core-async/src/btree/mod.rs at line 277
[8.164856]→[8.164856:164941](∅→∅) − pub async fn create_db_<T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(
+ pub async unsafe fn create_db_<T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core-async/src/btree/mod.rs at line 291
[8.165277]→[8.165277:165341](∅→∅) − pub async fn create_db<T: AllocPage, K: Storable, V: Storable>(
+ pub async unsafe fn create_db<T: AllocPage, K: Storable, V: Storable>(
replacement in sanakirja-core-async/src/btree/mod.rs at line 298
[8.165461]→[8.165461:165564](∅→∅) − pub async fn fork_db<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(
+ pub async fn fork_db<
+ T: AllocPage,
+ K: Storable + ?Sized,
+ V: Storable + ?Sized,
+ P: BTreeMutPage<K, V>,
+ >(
replacement in sanakirja-core-async/src/btree/mod.rs at line 320
[8.166084]→[8.166084:166200](∅→∅) − pub async fn get_shared<'a, T: LoadPage, K: 'a + Storable + ?Sized, V: 'a + Storable + ?Sized, P: BTreePage<K, V>>(
+ pub async fn get_shared<
+ 'a,
+ T: LoadPage,
+ K: 'a + Storable + ?Sized,
+ V: 'a + Storable + ?Sized,
+ P: BTreePage<K, V>,
+ >(
edit in sanakirja-core-async/src/btree/mod.rs at line 332
[8.166323]→[8.166323:166324](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 335
[8.166474]→[8.166474:166522](∅→∅) − let mut page = txn.load_page(db.db).await?;
+ let mut page = unsafe { txn.load_page(db.db).await? };
replacement in sanakirja-core-async/src/btree/mod.rs at line 345
[8.166971]→[8.166971:167049](∅→∅) − } else if let Some((k, v, _)) = P::current(page.as_page(), &cursor) {
+ } else if let Some((k, v, _)) = P::current(txn, page.as_page(), &cursor).await {
replacement in sanakirja-core-async/src/btree/mod.rs at line 350
[8.167294]→[8.167294:167398](∅→∅) − unsafe { last_match = Some((core::mem::transmute(k), core::mem::transmute(v), is_shared)) }
+ unsafe {
+ last_match = Some((core::mem::transmute(k), core::mem::transmute(v), is_shared))
+ }
replacement in sanakirja-core-async/src/btree/mod.rs at line 359
[8.167666]→[8.167666:167718](∅→∅) − page = txn.load_page(next_page).await?;
+ page = unsafe { txn.load_page(next_page).await? };
edit in sanakirja-core-async/src/btree/mod.rs at line 367
[8.167843]→[8.167843:167844](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 372
[8.168100]→[8.168100:168209](∅→∅) − pub async fn get<'a, T: LoadPage, K: 'a + Storable + ?Sized, V: 'a + Storable + ?Sized, P: BTreePage<K, V>>(
+ pub async fn get<
+ 'a,
+ T: LoadPage,
+ K: 'a + Storable + ?Sized,
+ V: 'a + Storable + ?Sized,
+ P: BTreePage<K, V>,
+ >(
edit in sanakirja-core-async/src/btree/mod.rs at line 384
[8.168326]→[8.168326:168327](∅→∅) replacement in sanakirja-core-async/src/btree/mod.rs at line 391
[8.168673]→[8.168673:168721](∅→∅) − let mut page = txn.load_page(db.db).await?;
+ let mut page = unsafe { txn.load_page(db.db).await? };
replacement in sanakirja-core-async/src/btree/mod.rs at line 400
[8.169097]→[8.169097:169175](∅→∅) − } else if let Some((k, v, _)) = P::current(page.as_page(), &cursor) {
+ } else if let Some((k, v, _)) = P::current(txn, page.as_page(), &cursor).await {
replacement in sanakirja-core-async/src/btree/mod.rs at line 412
[8.169781]→[8.169781:169833](∅→∅) − page = txn.load_page(next_page).await?;
+ page = unsafe { txn.load_page(next_page).await? };
replacement in sanakirja-core-async/src/btree/mod.rs at line 422
[8.170025]→[8.170025:170122](∅→∅) − pub async fn drop<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
+ pub async unsafe fn drop<
+ T: AllocPage,
+ K: Storable + ?Sized,
+ V: Storable + ?Sized,
+ P: BTreePage<K, V>,
+ >(
replacement in sanakirja-core-async/src/btree/mod.rs at line 435
[8.170246]→[8.170246:170348](∅→∅) − struct PageCursor_<K:?Sized, V:?Sized, P: BTreePage<K, V>>(MaybeUninit<cursor::PageCursor<K, V, P>>);
+ struct PageCursor_<K: ?Sized, V: ?Sized, P: BTreePage<K, V>>(
+ MaybeUninit<cursor::PageCursor<K, V, P>>,
+ );
replacement in sanakirja-core-async/src/btree/mod.rs at line 439
[8.170349]→[8.170349:170435](∅→∅) − unsafe impl<K: ?Sized, V:?Sized, P: BTreePage<K, V>> Send for PageCursor_<K, V, P> {}
+ unsafe impl<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> Send for PageCursor_<K, V, P> {}
replacement in sanakirja-core-async/src/btree/mod.rs at line 441
[8.170436]→[8.170436:170437](∅→∅),
[8.170437]→[8.170437:170531](∅→∅) −
− async fn drop_<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
+ async unsafe fn drop_<
+ T: AllocPage,
+ K: Storable + ?Sized,
+ V: Storable + ?Sized,
+ P: BTreePage<K, V>,
+ >(
replacement in sanakirja-core-async/src/btree/mod.rs at line 505
[8.172894]→[8.172894:173024](∅→∅) − let cur = unsafe { &mut *stack[ptr].0.as_mut_ptr() };
− P::current(cur.page.as_page(), &cur.cursor)
+ let (page, cursor) = unsafe {
+ let cur = &mut *stack[ptr].0.as_mut_ptr();
+ (cur.page.as_page(), &cur.cursor)
+ };
+ P::current(txn, page, cursor).await
replacement in sanakirja-core-async/src/btree/mod.rs at line 518
[8.173340]→[8.173340:173534](∅→∅) − let cur = unsafe { &mut *stack[ptr].0.as_mut_ptr() };
− if P::move_next(&mut cur.cursor) {
− Some(P::left_child(cur.page.as_page(), &cur.cursor))
+ let (page, cursor) = unsafe {
+ let cur = &mut *stack[ptr].0.as_mut_ptr();
+ (cur.page.as_page(), &mut cur.cursor)
+ };
+ if P::move_next(cursor) {
+ Some(P::left_child(page, cursor))
edit in sanakirja-core-async/src/btree/del.rs at line 6
+ use core::cmp::Ordering;
replacement in sanakirja-core-async/src/btree/del.rs at line 83
[8.177587]→[8.177587:177677](∅→∅) − K: Storable + ?Sized + PartialEq + Sync,
− V: Storable + ?Sized + PartialEq + Sync,
+ K: Storable + ?Sized + Sync,
+ V: Storable + ?Sized + Sync,
replacement in sanakirja-core-async/src/btree/del.rs at line 92
[8.177817]→[8.177817:177867](∅→∅) − let mut cursor = Cursor::new(txn, db).await?;
+ let mut cursor = unsafe { Cursor::new(txn, db).await? };
replacement in sanakirja-core-async/src/btree/del.rs at line 95
[8.177974]→[8.177974:178089](∅→∅) − (Some((k, v)), Some(value)) if k == key && v == value => {}
− (Some((k, _)), None) if k == key => {}
+ (Some((k, v)), Some(value))
+ if k.compare(txn, key).await == Ordering::Equal
+ && v.compare(txn, value).await == Ordering::Equal => {}
+ (Some((k, _)), None) if k.compare(txn, key).await == Ordering::Equal => {}
edit in sanakirja-core-async/src/btree/del.rs at line 108
[8.178395]→[8.178395:178396](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 114
[8.178605]→[8.178605:178695](∅→∅) − K: Storable + ?Sized + PartialEq + Sync,
− V: Storable + ?Sized + PartialEq + Sync,
+ K: Storable + ?Sized + Sync,
+ V: Storable + ?Sized + Sync,
replacement in sanakirja-core-async/src/btree/del.rs at line 123
[8.178835]→[8.178835:178885](∅→∅) − let mut cursor = Cursor::new(txn, db).await?;
+ let mut cursor = unsafe { Cursor::new(txn, db).await? };
replacement in sanakirja-core-async/src/btree/del.rs at line 126
[8.178992]→[8.178992:179107](∅→∅) − (Some((k, v)), Some(value)) if k == key && v == value => {}
− (Some((k, _)), None) if k == key => {}
+ (Some((k, v)), Some(value))
+ if k.compare(txn, key).await == Ordering::Equal
+ && v.compare(txn, value).await == Ordering::Equal => {}
+ (Some((k, _)), None) if k.compare(txn, key).await == Ordering::Equal => {}
replacement in sanakirja-core-async/src/btree/del.rs at line 145
[8.179573]→[8.179573:179618](∅→∅) − K: Storable + ?Sized + PartialEq + Sync,
+ K: Storable + ?Sized + Sync,
replacement in sanakirja-core-async/src/btree/del.rs at line 171
[8.180570]→[8.180570:180635](∅→∅) − P::current(cur.page.as_page(), &cur.cursor).unwrap()
+ P::current(txn, cur.page.as_page(), &cur.cursor)
+ .await
+ .unwrap()
replacement in sanakirja-core-async/src/btree/del.rs at line 175
[8.180646]→[8.180646:180708](∅→∅) − delk.drop(txn).await?;
− delv.drop(txn).await?;
+ unsafe {
+ delk.drop(txn).await?;
+ delv.drop(txn).await?;
+ }
edit in sanakirja-core-async/src/btree/del.rs at line 180
[8.180714]→[8.180714:180715](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 184
[8.180930]→[8.180930:180984](∅→∅) − cursor.set_first_leaf(txn, right_subtree).await?;
+ unsafe { cursor.set_first_leaf(txn, right_subtree).await? };
replacement in sanakirja-core-async/src/btree/del.rs at line 236
[8.183072]→[8.183072:183179](∅→∅) − last_op = handle_merge(txn, cursor, p0, &k0v0, incr_page, incr_mid, mil, merge, &mut free).await?;
+ last_op = handle_merge(
+ txn, cursor, p0, &k0v0, incr_page, incr_mid, mil, merge, &mut free,
+ )
+ .await?;
edit in sanakirja-core-async/src/btree/del.rs at line 250
[8.183617]→[8.183617:183618](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 257
[8.183960]→[8.183960:184129](∅→∅),
[8.184129]→[8.184129:184139](∅→∅),
[8.184139]→[8.184139:184281](∅→∅) − for p in free.iter() {
− if p[0] & 1 == 1 {
− txn.decr_rc_owned(p[0] ^ 1).await?;
− } else if p[0] > 0 {
− txn.decr_rc(p[0]).await?;
− }
− if p[1] & 1 == 1 {
− txn.decr_rc_owned(p[1] ^ 1).await?;
− } else if p[1] > 0 {
− txn.decr_rc(p[1]).await?;
+ unsafe {
+ for p in free.iter() {
+ if p[0] & 1 == 1 {
+ txn.decr_rc_owned(p[0] ^ 1).await?;
+ } else if p[0] > 0 {
+ txn.decr_rc(p[0]).await?;
+ }
+ if p[1] & 1 == 1 {
+ txn.decr_rc_owned(p[1] ^ 1).await?;
+ } else if p[1] > 0 {
+ txn.decr_rc(p[1]).await?;
+ }
replacement in sanakirja-core-async/src/btree/del.rs at line 295
[8.185093]→[8.185093:185165](∅→∅) − let (k, v, _) = P::current(curs0.page.as_page(), &c1).unwrap();
+ let (k, v, _) = P::current(txn, curs0.page.as_page(), &c1).await.unwrap();
replacement in sanakirja-core-async/src/btree/del.rs at line 353
[8.187008]→[8.187008:187100](∅→∅) − let other = txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor)).await?;
+ let other = unsafe {
+ txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))
+ .await?
+ };
replacement in sanakirja-core-async/src/btree/del.rs at line 382
[8.188251]→[8.188251:188328](∅→∅) − if let Some(x) = P::current(curs.page.as_page(), &curs.cursor) {
+ if let Some(x) = P::current(txn, curs.page.as_page(), &curs.cursor).await {
replacement in sanakirja-core-async/src/btree/del.rs at line 387
[8.188473]→[8.188473:188562](∅→∅) − let (k, v, _) = P::prev(curs.page.as_page(), &mut curs.cursor).unwrap();
+ let (k, v, _) = P::prev(txn, curs.page.as_page(), &mut curs.cursor)
+ .await
+ .unwrap();
replacement in sanakirja-core-async/src/btree/del.rs at line 393
[8.188686]→[8.188686:188731](∅→∅) − let other = txn.load_page(r).await?;
+ let other = unsafe { txn.load_page(r).await? };
replacement in sanakirja-core-async/src/btree/del.rs at line 420
[8.189680]→[8.189680:189718](∅→∅) − K: Storable + ?Sized + PartialEq,
replacement in sanakirja-core-async/src/btree/del.rs at line 431
[8.189935]→[8.189935:190014](∅→∅) − mod_is_left: bool, // The modified page in the `merge` is the left one.
+ mod_is_left: bool, // The modified page in the `merge` is the left one.
replacement in sanakirja-core-async/src/btree/del.rs at line 459
[8.190797]→[8.190797:190851](∅→∅) − Op::Merged {.. } | Op::Rebalanced { .. } => {
+ Op::Merged { .. } | Op::Rebalanced { .. } => {
replacement in sanakirja-core-async/src/btree/del.rs at line 470
[8.191380]→[8.191380:191464](∅→∅) − while let Some((k0, v0, r)) = P::next(other.as_page(), &mut curs) {
+ while let Some((k0, v0, r)) = P::next(txn, other.as_page(), &mut curs).await {
replacement in sanakirja-core-async/src/btree/del.rs at line 507
[8.192640]→[8.192640:192759](∅→∅) − Op::Rebalanced {
− k,
− v,
− l,
− r,
− freed,
− } => {
+ Op::Rebalanced { k, v, l, r, freed } => {
replacement in sanakirja-core-async/src/btree/del.rs at line 625
[8.197583]→[8.197583:197595](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 637
[8.197902]→[8.197902:197971](∅→∅) − while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c0) {
+ while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c0).await {
replacement in sanakirja-core-async/src/btree/del.rs at line 662
[8.198691]→[8.198691:198757](∅→∅) − if let Some((k, v, r)) = P::next(m.page.as_page(), &mut c1) {
+ if let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1).await {
replacement in sanakirja-core-async/src/btree/del.rs at line 676
[8.199310]→[8.199310:199379](∅→∅) − while let Some((k, v, r)) = P::next(m.page.as_page(), &mut c1) {
+ while let Some((k, v, r)) = P::next(txn, m.page.as_page(), &mut c1).await {
replacement in sanakirja-core-async/src/btree/del.rs at line 688
[8.199597]→[8.199597:199609](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 707
[8.200228]→[8.200228:200351](∅→∅) − if d > 0 {
− if last_op.page.is_dirty() {
− txn.decr_rc_owned(last_op.page.offset).await?;
+ unsafe {
+ if d > 0 {
+ if last_op.page.is_dirty() {
+ txn.decr_rc_owned(last_op.page.offset).await?;
+ } else {
+ txn.decr_rc(last_op.page.offset).await?;
+ }
+ db.db = d;
replacement in sanakirja-core-async/src/btree/del.rs at line 716
[8.200372]→[8.200372:200429](∅→∅) − txn.decr_rc(last_op.page.offset).await?;
+ // The page becomes empty.
+ let (page, freed) =
+ P::del(txn, last_op.page, last_op.mutable, &last_op.c1, d).await?;
+ free[0][0] = freed;
+ db.db = page.0.offset
edit in sanakirja-core-async/src/btree/del.rs at line 722
[8.200443]→[8.200443:200687](∅→∅) − db.db = d;
− } else {
− // The page becomes empty.
− let (page, freed) = P::del(txn, last_op.page, last_op.mutable, &last_op.c1, d).await?;
− free[0][0] = freed;
− db.db = page.0.offset
replacement in sanakirja-core-async/src/btree/del.rs at line 747
[8.201614]→[8.201614:201666](∅→∅) − let mut page = txn.alloc_page().await?;
+ let mut page = unsafe { txn.alloc_page().await? };
replacement in sanakirja-core-async/src/btree/del.rs at line 751
[8.201783]→[8.201783:201980](∅→∅) − let page = if let Put::Ok(p) = P::put(txn, page.0, true, false, &c, k, v, None, l, r).await? {
− p.page
− } else {
− unreachable!()
− };
+ let page =
+ if let Put::Ok(p) = P::put(txn, page.0, true, false, &c, k, v, None, l, r).await? {
+ p.page
+ } else {
+ unreachable!()
+ };
replacement in sanakirja-core-async/src/btree/del.rs at line 800
[8.203426]→[8.203426:203528](∅→∅) − async fn modify<'a, T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(
+ async fn modify<
+ 'a,
+ T: AllocPage,
+ K: Storable + ?Sized,
+ V: Storable + ?Sized,
+ P: BTreeMutPage<K, V>,
+ >(
replacement in sanakirja-core-async/src/btree/del.rs at line 837
[8.204595]→[8.204595:204611](∅→∅) replacement in sanakirja-core-async/src/btree/del.rs at line 848
[8.205010]→[8.205010:205130](∅→∅) − Ok(Put::Ok(P::update_left_child(
− txn, m.page, m.mutable, &m.c1, m.l,
− ).await?))
+ Ok(Put::Ok(
+ P::update_left_child(txn, m.page, m.mutable, &m.c1, m.l).await?,
+ ))
replacement in sanakirja-core-async/src/btree/del.rs at line 858
[8.205448]→[8.205448:205566](∅→∅) − Ok(Put::Ok(P::update_left_child(
− txn, m.page, m.mutable, &c1, m.r,
− ).await?))
+ Ok(Put::Ok(
+ P::update_left_child(txn, m.page, m.mutable, &c1, m.r).await?,
+ ))
replacement in sanakirja-core-async/src/btree/cursor.rs at line 10
[8.205837]→[8.205837:205975](∅→∅) − unsafe impl<K, V, P: BTreePage<K, V>> Send for PageCursor<K, V, P>{}
− unsafe impl<K, V, P: BTreePage<K, V>> Sync for PageCursor<K, V, P>{}
+ unsafe impl<K, V, P: BTreePage<K, V>> Send for PageCursor<K, V, P> {}
+ unsafe impl<K, V, P: BTreePage<K, V>> Sync for PageCursor<K, V, P> {}
replacement in sanakirja-core-async/src/btree/cursor.rs at line 38
[8.207097]→[8.207097:207227](∅→∅) − unsafe impl<K, V, P: BTreePage<K, V>> Send for Cursor<K, V, P>{}
− unsafe impl<K, V, P: BTreePage<K, V>> Sync for Cursor<K, V, P>{}
+ struct StackElt<K: ?Sized, V: ?Sized, P: BTreePage<K, V>>(*mut PageCursor<K, V, P>);
+ unsafe impl<K, V, P: BTreePage<K, V>> Send for StackElt<K, V, P> {}
+ unsafe impl<K, V, P: BTreePage<K, V>> Sync for StackElt<K, V, P> {}
+
+ unsafe impl<K, V, P: BTreePage<K, V>> Send for Cursor<K, V, P> {}
+ unsafe impl<K, V, P: BTreePage<K, V>> Sync for Cursor<K, V, P> {}
+
+ impl<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> StackElt<K, V, P> {
+ unsafe fn page<'a>(&self) -> Page<'a> {
+ (&*self.0).page.as_page()
+ }
+ unsafe fn cursor<'a>(&self) -> &'a P::Cursor {
+ &(&*self.0).cursor
+ }
+ }
replacement in sanakirja-core-async/src/btree/cursor.rs at line 56
[8.207404]→[8.207404:207494](∅→∅) − pub async fn new<T: LoadPage>(txn: &T, db: &Db_<K, V, P>) -> Result<Self, T::Error> {
+ pub async unsafe fn new<T: LoadPage>(txn: &T, db: &Db_<K, V, P>) -> Result<Self, T::Error> {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 58
[8.207567]→[8.207567:207593](∅→∅) + let mut stack: [core::mem::MaybeUninit<PageCursor<K, V, P>>; N_CURSORS] = [
edit in sanakirja-core-async/src/btree/cursor.rs at line 103
+ }
+
+ unsafe fn stack_elt(&mut self, i: usize) -> StackElt<K, V, P> {
+ StackElt(self.stack[i].assume_init_mut())
replacement in sanakirja-core-async/src/btree/cursor.rs at line 144
[8.210415]→[8.210415:210468](∅→∅) − pub(super) async fn set_first_leaf<T: LoadPage>(
+ pub(super) async unsafe fn set_first_leaf<T: LoadPage>(
replacement in sanakirja-core-async/src/btree/cursor.rs at line 188
[8.212043]→[8.212043:212107](∅→∅) − let init = unsafe { &mut *self.stack[0].as_mut_ptr() };
+ let init = unsafe { self.stack[0].assume_init_mut() };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 194
[8.212280]→[8.212280:212380](∅→∅) − let current = unsafe { &mut *self.stack.get_unchecked_mut(self.len - 1).as_mut_ptr() };
+ let current = unsafe { self.stack.get_unchecked_mut(self.len - 1).assume_init_mut() };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 199
[8.212579]→[8.212579:212681](∅→∅) − if let Ok((kk, vv, _)) = P::set_cursor(txn, current.page.as_page(), cursor, k, v).await {
+ if let Ok((kk, vv, _)) = P::set_cursor(txn, current.page.as_page(), cursor, k, v).await
+ {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 209
[8.212990]→[8.212990:213089](∅→∅) − let page = txn.load_page(next_page).await?;
− self.push(PageCursor {
+ let page = unsafe { txn.load_page(next_page).await? };
+
+ // Pushing
+ self.stack[self.len] = MaybeUninit::new(PageCursor {
edit in sanakirja-core-async/src/btree/cursor.rs at line 215
+ });
+ self.len += 1;
+ /*
+ self.push(PageCursor {
+ cursor: P::cursor_before(&page),
+ page,
edit in sanakirja-core-async/src/btree/cursor.rs at line 222
replacement in sanakirja-core-async/src/btree/cursor.rs at line 237
[8.213564]→[8.213564:213676](∅→∅) − pub async fn set_last< T: LoadPage>(
− &mut self,
− txn: &'a T,
− ) -> Result<(), T::Error> {
+ pub async fn set_last<T: LoadPage>(&mut self, txn: &'a T) -> Result<(), T::Error> {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 240
[8.213737]→[8.213737:213815](∅→∅) − let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
+ let current = unsafe { self.stack[self.len - 1].assume_init_mut() };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 243
[8.213887]→[8.213887:213969](∅→∅) − let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
+ let current = unsafe { self.stack[self.len - 1].assume_init_mut() };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 249
[8.214218]→[8.214218:214270](∅→∅) − let page = txn.load_page(l).await?;
+ let page = unsafe { txn.load_page(l).await? };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 262
[8.214547]→[8.214547:214580](∅→∅) − pub fn current<T: LoadPage>(
+ pub async fn current<T: LoadPage>(
replacement in sanakirja-core-async/src/btree/cursor.rs at line 264
[8.214599]→[8.214599:214620](∅→∅) replacement in sanakirja-core-async/src/btree/cursor.rs at line 267
[8.214687]→[8.214687:214814](∅→∅) − let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
− if P::is_init(¤t.cursor) {
+ let current = unsafe { self.stack_elt(self.len - 1) };
+ if P::is_init(unsafe { current.cursor() }) {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 270
[8.214861]→[8.214861:214989](∅→∅) − return Ok(None)
− } else if let Some((k, v, _)) = P::current(current.page.as_page(), ¤t.cursor)
+ return Ok(None);
+ } else if let Some((k, v, _)) =
+ unsafe { P::current(txn, current.page(), ¤t.cursor()).await }
replacement in sanakirja-core-async/src/btree/cursor.rs at line 288
[8.215448]→[8.215448:215485](∅→∅) − pub async fn next< T: LoadPage>(
+ pub async fn next<T: LoadPage>(
replacement in sanakirja-core-async/src/btree/cursor.rs at line 293
[8.215591]→[8.215591:215719](∅→∅) − let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
− if P::is_empty(¤t.cursor) {
+ let current = unsafe { self.stack_elt(self.len - 1) };
+ if P::is_empty(unsafe { current.cursor() }) {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 304
[8.216019]→[8.216019:216135](∅→∅),
[8.216135]→[8.216135:216198](∅→∅),
[8.216198]→[8.216198:216282](∅→∅) − let (cur_entry, r) = if let Some((k, v, r)) = P::current(current.page.as_page(), ¤t.cursor) {
− (Some((k, v)), r)
− } else {
− (None, P::right_child(current.page.as_page(), ¤t.cursor))
+ let (cur_entry, r) = {
+ let cur_page = unsafe { current.page() };
+ let cur_cursor = unsafe { current.cursor() };
+ if let Some((k, v, r)) = P::current(txn, cur_page, cur_cursor).await {
+ (Some((k, v)), r)
+ } else {
+ (None, P::right_child(cur_page, cur_cursor))
+ }
replacement in sanakirja-core-async/src/btree/cursor.rs at line 313
[8.216301]→[8.216301:216352](∅→∅) − P::move_next(&mut current.cursor);
+ unsafe {
+ P::move_next(&mut (&mut *current.0).cursor);
+ }
replacement in sanakirja-core-async/src/btree/cursor.rs at line 317
[8.216380]→[8.216380:216479](∅→∅) − let page = txn.load_page(r).await?;
− self.push(PageCursor {
+ let page = unsafe { txn.load_page(r).await? };
+ // Pushing
+ self.stack[self.len] = MaybeUninit::new(PageCursor {
edit in sanakirja-core-async/src/btree/cursor.rs at line 323
replacement in sanakirja-core-async/src/btree/cursor.rs at line 340
[8.217208]→[8.217208:217245](∅→∅) − pub async fn prev< T: LoadPage>(
+ pub async fn prev<T: LoadPage>(
replacement in sanakirja-core-async/src/btree/cursor.rs at line 345
[8.217351]→[8.217351:217433](∅→∅) − let current = unsafe { &mut *self.stack[self.len - 1].as_mut_ptr() };
+ let current = unsafe { self.stack_elt(self.len - 1) };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 347
[8.217434]→[8.217434:217479](∅→∅) − if P::is_init(¤t.cursor) {
+ if P::is_init(unsafe { current.cursor() }) {
replacement in sanakirja-core-async/src/btree/cursor.rs at line 359
[8.217925]→[8.217925:218093](∅→∅) − let cur_entry = P::current(current.page.as_page(), ¤t.cursor);
− let left = P::left_child(current.page.as_page(), ¤t.cursor);
+ let cur_entry = unsafe { P::current(txn, current.page(), current.cursor()).await };
+ let left = unsafe { P::left_child(current.page(), current.cursor()) };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 362
[8.218124]→[8.218124:218183](∅→∅) − let page = txn.load_page(left).await?;
+ let page = unsafe { txn.load_page(left).await? };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 372
[8.218561]→[8.218561:218616](∅→∅) − P::move_prev(&mut current.cursor);
+ unsafe { P::move_prev(&mut (&mut *current.0).cursor) };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 400
[8.219293]→[8.219293:219343](∅→∅) − let mut cursor = Cursor::new(txn, db).await?;
+ let mut cursor = unsafe { Cursor::new(txn, db).await? };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 415
[8.219625]→[8.219625:219744](∅→∅) − pub async fn next(&mut self) -> Result<Option<(&'a K, &'a V)>, T::Error>{
− self.cursor.prev(self.txn).await
+ pub async fn next(&mut self) -> Result<Option<(&'a K, &'a V)>, T::Error> {
+ self.cursor.next(self.txn).await
edit in sanakirja-core-async/src/btree/cursor.rs at line 419
[8.219752]→[8.219752:219753](∅→∅) replacement in sanakirja-core-async/src/btree/cursor.rs at line 437
[8.220175]→[8.220175:220225](∅→∅) − let mut cursor = Cursor::new(txn, db).await?;
+ let mut cursor = unsafe { Cursor::new(txn, db).await? };
replacement in sanakirja-core-async/src/btree/cursor.rs at line 454
[8.220563]→[8.220563:220641](∅→∅) − pub async fn next(&mut self) -> Result<Option<(&'a K, &'a V)>, T::Error>{
+ pub async fn next(&mut self) -> Result<Option<(&'a K, &'a V)>, T::Error> {
replacement in sanakirja-core-async/Cargo.toml at line 3
[8.220767]→[8.220767:220785](∅→∅) replacement in sanakirja-core-async/Cargo.toml at line 41
[8.221811]→[8.221811:221855](∅→∅) − uuid = { version = "0.8", optional = true }
+ uuid = { version = "1.3.3", optional = true }
replacement in sanakirja-core-async/Cargo.toml at line 43
[8.221908]→[8.221908:221928](∅→∅) edit in sanakirja-core/src/lib.rs at line 48
+ ///
+ /// The size limit for an entry depends on the datastructure. For B
+ /// trees, nodes are guaranteed to be at least half-full (i.e. at
+ /// least 2kiB), and we need at least two entries in each page in
+ /// order to be able to rebalance in a deletion. A sufficient
+ /// condition for this is that the size of any entry is less than
+ /// 1/4th of the blocks. Now, internal nodes need 16 bytes of block
+ /// header, and then 8 extra bytes for each entry. Entries must
+ /// therefore not exceed 4080/4 - 8 = 1012 bytes.
+
replacement in sanakirja-core/src/lib.rs at line 71
− fn drop<T: AllocPage>(&self, txn: &mut T) -> Result<(), T::Error> {
+ ///
+ /// # Safety
+ ///
+ /// The caller must not keep any reference to the deleted value.
+ unsafe fn drop<T: AllocPage>(&self, txn: &mut T) -> Result<(), T::Error> {
edit in sanakirja-core/src/lib.rs at line 87
+ }
+
+ /// A trait to serialize the identity of complex types and check the
+ /// validity of database schemas.
+ #[cfg(feature = "typeids")]
+ pub trait TypeId {
+ fn type_id() -> [u8; 32];
edit in sanakirja-core/src/lib.rs at line 96
+ #[cfg(feature = "typeids")]
+ pub use sha2;
+ #[cfg(feature = "typeids")]
+ use sha2::Digest;
+
+ #[cfg(feature = "typeids")]
+ impl TypeId for () {
+ fn type_id() -> [u8; 32] {
+ [0; 32]
+ }
+ }
+
replacement in sanakirja-core/src/lib.rs at line 137
[8.758]→[8.758:897](∅→∅),
[8.897]→[5.0:82](∅→∅) − /// Write to a page. Must not overwrite the allocated size, but
− /// this isn't checked (which is why it's unsafe).
− unsafe fn write_to_page<T: AllocPage>(&self, _: &mut T, p: *mut u8) {
+ unsafe fn write_to_page(&self, p: *mut u8) {
replacement in sanakirja-core/src/lib.rs at line 192
− unsafe fn write_to_page<T: AllocPage>(&self, t: &mut T, p: *mut u8);
+ unsafe fn write_to_page(&self, _: *mut u8) {
+ unimplemented!()
+ }
+
+ /// Write to a page. Must not overwrite the allocated size, but
+ /// this isn't checked (which is why it's unsafe).
+ ///
+ /// This is similar to `write_to_page`, but allows the user to
+ /// allocate a value as needed when inserting the value into the
+ /// base; do not implement both methods, since only
+ /// `write_to_page_alloc` gets called by the library.
+ ///
+ /// The default implementation just calls `write_to_page`.
+ unsafe fn write_to_page_alloc<T: AllocPage>(&self, _: &mut T, p: *mut u8) {
+ self.write_to_page(p)
+ }
edit in sanakirja-core/src/lib.rs at line 265
+ }
+ }
+
+ #[cfg(feature = "typeids")]
+ impl<'a> TypeId for Slice<'a> {
+ fn type_id() -> [u8; 32] {
+ let mut h = sha2::Sha256::new();
+ h.update(b"sanakirja-core::Slice");
+ h.finalize().into()
replacement in sanakirja-core/src/lib.rs at line 284
[6.1620]→[6.1620:1740](∅→∅) − let len_up = ((plen + PAGE_SIZE as u64 - 1) / PAGE_SIZE as u64)
− * PAGE_SIZE as u64;
+ let len_up = ((plen + PAGE_SIZE as u64 - 1) / PAGE_SIZE as u64) * PAGE_SIZE as u64;
replacement in sanakirja-core/src/lib.rs at line 357
[6.3635]→[6.3635:3709](∅→∅) − unsafe fn write_to_page<T: AllocPage>(&self, t: &mut T, p: *mut u8) {
+ unsafe fn write_to_page_alloc<T: AllocPage>(&self, t: &mut T, p: *mut u8) {
replacement in sanakirja-core/src/lib.rs at line 365
[6.3988]→[6.3988:4299](∅→∅) − let page = if len > 4096 {
− t.alloc_contiguous(
− (((len + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE)
− as u64
− ).unwrap()
− } else {
− t.alloc_page().unwrap()
− };
+ let page = t
+ .alloc_contiguous((((len + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE) as u64)
+ .unwrap();
+ assert!(page.0.offset > 0);
replacement in sanakirja-core/src/lib.rs at line 379
[6.4781]→[6.4781:4887](∅→∅) − core::ptr::copy(&self.len as *const u16 as *const u8, p, 2 + u16::from_le(self.len) as usize)
+ core::ptr::copy(
+ &self.len as *const u16 as *const u8,
+ p,
+ 2 + u16::from_le(self.len) as usize,
+ )
replacement in sanakirja-core/src/lib.rs at line 413
[8.1127]→[5.157:221](∅→∅) − unsafe fn write_to_page<T>(&self, _t: &mut T, p: *mut u8) {
+ unsafe fn write_to_page_alloc<T: AllocPage>(&self, _txn: &mut T, p: *mut u8) {
replacement in sanakirja-core/src/lib.rs at line 479
[8.47]→[8.47:276](∅→∅),
[8.276]→[8.0:192](∅→∅),
[8.192]→[5.222:311](∅→∅),
[5.311]→[8.116:126](∅→∅),
[8.485]→[8.116:126](∅→∅),
[8.116]→[8.116:126](∅→∅),
[8.126]→[8.486:512](∅→∅) − pub fn crc(&self, hasher: &crc32fast::Hasher) -> u32 {
− let mut hasher = hasher.clone();
− hasher.reset();
− // Hash the beginning and the end of the page (i.e. remove
− // the CRC).
− unsafe {
− // Remove the dirty bit.
− let x = [(*self.data) & 0xfe];
− hasher.update(&x[..]);
− hasher.update(core::slice::from_raw_parts(self.data.add(1), 3));
− hasher.update(core::slice::from_raw_parts(self.data.add(8), PAGE_SIZE - 8));
− }
− hasher.finalize()
+ pub unsafe fn crc(&self, hasher: &crc32fast::Hasher) -> u32 {
+ crc(self.data, hasher)
replacement in sanakirja-core/src/lib.rs at line 484
[8.549]→[8.549:615](∅→∅),
[8.615]→[8.193:271](∅→∅),
[8.271]→[8.686:718](∅→∅),
[8.686]→[8.686:718](∅→∅) − pub fn crc_check(&self, hasher: &crc32fast::Hasher) -> bool {
− let crc = unsafe { u32::from_le(*(self.data as *const u32).add(1)) };
− self.crc(hasher) == crc
+ pub unsafe fn crc_check(&self, hasher: &crc32fast::Hasher) -> bool {
+ crc_check(self.data, hasher)
replacement in sanakirja-core/src/lib.rs at line 496
[8.754]→[8.2570:2606](∅→∅),
[8.2570]→[8.2570:2606](∅→∅),
[8.2606]→[8.363:403](∅→∅) − pub fn clear_dirty(&mut self) {
− unsafe { *self.0.data &= 0xfe }
+ pub unsafe fn clear_dirty(&mut self) {
+ *self.0.data &= 0xfe
replacement in sanakirja-core/src/lib.rs at line 501
[8.792]→[8.792:907](∅→∅),
[8.907]→[8.215:271](∅→∅),
[8.271]→[8.966:1014](∅→∅),
[8.966]→[8.966:1014](∅→∅) − pub fn clear_dirty(&mut self, hasher: &crc32fast::Hasher) {
− unsafe {
− *self.0.data &= 0xfe;
− let crc = (self.0.data as *mut u32).add(1);
− *crc = self.0.crc(hasher)
− }
+ pub unsafe fn clear_dirty(&mut self, hasher: &crc32fast::Hasher) {
+ *self.0.data &= 0xfe;
+ let crc_ = (self.0.data as *mut u32).add(1);
+ *crc_ = crc(self.0.data, hasher)
+ }
+ }
+
+ #[cfg(feature = "crc32")]
+ pub unsafe fn crc(data: *mut u8, hasher: &crc32fast::Hasher) -> u32 {
+ let mut hasher = hasher.clone();
+ hasher.reset();
+ // Hash the beginning and the end of the page (i.e. remove
+ // the CRC).
+ unsafe {
+ // Remove the dirty bit.
+ let x = [(*data) & 0xfe];
+ hasher.update(&x[..]);
+ hasher.update(core::slice::from_raw_parts(data.add(1), 3));
+ hasher.update(core::slice::from_raw_parts(data.add(8), PAGE_SIZE - 8));
+ }
+ hasher.finalize()
+ }
+
+ #[cfg(feature = "crc32")]
+ pub unsafe fn crc_check(data: *mut u8, hasher: &crc32fast::Hasher) -> bool {
+ let crc_ = unsafe { u32::from_le(*(data as *const u32).add(1)) };
+ crc(data, hasher) == crc_
+ }
+
+ #[cfg(not(feature = "crc32"))]
+ pub fn clear_dirty(p: *mut u8) {
+ unsafe { *p &= 0xfe }
+ }
+
+ #[cfg(feature = "crc32")]
+ pub fn clear_dirty(p: *mut u8, hasher: &crc32fast::Hasher) {
+ unsafe {
+ *p &= 0xfe;
+ let crc_ = (p as *mut u32).add(1);
+ *crc_ = crc(p, hasher)
replacement in sanakirja-core/src/lib.rs at line 558
[8.2897]→[8.556:623](∅→∅) − fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>;
+ unsafe fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>;
+
+ /// Loading multiple pages written contiguously in the underlying
+ /// storage media.
+ ///
+ /// If the type also implements `AllocPage`, attention must be
+ /// paid to the compatibility with `alloc_contiguous`.
+ unsafe fn load_page_contiguous(&self, _off: u64, _len: u64) -> Result<CowPage, Self::Error> {
+ unimplemented!()
+ }
replacement in sanakirja-core/src/lib.rs at line 587
[8.2798]→[8.3167:3229](∅→∅),
[8.3167]→[8.3167:3229](∅→∅),
[8.3229]→[6.4907:4968](∅→∅),
[6.4968]→[6.4968:5049](∅→∅) − fn alloc_page(&mut self) -> Result<MutPage, Self::Error>;
− /// Allocate many contiguous pages, return the first one
− fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Self::Error>;
+ unsafe fn alloc_page(&mut self) -> Result<MutPage, Self::Error>;
+ /// Allocate a new page, in a context where we cannot use the
+ /// "dirty bit" trick directly on the page.
+ unsafe fn alloc_page_no_dirty(&mut self) -> Result<MutPage, Self::Error> {
+ unimplemented!()
+ }
+ /// Allocate many contiguous pages, return the first one. The
+ /// dirty bit is not needed.
+ unsafe fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Self::Error>;
replacement in sanakirja-core/src/lib.rs at line 601
[8.3043]→[8.134:201](∅→∅),
[8.134]→[8.134:201](∅→∅) − fn decr_rc(&mut self, off: u64) -> Result<usize, Self::Error>;
+ unsafe fn decr_rc(&mut self, off: u64) -> Result<usize, Self::Error>;
replacement in sanakirja-core/src/lib.rs at line 606
[8.3274]→[8.241:314](∅→∅),
[8.241]→[8.241:314](∅→∅) − fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Self::Error>;
+ unsafe fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Self::Error>;
replacement in sanakirja-core/src/btree/put.rs at line 30
[8.146]→[8.330:360](∅→∅),
[8.360]→[8.2:54](∅→∅),
[8.54]→[8.460:490](∅→∅),
[8.2168]→[8.460:490](∅→∅),
[8.460]→[8.460:490](∅→∅) − pub fn put<
− T: AllocPage,
− K: Storable + ?Sized,
− V: Storable + ?Sized,
− P: BTreeMutPage<K, V>,
− >(
+ pub fn put<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core/src/btree/put.rs at line 55
[8.2172]→[8.4485:4538](∅→∅),
[8.4485]→[8.4485:4538](∅→∅),
[8.4538]→[8.2173:2191](∅→∅),
[8.2191]→[8.0:15](∅→∅),
[8.50]→[8.0:15](∅→∅),
[8.15]→[8.45:66](∅→∅),
[8.50]→[8.45:66](∅→∅),
[8.66]→[8.4625:4653](∅→∅),
[8.4625]→[8.4625:4653](∅→∅),
[8.4653]→[8.167:181](∅→∅),
[8.181]→[8.4653:4683](∅→∅),
[8.4653]→[8.4653:4683](∅→∅) − let put = P::put(
− txn,
− cur.page,
− is_owned,
− false,
− &cur.cursor,
− key,
− value,
− None,
− 0,
− 0,
− )?;
+ let put = unsafe {
+ P::put(
+ txn,
+ cur.page,
+ is_owned,
+ false,
+ &cur.cursor,
+ key,
+ value,
+ None,
+ 0,
+ 0,
+ )?
+ };
replacement in sanakirja-core/src/btree/put.rs at line 85
[8.1240]→[8.67:136](∅→∅),
[8.4718]→[8.67:136](∅→∅),
[8.136]→[8.1241:1267](∅→∅),
[8.1267]→[8.4807:4931](∅→∅),
[8.4807]→[8.4807:4931](∅→∅) − db.db = put_cascade(txn, &mut cursor, put, &mut free)?.0.offset;
− for f in &free[..p] {
− if *f & 1 != 0 {
− txn.decr_rc_owned((*f) ^ 1)?;
− } else if *f > 0 {
− txn.decr_rc(*f)?;
+ unsafe {
+ db.db = core::num::NonZeroU64::new_unchecked(
+ put_cascade(txn, &mut cursor, put, &mut free)?.0.offset,
+ );
+ for f in &free[..p] {
+ if *f & 1 != 0 {
+ txn.decr_rc_owned((*f) ^ 1)?;
+ } else if *f > 0 {
+ txn.decr_rc(*f)?;
+ }
replacement in sanakirja-core/src/btree/put.rs at line 100
[8.4963]→[8.491:525](∅→∅),
[8.525]→[8.55:107](∅→∅),
[8.107]→[8.625:655](∅→∅),
[8.2259]→[8.625:655](∅→∅),
[8.625]→[8.625:655](∅→∅) − fn put_cascade<
− T: AllocPage,
− K: Storable + ?Sized,
− V: Storable + ?Sized,
− P: BTreeMutPage<K, V>,
− >(
+ fn put_cascade<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core/src/btree/put.rs at line 128
[8.781]→[8.118:215](∅→∅),
[8.2607]→[8.118:215](∅→∅),
[8.118]→[8.118:215](∅→∅),
[8.215]→[8.2608:2642](∅→∅),
[8.2642]→[8.16:47](∅→∅),
[8.190]→[8.16:47](∅→∅),
[8.47]→[8.137:174](∅→∅),
[8.190]→[8.137:174](∅→∅),
[8.174]→[8.333:405](∅→∅),
[8.333]→[8.333:405](∅→∅),
[8.405]→[8.182:212](∅→∅),
[8.212]→[8.405:484](∅→∅),
[8.405]→[8.405:484](∅→∅),
[8.484]→[8.135:159](∅→∅) − put = P::put(
− txn,
− cur.page,
− is_owned,
− false,
− &cur.cursor,
− split_key,
− split_value,
− None,
− left.0.offset,
− right.0.offset,
− )?;
+ put = unsafe {
+ P::put(
+ txn,
+ cur.page,
+ is_owned,
+ false,
+ &cur.cursor,
+ split_key,
+ split_value,
+ None,
+ left.0.offset,
+ right.0.offset,
+ )?
+ };
replacement in sanakirja-core/src/btree/put.rs at line 146
[8.786]→[8.832:883](∅→∅),
[8.2088]→[8.832:883](∅→∅),
[8.2831]→[8.832:883](∅→∅),
[8.832]→[8.832:883](∅→∅) − let mut p = txn.alloc_page()?;
+ let mut p = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/put.rs at line 149
[8.920]→[8.1798:1846](∅→∅),
[8.1846]→[8.5791:5879](∅→∅),
[8.5791]→[8.5791:5879](∅→∅),
[8.5879]→[8.48:79](∅→∅),
[8.79]→[8.1847:1880](∅→∅),
[8.232]→[8.5927:5999](∅→∅),
[8.978]→[8.5927:5999](∅→∅),
[8.1880]→[8.5927:5999](∅→∅),
[8.5927]→[8.5927:5999](∅→∅),
[8.5999]→[8.213:243](∅→∅),
[8.243]→[8.5999:6078](∅→∅),
[8.5999]→[8.5999:6078](∅→∅),
[8.6078]→[8.1881:1906](∅→∅) − if let Put::Ok(p) = P::put(
− txn,
− p.0,
− true,
− false,
− &cursor,
− split_key,
− split_value,
− None,
− left.0.offset,
− right.0.offset,
− )? {
+ if let Put::Ok(p) = unsafe {
+ P::put(
+ txn,
+ p.0,
+ true,
+ false,
+ &cursor,
+ split_key,
+ split_value,
+ None,
+ left.0.offset,
+ right.0.offset,
+ )?
+ } {
replacement in sanakirja-core/src/btree/put.rs at line 171
[8.626]→[8.626:746](∅→∅),
[8.746]→[8.2951:2985](∅→∅),
[8.2985]→[8.233:271](∅→∅),
[8.330]→[8.233:271](∅→∅),
[8.271]→[8.865:928](∅→∅),
[8.865]→[8.865:928](∅→∅) − put = Put::Ok(P::update_left_child(
− txn,
− curs.page,
− is_owned,
− &curs.cursor,
− page.0.offset,
− )?)
+ // Same as above: increment the relevant reference
+ // counters.
+ incr_descendants::<T, K, V, P>(txn, cursor, free, freed)?;
+ // And update the left child of the current cursor,
+ // since the main invariant of cursors is that we're
+ // always visiting the left child (if we're visiting
+ // the last child of a page, the cursor is set to the
+ // position strictly after the entries).
+ let is_owned = cursor.len() < cursor.first_rc_len();
+ if let Some(curs) = cursor.pop() {
+ // If we aren't at the root, just update the child.
+ put = Put::Ok(unsafe {
+ P::update_left_child(txn, curs.page, is_owned, &curs.cursor, page.0.offset)?
+ })
edit in sanakirja-core/src/btree/put.rs at line 254
[8.140]→[8.2134:2230](∅→∅),
[8.7298]→[8.2134:2230](∅→∅),
[8.2230]→[8.160:235](∅→∅),
[8.235]→[8.2323:2656](∅→∅),
[8.2323]→[8.2323:2656](∅→∅),
[8.2656]→[8.802:871](∅→∅),
[8.871]→[8.2899:2950](∅→∅),
[8.2899]→[8.2899:2950](∅→∅),
[8.2950]→[8.2657:2729](∅→∅),
[8.263]→[8.2657:2729](∅→∅) − // Same as above: increment the relevant reference
− // counters.
− incr_descendants::<T, K, V, P>(txn, cursor, free, freed)?;
− // And update the left child of the current cursor,
− // since the main invariant of cursors is that we're
− // always visiting the left child (if we're visiting
− // the last child of a page, the cursor is set to the
− // position strictly after the entries).
− let is_owned = cursor.len() < cursor.first_rc_len();
− if let Some(curs) = cursor.pop() {
− // If we aren't at the root, just update the child.
resolve order conflict in sanakirja-core/src/btree/put.rs at line 254
replacement in sanakirja-core/src/btree/page_unsized.rs at line 153
[8.4811]→[8.1103:1206](∅→∅) − let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
+ let off =
+ unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };
replacement in sanakirja-core/src/btree/page_unsized.rs at line 228
− let s = core::slice::from_raw_parts(
− page.data.as_ptr().add(HDR) as *const u64,
− hdr.n() as usize,
− );
+ let s =
+ core::slice::from_raw_parts(page.data.as_ptr().add(HDR) as *const u64, hdr.n() as usize);
replacement in sanakirja-core/src/btree/page_unsized.rs at line 254
[8.1697]→[8.1697:1757](∅→∅) − let off = u64::from_le(s[i-1]) & 0xfff;
+ let off = u64::from_le(s[i - 1]) & 0xfff;
replacement in sanakirja-core/src/btree/page_unsized.rs at line 260
[8.2032]→[8.2032:2062](∅→∅) edit in sanakirja-core/src/btree/page_unsized.rs at line 269
[8.2131]→[8.2131:2132](∅→∅) replacement in sanakirja-core/src/btree/page_unsized.rs at line 276
[8.2348]→[8.2348:2473](∅→∅) − let s = core::slice::from_raw_parts(
− page.data.as_ptr().add(HDR) as *const u16,
− hdr.n() as usize,
− );
+ let s =
+ core::slice::from_raw_parts(page.data.as_ptr().add(HDR) as *const u16, hdr.n() as usize);
replacement in sanakirja-core/src/btree/page_unsized.rs at line 302
[8.3386]→[8.3386:3438](∅→∅) − let off = u16::from_le(s[i-1]);
+ let off = u16::from_le(s[i - 1]);
replacement in sanakirja-core/src/btree/page_unsized.rs at line 308
[8.3713]→[8.3713:3743](∅→∅) edit in sanakirja-core/src/btree/page_unsized.rs at line 316
[8.2327]→[8.2327:2328](∅→∅) replacement in sanakirja-core/src/btree/page_unsized.rs at line 346
[8.9753]→[8.3641:3671](∅→∅),
[8.3641]→[8.3641:3671](∅→∅) − fn put<'a, T: AllocPage>(
+ unsafe fn put<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 406
− unsafe fn set_left_child(
− page: &mut MutPage,
− c: &Self::Cursor,
− l: u64
− ) {
+ unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64) {
replacement in sanakirja-core/src/btree/page_unsized.rs at line 412
[8.9908]→[8.4585:4625](∅→∅),
[8.4585]→[8.4585:4625](∅→∅) − fn update_left_child<T: AllocPage>(
+ unsafe fn update_left_child<T: AllocPage>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 456
[8.10935]→[8.1190:1216](∅→∅),
[8.5967]→[8.1190:1216](∅→∅) + unsafe fn del<T: AllocPage>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 561
[8.15279]→[8.8592:8637](∅→∅),
[8.8592]→[8.8592:8637](∅→∅) − fn merge_or_rebalance<'a, T: AllocPage>(
+ unsafe fn merge_or_rebalance<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 702
[8.17887]→[5.540:651](∅→∅) − fn alloc_write<T: AllocPage>(t: &mut T, new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize);
+ fn alloc_write<T: AllocPage>(
+ txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ );
replacement in sanakirja-core/src/btree/page_unsized.rs at line 715
[8.18046]→[5.652:792](∅→∅) − fn modify<T: LoadPage + AllocPage, K: core::fmt::Debug + ?Sized, V: core::fmt::Debug + ?Sized, P: BTreeMutPage<K, V>, L: AllocWrite<K, V>>(
+ fn modify<
+ T: LoadPage + AllocPage,
+ K: core::fmt::Debug + ?Sized,
+ V: core::fmt::Debug + ?Sized,
+ P: BTreeMutPage<K, V>,
+ L: AllocWrite<K, V>,
+ >(
replacement in sanakirja-core/src/btree/page_unsized.rs at line 796
[8.1963]→[8.19413:19450](∅→∅),
[8.19413]→[8.19413:19450](∅→∅) − let mut new = txn.alloc_page()?;
+ let mut new = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 6
[8.21592]→[8.22942:22972](∅→∅),
[8.22942]→[8.22942:22972](∅→∅) − pub(crate) fn rebalance_left<
+ pub(crate) unsafe fn rebalance_left<
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 31
[8.5051]→[8.533:612](∅→∅),
[8.197]→[8.23842:23920](∅→∅),
[8.612]→[8.23842:23920](∅→∅),
[8.1679]→[8.23842:23920](∅→∅),
[8.23842]→[8.23842:23920](∅→∅),
[8.23920]→[8.21969:22004](∅→∅),
[8.1698]→[8.23920:24072](∅→∅),
[8.22004]→[8.23920:24072](∅→∅),
[8.23920]→[8.23920:24072](∅→∅) − let new_left = if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn,
− m.modified.page,
− m.modified.mutable,
− m.modified.skip_first,
− &m.modified.c1,
− k,
− v,
− m.modified.ins2,
− m.modified.l,
− m.modified.r,
− )? {
+ let new_left = if let Put::Ok(Ok { page, freed }) = unsafe {
+ <Page<K, V>>::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ m.modified.skip_first,
+ &m.modified.c1,
+ k,
+ v,
+ m.modified.ins2,
+ m.modified.l,
+ m.modified.r,
+ )?
+ } {
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 57
[8.876]→[8.876:1031](∅→∅) − if let Put::Ok(Ok { freed, page }) = <Page<K, V>>::put(
− txn, new_left.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− )? {
+ if let Put::Ok(Ok { freed, page }) = unsafe {
+ <Page<K, V>>::put(
+ txn, new_left.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
+ )?
+ } {
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 88
[8.1414]→[8.1996:2041](∅→∅) − if let Put::Ok(Ok { freed, page }) =
+ if let Put::Ok(Ok { freed, page }) = unsafe {
replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 90
[8.2134]→[8.2134:2144](∅→∅) replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 172
[8.23054]→[8.2924:2955](∅→∅) − pub(crate) fn rebalance_right<
+ pub(crate) unsafe fn rebalance_right<
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 88
[8.2520]→[8.28228:28269](∅→∅),
[8.4092]→[8.28228:28269](∅→∅),
[8.25858]→[8.28228:28269](∅→∅),
[8.28228]→[8.28228:28269](∅→∅) − let mut new = txn.alloc_page()?;
+ let mut new = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 142
[8.26818]→[8.29628:29666](∅→∅),
[8.29628]→[8.29628:29666](∅→∅) − let mut left = txn.alloc_page()?;
+ let mut left = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 145
[8.29724]→[8.29724:29763](∅→∅) − let mut right = txn.alloc_page()?;
+ let mut right = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 154
[8.35225]→[8.35225:35254](∅→∅) + (0, u16::from_le(self.0) as usize)
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 160
[8.43968]→[8.43968:43992](∅→∅) + u16::from_le(self.0) as usize
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 170
[8.35336]→[8.35336:35389](∅→∅) − (self.0 & !0xfff, (self.0 & 0xfff) as usize)
+ (
+ u64::from_le(self.0) & !0xfff,
+ (u64::from_le(self.0) & 0xfff) as usize,
+ )
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 179
[8.44279]→[8.44279:44303](∅→∅) + u64::from_le(self.0) as usize
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 185
[5.2338]→[5.2338:2357](∅→∅) replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 193
[5.2479]→[5.2479:2541](∅→∅) − alloc_write::<T, K, V, Self>(t, new, k0, v0, l, r, n)
+ alloc_write::<K, V, Self, T>(txn, new, k0, v0, l, r, n)
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 202
[5.2576]→[5.2576:2595](∅→∅) replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 210
[5.2717]→[5.2717:2779](∅→∅) − alloc_write::<T, K, V, Self>(t, new, k0, v0, l, r, n)
+ alloc_write::<K, V, Self, T>(txn, new, k0, v0, l, r, n)
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 220
[8.35950]→[5.2780:2878](∅→∅) − fn alloc_write<T: AllocPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized, L: Alloc>(
+ fn alloc_write<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized, L: Alloc, T: AllocPage>(
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 233
[8.36283]→[5.2896:2936](∅→∅) − k0.write_to_page(txn, new_ptr);
+ k0.write_to_page_alloc(txn, new_ptr);
replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 236
[8.36418]→[5.2937:2975](∅→∅) − v0.write_to_page(txn, v_ptr);
+ v0.write_to_page_alloc(txn, v_ptr);
replacement in sanakirja-core/src/btree/page.rs at line 222
[8.8675]→[8.4966:4988](∅→∅),
[8.4966]→[8.4966:4988](∅→∅),
[8.4988]→[8.910:1013](∅→∅) − let off =
− unsafe { *(page.data.as_ptr().offset((HDR as isize + c.cur * 8) - 8) as *const u64) };
+ let off = unsafe {
+ *(page.data.as_ptr().offset((HDR as isize + c.cur * 8) - 8) as *const u64)
+ };
replacement in sanakirja-core/src/btree/page.rs at line 317
[8.1212]→[8.1522:1552](∅→∅),
[8.10826]→[8.1522:1552](∅→∅),
[8.10923]→[8.1522:1552](∅→∅) − fn put<'a, T: AllocPage>(
+ unsafe fn put<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 340
[8.11472]→[5.2976:3093](∅→∅) − unsafe fn put_mut<T: AllocPage>(txn: &mut T, page: &mut MutPage, c: &mut Self::Cursor, k0: &K, v0: &V, r: u64) {
+ unsafe fn put_mut<T: AllocPage>(
+ txn: &mut T,
+ page: &mut MutPage,
+ c: &mut Self::Cursor,
+ k0: &K,
+ v0: &V,
+ r: u64,
+ ) {
replacement in sanakirja-core/src/btree/page.rs at line 365
[8.10982]→[8.1588:1628](∅→∅),
[8.1520]→[8.1588:1628](∅→∅) − fn update_left_child<T: AllocPage>(
+ unsafe fn update_left_child<T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 381
[8.11302]→[8.2248:2293](∅→∅),
[8.11813]→[8.2248:2293](∅→∅) − let mut new = txn.alloc_page()?;
+ let mut new = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page.rs at line 402
[8.12564]→[8.5161:5187](∅→∅) + unsafe fn del<T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 433
[8.12650]→[8.12650:12675](∅→∅),
[8.12675]→[8.12675:12770](∅→∅),
[8.12770]→[8.12770:12788](∅→∅) − unsafe {
− core::ptr::copy(p.add(off + f), p.add(off), f * (n - c.cur as usize - 1));
− }
+ core::ptr::copy(p.add(off + f), p.add(off), f * (n - c.cur as usize - 1));
replacement in sanakirja-core/src/btree/page.rs at line 509
[8.15708]→[8.2545:2590](∅→∅),
[8.15688]→[8.2545:2590](∅→∅) − fn merge_or_rebalance<'a, T: AllocPage>(
+ unsafe fn merge_or_rebalance<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/page.rs at line 558
[8.17488]→[8.7535:7580](∅→∅),
[8.3536]→[8.7535:7580](∅→∅),
[8.3585]→[8.6024:6126](∅→∅),
[8.7580]→[8.6024:6126](∅→∅),
[8.6024]→[8.6024:6126](∅→∅),
[8.6126]→[8.17489:17532](∅→∅),
[8.7607]→[8.6126:6162](∅→∅),
[8.17532]→[8.6126:6162](∅→∅),
[8.6126]→[8.6126:6162](∅→∅),
[8.6162]→[8.3586:3669](∅→∅),
[8.3669]→[8.6212:6246](∅→∅),
[8.6212]→[8.6212:6246](∅→∅),
[8.6246]→[8.188:222](∅→∅),
[8.222]→[8.3670:3692](∅→∅) − return Ok(Op::Put(Self::put(
− txn,
− m.modified.page,
− m.modified.mutable,
− m.modified.skip_first,
− &m.modified.c1,
− k,
− v,
− m.modified.ins2,
− m.modified.l,
− m.modified.r,
− )?));
+ return Ok(Op::Put(unsafe {
+ Self::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ m.modified.skip_first,
+ &m.modified.c1,
+ k,
+ v,
+ m.modified.ins2,
+ m.modified.l,
+ m.modified.r,
+ )?
+ }));
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 29
[8.9149]→[8.4795:4870](∅→∅),
[8.2012]→[8.1336:1414](∅→∅),
[8.4870]→[8.1336:1414](∅→∅),
[8.8433]→[8.1336:1414](∅→∅),
[8.1336]→[8.1336:1414](∅→∅),
[8.1414]→[8.22945:22980](∅→∅),
[8.8452]→[8.1414:1566](∅→∅),
[8.22980]→[8.1414:1566](∅→∅),
[8.1414]→[8.1414:1566](∅→∅) − let page = if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn,
− m.modified.page,
− m.modified.mutable,
− m.modified.skip_first,
− &m.modified.c1,
− k,
− v,
− m.modified.ins2,
− m.modified.l,
− m.modified.r,
− )? {
+ let page = if let Put::Ok(Ok { page, freed }) = unsafe {
+ <Page<K, V>>::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ m.modified.skip_first,
+ &m.modified.c1,
+ k,
+ v,
+ m.modified.ins2,
+ m.modified.l,
+ m.modified.r,
+ )?
+ } {
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 55
[8.5130]→[8.5130:5281](∅→∅) − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− )? {
+ if let Put::Ok(Ok { page, freed }) = unsafe {
+ <Page<K, V>>::put(txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl)?
+ } {
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 73
[8.9256]→[8.7894:7941](∅→∅),
[8.1650]→[8.7894:7941](∅→∅),
[8.7941]→[8.4547:4679](∅→∅),
[8.4547]→[8.4547:4679](∅→∅),
[8.4679]→[8.7942:7954](∅→∅) − let (page, freed) = <Page<K, V>>::del(
− txn,
− m.modified.page,
− m.modified.mutable,
− &m.modified.c1,
− m.modified.l,
− )?;
+ let (page, freed) = unsafe {
+ <Page<K, V>>::del(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ &m.modified.c1,
+ m.modified.l,
+ )?
+ };
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 90
[8.5664]→[8.5664:5815](∅→∅) − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− )? {
+ if let Put::Ok(Ok { page, freed }) = unsafe {
+ <Page<K, V>>::put(txn, page.0, true, false, &lc, m.mid.0, m.mid.1, None, 0, rl)?
+ } {
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 108
[8.6026]→[8.6026:6200](∅→∅) − if let Put::Ok(Ok { page, freed }) = <Page<K, V>>::put(
− txn, m.modified.page, m.modified.mutable, false, &lc, m.mid.0, m.mid.1, None, 0, rl,
− )? {
+ if let Put::Ok(Ok { page, freed }) = unsafe {
+ <Page<K, V>>::put(
+ txn,
+ m.modified.page,
+ m.modified.mutable,
+ false,
+ &lc,
+ m.mid.0,
+ m.mid.1,
+ None,
+ 0,
+ rl,
+ )?
+ } {
replacement in sanakirja-core/src/btree/page/rebalance.rs at line 194
[8.9718]→[8.8177:8267](∅→∅),
[8.47398]→[8.8177:8267](∅→∅) − let (page, freed) = <Page<K, V>>::del(txn, m.other, m.other_is_mutable, &rc, r)?;
+ let (page, freed) = unsafe { <Page<K, V>>::del(txn, m.other, m.other_is_mutable, &rc, r)? };
replacement in sanakirja-core/src/btree/page/put.rs at line 48
[8.6275]→[8.7156:7197](∅→∅),
[8.40080]→[8.7156:7197](∅→∅),
[8.7156]→[8.7156:7197](∅→∅) − let mut new = txn.alloc_page()?;
+ let mut new = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page/put.rs at line 124
[8.41060]→[8.11374:11417](∅→∅),
[8.11374]→[8.11374:11417](∅→∅) − let mut right = txn.alloc_page()?;
+ let mut right = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page/put.rs at line 160
[8.41969]→[8.10002:10040](∅→∅),
[8.10002]→[8.10002:10040](∅→∅) − left = txn.alloc_page()?;
+ left = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page/put.rs at line 188
[8.42302]→[8.11447:11481](∅→∅),
[8.11447]→[8.11447:11481](∅→∅) − left = txn.alloc_page()?;
+ left = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page/put.rs at line 217
[8.42839]→[8.12379:12418](∅→∅),
[8.12379]→[8.12379:12418](∅→∅) − right = txn.alloc_page()?;
+ right = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/page/alloc.rs at line 306
[8.43824]→[5.3484:3658](∅→∅) − fn alloc_write<T: AllocPage>(t: &mut T, new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
− alloc_write::<T, K, V, Self>(t, new, k0, v0, l, r, n)
+ fn alloc_write<T: AllocPage>(
+ _txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
+ alloc_write::<K, V, Self>(new, k0, v0, l, r, n)
replacement in sanakirja-core/src/btree/page/alloc.rs at line 325
[8.44063]→[5.3659:3833](∅→∅) − fn alloc_write<T: AllocPage>(t: &mut T, new: &mut MutPage, k0: &K, v0: &V, l: u64, r: u64, n: &mut isize) {
− alloc_write::<T, K, V, Self>(t, new, k0, v0, l, r, n)
+ fn alloc_write<T: AllocPage>(
+ _txn: &mut T,
+ new: &mut MutPage,
+ k0: &K,
+ v0: &V,
+ l: u64,
+ r: u64,
+ n: &mut isize,
+ ) {
+ alloc_write::<K, V, Self>(new, k0, v0, l, r, n)
replacement in sanakirja-core/src/btree/page/alloc.rs at line 343
[8.44307]→[5.3834:3916](∅→∅) − fn alloc_write<T: AllocPage, K: Storable, V: Storable, L: Alloc>(
− _t: &mut T,
+ fn alloc_write<K: Storable, V: Storable, L: Alloc>(
replacement in sanakirja-core/src/btree/mod.rs at line 167
[8.10988]→[8.14162:14192](∅→∅),
[8.45362]→[8.14162:14192](∅→∅),
[8.29786]→[8.14162:14192](∅→∅) − fn put<'a, T: AllocPage>(
+ unsafe fn put<'a, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 194
[8.1604]→[8.1604:1703](∅→∅),
[8.1703]→[8.2481:2488](∅→∅) − unsafe fn set_left_child(
− page: &mut MutPage,
− c: &Self::Cursor,
− l: u64
− );
+ unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64);
edit in sanakirja-core/src/btree/mod.rs at line 196
[8.1743]→[8.1743:1744](∅→∅) replacement in sanakirja-core/src/btree/mod.rs at line 198
[8.11093]→[8.14193:14233](∅→∅),
[8.48501]→[8.14193:14233](∅→∅) − fn update_left_child<T: AllocPage>(
+ unsafe fn update_left_child<T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 219
[8.2178]→[8.8946:8972](∅→∅),
[8.11562]→[8.8946:8972](∅→∅),
[8.48665]→[8.8946:8972](∅→∅) + unsafe fn del<T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 228
[8.11615]→[8.14379:14428](∅→∅),
[8.49208]→[8.14379:14428](∅→∅) − fn merge_or_rebalance<'a, 'b, T: AllocPage>(
+ unsafe fn merge_or_rebalance<'a, 'b, T: AllocPage>(
replacement in sanakirja-core/src/btree/mod.rs at line 237
[8.11214]→[8.9162:9179](∅→∅),
[8.9926]→[8.9162:9179](∅→∅) + pub db: core::num::NonZeroU64,
replacement in sanakirja-core/src/btree/mod.rs at line 246
[8.3818]→[8.3818:3914](∅→∅) − impl<K:Storable, V:Storable, P: BTreePage<K, V> + core::fmt::Debug> Storable for Db_<K, V, P> {
+ #[cfg(feature = "typeids")]
+ impl<K: Storable + TypeId, V: Storable + TypeId, P: BTreePage<K, V> + core::fmt::Debug> TypeId
+ for Db_<K, V, P>
+ {
+ fn type_id() -> [u8; 32] {
+ let mut h = sha2::Sha256::new();
+ h.update("sanakirja-core::Db".as_bytes());
+ h.update(&K::type_id());
+ h.update(&V::type_id());
+ h.finalize().into()
+ }
+ }
+
+ impl<K: Storable, V: Storable, P: BTreePage<K, V> + core::fmt::Debug> Storable for Db_<K, V, P> {
replacement in sanakirja-core/src/btree/mod.rs at line 262
[8.4019]→[8.4019:4053](∅→∅) − core::iter::once(self.db)
+ core::iter::once(self.db.into())
replacement in sanakirja-core/src/btree/mod.rs at line 265
[8.4060]→[8.4060:4130](∅→∅) − fn drop<T: AllocPage>(&self, t: &mut T) -> Result<(), T::Error> {
+ unsafe fn drop<T: AllocPage>(&self, t: &mut T) -> Result<(), T::Error> {
edit in sanakirja-core/src/btree/mod.rs at line 267
+ }
+ }
+
+ impl<K: Storable, V: Storable, P: BTreePage<K, V> + core::fmt::Debug> Storable
+ for Option<Db_<K, V, P>>
+ {
+ type PageReferences = core::iter::Once<u64>;
+ fn page_references(&self) -> Self::PageReferences {
+ if let Some(ref db) = self {
+ core::iter::once(db.db.into())
+ } else {
+ let mut it = core::iter::once(0);
+ it.next();
+ it
+ }
+ }
+
+ unsafe fn drop<T: AllocPage>(&self, t: &mut T) -> Result<(), T::Error> {
+ if let Some(ref db) = self {
+ drop_(t, db)
+ } else {
+ Ok(())
+ }
replacement in sanakirja-core/src/btree/mod.rs at line 298
[8.1367]→[8.9231:9271](∅→∅),
[8.221]→[8.9231:9271](∅→∅) − pub fn from_page(db: u64) -> Self {
+ pub unsafe fn from_page(db: u64) -> Self {
replacement in sanakirja-core/src/btree/mod.rs at line 300
+ db: core::num::NonZeroU64::new_unchecked(db),
replacement in sanakirja-core/src/btree/mod.rs at line 309
[8.1429]→[8.11278:11356](∅→∅) − pub fn create_db_<T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(
+ pub unsafe fn create_db_<T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(
replacement in sanakirja-core/src/btree/mod.rs at line 315
[8.258]→[8.9272:9299](∅→∅) + db: core::num::NonZeroU64::new_unchecked(page.0.offset),
replacement in sanakirja-core/src/btree/mod.rs at line 323
[8.1479]→[8.11357:11415](∅→∅) − pub fn create_db<T: AllocPage, K: Storable, V: Storable>(
+ pub unsafe fn create_db<T: AllocPage, K: Storable, V: Storable>(
replacement in sanakirja-core/src/btree/mod.rs at line 334
[8.15515]→[8.9300:9325](∅→∅) + txn.incr_rc(db.db.into())?;
replacement in sanakirja-core/src/btree/mod.rs at line 347
[8.4346]→[8.4346:4446](∅→∅) − pub fn get_shared<'a, T: LoadPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
+ pub fn get_shared<
+ 'a,
+ T: LoadPage,
+ K: Storable + ?Sized,
+ V: Storable + ?Sized,
+ P: BTreePage<K, V>,
+ >(
edit in sanakirja-core/src/btree/mod.rs at line 359
[8.4569]→[8.4569:4570](∅→∅) replacement in sanakirja-core/src/btree/mod.rs at line 362
[8.4720]→[8.4720:4807](∅→∅) − let mut page = txn.load_page(db.db)?;
− let mut is_shared = txn.rc(db.db)? >= 2;
+ let mut page = unsafe { txn.load_page(db.db.into())? };
+ let mut is_shared = txn.rc(db.db.into())? >= 2;
replacement in sanakirja-core/src/btree/mod.rs at line 377
[8.5527]→[8.5527:5631](∅→∅) − unsafe { last_match = Some((core::mem::transmute(k), core::mem::transmute(v), is_shared)) }
+ unsafe {
+ last_match = Some((core::mem::transmute(k), core::mem::transmute(v), is_shared))
+ }
replacement in sanakirja-core/src/btree/mod.rs at line 386
[8.5899]→[8.5899:5991](∅→∅) − page = txn.load_page(next_page)?;
− is_shared |= txn.rc(db.db)? >= 2;
+ page = unsafe { txn.load_page(next_page)? };
+ is_shared |= txn.rc(db.db.into())? >= 2;
edit in sanakirja-core/src/btree/mod.rs at line 394
[8.6064]→[8.6064:6065](∅→∅) edit in sanakirja-core/src/btree/mod.rs at line 405
[8.621]→[8.6322:6323](∅→∅) replacement in sanakirja-core/src/btree/mod.rs at line 412
[8.771]→[8.9326:9368](∅→∅) − let mut page = txn.load_page(db.db)?;
+ let mut page = unsafe { txn.load_page(db.db.into())? };
replacement in sanakirja-core/src/btree/mod.rs at line 433
[8.1426]→[8.1426:1472](∅→∅) − page = txn.load_page(next_page)?;
+ page = unsafe { txn.load_page(next_page)? };
replacement in sanakirja-core/src/btree/mod.rs at line 443
[8.1743]→[8.11608:11699](∅→∅) − pub fn drop<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
+ pub unsafe fn drop<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
replacement in sanakirja-core/src/btree/mod.rs at line 450
[8.6571]→[8.6571:6659](∅→∅) − fn drop_<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
+ unsafe fn drop_<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(
replacement in sanakirja-core/src/btree/mod.rs at line 495
[8.4975]→[8.1912:1950](∅→∅),
[8.1912]→[8.1912:1950](∅→∅) − let page = txn.load_page(db.db)?;
+ let page = txn.load_page(db.db.into())?;
edit in sanakirja-core/src/btree/del.rs at line 105
[8.6809]→[8.6809:6810](∅→∅) replacement in sanakirja-core/src/btree/del.rs at line 168
[8.1194]→[8.8072:8122](∅→∅) − delk.drop(txn)?;
− delv.drop(txn)?;
+ unsafe {
+ delk.drop(txn)?;
+ delv.drop(txn)?;
+ }
edit in sanakirja-core/src/btree/del.rs at line 195
+ // Then, climb up the stack, performing the operations lazily. At
+ // each step, we are one level above the page that we plan to
+ // modify, since `last_op` is the result of popping the
+ // stack.
+ //
+ // We iterate up to the root. The last iteration builds a modified
+ // page for the root, but doesn't actually execute it.
+ while cursor.len() > 0 {
+ // Prepare a plan for merging the current modified page (which
+ // is stored in `last_op`) with one of its neighbours.
+ let concat = concat(txn, cursor, p0, &k0v0, last_op)?;
+ let mil = concat.mod_is_left;
+
+ let incr_page = if !concat.other_is_mutable {
+ Some(CowPage {
+ offset: concat.other.offset,
+ data: concat.other.data,
+ })
+ } else {
+ None
+ };
+ let incr_mid = if cursor.len() >= cursor.first_rc_len() {
+ Some(concat.mid)
+ } else {
+ None
+ };
+
+ // Execute the modification plan, resulting in one of four
+ // different outcomes (described in the big match in
+ // `handle_merge`). This mutates or clones the current
+ // modified page, returning an `Op` describing what happened
+ // (between update, merge, rebalance and split).
+ let merge = unsafe { P::merge_or_rebalance(txn, concat)? };
replacement in sanakirja-core/src/btree/del.rs at line 230
[8.15103]→[8.7132:7233](∅→∅) − last_op = handle_merge(txn, cursor, p0, &k0v0, incr_page, incr_mid, mil, merge, &mut free)?;
+ last_op = handle_merge(
+ txn, cursor, p0, &k0v0, incr_page, incr_mid, mil, merge, &mut free,
+ )?;
replacement in sanakirja-core/src/btree/del.rs at line 247
[8.15419]→[8.8927:8996](∅→∅),
[8.37765]→[8.8927:8996](∅→∅),
[8.8927]→[8.8927:8996](∅→∅) − update_root(txn, db, last_op, k0v0, root_is_shared, &mut free)?;
+ unsafe { update_root(txn, db, last_op, k0v0, root_is_shared, &mut free)? };
replacement in sanakirja-core/src/btree/del.rs at line 251
[8.9120]→[8.9120:9147](∅→∅),
[8.1478]→[8.60797:60824](∅→∅),
[8.9147]→[8.60797:60824](∅→∅),
[8.10577]→[8.60797:60824](∅→∅),
[8.60797]→[8.60797:60824](∅→∅),
[8.60824]→[8.1306:1348](∅→∅),
[8.1348]→[8.60865:60894](∅→∅),
[8.60865]→[8.60865:60894](∅→∅),
[8.60894]→[8.1349:1381](∅→∅),
[8.1381]→[8.60931:60968](∅→∅),
[8.31399]→[8.60931:60968](∅→∅),
[8.60931]→[8.60931:60968](∅→∅),
[8.60968]→[8.1382:1424](∅→∅),
[8.1424]→[8.61009:61038](∅→∅),
[8.61009]→[8.61009:61038](∅→∅),
[8.61038]→[8.1425:1457](∅→∅) − for p in free.iter() {
− if p[0] & 1 == 1 {
− txn.decr_rc_owned(p[0] ^ 1)?;
− } else if p[0] > 0 {
− txn.decr_rc(p[0])?;
− }
− if p[1] & 1 == 1 {
− txn.decr_rc_owned(p[1] ^ 1)?;
− } else if p[1] > 0 {
− txn.decr_rc(p[1])?;
+ unsafe {
+ for p in free.iter() {
+ if p[0] & 1 == 1 {
+ txn.decr_rc_owned(p[0] ^ 1)?;
+ } else if p[0] > 0 {
+ txn.decr_rc(p[0])?;
+ }
+ if p[1] & 1 == 1 {
+ txn.decr_rc_owned(p[1] ^ 1)?;
+ } else if p[1] > 0 {
+ txn.decr_rc(p[1])?;
+ }
replacement in sanakirja-core/src/btree/del.rs at line 347
[8.2697]→[8.15760:15846](∅→∅) − let other = txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))?;
+ let other = unsafe { txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))? };
replacement in sanakirja-core/src/btree/del.rs at line 382
[8.7936]→[8.62649:62688](∅→∅),
[8.16331]→[8.62649:62688](∅→∅),
[8.33412]→[8.62649:62688](∅→∅),
[8.62649]→[8.62649:62688](∅→∅) − let other = txn.load_page(r)?;
+ let other = unsafe { txn.load_page(r)? };
replacement in sanakirja-core/src/btree/del.rs at line 420
− mod_is_left: bool, // The modified page in the `merge` is the left one.
+ mod_is_left: bool, // The modified page in the `merge` is the left one.
replacement in sanakirja-core/src/btree/del.rs at line 448
[8.7600]→[8.7600:7654](∅→∅) − Op::Merged {.. } | Op::Rebalanced { .. } => {
+ Op::Merged { .. } | Op::Rebalanced { .. } => {
replacement in sanakirja-core/src/btree/del.rs at line 496
[8.35183]→[8.4764:4868](∅→∅),
[8.4892]→[8.4892:4907](∅→∅) − Op::Rebalanced {
− k,
− v,
− l,
− r,
− freed,
− } => {
+ Op::Rebalanced { k, v, l, r, freed } => {
replacement in sanakirja-core/src/btree/del.rs at line 675
[8.38187]→[8.38187:38203](∅→∅) replacement in sanakirja-core/src/btree/del.rs at line 700
[8.6762]→[8.6762:6785](∅→∅) + db.db = core::num::NonZeroU64::new_unchecked(d);
replacement in sanakirja-core/src/btree/del.rs at line 705
[8.11403]→[8.7203:7237](∅→∅),
[8.7203]→[8.7203:7237](∅→∅) + db.db = core::num::NonZeroU64::new_unchecked(page.0.offset);
replacement in sanakirja-core/src/btree/del.rs at line 718
[8.7438]→[8.7438:7472](∅→∅) + db.db = core::num::NonZeroU64::new_unchecked(page.0.offset)
replacement in sanakirja-core/src/btree/del.rs at line 731
[8.7632]→[8.38957:39003](∅→∅),
[8.38957]→[8.38957:39003](∅→∅) − let mut page = txn.alloc_page()?;
+ let mut page = unsafe { txn.alloc_page()? };
replacement in sanakirja-core/src/btree/del.rs at line 735
[8.12118]→[8.11959:12060](∅→∅) − let page = if let Put::Ok(p) = P::put(txn, page.0, true, false, &c, k, v, None, l, r)? {
+ let page = if let Put::Ok(p) =
+ unsafe { P::put(txn, page.0, true, false, &c, k, v, None, l, r)? }
+ {
replacement in sanakirja-core/src/btree/del.rs at line 762
[8.12648]→[8.10760:10794](∅→∅),
[8.39551]→[8.10760:10794](∅→∅) + db.db = core::num::NonZeroU64::new_unchecked(page.0.offset)
replacement in sanakirja-core/src/btree/del.rs at line 805
[8.1343]→[8.12618:12720](∅→∅),
[8.13175]→[8.12618:12720](∅→∅),
[8.12618]→[8.12618:12720](∅→∅),
[8.12720]→[8.1344:1361](∅→∅),
[8.1361]→[8.12739:12833](∅→∅),
[8.12739]→[8.12739:12833](∅→∅) − P::put(
− txn,
− m.page,
− m.mutable,
− m.skip_first,
− &c1,
− k,
− v,
− m.ins2,
− m.l,
− m.r,
− )
+ unsafe {
+ P::put(
+ txn,
+ m.page,
+ m.mutable,
+ m.skip_first,
+ &c1,
+ k,
+ v,
+ m.ins2,
+ m.l,
+ m.r,
+ )
+ }
replacement in sanakirja-core/src/btree/del.rs at line 823
[8.12872]→[8.12872:12949](∅→∅) − let (page, freed) = P::del(txn, m.page, m.mutable, &m.c1, m.l)?;
+ let (page, freed) = unsafe { P::del(txn, m.page, m.mutable, &m.c1, m.l)? };
replacement in sanakirja-core/src/btree/del.rs at line 828
[8.13382]→[8.13021:13066](∅→∅),
[8.13021]→[8.13021:13066](∅→∅),
[8.13066]→[8.13066:13118](∅→∅),
[8.13118]→[8.13118:13135](∅→∅) − Ok(Put::Ok(P::update_left_child(
− txn, m.page, m.mutable, &m.c1, m.l,
− )?))
+ Ok(Put::Ok(unsafe {
+ P::update_left_child(txn, m.page, m.mutable, &m.c1, m.l)?
+ }))
replacement in sanakirja-core/src/btree/del.rs at line 838
[8.13226]→[8.13226:13271](∅→∅),
[8.13271]→[8.13271:13321](∅→∅),
[8.13321]→[8.13321:13338](∅→∅) − Ok(Put::Ok(P::update_left_child(
− txn, m.page, m.mutable, &c1, m.r,
− )?))
+ Ok(Put::Ok(unsafe {
+ P::update_left_child(txn, m.page, m.mutable, &c1, m.r)?
+ }))
edit in sanakirja-core/src/btree/del.rs at line 844
[8.55587]→[8.13989:14600](∅→∅),
[8.14600]→[8.6763:7131](∅→∅),
[8.7131]→[8.17538:17539](∅→∅),
[8.14600]→[8.17538:17539](∅→∅),
[8.30986]→[8.17538:17539](∅→∅),
[8.17539]→[8.14601:14918](∅→∅),
[8.14918]→[8.14918:14975](∅→∅) − // Then, climb up the stack, performing the operations lazily. At
− // each step, we are one level above the page that we plan to
− // modify, since `last_op` is the result of popping the
− // stack.
− //
− // We iterate up to the root. The last iteration builds a modified
− // page for the root, but doesn't actually execute it.
− while cursor.len() > 0 {
− // Prepare a plan for merging the current modified page (which
− // is stored in `last_op`) with one of its neighbours.
− let concat = concat(txn, cursor, p0, &k0v0, last_op)?;
− let mil = concat.mod_is_left;
−
− let incr_page = if !concat.other_is_mutable {
− Some(CowPage {
− offset: concat.other.offset,
− data: concat.other.data,
− })
− } else {
− None
− };
− let incr_mid = if cursor.len() >= cursor.first_rc_len() {
− Some(concat.mid)
− } else {
− None
− };
−
− // Execute the modification plan, resulting in one of four
− // different outcomes (described in the big match in
− // `handle_merge`). This mutates or clones the current
− // modified page, returning an `Op` describing what happened
− // (between update, merge, rebalance and split).
− let merge = P::merge_or_rebalance(txn, concat)?;
resolve order conflict in sanakirja-core/src/btree/del.rs at line 844
replacement in sanakirja-core/src/btree/cursor.rs at line 75
[8.14941]→[8.10908:10950](∅→∅),
[8.65424]→[8.10908:10950](∅→∅) − let page = txn.load_page(db.db)?;
+ let page = unsafe { txn.load_page(db.db.into())? };
+ if page.offset == 0 {
+ return Ok(Cursor {
+ stack,
+ first_rc_len: N_CURSORS,
+ len: 0,
+ });
+ }
edit in sanakirja-core/src/btree/cursor.rs at line 137
+ }
+ let page = unsafe { txn.load_page(left_page)? };
+ if page.offset == 0 {
+ break;
edit in sanakirja-core/src/btree/cursor.rs at line 142
[8.39441]→[8.39441:39491](∅→∅) − let page = txn.load_page(left_page)?;
replacement in sanakirja-core/src/btree/cursor.rs at line 196
[8.67194]→[8.11168:11222](∅→∅) − let page = txn.load_page(next_page)?;
+ let page = unsafe { txn.load_page(next_page)? };
+ if page.offset == 0 {
+ break;
+ }
replacement in sanakirja-core/src/btree/cursor.rs at line 218
[8.40742]→[8.11211:11288](∅→∅),
[8.67642]→[8.11211:11288](∅→∅),
[8.11288]→[8.9302:9334](∅→∅) − pub fn set_last<'a, T: LoadPage>(
− &mut self,
− txn: &'a T,
− ) -> Result<(), T::Error> {
+ pub fn set_last<'a, T: LoadPage>(&mut self, txn: &'a T) -> Result<(), T::Error> {
replacement in sanakirja-core/src/btree/cursor.rs at line 230
[8.9506]→[8.9506:9552](∅→∅) − let page = txn.load_page(l)?;
+ let page = unsafe { txn.load_page(l)? };
+ if page.offset == 0 {
+ break;
+ }
replacement in sanakirja-core/src/btree/cursor.rs at line 254
[8.10133]→[8.10133:10165](∅→∅) replacement in sanakirja-core/src/btree/cursor.rs at line 287
− let (cur_entry, r) = if let Some((k, v, r)) = P::current(txn, current.page.as_page(), ¤t.cursor) {
+ let (cur_entry, r) = if let Some((k, v, r)) =
+ P::current(txn, current.page.as_page(), ¤t.cursor)
+ {
replacement in sanakirja-core/src/btree/cursor.rs at line 292
− (None, P::right_child(current.page.as_page(), ¤t.cursor))
+ (
+ None,
+ P::right_child(current.page.as_page(), ¤t.cursor),
+ )
replacement in sanakirja-core/src/btree/cursor.rs at line 299
[3.725]→[8.12823:12873](∅→∅),
[8.12823]→[8.12823:12873](∅→∅) − let page = txn.load_page(r)?;
+ let page = unsafe { txn.load_page(r)? };
+ if page.offset == 0 {
+ return Ok(None);
+ }
replacement in sanakirja-core/src/btree/cursor.rs at line 345
[8.2637]→[8.2637:2690](∅→∅) − let page = txn.load_page(left)?;
+ let page = unsafe { txn.load_page(left)? };
+ if page.offset == 0 {
+ return Ok(None);
+ }
replacement in sanakirja-core/Cargo.toml at line 3
[8.70812]→[6.5050:5068](∅→∅) edit in sanakirja-core/Cargo.toml at line 38
replacement in sanakirja-core/Cargo.toml at line 42
[8.10850]→[8.589:633](∅→∅) − uuid = { version = "0.8", optional = true }
+ uuid = { version = "1.3.3", optional = true }
edit in sanakirja-core/Cargo.toml at line 44
+ sha2 = { version = "0.10", optional = true }
edit in sanakirja/src/tests.rs at line 11
+ fn add_refs<T: LoadPage, C: Check>(
+ txn: &T,
+ c: &C,
+ refs: &mut BTreeMap<u64, usize>,
+ ) -> Result<(), T::Error>
+ where
+ T::Error: std::fmt::Debug,
+ {
+ c.add_refs(txn, refs)
+ }
+
+ impl Check for A {}
+ impl Check for U {}
+ impl Check for V {}
+ impl Check for [u8] {}
+
replacement in sanakirja/src/tests.rs at line 41
[8.1998]→[8.1998:2427](∅→∅) − env_logger::try_init().unwrap_or(());
− let path = tempfile::tempdir().unwrap();
− let path = path.path().join("db");
− let l0 = 1 << 13; // 2 pages
− let env = Env::new(&path, l0, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db::<MutTxn<&Env, ()>, u64, u64>(&mut txn).unwrap();
− let n = 100_000u64;
− for i in 0..n {
− put(&mut txn, &mut db, &i, &i).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let path = tempfile::tempdir().unwrap();
+ let path = path.path().join("db");
+ let l0 = 1 << 13; // 2 pages
+ let env = Env::new(&path, l0, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db::<MutTxn<&Env, ()>, u64, u64>(&mut txn).unwrap();
+ let n = 100_000u64;
+ for i in 0..n {
+ put(&mut txn, &mut db, &i, &i).unwrap();
+ }
+ println!("{:?}", env.mmaps);
+ let len = std::fs::metadata(&path).unwrap().len();
+ assert_eq!(len, (l0 << 9) - l0);
+
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ let db: Db<u64, u64> = txn.root_db(0).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
edit in sanakirja/src/tests.rs at line 65
[8.2433]→[8.2433:2558](∅→∅),
[8.2558]→[8.22:23](∅→∅),
[8.23]→[8.23:324](∅→∅) − println!("{:?}", env.mmaps);
− let len = std::fs::metadata(&path).unwrap().len();
− assert_eq!(len, (l0 << 9) - l0);
−
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− let db: Db<u64, u64> = txn.root_db(0).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
edit in sanakirja/src/tests.rs at line 66
[8.10882]→[8.10882:10883](∅→∅) replacement in sanakirja/src/tests.rs at line 89
[8.11411]→[8.325:495](∅→∅),
[8.495]→[8.11445:11467](∅→∅),
[8.11445]→[8.11445:11467](∅→∅),
[8.11513]→[8.11513:11967](∅→∅) − let path = "/tmp/sanakirja1";
− std::fs::remove_dir_all(path).unwrap_or(());
− std::fs::create_dir_all(path).unwrap();
− let path = Path::new(path).join("db");
− let l0 = 1 << 20;
− let env = Env::new(&path, l0, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
− use rand::{Rng, SeedableRng};
− let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
− let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
− use std::collections::HashMap;
− let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
+ unsafe {
+ let path = "/tmp/sanakirja1";
+ std::fs::remove_dir_all(path).unwrap_or(());
+ std::fs::create_dir_all(path).unwrap();
+ let path = Path::new(path).join("db");
+ let l0 = 1 << 20;
+ let env = Env::new(&path, l0, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
+ use rand::{Rng, SeedableRng};
+ let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
+ let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
+ use std::collections::HashMap;
+ let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
replacement in sanakirja/src/tests.rs at line 104
[8.11968]→[8.11968:12034](∅→∅) − let mut refs = BTreeMap::new();
− let mut dbs = Vec::new();
+ let mut refs = BTreeMap::new();
+ let mut dbs = Vec::new();
replacement in sanakirja/src/tests.rs at line 107
[8.12035]→[8.496:626](∅→∅),
[8.626]→[8.12182:12383](∅→∅),
[8.12182]→[8.12182:12383](∅→∅) − env_logger::try_init().unwrap_or(());
− for i in 0..1_000_000 {
− let do_debug = false;
− if i % 100_000 == 0 {
− info!("========== i = {:?} {:?}", i, db.db);
− }
− dbs.push(fork_db(&mut txn, &db).unwrap());
− if rng.gen_range(0..4) == 3 {
− if let Some((k, v)) = ve.pop() {
+ env_logger::try_init().unwrap_or(());
+ for i in 0..200_000 {
+ let do_debug = false;
+ if i % 100_000 == 0 {
+ info!("========== i = {:?} {:?}", i, db.db);
+ }
+ dbs.push(fork_db(&mut txn, &db).unwrap());
+ if rng.gen_range(0..4) == 3 {
+ if let Some((k, v)) = ve.pop() {
+ if do_debug {
+ debug!("del {:?} {:?}", k.0[0], v.0[0]);
+ }
+ assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
+ }
+ } else {
+ let k = U([rng.gen(), rng.gen(), rng.gen()]);
+ let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 125
[8.12413]→[8.12413:12474](∅→∅) − debug!("del {:?} {:?}", k.0[0], v.0[0]);
+ debug!("put {:?} {:?}", k.0[0], v.0[0]);
replacement in sanakirja/src/tests.rs at line 127
[8.12492]→[8.12492:12563](∅→∅) − assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
+ put(&mut txn, &mut db, &k, &v).unwrap();
+ ve.push((k, v));
+ h.insert(k, v);
edit in sanakirja/src/tests.rs at line 131
[8.12577]→[8.12577:12732](∅→∅) − } else {
− let k = U([rng.gen(), rng.gen(), rng.gen()]);
− let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 132
[8.12758]→[8.12758:13229](∅→∅) − debug!("put {:?} {:?}", k.0[0], v.0[0]);
− }
− put(&mut txn, &mut db, &k, &v).unwrap();
− ve.push((k, v));
− h.insert(k, v);
− }
− if do_debug {
− debug(&txn, &[&db], format!("debug_{}", i), true);
− for (i, (k, v)) in ve.iter().enumerate() {
− if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
− panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
+ debug(&txn, &[&db], format!("debug_{}", i), true);
+ for (i, (k, v)) in ve.iter().enumerate() {
+ if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
+ panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
+ }
replacement in sanakirja/src/tests.rs at line 138
[8.13247]→[8.13247:13441](∅→∅) − }
− for x in iter(&txn, &db, None).unwrap() {
− let (k, v) = x.unwrap();
− if h.get(k) != Some(v) {
− panic!("test {:?}", k);
+ for x in iter(&txn, &db, None).unwrap() {
+ let (k, v) = x.unwrap();
+ if h.get(k) != Some(v) {
+ panic!("test {:?}", k);
+ }
replacement in sanakirja/src/tests.rs at line 144
[8.13459]→[8.13459:14061](∅→∅) − }
− refs.clear();
− add_refs(&txn, &db, &mut refs).unwrap();
− for db in dbs.iter() {
− add_refs(&txn, db, &mut refs).unwrap();
− }
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− if let Some(ref rc) = txn.rc {
− let mut last = 0;
− for r in iter(&txn, rc, None).unwrap() {
− let (r, _) = r.unwrap();
− if last > 0 && last == (r & !0xfff) {
− panic!("r = {:?} last = {:?}", r, last);
+ refs.clear();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ for db in dbs.iter() {
+ add_refs(&txn, db, &mut refs).unwrap();
+ }
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ if let Some(ref rc) = txn.rc {
+ let mut last = 0;
+ for r in iter(&txn, rc, None).unwrap() {
+ let (r, _) = r.unwrap();
+ let r = r.as_u64();
+ if last > 0 && last == (r & !0xfff) {
+ panic!("r = {:?} last = {:?}", r, last);
+ }
+ last = r & !0xfff;
edit in sanakirja/src/tests.rs at line 161
[8.14083]→[8.14083:14122](∅→∅) replacement in sanakirja/src/tests.rs at line 162
[8.14140]→[8.14140:14394](∅→∅) − }
− let mut n = Vec::new();
− for (p, r) in refs.iter() {
− if *r >= 2 {
− let rc = txn.rc(*p).unwrap();
− if rc != *r as u64 {
− n.push((p, *r, rc))
+ let mut n = Vec::new();
+ for (p, r) in refs.iter() {
+ if *r >= 2 {
+ let rc = txn.rc(*p).unwrap();
+ if rc != *r as u64 {
+ n.push((p, *r, rc))
+ }
+ } else {
+ assert_eq!(txn.rc(*p).unwrap(), 0);
replacement in sanakirja/src/tests.rs at line 172
[8.14416]→[8.14416:14497](∅→∅) − } else {
− assert_eq!(txn.rc(*p).unwrap(), 0);
+ }
+ if !n.is_empty() {
+ panic!("n = {:?} {:?}", n, n.len());
edit in sanakirja/src/tests.rs at line 177
[8.14529]→[8.14529:14613](∅→∅),
[8.14613]→[8.14613:14627](∅→∅) − if !n.is_empty() {
− panic!("n = {:?} {:?}", n, n.len());
− }
edit in sanakirja/src/tests.rs at line 180
[8.14645]→[8.14645:14646](∅→∅) edit in sanakirja/src/tests.rs at line 181
[8.14647]→[8.14647:14648](∅→∅) replacement in sanakirja/src/tests.rs at line 183
[8.14694]→[8.627:797](∅→∅),
[8.797]→[8.14728:14750](∅→∅),
[8.14728]→[8.14728:14750](∅→∅),
[8.14796]→[8.14796:15250](∅→∅) − let path = "/tmp/sanakirja2";
− std::fs::remove_dir_all(path).unwrap_or(());
− std::fs::create_dir_all(path).unwrap();
− let path = Path::new(path).join("db");
− let l0 = 1 << 20;
− let env = Env::new(&path, l0, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
− use rand::{Rng, SeedableRng};
− let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
− let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
− use std::collections::HashMap;
− let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
+ unsafe {
+ let path = "/tmp/sanakirja2";
+ std::fs::remove_dir_all(path).unwrap_or(());
+ std::fs::create_dir_all(path).unwrap();
+ let path = Path::new(path).join("db");
+ let l0 = 1 << 20;
+ let env = Env::new(&path, l0, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db::<MutTxn<&Env, ()>, U, V>(&mut txn).unwrap();
+ use rand::{Rng, SeedableRng};
+ let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
+ let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
+ use std::collections::HashMap;
+ let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
replacement in sanakirja/src/tests.rs at line 198
[8.15251]→[8.15251:15287](∅→∅) − let mut refs = BTreeMap::new();
+ let mut refs = BTreeMap::new();
replacement in sanakirja/src/tests.rs at line 200
[8.15288]→[8.798:880](∅→∅),
[8.880]→[8.15351:15573](∅→∅),
[8.15351]→[8.15351:15573](∅→∅) − for i in 0..1_000_000 {
− let do_debug = false; // i % 10_000_000 == 0;
− if do_debug {
− env_logger::try_init().unwrap_or(());
− info!("========== i = {:?} {:?}", i, db.db);
− }
− if rng.gen_range(0..4) == 3 {
− if let Some((k, v)) = ve.pop() {
+ for i in 0..1_000_000 {
+ let do_debug = false; // i % 10_000_000 == 0;
+ if do_debug {
+ env_logger::try_init().unwrap_or(());
+ info!("========== i = {:?} {:?}", i, db.db);
+ }
+ if rng.gen_range(0..4) == 3 {
+ if let Some((k, v)) = ve.pop() {
+ if do_debug {
+ debug!("del {:?} {:?}", k.0[0], v.0[0]);
+ }
+ assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
+ }
+ } else {
+ let k = U([rng.gen(), rng.gen(), rng.gen()]);
+ let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 217
[8.15603]→[8.15603:15664](∅→∅) − debug!("del {:?} {:?}", k.0[0], v.0[0]);
+ debug!("put {:?} {:?}", k.0[0], v.0[0]);
replacement in sanakirja/src/tests.rs at line 219
[8.15682]→[8.15682:15753](∅→∅) − assert!(del(&mut txn, &mut db, &k, Some(&v)).unwrap())
+ put(&mut txn, &mut db, &k, &v).unwrap();
+ ve.push((k, v));
+ h.insert(k, v);
edit in sanakirja/src/tests.rs at line 223
[8.15767]→[8.15767:15922](∅→∅) − } else {
− let k = U([rng.gen(), rng.gen(), rng.gen()]);
− let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 224
[8.15948]→[8.15948:16356](∅→∅) − debug!("put {:?} {:?}", k.0[0], v.0[0]);
− }
− put(&mut txn, &mut db, &k, &v).unwrap();
− ve.push((k, v));
− h.insert(k, v);
− }
− if do_debug {
− for (i, (k, v)) in ve.iter().enumerate() {
− if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
− panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
+ for (i, (k, v)) in ve.iter().enumerate() {
+ if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
+ panic!("test {:?} {:?} {:?}", i, k.0[0], v.0[0]);
+ }
replacement in sanakirja/src/tests.rs at line 229
[8.16374]→[8.16374:16568](∅→∅) − }
− for x in iter(&txn, &db, None).unwrap() {
− let (k, v) = x.unwrap();
− if h.get(k) != Some(v) {
− panic!("test {:?}", k);
+ for x in iter(&txn, &db, None).unwrap() {
+ let (k, v) = x.unwrap();
+ if h.get(k) != Some(v) {
+ panic!("test {:?}", k);
+ }
replacement in sanakirja/src/tests.rs at line 235
[8.16586]→[8.16586:16948](∅→∅) − }
− refs.clear();
− add_refs(&txn, &db, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− for (p, r) in refs.iter() {
− if *r >= 2 {
− let rc = txn.rc(*p).unwrap();
− if rc != *r as u64 {
− panic!("p {:?} r {:?} {:?}", p, r, rc);
+ refs.clear();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ for (p, r) in refs.iter() {
+ if *r >= 2 {
+ let rc = txn.rc(*p).unwrap();
+ if rc != *r as u64 {
+ panic!("p {:?} r {:?} {:?}", p, r, rc);
+ }
+ } else {
+ assert_eq!(txn.rc(*p).unwrap(), 0);
edit in sanakirja/src/tests.rs at line 247
[8.16970]→[8.16970:17051](∅→∅) − } else {
− assert_eq!(txn.rc(*p).unwrap(), 0);
edit in sanakirja/src/tests.rs at line 253
[8.17102]→[8.17102:17103](∅→∅) replacement in sanakirja/src/tests.rs at line 258
[8.17152]→[8.1038:1208](∅→∅),
[8.1208]→[8.17187:17209](∅→∅),
[8.17187]→[8.17187:17209](∅→∅),
[8.17255]→[8.17255:17743](∅→∅) − let path = "/tmp/sanakirja3";
− std::fs::remove_dir_all(path).unwrap_or(());
− std::fs::create_dir_all(path).unwrap();
− let path = Path::new(path).join("db");
− let l0 = 1 << 20;
− let env = Env::new(&path, l0, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, U, V, btree::page_unsized::Page<U, V>>(&mut txn).unwrap();
− use rand::{Rng, SeedableRng};
− let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
− let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
− use std::collections::HashMap;
− let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
+ unsafe {
+ let path = "/tmp/sanakirja3";
+ std::fs::remove_dir_all(path).unwrap_or(());
+ std::fs::create_dir_all(path).unwrap();
+ let path = Path::new(path).join("db");
+ let l0 = 1 << 20;
+ let env = Env::new(&path, l0, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db =
+ create_db_::<MutTxn<&Env, ()>, U, V, btree::page_unsized::Page<U, V>>(&mut txn)
+ .unwrap();
+ use rand::{Rng, SeedableRng};
+ let mut rng = rand::rngs::SmallRng::from_seed(*b"rc',.snjcg'sthomw,.vbw,.p84fcxjw");
+ let mut ve: Vec<(U, V)> = Vec::with_capacity(100_000);
+ use std::collections::HashMap;
+ let mut h: HashMap<U, V> = HashMap::with_capacity(100_000);
replacement in sanakirja/src/tests.rs at line 275
[8.17744]→[8.17744:17780](∅→∅) − let mut refs = BTreeMap::new();
+ let mut refs = BTreeMap::new();
replacement in sanakirja/src/tests.rs at line 277
[8.17781]→[8.1209:1271](∅→∅),
[8.1271]→[8.17853:18166](∅→∅),
[8.17853]→[8.17853:18166](∅→∅),
[8.18166]→[8.1272:1329](∅→∅),
[8.1329]→[8.18166:18184](∅→∅),
[8.18166]→[8.18166:18184](∅→∅),
[8.18184]→[8.1330:1439](∅→∅) − for i in 0..448696 {
− let do_debug = i >= 448_693;
− if do_debug {
− env_logger::try_init().unwrap_or(());
− info!("========== i = {:?} {:?}", i, db.db);
− }
− if rng.gen_range(0..4) == 3 {
− if let Some((k, v)) = ve.pop() {
− if do_debug {
− debug!("del {:?} {:?}", k.0[0], v.0[0]);
− debug(&txn, &[&db], "debug0", true);
− }
− if !del(&mut txn, &mut db, &k, Some(&v)).unwrap() {
− panic!("del {}", i);
+ for i in 0..448696 {
+ let do_debug = i >= 448_693;
+ if do_debug {
+ env_logger::try_init().unwrap_or(());
+ info!("========== i = {:?} {:?}", i, db.db);
+ }
+ if rng.gen_range(0..4) == 3 {
+ if let Some((k, v)) = ve.pop() {
+ if do_debug {
+ debug!("del {:?} {:?}", k.0[0], v.0[0]);
+ debug(&txn, &[&db], "debug0", true);
+ }
+ if !del(&mut txn, &mut db, &k, Some(&v)).unwrap() {
+ panic!("del {}", i);
+ }
+ if do_debug {
+ debug(&txn, &[&db], "debug1", true);
+ }
edit in sanakirja/src/tests.rs at line 296
+ } else {
+ let k = U([rng.gen(), rng.gen(), rng.gen()]);
+ let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 300
[8.1487]→[8.1487:1544](∅→∅) − debug(&txn, &[&db], "debug1", true);
+ debug!("put {:?} {:?}", k.0[0], v.0[0]);
edit in sanakirja/src/tests.rs at line 302
+ put(&mut txn, &mut db, &k, &v).unwrap();
+ ve.push((k, v));
+ h.insert(k, v);
edit in sanakirja/src/tests.rs at line 306
[8.18269]→[8.18269:18424](∅→∅) − } else {
− let k = U([rng.gen(), rng.gen(), rng.gen()]);
− let v = V([rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()]);
replacement in sanakirja/src/tests.rs at line 307
[8.18450]→[8.18450:18663](∅→∅),
[8.18663]→[8.1563:1619](∅→∅),
[8.1619]→[8.18718:18788](∅→∅),
[8.18718]→[8.18718:18788](∅→∅),
[8.18788]→[8.1620:1756](∅→∅) − debug!("put {:?} {:?}", k.0[0], v.0[0]);
− }
− put(&mut txn, &mut db, &k, &v).unwrap();
− ve.push((k, v));
− h.insert(k, v);
− }
− if do_debug {
− for (i_, (k, v)) in ve.iter().enumerate() {
− if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
− debug(&txn, &[&db], "debug1", true);
− panic!("test {:?} {:?} {:?} {:?}", i, i_, k.0[0], v.0[0]);
+ for (i_, (k, v)) in ve.iter().enumerate() {
+ if get(&txn, &db, k, None).unwrap() != Some((k, v)) {
+ debug(&txn, &[&db], "debug1", true);
+ panic!("test {:?} {:?} {:?} {:?}", i, i_, k.0[0], v.0[0]);
+ }
replacement in sanakirja/src/tests.rs at line 313
[8.18876]→[8.18876:19070](∅→∅) − }
− for x in iter(&txn, &db, None).unwrap() {
− let (k, v) = x.unwrap();
− if h.get(k) != Some(v) {
− panic!("test {:?}", k);
+ for x in iter(&txn, &db, None).unwrap() {
+ let (k, v) = x.unwrap();
+ if h.get(k) != Some(v) {
+ panic!("test {:?}", k);
+ }
replacement in sanakirja/src/tests.rs at line 319
[8.19088]→[8.19088:19450](∅→∅) − }
− refs.clear();
− add_refs(&txn, &db, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− for (p, r) in refs.iter() {
− if *r >= 2 {
− let rc = txn.rc(*p).unwrap();
− if rc != *r as u64 {
− panic!("p {:?} r {:?} {:?}", p, r, rc);
+ refs.clear();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ for (p, r) in refs.iter() {
+ if *r >= 2 {
+ let rc = txn.rc(*p).unwrap();
+ if rc != *r as u64 {
+ panic!("p {:?} r {:?} {:?}", p, r, rc);
+ }
+ } else {
+ assert_eq!(txn.rc(*p).unwrap(), 0);
edit in sanakirja/src/tests.rs at line 331
[8.19472]→[8.19472:19553](∅→∅) − } else {
− assert_eq!(txn.rc(*p).unwrap(), 0);
edit in sanakirja/src/tests.rs at line 337
[8.19603]→[8.19603:19604](∅→∅),
[8.19604]→[8.19604:19605](∅→∅),
[8.19605]→[8.19605:19607](∅→∅),
[8.2560]→[8.978:979](∅→∅),
[8.19607]→[8.978:979](∅→∅),
[8.25573]→[8.978:979](∅→∅),
[8.978]→[8.978:979](∅→∅) replacement in sanakirja/src/tests.rs at line 339
[8.1049]→[8.1049:1091](∅→∅),
[8.1091]→[8.1019:1071](∅→∅),
[8.1071]→[8.1140:1193](∅→∅),
[8.1140]→[8.1140:1193](∅→∅),
[8.1193]→[8.25574:25649](∅→∅),
[8.25649]→[8.14499:14521](∅→∅),
[8.14521]→[8.1312:1330](∅→∅),
[8.1312]→[8.1312:1330](∅→∅),
[8.1374]→[8.1374:1465](∅→∅),
[8.1525]→[8.1525:1600](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db::<MutTxn<&Env, ()>, u64, A>(&mut txn).unwrap();
− let n = 1_000u64;
− let m = 1000;
− let mut values = Vec::with_capacity(n as usize);
− let i0 = 500;
− for i in 0..n {
− if i != i0 && (i * i) % m == (i0 * i0) % m {
− continue;
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db::<MutTxn<&Env, ()>, u64, A>(&mut txn).unwrap();
+ let n = 1_000u64;
+ let m = 1000;
+ let mut values = Vec::with_capacity(n as usize);
+ let i0 = 500;
+ for i in 0..n {
+ if i != i0 && (i * i) % m == (i0 * i0) % m {
+ continue;
+ }
+ let a = A([i * i * i; 100]);
+ if put(&mut txn, &mut db, &((i * i) % m), &a).unwrap() {
+ values.push((i * i) % m);
+ }
replacement in sanakirja/src/tests.rs at line 357
[8.1610]→[8.25650:25687](∅→∅),
[8.25687]→[8.1673:1776](∅→∅),
[8.1673]→[8.1673:1776](∅→∅) − let a = A([i * i * i; 100]);
− if put(&mut txn, &mut db, &((i * i) % m), &a).unwrap() {
− values.push((i * i) % m);
+ values.sort();
+ debug(&txn, &[&db], "debug0", true);
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ let mut nn = 0;
+ while let Some((k, v)) = curs.next(&mut txn).unwrap() {
+ debug!("{:?} {:?}", k, v.0[0]);
+ assert_eq!(*k, values[nn]);
+ nn += 1;
replacement in sanakirja/src/tests.rs at line 366
[8.1842]→[8.1842:1848](∅→∅),
[8.1933]→[8.1933:1952](∅→∅),
[8.1953]→[8.14522:14589](∅→∅),
[8.14589]→[8.2005:2025](∅→∅),
[8.2005]→[8.2005:2025](∅→∅),
[8.2025]→[8.14590:14690](∅→∅),
[8.14690]→[8.2148:2241](∅→∅),
[8.2148]→[8.2148:2241](∅→∅) − }
− values.sort();
− let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− let mut nn = 0;
− while let Some((k, v)) = curs.next(&mut txn).unwrap() {
− debug!("{:?} {:?}", k, v.0[0]);
− assert_eq!(*k, values[nn]);
− nn += 1;
− }
− assert_eq!(nn, values.len());
+ assert_eq!(nn, values.len());
replacement in sanakirja/src/tests.rs at line 368
[8.2242]→[8.1757:1804](∅→∅),
[8.1804]→[8.25688:25713](∅→∅),
[8.1199]→[8.25688:25713](∅→∅),
[8.25713]→[8.11492:11543](∅→∅),
[8.11543]→[8.14691:14758](∅→∅),
[8.14758]→[8.41662:41737](∅→∅),
[8.41737]→[8.2551:2626](∅→∅),
[8.2551]→[8.2551:2626](∅→∅) − let db2 = fork_db(&mut txn, &db).unwrap();
− let a = A([0; 100]);
− put(&mut txn, &mut db, &(m / 2), &a).unwrap();
− let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− let (k, v) = curs.set(&txn, &((i0 * i0) % m), None).unwrap().unwrap();
− assert_eq!((i0 * i0) % m, *k);
− assert_eq!(i0 * i0 * i0, (v.0)[0]);
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ let a = A([0; 100]);
+ put(&mut txn, &mut db, &(m / 2), &a).unwrap();
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ let (k, v) = curs.set(&txn, &((i0 * i0) % m), None).unwrap().unwrap();
+ assert_eq!((i0 * i0) % m, *k);
+ assert_eq!(i0 * i0 * i0, (v.0)[0]);
replacement in sanakirja/src/tests.rs at line 376
[8.2627]→[8.14759:14826](∅→∅),
[8.14826]→[8.25714:25750](∅→∅),
[8.2679]→[8.25714:25750](∅→∅),
[8.25750]→[8.41738:41817](∅→∅),
[8.41817]→[8.2855:2930](∅→∅),
[8.2855]→[8.2855:2930](∅→∅) − let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− let a = A([i0 * i0 * i0; 100]);
− let (k, v) = curs.set(&txn, &((i0 * i0) % m), Some(&a)).unwrap().unwrap();
− assert_eq!((i0 * i0) % m, *k);
− assert_eq!(i0 * i0 * i0, (v.0)[0]);
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ let a = A([i0 * i0 * i0; 100]);
+ let (k, v) = curs.set(&txn, &((i0 * i0) % m), Some(&a)).unwrap().unwrap();
+ assert_eq!((i0 * i0) % m, *k);
+ assert_eq!(i0 * i0 * i0, (v.0)[0]);
replacement in sanakirja/src/tests.rs at line 382
[8.2931]→[8.155:196](∅→∅),
[8.196]→[8.14882:14949](∅→∅),
[8.14882]→[8.14882:14949](∅→∅),
[8.14949]→[8.1745:1831](∅→∅),
[8.1831]→[8.3039:3082](∅→∅),
[8.3039]→[8.3039:3082](∅→∅),
[8.3082]→[8.1805:1832](∅→∅) − debug(&txn, &[&db], "debug0", true);
− let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− curs.set_last(&txn).unwrap();
− let (k, _) = curs.prev(&txn).unwrap().unwrap();
− assert_eq!(k, values.last().unwrap());
− txn.commit().unwrap();
+ debug(&txn, &[&db], "debug0", true);
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ curs.set_last(&txn).unwrap();
+ let (k, _) = curs.prev(&txn).unwrap().unwrap();
+ assert_eq!(k, values.last().unwrap());
+ txn.commit().unwrap();
replacement in sanakirja/src/tests.rs at line 389
[8.1833]→[8.1833:2128](∅→∅) − let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 401
[8.4334]→[8.4334:4376](∅→∅),
[8.4376]→[8.1200:1252](∅→∅),
[8.1252]→[8.4425:4478](∅→∅),
[8.4425]→[8.4425:4478](∅→∅),
[8.4478]→[8.25751:25811](∅→∅),
[8.25811]→[8.0:27](∅→∅),
[8.27]→[8.4616:4708](∅→∅),
[8.608]→[8.4616:4708](∅→∅),
[8.4616]→[8.4616:4708](∅→∅),
[8.4750]→[8.4750:4786](∅→∅),
[8.4786]→[8.2129:2196](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
− let n = 10_000_000u64;
− for i in 0..n {
− put(&mut txn, &mut db, &((i * i) % 1_000), &()).unwrap();
− }
− let d = 10;
− for i in 0..d {
− del(&mut txn, &mut db, &((i * i) % 1_000), None).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
+ let n = 10_000_000u64;
+ for i in 0..n {
+ put(&mut txn, &mut db, &((i * i) % 1_000), &()).unwrap();
+ }
+ let d = 10;
+ for i in 0..d {
+ del(&mut txn, &mut db, &((i * i) % 1_000), None).unwrap();
+ }
+ txn.set_root(0, db.db.into());
+ txn.commit().unwrap();
+
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_refs(
+ &txn,
+ &txn.root_db::<u64, (), btree::page::Page<u64, ()>>(0)
+ .unwrap(),
+ &mut refs,
+ )
+ .unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
edit in sanakirja/src/tests.rs at line 430
[8.2202]→[8.2202:2229](∅→∅),
[8.2229]→[8.2229:2230](∅→∅),
[8.2230]→[8.2230:2434](∅→∅) − txn.commit().unwrap();
−
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
replacement in sanakirja/src/tests.rs at line 434
[8.2473]→[8.2473:2867](∅→∅),
[8.2867]→[8.609:709](∅→∅),
[8.4786]→[8.609:709](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
− let n = 40u64;
− let a = A([0; 100]);
− for i in 0..n {
− put(&mut txn, &mut db, &i, &a).unwrap();
− }
− debug(&txn, &[&db], "debug0", true);
− for i in (0..n).rev() {
− del(&mut txn, &mut db, &((i * i) % 1_000), None).unwrap();
− }
− txn.commit().unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
+ let n = 40u64;
+ let a = A([0; 100]);
+ for i in 0..n {
+ put(&mut txn, &mut db, &i, &a).unwrap();
+ }
+ debug(&txn, &[&db], "debug0", true);
+ for i in (0..n).rev() {
+ del(&mut txn, &mut db, &((i * i) % 1_000), None).unwrap();
+ }
+ txn.commit().unwrap();
replacement in sanakirja/src/tests.rs at line 450
[8.2869]→[8.2869:3118](∅→∅) − let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 461
[8.739]→[8.739:947](∅→∅),
[8.947]→[8.28:54](∅→∅),
[8.54]→[8.977:1062](∅→∅),
[8.977]→[8.977:1062](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
− let n = 1_000_000u64;
− for i in 0..n {
− put(&mut txn, &mut db, &((i * i) % 1_000), &i).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
+ let n = 1_000_000u64;
+ for i in 0..n {
+ put(&mut txn, &mut db, &((i * i) % 1_000), &i).unwrap();
+ }
+ txn.set_root(0, db.db.into());
+ txn.commit().unwrap();
+
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
edit in sanakirja/src/tests.rs at line 480
[8.4916]→[8.4916:4943](∅→∅),
[8.4943]→[8.3119:3324](∅→∅) − txn.commit().unwrap();
−
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
replacement in sanakirja/src/tests.rs at line 484
[8.5018]→[8.5018:5060](∅→∅),
[8.5060]→[8.1317:1369](∅→∅),
[8.1369]→[8.5109:5162](∅→∅),
[8.5109]→[8.5109:5162](∅→∅),
[8.5162]→[8.25812:25872](∅→∅),
[8.25872]→[8.55:79](∅→∅),
[8.79]→[8.5256:5276](∅→∅),
[8.5256]→[8.5256:5276](∅→∅),
[8.5320]→[8.5320:5465](∅→∅),
[8.5465]→[8.1470:1517](∅→∅),
[8.1517]→[8.14950:15017](∅→∅),
[8.15017]→[8.1832:1920](∅→∅),
[8.1920]→[8.1518:1844](∅→∅),
[8.5650]→[8.1518:1844](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
− let n = 100_000u64;
− let m = 10_000;
− let mut max = 0;
− for i in 0..n {
− put(&mut txn, &mut db, &((i * i) % m), &()).unwrap();
− max = max.max((i * i) % m);
− }
− let db2 = fork_db(&mut txn, &db).unwrap();
− let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− curs.set_last(&txn).unwrap();
− let (&nn, _) = curs.prev(&txn).unwrap().unwrap();
− assert_eq!(max, nn);
− let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− for (p, r) in refs.iter() {
− if *r >= 2 {
− assert_eq!(txn.rc(*p).unwrap(), *r as u64);
− } else {
− assert_eq!(txn.rc(*p).unwrap(), 0);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
+ let n = 100_000u64;
+ let m = 10_000;
+ let mut max = 0;
+ for i in 0..n {
+ put(&mut txn, &mut db, &((i * i) % m), &()).unwrap();
+ max = max.max((i * i) % m);
+ }
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ curs.set_last(&txn).unwrap();
+ let (&nn, _) = curs.prev(&txn).unwrap().unwrap();
+ assert_eq!(max, nn);
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ for (p, r) in refs.iter() {
+ if *r >= 2 {
+ assert_eq!(txn.rc(*p).unwrap(), *r as u64);
+ } else {
+ assert_eq!(txn.rc(*p).unwrap(), 0);
+ }
edit in sanakirja/src/tests.rs at line 511
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ check_refs(&txn, &refs);
+ txn.commit().unwrap();
edit in sanakirja/src/tests.rs at line 516
[8.1860]→[8.3325:3467](∅→∅) − add_free_refs_mut(&txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− check_refs(&txn, &refs);
− txn.commit().unwrap();
replacement in sanakirja/src/tests.rs at line 520
[8.237]→[8.237:507](∅→∅),
[8.507]→[8.1921:2004](∅→∅),
[8.2004]→[8.3468:3824](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let db: Db<u64, ()> = create_db(&mut txn).unwrap();
− let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− curs.set_last(&txn).unwrap();
− assert!(curs.next(&txn).unwrap().is_none());
− txn.set_root(0, db.db);
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− let db: Db<u64, u64> = txn.root_db(0).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let db: Db<u64, ()> = create_db(&mut txn).unwrap();
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ curs.set_last(&txn).unwrap();
+ assert!(curs.next(&txn).unwrap().is_none());
+ txn.set_root(0, db.db.into());
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ let db: Db<u64, u64> = txn.root_db(0).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 542
[8.8950]→[8.8950:8992](∅→∅),
[8.8992]→[8.1434:1486](∅→∅),
[8.1486]→[8.9041:9094](∅→∅),
[8.9041]→[8.9041:9094](∅→∅),
[8.9094]→[8.25873:25933](∅→∅),
[8.25933]→[8.80:102](∅→∅),
[8.102]→[8.9230:9389](∅→∅),
[8.9230]→[8.9230:9389](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
− let n = 2_000u64;
− let mut values = Vec::with_capacity(n as usize);
− for i in 0..n - 1 {
− if put(&mut txn, &mut db, &i, &()).unwrap() {
− values.push(i);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, ()> = create_db(&mut txn).unwrap();
+ let n = 2_000u64;
+ let mut values = Vec::with_capacity(n as usize);
+ for i in 0..n - 1 {
+ if put(&mut txn, &mut db, &i, &()).unwrap() {
+ values.push(i);
+ }
edit in sanakirja/src/tests.rs at line 554
+ del(&mut txn, &mut db, &1274, None).unwrap();
+ del(&mut txn, &mut db, &1529, None).unwrap();
+ assert!(!del(&mut txn, &mut db, &(n + 1), None).unwrap());
+ txn.set_root(0, db.db.into());
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ let db: Db<u64, ()> = txn.root_db(0).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
edit in sanakirja/src/tests.rs at line 567
[8.9499]→[8.9499:9549](∅→∅),
[8.9644]→[8.9644:9694](∅→∅),
[8.9744]→[8.9744:9807](∅→∅),
[8.9807]→[8.3825:4180](∅→∅) − del(&mut txn, &mut db, &1274, None).unwrap();
− del(&mut txn, &mut db, &1529, None).unwrap();
− assert!(!del(&mut txn, &mut db, &(n + 1), None).unwrap());
− txn.set_root(0, db.db);
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− let db: Db<u64, ()> = txn.root_db(0).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
replacement in sanakirja/src/tests.rs at line 571
[8.235]→[8.235:382](∅→∅),
[8.382]→[8.2005:2084](∅→∅),
[8.2084]→[8.122:142](∅→∅),
[8.122]→[8.122:142](∅→∅),
[8.142]→[8.10810:10883](∅→∅),
[8.490]→[8.10810:10883](∅→∅),
[8.10883]→[8.2085:2163](∅→∅),
[8.2163]→[8.10932:10981](∅→∅),
[8.10932]→[8.10932:10981](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
− let n = 200u64;
− let i0 = 10u64;
− let mut values = Vec::with_capacity(n as usize);
− for i in 0..n {
− let a = A([i; 100]);
− put(&mut txn, &mut db, &i, &a).unwrap();
− if i != i0 {
− values.push(i);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
+ let n = 200u64;
+ let i0 = 10u64;
+ let mut values = Vec::with_capacity(n as usize);
+ for i in 0..n {
+ let a = A([i; 100]);
+ put(&mut txn, &mut db, &i, &a).unwrap();
+ if i != i0 {
+ values.push(i);
+ }
replacement in sanakirja/src/tests.rs at line 586
[8.10991]→[8.10991:10997](∅→∅),
[8.10997]→[8.2164:2211](∅→∅),
[8.2211]→[8.11044:11092](∅→∅),
[8.3771]→[8.11044:11092](∅→∅),
[8.11044]→[8.11044:11092](∅→∅),
[8.11092]→[8.2212:2259](∅→∅),
[8.2259]→[8.11092:11108](∅→∅),
[8.11092]→[8.11092:11108](∅→∅),
[8.11108]→[8.143:173](∅→∅),
[8.173]→[8.11145:11261](∅→∅),
[8.11145]→[8.11145:11261](∅→∅),
[8.11261]→[8.4181:4238](∅→∅) − }
− let db2 = fork_db(&mut txn, &db).unwrap();
− del(&mut txn, &mut db, &i0, None).unwrap();
− debug(&txn, &[&db, &db2], "debug0", true);
− assert_eq!(
− iter(&txn, &db, None)
− .unwrap()
− .map(|kv| *kv.unwrap().0)
− .collect::<Vec<_>>(),
− values
− );
− txn.set_root(0, db.db);
− txn.set_root(1, db2.db);
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ del(&mut txn, &mut db, &i0, None).unwrap();
+ debug(&txn, &[&db, &db2], "debug0", true);
+ assert_eq!(
+ iter(&txn, &db, None)
+ .unwrap()
+ .map(|kv| *kv.unwrap().0)
+ .collect::<Vec<_>>(),
+ values
+ );
+ txn.set_root(0, db.db.into());
+ txn.set_root(1, db2.db.into());
replacement in sanakirja/src/tests.rs at line 599
[8.4239]→[8.4239:4662](∅→∅) − txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− let db: Db<u64, A> = txn.root_db(0).unwrap();
− let db2: Db<u64, A> = txn.root_db(1).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ let db: Db<u64, A> = txn.root_db(0).unwrap();
+ let db2: Db<u64, A> = txn.root_db(1).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 614
[8.11296]→[8.11296:11504](∅→∅),
[8.11504]→[8.174:215](∅→∅),
[8.215]→[8.490:661](∅→∅),
[8.11553]→[8.490:661](∅→∅),
[8.490]→[8.490:661](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
− let n = 256u64;
− let i0 = 127u64;
− let mut values = Vec::with_capacity(n as usize);
− for i in 0..n {
− put(&mut txn, &mut db, &i, &i).unwrap();
− if i != i0 {
− values.push(i);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
+ let n = 256u64;
+ let i0 = 127u64;
+ let mut values = Vec::with_capacity(n as usize);
+ for i in 0..n {
+ put(&mut txn, &mut db, &i, &i).unwrap();
+ if i != i0 {
+ values.push(i);
+ }
replacement in sanakirja/src/tests.rs at line 628
[8.671]→[8.671:677](∅→∅),
[8.20955]→[8.11608:11639](∅→∅),
[8.11608]→[8.11608:11639](∅→∅),
[8.11639]→[8.561:601](∅→∅),
[8.601]→[8.13307:13354](∅→∅),
[8.13307]→[8.13307:13354](∅→∅),
[8.11639]→[8.724:772](∅→∅),
[8.13354]→[8.724:772](∅→∅),
[8.724]→[8.724:772](∅→∅),
[8.772]→[8.602:649](∅→∅),
[8.649]→[8.11640:11810](∅→∅),
[8.21017]→[8.11640:11810](∅→∅),
[8.772]→[8.11640:11810](∅→∅),
[8.11810]→[8.650:703](∅→∅),
[8.703]→[8.772:788](∅→∅),
[8.11877]→[8.772:788](∅→∅),
[8.772]→[8.772:788](∅→∅),
[8.788]→[8.216:246](∅→∅),
[8.246]→[8.825:941](∅→∅),
[8.825]→[8.825:941](∅→∅),
[8.941]→[8.4663:4720](∅→∅) − }
− debug!("===============");
− debug(&txn, &[&db], "debug", true);
− let db2 = fork_db(&mut txn, &db).unwrap();
− del(&mut txn, &mut db, &i0, None).unwrap();
− debug(&txn, &[&db, &db2], "debug1", true);
− let db3: Db<u64, u64> = Db {
− db: 20480,
− k: std::marker::PhantomData,
− v: std::marker::PhantomData,
− p: std::marker::PhantomData,
− };
− debug(&txn, &[&db, &db2, &db3], "debug2", true);
− assert_eq!(
− iter(&txn, &db, None)
− .unwrap()
− .map(|kv| *kv.unwrap().0)
− .collect::<Vec<_>>(),
− values
− );
− txn.set_root(0, db.db);
− txn.set_root(1, db2.db);
+ debug!("===============");
+ debug(&txn, &[&db], "debug", true);
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ del(&mut txn, &mut db, &i0, None).unwrap();
+ debug(&txn, &[&db, &db2], "debug1", true);
+ let db3: Db<u64, u64> = Db {
+ db: core::num::NonZeroU64::new_unchecked(20480),
+ k: std::marker::PhantomData,
+ v: std::marker::PhantomData,
+ p: std::marker::PhantomData,
+ };
+ debug(&txn, &[&db, &db2, &db3], "debug2", true);
+ assert_eq!(
+ iter(&txn, &db, None)
+ .unwrap()
+ .map(|kv| *kv.unwrap().0)
+ .collect::<Vec<_>>(),
+ values
+ );
+ txn.set_root(0, db.db.into());
+ txn.set_root(1, db2.db.into());
replacement in sanakirja/src/tests.rs at line 650
[8.4721]→[8.4721:5043](∅→∅) − txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 663
[8.11899]→[8.5742:5784](∅→∅),
[8.5742]→[8.5742:5784](∅→∅),
[8.5784]→[8.1551:1603](∅→∅),
[8.1603]→[8.5833:5886](∅→∅),
[8.5833]→[8.5833:5886](∅→∅),
[8.5886]→[8.25934:25993](∅→∅),
[8.25993]→[8.247:266](∅→∅),
[8.266]→[8.6021:6074](∅→∅),
[8.21041]→[8.6021:6074](∅→∅),
[8.26016]→[8.6021:6074](∅→∅),
[8.6021]→[8.6021:6074](∅→∅),
[8.6074]→[8.26017:26042](∅→∅),
[8.26042]→[8.6074:6098](∅→∅),
[8.6074]→[8.6074:6098](∅→∅),
[8.6098]→[8.26043:26096](∅→∅),
[8.26096]→[8.6152:6180](∅→∅),
[8.6152]→[8.6152:6180](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
− let n = 19u64;
− let mut values = Vec::with_capacity(n as usize);
− let a = A([0; 100]);
− for i in 0..n - 1 {
− if put(&mut txn, &mut db, &i, &a).unwrap() {
− values.push(i);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
+ let n = 19u64;
+ let mut values = Vec::with_capacity(n as usize);
+ let a = A([0; 100]);
+ for i in 0..n - 1 {
+ if put(&mut txn, &mut db, &i, &a).unwrap() {
+ values.push(i);
+ }
edit in sanakirja/src/tests.rs at line 676
[8.6190]→[8.6190:6196](∅→∅) replacement in sanakirja/src/tests.rs at line 677
[8.1862]→[8.6231:6278](∅→∅),
[8.6231]→[8.6231:6278](∅→∅),
[8.6328]→[8.6328:6386](∅→∅),
[8.6386]→[8.704:751](∅→∅),
[8.751]→[8.1460:1482](∅→∅),
[8.21103]→[8.1460:1482](∅→∅),
[8.6386]→[8.1460:1482](∅→∅),
[8.119]→[8.6386:6410](∅→∅),
[8.1482]→[8.6386:6410](∅→∅),
[8.1908]→[8.6386:6410](∅→∅),
[8.6386]→[8.6386:6410](∅→∅),
[8.6410]→[8.26097:26150](∅→∅),
[8.26150]→[8.6464:6492](∅→∅),
[8.6464]→[8.6464:6492](∅→∅) − let db2 = fork_db(&mut txn, &db).unwrap();
− let mut values2 = values.clone();
− values2.sort();
− debug(&txn, &[&db, &db2], "debug0", true);
− debug!(">>>>>>");
− for i in n - 1..n {
− if put(&mut txn, &mut db, &i, &a).unwrap() {
− values.push(i);
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ let mut values2 = values.clone();
+ values2.sort();
+ debug(&txn, &[&db, &db2], "debug0", true);
+ debug!(">>>>>>");
+ for i in n - 1..n {
+ if put(&mut txn, &mut db, &i, &a).unwrap() {
+ values.push(i);
+ }
replacement in sanakirja/src/tests.rs at line 687
[8.6502]→[8.6502:6508](∅→∅),
[8.6508]→[8.1483:1508](∅→∅),
[8.1508]→[8.6508:6527](∅→∅),
[8.6508]→[8.6508:6527](∅→∅),
[8.6527]→[8.752:799](∅→∅) − }
− debug!("<<<<<<<<<");
− values.sort();
− debug(&txn, &[&db, &db2], "debug1", true);
+ debug!("<<<<<<<<<");
+ values.sort();
+ debug(&txn, &[&db, &db2], "debug1", true);
replacement in sanakirja/src/tests.rs at line 691
[8.6528]→[8.15018:15085](∅→∅),
[8.15085]→[8.6677:6757](∅→∅),
[8.6677]→[8.6677:6757](∅→∅),
[8.6787]→[8.6787:6846](∅→∅) − let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− let mut nn = 0;
− while let Some((k, _)) = curs.next(&mut txn).unwrap() {
− assert_eq!(*k, values[nn]);
− nn += 1;
− }
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ let mut nn = 0;
+ while let Some((k, _)) = curs.next(&mut txn).unwrap() {
+ assert_eq!(*k, values[nn]);
+ nn += 1;
+ }
replacement in sanakirja/src/tests.rs at line 698
[8.6847]→[8.15086:15153](∅→∅),
[8.15153]→[8.41818:41863](∅→∅) − let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
− curs.set(&txn, &500, Some(&a)).unwrap();
+ let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ curs.set(&txn, &500, Some(&a)).unwrap();
replacement in sanakirja/src/tests.rs at line 701
[8.6954]→[8.6954:6988](∅→∅),
[8.6988]→[8.15154:15222](∅→∅),
[8.15222]→[8.7041:7121](∅→∅),
[8.7041]→[8.7041:7121](∅→∅),
[8.7121]→[8.21166:21194](∅→∅),
[8.21194]→[8.7121:7216](∅→∅),
[8.7121]→[8.7121:7216](∅→∅) − assert_eq!(nn, values.len());
− let mut curs = btree::cursor::Cursor::new(&txn, &db2).unwrap();
− let mut nn = 0;
− while let Some((k, _)) = curs.next(&mut txn).unwrap() {
− debug!("{:?}", *k);
− assert_eq!(*k, values2[nn]);
− nn += 1;
− }
− assert_eq!(nn, values2.len());
+ assert_eq!(nn, values.len());
+ let mut curs = btree::cursor::Cursor::new(&txn, &db2).unwrap();
+ let mut nn = 0;
+ while let Some((k, _)) = curs.next(&mut txn).unwrap() {
+ debug!("{:?}", *k);
+ assert_eq!(*k, values2[nn]);
+ nn += 1;
+ }
+ assert_eq!(nn, values2.len());
replacement in sanakirja/src/tests.rs at line 711
[8.9981]→[8.122:164](∅→∅),
[8.164]→[8.800:847](∅→∅) − debug!("{:?}", txn.free_owned_pages);
− debug(&txn, &[&db, &db2], "debug0", true);
+ debug!("{:?}", txn.free_owned_pages);
+ debug(&txn, &[&db, &db2], "debug0", true);
replacement in sanakirja/src/tests.rs at line 714
[8.26206]→[8.26206:26345](∅→∅),
[8.26345]→[8.848:895](∅→∅),
[8.895]→[8.248:277](∅→∅),
[8.26406]→[8.248:277](∅→∅),
[8.10125]→[8.248:277](∅→∅),
[8.277]→[8.9607:9628](∅→∅),
[8.9628]→[8.896:962](∅→∅),
[8.962]→[8.11980:12016](∅→∅),
[8.11980]→[8.11980:12016](∅→∅),
[8.306]→[8.10238:10295](∅→∅),
[8.9628]→[8.10238:10295](∅→∅),
[8.12016]→[8.10238:10295](∅→∅),
[8.26427]→[8.10238:10295](∅→∅),
[8.10238]→[8.10238:10295](∅→∅),
[8.9690]→[8.9690:9771](∅→∅),
[8.9771]→[8.358:392](∅→∅),
[8.10652]→[8.358:392](∅→∅),
[8.392]→[8.963:1010](∅→∅) − debug!("==============");
− del(&mut txn, &mut db, &11, None).unwrap();
− debug!("free_owned_pages = {:?}", txn.free_owned_pages);
− debug(&txn, &[&db, &db2], "debug1", true);
− debug!("=============");
− for i in 0..15 {
− debug(&txn, &[&db, &db2], &format!("debug-{}", i), true);
− debug!("deleting {:?}", i);
− del(&mut txn, &mut db, &i, None).unwrap();
− }
− for i in n / 2..n {
− del(&mut txn, &mut db, &i, None).unwrap();
− }
− debug!("{:?} {:?}", db, db2);
− debug(&txn, &[&db, &db2], "debug3", true);
+ debug!("==============");
+ del(&mut txn, &mut db, &11, None).unwrap();
+ debug!("free_owned_pages = {:?}", txn.free_owned_pages);
+ debug(&txn, &[&db, &db2], "debug1", true);
+ debug!("=============");
+ for i in 0..15 {
+ debug(&txn, &[&db, &db2], &format!("debug-{}", i), true);
+ debug!("deleting {:?}", i);
+ del(&mut txn, &mut db, &i, None).unwrap();
+ }
+ for i in n / 2..n {
+ del(&mut txn, &mut db, &i, None).unwrap();
+ }
+ debug!("{:?} {:?}", db, db2);
+ debug(&txn, &[&db, &db2], "debug3", true);
replacement in sanakirja/src/tests.rs at line 730
[8.2189]→[8.7217:7253](∅→∅),
[8.10652]→[8.7217:7253](∅→∅),
[8.7217]→[8.7217:7253](∅→∅),
[8.7287]→[8.7287:7378](∅→∅),
[8.7378]→[8.2190:2239](∅→∅),
[8.2239]→[8.26521:26542](∅→∅),
[8.26542]→[8.2239:2329](∅→∅),
[8.2239]→[8.2239:2329](∅→∅),
[8.2329]→[8.26543:26689](∅→∅) − let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− // add_refs(&txn, &db3, &mut refs).unwrap();
− let mut err = 0;
− for (p, r) in refs.iter() {
− println!("{:?} {:?}", p, r);
− if *r >= 2 {
− if txn.rc(*p).unwrap() != *r as u64 {
− error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
− err += 1;
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ // add_refs(&txn, &db3, &mut refs).unwrap();
+ let mut err = 0;
+ for (p, r) in refs.iter() {
+ println!("{:?} {:?}", p, r);
+ if *r >= 2 {
+ if txn.rc(*p).unwrap() != *r as u64 {
+ error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
+ err += 1;
+ }
+ } else {
+ if txn.rc(*p).unwrap() != 0 {
+ error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
+ err += 1;
+ }
edit in sanakirja/src/tests.rs at line 748
[8.26703]→[8.2385:2402](∅→∅),
[8.2385]→[8.2385:2402](∅→∅),
[8.2402]→[8.26704:26835](∅→∅),
[8.26835]→[8.26835:26849](∅→∅) − } else {
− if txn.rc(*p).unwrap() != 0 {
− error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
− err += 1;
− }
edit in sanakirja/src/tests.rs at line 749
+ assert_eq!(err, 0);
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ debug!("{:?}", refs);
edit in sanakirja/src/tests.rs at line 757
[8.2466]→[8.26850:26874](∅→∅),
[8.2466]→[8.7378:7458](∅→∅),
[8.26874]→[8.7378:7458](∅→∅),
[8.7378]→[8.7378:7458](∅→∅) − assert_eq!(err, 0);
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
replacement in sanakirja/src/tests.rs at line 762
[8.1793]→[8.1793:1912](∅→∅) − std::fs::remove_dir_all("/tmp/sanakirja0").unwrap_or(());
− std::fs::create_dir_all("/tmp/sanakirja0").unwrap();
+ unsafe {
+ std::fs::remove_dir_all("/tmp/sanakirja_multi_txn").unwrap_or(());
+ std::fs::create_dir_all("/tmp/sanakirja_multi_txn").unwrap();
replacement in sanakirja/src/tests.rs at line 766
[8.793]→[8.793:835](∅→∅),
[8.835]→[8.360:401](∅→∅),
[8.401]→[8.880:917](∅→∅),
[8.880]→[8.880:917](∅→∅) − env_logger::try_init().unwrap_or(());
− let child = unsafe { libc::fork() };
− if child == 0 {
− // child
+ env_logger::try_init().unwrap_or(());
+ let child = libc::fork();
+ if child == 0 {
+ // child
replacement in sanakirja/src/tests.rs at line 771
− let env = Env::new("/tmp/sanakirja0/db", 4096 * 20, 2).unwrap();
+ let env = Env::new("/tmp/sanakirja_multi_txn/db", 4096 * 20, 2).unwrap();
replacement in sanakirja/src/tests.rs at line 773
[8.989]→[8.989:1069](∅→∅),
[8.1069]→[8.476:535](∅→∅) − // Mutable txn
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− info!("started child mutable txn {:?}", txn.root);
+ // Mutable txn
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ info!("started child mutable txn {:?}", txn.root);
replacement in sanakirja/src/tests.rs at line 777
− assert_eq!(txn.root, 0);
+ assert_eq!(txn.root, 0);
replacement in sanakirja/src/tests.rs at line 779
[8.570]→[8.1139:1215](∅→∅),
[8.1139]→[8.1139:1215](∅→∅),
[8.1215]→[8.15620:15688](∅→∅),
[8.15688]→[8.571:638](∅→∅),
[8.638]→[8.1360:1522](∅→∅),
[8.1360]→[8.1360:1522](∅→∅) − let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
− debug!("db = {:?}", db.db);
− txn.set_root(0, db.db);
− std::thread::sleep(std::time::Duration::from_millis(200));
− txn.commit().unwrap();
− info!("committed");
− let t = std::time::SystemTime::now();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
+ debug!("db = {:?}", db.db);
+ txn.set_root(0, db.db.into());
+ std::thread::sleep(std::time::Duration::from_millis(200));
+ txn.commit().unwrap();
+ info!("committed");
+ let t = std::time::SystemTime::now();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
replacement in sanakirja/src/tests.rs at line 788
− assert_eq!(txn.root, 1);
+ assert_eq!(txn.root, 1);
replacement in sanakirja/src/tests.rs at line 790
[8.674]→[8.1522:1689](∅→∅),
[8.1522]→[8.1522:1689](∅→∅),
[8.1689]→[8.675:813](∅→∅),
[8.813]→[8.1839:1915](∅→∅),
[8.1839]→[8.1839:1915](∅→∅),
[8.1915]→[8.15689:15725](∅→∅),
[8.15725]→[8.2561:2593](∅→∅),
[8.2593]→[8.814:881](∅→∅),
[8.881]→[8.2060:2091](∅→∅),
[8.2060]→[8.2060:2091](∅→∅) − // Since the parent has an immutable transaction started, we
− // need to wait for at least some time (1s - 100ms of
− // synchronisation margin).
− assert!(t.elapsed().unwrap() >= std::time::Duration::from_millis(90));
− info!("started child mutable txn {:?}", txn.root);
− let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
− debug!("db = {:?}", db.db);
− txn.set_root(1, db.db);
− std::thread::sleep(std::time::Duration::from_millis(100));
− txn.commit().unwrap();
+ // Since the parent has an immutable transaction started, we
+ // need to wait for at least some time (1s - 100ms of
+ // synchronisation margin).
+ assert!(t.elapsed().unwrap() >= std::time::Duration::from_millis(90));
+ info!("started child mutable txn {:?}", txn.root);
+ let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
+ debug!("db = {:?}", db.db);
+ txn.set_root(1, db.db.into());
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ txn.commit().unwrap();
replacement in sanakirja/src/tests.rs at line 801
[8.2092]→[8.5074:5298](∅→∅),
[8.5298]→[8.2092:2156](∅→∅),
[8.2092]→[8.2092:2156](∅→∅),
[8.2156]→[8.882:949](∅→∅) − let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
− unsafe { libc::exit(0) }
− } else {
− // parent
− std::thread::sleep(std::time::Duration::from_millis(100));
+ /*
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ */
+ debug!("child exit");
+ libc::exit(0)
+ } else {
+ // parent
+ std::thread::sleep(std::time::Duration::from_millis(100));
replacement in sanakirja/src/tests.rs at line 814
[8.2220]→[8.2594:2667](∅→∅) − let env = Env::new("/tmp/sanakirja0/db", 4096 * 20, 2).unwrap();
+ let env = Env::new("/tmp/sanakirja_multi_txn/db", 4096 * 20, 2).unwrap();
replacement in sanakirja/src/tests.rs at line 816
[8.2291]→[8.2291:2312](∅→∅),
[8.2365]→[8.2365:2414](∅→∅),
[8.2414]→[8.950:1002](∅→∅) − // Immutable
− let txn = Env::txn_begin(&env).unwrap();
− info!("started parent txn {:?}", txn.root);
+ // Immutable
+ let txn = Env::txn_begin(&env).unwrap();
+ info!("started parent txn {:?}", txn.root);
replacement in sanakirja/src/tests.rs at line 820
[8.1003]→[8.1003:1076](∅→∅) − // The child didn't commit yet.
− assert_eq!(txn.root, 1);
+ // The child didn't commit yet.
+ assert_eq!(txn.root, 1);
replacement in sanakirja/src/tests.rs at line 823
[8.1077]→[8.1077:1144](∅→∅),
[8.1144]→[8.2514:2543](∅→∅),
[8.2514]→[8.2514:2543](∅→∅) − std::thread::sleep(std::time::Duration::from_millis(300));
− std::mem::drop(txn);
+ std::thread::sleep(std::time::Duration::from_millis(300));
+ std::mem::drop(txn);
replacement in sanakirja/src/tests.rs at line 826
[8.2544]→[8.1145:1313](∅→∅) − std::thread::sleep(std::time::Duration::from_millis(100));
− let txn = Env::txn_begin(&env).unwrap();
− info!("started parent txn {:?}", txn.root);
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ let txn = Env::txn_begin(&env).unwrap();
+ info!("started parent txn {:?}", txn.root);
replacement in sanakirja/src/tests.rs at line 830
[8.1314]→[8.1314:1407](∅→∅) − // The parent committed, this is a new transaction.
− assert_eq!(txn.root, 0);
+ // The parent committed, this is a new transaction.
+ assert_eq!(txn.root, 0);
replacement in sanakirja/src/tests.rs at line 833
[8.1408]→[8.1408:1511](∅→∅),
[8.1511]→[8.5299:5552](∅→∅) − let mut status = 1;
− unsafe { libc::wait(&mut status) };
− assert_eq!(status, 0);
− std::mem::drop(txn);
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
+ let mut status = 1;
+ libc::wait(&mut status);
+ assert_eq!(status, 0);
+ std::mem::drop(txn);
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_refs(
+ &txn,
+ &txn.root_db::<u64, (), btree::page::Page<u64, ()>>(0)
+ .unwrap(),
+ &mut refs,
+ )
+ .unwrap();
+ add_refs(
+ &txn,
+ &txn.root_db::<u64, (), btree::page::Page<u64, ()>>(1)
+ .unwrap(),
+ &mut refs,
+ )
+ .unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ }
replacement in sanakirja/src/tests.rs at line 865
[8.52176]→[8.52176:52417](∅→∅),
[8.52417]→[8.0:23](∅→∅),
[8.23]→[8.52438:52781](∅→∅),
[8.52438]→[8.52438:52781](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
− let n = 10_000u64;
− let m = 1000;
− let mut values = Vec::with_capacity(n as usize);
− for i in 0..n {
− debug!("=============== putting {:?}", i);
− let alpha = b"abcdefgihjklmnopqrstuvwxyz";
− let a = &alpha[..((i as usize * 7) % 25) + 1];
− if put(&mut txn, &mut db, &i, &a[..]).unwrap() {
− values.push((i * i) % m);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
+ let n = 10_000u64;
+ let m = 1000;
+ let mut values = Vec::with_capacity(n as usize);
+ for i in 0..n {
+ debug!("=============== putting {:?}", i);
+ let alpha = b"abcdefgihjklmnopqrstuvwxyz";
+ let a = &alpha[..((i as usize * 7) % 25) + 1];
+ if put(&mut txn, &mut db, &i, &a[..]).unwrap() {
+ values.push((i * i) % m);
+ }
edit in sanakirja/src/tests.rs at line 881
edit in sanakirja/src/tests.rs at line 883
[8.52797]→[8.52797:52816](∅→∅) replacement in sanakirja/src/tests.rs at line 887
[8.1553]→[8.1553:1712](∅→∅) − env_logger::try_init().unwrap_or(());
− let n = 5;
− let env = Env::new_anon(40960, n).unwrap();
−
− let mut txn = Env::mut_txn_begin(&env).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let n = 5;
+ let env = Env::new_anon(40960, n).unwrap();
edit in sanakirja/src/tests.rs at line 892
[8.1713]→[8.1713:1916](∅→∅),
[8.1916]→[8.1916:1917](∅→∅),
[8.1917]→[8.1917:1937](∅→∅) − // Allocate two pages.
− for i in 0..n {
− let page = txn.alloc_page().unwrap();
− debug!("page = {:?}", page);
− txn.set_root(i, page.0.offset);
− }
− txn.commit().unwrap();
−
− for i in 0..n {
edit in sanakirja/src/tests.rs at line 893
[8.1994]→[8.1994:2192](∅→∅) − // Free one of the pages.
− debug!("root(0) = {:?}", txn.root(i));
− txn.decr_rc(txn.root(i).unwrap()).unwrap();
− txn.remove_root(i);
− txn.commit().unwrap();
− }
replacement in sanakirja/src/tests.rs at line 894
[8.2193]→[8.2193:2719](∅→∅) − let mut txn = Env::mut_txn_begin(&env).unwrap();
− unsafe {
− let p = &*(env.mmaps.lock()[0].ptr.add(txn.root * PAGE_SIZE) as *const GlobalHeader);
− debug!("free page: 0x{:x}", u64::from_le(p.free_db));
− let db: Db<u64, ()> = Db {
− db: u64::from_le(p.free_db),
− k: std::marker::PhantomData,
− v: std::marker::PhantomData,
− p: std::marker::PhantomData,
− };
− for x in iter(&txn, &db, None).unwrap() {
− debug!("0x{:x}", x.unwrap().0);
+ // Allocate two pages.
+ for i in 0..n {
+ let page = txn.alloc_page().unwrap();
+ debug!("page = {:?}", page);
+ txn.set_root(i, page.0.offset);
replacement in sanakirja/src/tests.rs at line 900
[8.2729]→[8.2729:2735](∅→∅),
[8.2735]→[8.2735:2736](∅→∅),
[8.2736]→[8.2736:2811](∅→∅),
[8.2811]→[8.52816:52818](∅→∅),
[8.52816]→[8.52816:52818](∅→∅),
[8.52818]→[8.11633:11815](∅→∅) − }
−
− let page = txn.alloc_page().unwrap();
− debug!("page = {:?}", page);
− }
−
− #[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();
replacement in sanakirja/src/tests.rs at line 902
[8.11816]→[8.24:115](∅→∅),
[8.115]→[8.11816:11860](∅→∅),
[8.11816]→[8.11816:11860](∅→∅),
[8.11860]→[8.0:22](∅→∅),
[8.22]→[8.11974:12041](∅→∅),
[8.143]→[8.11974:12041](∅→∅),
[8.11974]→[8.11974:12041](∅→∅),
[8.12041]→[8.2251:2309](∅→∅),
[8.2309]→[8.12090:12096](∅→∅),
[8.12090]→[8.12090:12096](∅→∅),
[8.12096]→[8.144:303](∅→∅),
[8.303]→[8.2812:2855](∅→∅),
[8.2855]→[8.353:410](∅→∅),
[8.353]→[8.353:410](∅→∅) − let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
− let now = std::time::SystemTime::now();
− let n = 1_000u64;
− for i in 0..n {
− debug!("=================== {:?}", i);
− assert!(put(&mut txn, &mut db, &i, &i).unwrap());
− }
− println!("sized put: {:?}", now.elapsed());
− let now = std::time::SystemTime::now();
− for i in 0..n {
− debug!("=================== {:?}", i);
− get(&txn, &db, &i, None).unwrap();
− }
− println!("sized lookup: {:?}", now.elapsed());
+ for i in 0..n {
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ // Free one of the pages.
+ debug!("root(0) = {:?}", txn.root(i));
+ txn.decr_rc(txn.root(i).unwrap()).unwrap();
+ txn.remove_root(i);
+ txn.commit().unwrap();
+ }
replacement in sanakirja/src/tests.rs at line 911
[8.411]→[8.12337:12418](∅→∅),
[8.12337]→[8.12337:12418](∅→∅),
[8.12418]→[8.2310:2331](∅→∅),
[8.2331]→[8.12437:12538](∅→∅),
[8.12437]→[8.12437:12538](∅→∅),
[8.12538]→[8.2332:2353](∅→∅) − let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− let mut err = 0;
− for (p, r) in refs.iter() {
− if *r >= 2 {
− error!("{:?} referenced twice", p);
− err += 1
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ {
+ let p = &*(env.mmaps.lock()[0].ptr.add(txn.root * PAGE_SIZE) as *const GlobalHeader);
+ debug!("free page: 0x{:x}", u64::from_le(p.free_db));
+ let db: Db<u64, ()> = Db {
+ db: core::num::NonZeroU64::new_unchecked(u64::from_le(p.free_db)),
+ k: std::marker::PhantomData,
+ v: std::marker::PhantomData,
+ p: std::marker::PhantomData,
+ };
+ for x in iter(&txn, &db, None).unwrap() {
+ debug!("0x{:x}", x.unwrap().0);
+ }
edit in sanakirja/src/tests.rs at line 925
[8.12567]→[8.12567:12573](∅→∅),
[8.12573]→[8.2594:2624](∅→∅),
[8.2624]→[8.23:76](∅→∅),
[8.76]→[8.1098:1135](∅→∅),
[8.2624]→[8.1098:1135](∅→∅),
[8.1135]→[8.2354:2378](∅→∅),
[8.2657]→[8.2354:2378](∅→∅),
[8.12573]→[8.2354:2378](∅→∅),
[8.2378]→[8.2658:2732](∅→∅) − }
− debug!("{:?}", txn.free);
− add_free_refs_mut(&mut txn, &mut refs).unwrap();
− check_free_mut(&mut txn, &refs);
− assert_eq!(err, 0);
− let len = txn.length >> 12;
− println!("sized length = {:?}", len);
replacement in sanakirja/src/tests.rs at line 926
[8.413]→[8.77:277](∅→∅),
[8.277]→[8.12694:12738](∅→∅),
[8.12694]→[8.12694:12738](∅→∅),
[8.12738]→[8.278:300](∅→∅),
[8.300]→[8.12762:12782](∅→∅),
[8.441]→[8.12762:12782](∅→∅),
[8.12762]→[8.12762:12782](∅→∅),
[8.12782]→[8.301:360](∅→∅),
[8.360]→[8.12831:12837](∅→∅),
[8.2492]→[8.12831:12837](∅→∅),
[8.12831]→[8.12831:12837](∅→∅),
[8.12837]→[8.490:604](∅→∅),
[8.604]→[8.361:405](∅→∅) − let env = Env::new_anon(409_600_000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db2 = create_db_::<MutTxn<&Env, ()>, u64, u64, UP<u64, u64>>(&mut txn).unwrap();
− let now = std::time::SystemTime::now();
− let n = 1_000u64;
− for i in 0..n {
− assert!(put(&mut txn, &mut db2, &i, &i).unwrap());
− }
− println!("unsized put: {:?}", now.elapsed());
− let now = std::time::SystemTime::now();
− for i in 0..n {
− get(&txn, &db2, &i, None).unwrap();
+ let page = txn.alloc_page().unwrap();
+ debug!("page = {:?}", page);
edit in sanakirja/src/tests.rs at line 929
[8.707]→[8.707:760](∅→∅),
[8.760]→[8.406:523](∅→∅),
[8.523]→[8.5553:5582](∅→∅),
[8.523]→[8.1136:1173](∅→∅),
[8.5582]→[8.1136:1173](∅→∅),
[8.3005]→[8.1136:1173](∅→∅) − println!("unsized lookup: {:?}", now.elapsed());
− refs.clear();
− add_refs(&txn, &db2, &mut refs).unwrap();
− add_free_refs_mut(&mut txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
replacement in sanakirja/src/tests.rs at line 932
[8.15768]→[8.1074:1148](∅→∅),
[8.1074]→[8.1074:1148](∅→∅),
[8.1148]→[8.45363:45409](∅→∅),
[8.15990]→[8.9892:10123](∅→∅),
[8.45409]→[8.9892:10123](∅→∅),
[8.9892]→[8.9892:10123](∅→∅),
[8.10123]→[8.15991:15992](∅→∅),
[8.10134]→[8.1200:1327](∅→∅),
[8.15992]→[8.1200:1327](∅→∅),
[8.1200]→[8.1200:1327](∅→∅),
[8.1327]→[8.5583:5649](∅→∅),
[8.5649]→[8.1327:1328](∅→∅),
[8.1327]→[8.1327:1328](∅→∅),
[8.1328]→[8.2668:2743](∅→∅) − fn lmdb() {
− use lmdb_rs::*;
− env_logger::try_init().unwrap_or(());
− for i in 1..2 {
− let n = i * 5000;
− let mut times = [0f64; 12];
− let mut test = Vec::with_capacity(n);
− let mut rng = rand::thread_rng();
− for _ in 0..n {
− use rand::Rng;
− test.push((rng.gen(), rng.gen()))
− }
−
− std::fs::remove_dir_all("/tmp/sanakirja0").unwrap_or(());
− std::fs::create_dir_all("/tmp/sanakirja0").unwrap();
− std::fs::remove_file("/tmp/sanakirja0/db").unwrap_or(());
−
− let env = Env::new("/tmp/sanakirja0/db", 409_600_000, 2).unwrap();
+ fn sized_vs_unsized() {
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409_600_000, 1).unwrap();
edit in sanakirja/src/tests.rs at line 939
[8.1590]→[8.1590:1591](∅→∅) replacement in sanakirja/src/tests.rs at line 940
[8.1834]→[8.1834:1930](∅→∅) − for (k, v) in test.iter() {
− assert!(put(&mut txn, &mut db, k, v).unwrap());
+ let n = 1_000u64;
+ for i in 0..n {
+ debug!("=================== {:?}", i);
+ assert!(put(&mut txn, &mut db, &i, &i).unwrap());
replacement in sanakirja/src/tests.rs at line 945
[8.1940]→[8.1940:1997](∅→∅) − times[0] = now.elapsed().unwrap().as_secs_f64();
+ println!("sized put: {:?}", now.elapsed());
replacement in sanakirja/src/tests.rs at line 947
[8.2045]→[8.1174:1218](∅→∅),
[8.1218]→[8.2045:2081](∅→∅),
[8.45468]→[8.2045:2081](∅→∅),
[8.2045]→[8.2045:2081](∅→∅),
[8.2081]→[8.2900:2972](∅→∅) − debug(&txn, &[&db], "debug", true);
− for (k, v) in test.iter() {
− assert_eq!(get(&txn, &db, &k, None).unwrap(), Some((k, v)))
+ for i in 0..n {
+ debug!("=================== {:?}", i);
+ get(&txn, &db, &i, None).unwrap();
replacement in sanakirja/src/tests.rs at line 951
[8.2170]→[8.2170:2227](∅→∅) − times[1] = now.elapsed().unwrap().as_secs_f64();
+ println!("sized lookup: {:?}", now.elapsed());
replacement in sanakirja/src/tests.rs at line 953
[8.10146]→[8.2228:2592](∅→∅),
[8.15994]→[8.2228:2592](∅→∅),
[8.2228]→[8.2228:2592](∅→∅),
[8.2592]→[8.1219:1263](∅→∅),
[8.1263]→[8.2592:2733](∅→∅),
[8.10205]→[8.2592:2733](∅→∅),
[8.2592]→[8.2592:2733](∅→∅),
[8.2733]→[8.2973:3045](∅→∅) − let env = Env::new_anon(409_600_000, 2).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
− let now = std::time::SystemTime::now();
− for (k, v) in test.iter() {
− assert!(put(&mut txn, &mut db, k, v).unwrap());
− }
− debug(&txn, &[&db], "debug", true);
− times[2] = now.elapsed().unwrap().as_secs_f64();
− let now = std::time::SystemTime::now();
− for (k, v) in test.iter() {
− assert_eq!(get(&txn, &db, &k, None).unwrap(), Some((k, v)))
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ let mut err = 0;
+ for (p, r) in refs.iter() {
+ if *r >= 2 {
+ error!("{:?} referenced twice", p);
+ err += 1
+ }
replacement in sanakirja/src/tests.rs at line 962
[8.2822]→[8.2822:2879](∅→∅) − times[3] = now.elapsed().unwrap().as_secs_f64();
+ debug!("{:?}", txn.free);
+ add_free_refs_mut(&mut txn, &mut refs).unwrap();
+ check_free_mut(&mut txn, &refs);
+ assert_eq!(err, 0);
+ let len = txn.length >> 12;
+ println!("sized length = {:?}", len);
replacement in sanakirja/src/tests.rs at line 969
[8.10217]→[8.2880:2935](∅→∅),
[8.2880]→[8.2880:2935](∅→∅) − let mut b = std::collections::BTreeMap::new();
+ let env = Env::new_anon(409_600_000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db2 = create_db_::<MutTxn<&Env, ()>, u64, u64, UP<u64, u64>>(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 973
[8.2983]→[8.2983:3049](∅→∅) − for (k, v) in test.iter() {
− b.insert(*k, *v);
+ let n = 1_000u64;
+ for i in 0..n {
+ assert!(put(&mut txn, &mut db2, &i, &i).unwrap());
replacement in sanakirja/src/tests.rs at line 977
[8.3059]→[8.3059:3116](∅→∅) − times[4] = now.elapsed().unwrap().as_secs_f64();
+ println!("unsized put: {:?}", now.elapsed());
replacement in sanakirja/src/tests.rs at line 979
[8.3164]→[8.3164:3243](∅→∅) − for (k, v) in test.iter() {
− assert_eq!(b.get(k), Some(v));
+ for i in 0..n {
+ get(&txn, &db2, &i, None).unwrap();
replacement in sanakirja/src/tests.rs at line 982
[8.3253]→[8.3253:3310](∅→∅) − times[5] = now.elapsed().unwrap().as_secs_f64();
+ println!("unsized lookup: {:?}", now.elapsed());
+ refs.clear();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ add_free_refs_mut(&mut txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ }
+ }
+
+ #[test]
+ fn lmdb() {
+ unsafe {
+ use lmdb_rs::*;
+ env_logger::try_init().unwrap_or(());
+ for i in 1..2 {
+ let n = i * 5000;
+ let mut times = [0f64; 12];
+ let mut test = Vec::with_capacity(n);
+ let mut rng = rand::thread_rng();
+ for _ in 0..n {
+ use rand::Rng;
+ test.push((rng.gen(), rng.gen()))
+ }
+
+ std::fs::remove_dir_all("/tmp/sanakirja0").unwrap_or(());
+ std::fs::create_dir_all("/tmp/sanakirja0").unwrap();
+ std::fs::remove_file("/tmp/sanakirja0/db").unwrap_or(());
+
+ let env = Env::new("/tmp/sanakirja0/db", 409_600_000, 2).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
replacement in sanakirja/src/tests.rs at line 1013
[8.3311]→[8.3311:3574](∅→∅) − std::fs::remove_dir_all("/tmp/test-lmdb").unwrap_or(());
− std::fs::create_dir_all("/tmp/test-lmdb").unwrap_or(());
− let env = EnvBuilder::new()
− .map_size(1 << 30)
− .open("/tmp/test-lmdb", 0o777)
− .unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
edit in sanakirja/src/tests.rs at line 1015
[8.3575]→[8.3575:3756](∅→∅) − let db_handle = env.get_default_db(lmdb_rs::core::DbIntKey).unwrap();
− let txn = env.new_transaction().unwrap();
− {
− let db = txn.bind(&db_handle);
replacement in sanakirja/src/tests.rs at line 1017
[8.3848]→[8.3848:3887](∅→∅) + assert!(put(&mut txn, &mut db, k, v).unwrap());
replacement in sanakirja/src/tests.rs at line 1019
[8.3901]→[8.3901:3972](∅→∅) − times[6] = now.elapsed().unwrap().as_secs_f64();
− }
+ times[0] = now.elapsed().unwrap().as_secs_f64();
+ let now = std::time::SystemTime::now();
+ debug(&txn, &[&db], "debug", true);
+ for (k, v) in test.iter() {
+ assert_eq!(get(&txn, &db, &k, None).unwrap(), Some((k, v)))
+ }
+ times[1] = now.elapsed().unwrap().as_secs_f64();
replacement in sanakirja/src/tests.rs at line 1027
[8.3973]→[8.3973:4239](∅→∅) − // Note: `commit` is choosen to be explicit as
− // in case of failure it is responsibility of
− // the client to handle the error
− match txn.commit() {
− Err(_) => panic!("failed to commit!"),
− Ok(_) => (),
− }
+ let env = Env::new_anon(409_600_000, 2).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, P<u64, u64>>(&mut txn).unwrap();
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ assert!(put(&mut txn, &mut db, k, v).unwrap());
+ }
+ debug(&txn, &[&db], "debug", true);
+ times[2] = now.elapsed().unwrap().as_secs_f64();
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ assert_eq!(get(&txn, &db, &k, None).unwrap(), Some((k, v)))
+ }
+ times[3] = now.elapsed().unwrap().as_secs_f64();
+
+ let mut b = std::collections::BTreeMap::new();
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ b.insert(*k, *v);
+ }
+ times[4] = now.elapsed().unwrap().as_secs_f64();
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ assert_eq!(b.get(k), Some(v));
+ }
+ times[5] = now.elapsed().unwrap().as_secs_f64();
replacement in sanakirja/src/tests.rs at line 1054
[8.4240]→[8.4240:4566](∅→∅),
[8.4566]→[8.10230:10241](∅→∅),
[8.10241]→[8.4567:5075](∅→∅),
[8.4567]→[8.4567:5075](∅→∅) − let reader = env.get_reader().unwrap();
− let db = reader.bind(&db_handle);
− let now = std::time::SystemTime::now();
− for (k, v) in test.iter() {
− let name = db.get::<u64>(k).ok();
− assert_eq!(name, Some(*v))
− }
− times[7] = now.elapsed().unwrap().as_secs_f64();
− /*
− std::fs::remove_dir_all("/tmp/test-sled").unwrap_or(());
− std::fs::create_dir_all("/tmp/test-sled").unwrap_or(());
− let db: sled::Db = sled::open("/tmp/test-sled").unwrap();
− let now = std::time::SystemTime::now();
− for (k, v) in test.iter() {
− unsafe {
− db.insert(
− std::slice::from_raw_parts(k as *const u64 as *const u8, 8),
− std::slice::from_raw_parts(v as *const u64 as *const u8, 8),
− )
+ std::fs::remove_dir_all("/tmp/test-lmdb").unwrap_or(());
+ std::fs::create_dir_all("/tmp/test-lmdb").unwrap_or(());
+ let env = EnvBuilder::new()
+ .map_size(1 << 30)
+ .open("/tmp/test-lmdb", 0o777)
edit in sanakirja/src/tests.rs at line 1060
+
+ let db_handle = env.get_default_db(lmdb_rs::core::DbIntKey).unwrap();
+ let txn = env.new_transaction().unwrap();
+ {
+ let db = txn.bind(&db_handle);
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ db.set(k, v).unwrap();
+ }
+ times[6] = now.elapsed().unwrap().as_secs_f64();
replacement in sanakirja/src/tests.rs at line 1071
[8.5116]→[8.5116:5404](∅→∅) − }
− times[8] = now.elapsed().unwrap().as_secs_f64();
− let now = std::time::SystemTime::now();
− for (k, _v) in test.iter() {
− unsafe {
− db.get(std::slice::from_raw_parts(k as *const u64 as *const u8, 8))
− .unwrap();
+
+ // Note: `commit` is choosen to be explicit as
+ // in case of failure it is responsibility of
+ // the client to handle the error
+ match txn.commit() {
+ Err(_) => panic!("failed to commit!"),
+ Ok(_) => (),
replacement in sanakirja/src/tests.rs at line 1079
[8.5418]→[8.5418:5485](∅→∅),
[8.5485]→[8.10242:10254](∅→∅),
[8.10254]→[8.3641:3652](∅→∅),
[8.5485]→[8.3641:3652](∅→∅),
[8.3652]→[8.5486:5862](∅→∅),
[8.5486]→[8.5486:5862](∅→∅) − }
− times[9] = now.elapsed().unwrap().as_secs_f64();
− */
− /*
− {
− use old_sanakirja::*;
− std::fs::remove_dir_all("/tmp/sanakirja1").unwrap_or(());
− std::fs::create_dir_all("/tmp/sanakirja1").unwrap();
− let env = Env::new("/tmp/sanakirja1", 409_600_000).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = txn.create_db::<u64, u64>().unwrap();
+
+ let reader = env.get_reader().unwrap();
+ let db = reader.bind(&db_handle);
edit in sanakirja/src/tests.rs at line 1083
[8.5914]→[8.5914:5960](∅→∅) − let mut rng = rand::thread_rng();
replacement in sanakirja/src/tests.rs at line 1084
[8.6000]→[8.6000:6070](∅→∅) − assert!(txn.put(&mut rng, &mut db, *k, *v).unwrap());
+ let name = db.get::<u64>(k).ok();
+ assert_eq!(name, Some(*v))
replacement in sanakirja/src/tests.rs at line 1087
[8.6084]→[8.6084:6146](∅→∅) − times[10] = now.elapsed().unwrap().as_secs_f64();
+ times[7] = now.elapsed().unwrap().as_secs_f64();
+ /*
+ std::fs::remove_dir_all("/tmp/test-sled").unwrap_or(());
+ std::fs::create_dir_all("/tmp/test-sled").unwrap_or(());
+ let db: sled::Db = sled::open("/tmp/test-sled").unwrap();
replacement in sanakirja/src/tests.rs at line 1094
[8.6238]→[8.6238:6308](∅→∅) − assert_eq!(txn.get(&db, *k, None).unwrap(), Some(*v))
+ unsafe {
+ db.insert(
+ std::slice::from_raw_parts(k as *const u64 as *const u8, 8),
+ std::slice::from_raw_parts(v as *const u64 as *const u8, 8),
+ )
+ .unwrap();
+ }
+ }
+ times[8] = now.elapsed().unwrap().as_secs_f64();
+ let now = std::time::SystemTime::now();
+ for (k, _v) in test.iter() {
+ unsafe {
+ db.get(std::slice::from_raw_parts(k as *const u64 as *const u8, 8))
+ .unwrap();
+ }
replacement in sanakirja/src/tests.rs at line 1110
[8.6322]→[8.6322:6394](∅→∅),
[8.6394]→[8.3653:3664](∅→∅),
[8.3664]→[8.6395:6482](∅→∅),
[8.6395]→[8.6395:6482](∅→∅) − times[11] = now.elapsed().unwrap().as_secs_f64();
− }
− */
− print!("{}", n);
− for t in times.iter() {
− print!(", {}", t)
+ times[9] = now.elapsed().unwrap().as_secs_f64();
+ */
+ /*
+ {
+ use old_sanakirja::*;
+ std::fs::remove_dir_all("/tmp/sanakirja1").unwrap_or(());
+ std::fs::create_dir_all("/tmp/sanakirja1").unwrap();
+ let env = Env::new("/tmp/sanakirja1", 409_600_000).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = txn.create_db::<u64, u64>().unwrap();
+ let now = std::time::SystemTime::now();
+ let mut rng = rand::thread_rng();
+ for (k, v) in test.iter() {
+ assert!(txn.put(&mut rng, &mut db, *k, *v).unwrap());
+ }
+ times[10] = now.elapsed().unwrap().as_secs_f64();
+ let now = std::time::SystemTime::now();
+ for (k, v) in test.iter() {
+ assert_eq!(txn.get(&db, *k, None).unwrap(), Some(*v))
+ }
+ times[11] = now.elapsed().unwrap().as_secs_f64();
+ }
+ */
+ print!("{}", n);
+ for t in times.iter() {
+ print!(", {}", t)
+ }
+ println!();
edit in sanakirja/src/tests.rs at line 1139
[8.6492]→[8.6492:6512](∅→∅) replacement in sanakirja/src/tests.rs at line 1144
[8.21]→[8.3694:4089](∅→∅),
[8.3694]→[8.3694:4089](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
− for i in (0..157).step_by(10) {
− for i in i..i + 4 {
− let a = [b'a'; 500];
− put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
+ for i in (0..157).step_by(10) {
+ for i in i..i + 4 {
+ let a = [b'a'; 500];
+ put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ }
+ put(&mut txn, &mut db, &(i + 9), &[b'b'; 250]).unwrap();
+ }
+ for i in (0..157).step_by(10) {
+ for i in i + 4..i + 7 {
+ let a = [b'a'; 500];
+ put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ }
replacement in sanakirja/src/tests.rs at line 1162
[8.4099]→[8.22:87](∅→∅),
[8.87]→[8.4164:4328](∅→∅),
[8.4164]→[8.4164:4328](∅→∅) − put(&mut txn, &mut db, &(i + 9), &[b'b'; 250]).unwrap();
− }
− for i in (0..157).step_by(10) {
− for i in i + 4..i + 7 {
− let a = [b'a'; 500];
− put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ for i in 0..3 {
+ debug!("====== del {:?}", i);
+ del(&mut txn, &mut db, &i, None).unwrap();
replacement in sanakirja/src/tests.rs at line 1166
[8.4338]→[8.4338:4344](∅→∅),
[8.4344]→[8.88:108](∅→∅),
[8.108]→[8.15995:16033](∅→∅),
[8.108]→[8.4468:4519](∅→∅),
[8.16033]→[8.4468:4519](∅→∅),
[8.4468]→[8.4468:4519](∅→∅) − }
− for i in 0..3 {
− debug!("====== del {:?}", i);
− del(&mut txn, &mut db, &i, None).unwrap();
+ assert_eq!(
+ depth::<_, u64, [u8], UP<u64, [u8]>>(&txn, db.db.into()).unwrap(),
+ 2
+ );
+ del(&mut txn, &mut db, &3, None).unwrap();
+ assert_eq!(
+ depth::<_, u64, [u8], UP<u64, [u8]>>(&txn, db.db.into()).unwrap(),
+ 3
+ );
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
edit in sanakirja/src/tests.rs at line 1183
[8.4525]→[8.109:358](∅→∅),
[8.358]→[8.5650:5926](∅→∅) − assert_eq!(
− depth::<_, u64, [u8], UP<u64, [u8]>>(&txn, db.db).unwrap(),
− 2
− );
− del(&mut txn, &mut db, &3, None).unwrap();
− assert_eq!(
− depth::<_, u64, [u8], UP<u64, [u8]>>(&txn, db.db).unwrap(),
− 3
− );
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
replacement in sanakirja/src/tests.rs at line 1194
[8.584]→[8.584:614](∅→∅),
[8.614]→[8.15786:15822](∅→∅),
[8.15822]→[8.21245:21288](∅→∅),
[8.21288]→[8.15874:15928](∅→∅),
[8.15874]→[8.15874:15928](∅→∅),
[8.15928]→[8.718:764](∅→∅),
[8.718]→[8.718:764](∅→∅) − let mut n = 1;
− loop {
− let pp = txn.load_page(p)?;
− let cursor = P::cursor_first(&pp);
− let l = P::left_child(pp.as_page(), &cursor);
− if l == 0 {
− return Ok(n);
+ unsafe {
+ let mut n = 1;
+ loop {
+ let pp = txn.load_page(p)?;
+ let cursor = P::cursor_first(&pp);
+ let l = P::left_child(pp.as_page(), &cursor);
+ if l == 0 {
+ return Ok(n);
+ }
+ p = l;
+ n += 1;
edit in sanakirja/src/tests.rs at line 1206
[8.774]→[8.15929:15944](∅→∅),
[8.15944]→[8.805:821](∅→∅),
[8.805]→[8.805:821](∅→∅) replacement in sanakirja/src/tests.rs at line 1211
[8.4714]→[8.4714:5109](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
− for i in (0..157).step_by(10) {
− for i in i..i + 4 {
− let a = [b'a'; 500];
− put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, [u8], UP<u64, [u8]>>(&mut txn).unwrap();
+ for i in (0..157).step_by(10) {
+ for i in i..i + 4 {
+ let a = [b'a'; 500];
+ put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ }
+ put(&mut txn, &mut db, &(i + 9), &[b'b'; 255]).unwrap();
replacement in sanakirja/src/tests.rs at line 1223
[8.5119]→[8.5119:5348](∅→∅) − put(&mut txn, &mut db, &(i + 9), &[b'b'; 255]).unwrap();
− }
− for i in (0..157).step_by(10) {
− for i in i + 4..i + 7 {
− let a = [b'a'; 500];
− put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ for i in (0..157).step_by(10) {
+ for i in i + 4..i + 7 {
+ let a = [b'a'; 500];
+ put(&mut txn, &mut db, &i, &a[..]).unwrap();
+ }
edit in sanakirja/src/tests.rs at line 1229
+ del(&mut txn, &mut db, &0, None).unwrap();
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut refs = BTreeMap::new();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
edit in sanakirja/src/tests.rs at line 1238
[8.5419]→[8.5419:5466](∅→∅),
[8.5466]→[8.5927:6203](∅→∅) − del(&mut txn, &mut db, &0, None).unwrap();
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut refs = BTreeMap::new();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− add_refs(&txn, &db, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
replacement in sanakirja/src/tests.rs at line 1324
[8.1382]→[8.1382:1470](∅→∅),
[8.1470]→[8.4923:4960](∅→∅),
[8.4960]→[8.1505:1569](∅→∅),
[8.1505]→[8.1505:1569](∅→∅),
[8.1592]→[8.1592:1672](∅→∅),
[8.1672]→[8.4961:4998](∅→∅),
[8.4998]→[8.1672:1730](∅→∅),
[8.1672]→[8.1672:1730](∅→∅),
[8.1730]→[8.4999:5193](∅→∅),
[8.5193]→[8.1305:1345](∅→∅),
[8.1345]→[8.5247:5264](∅→∅),
[8.5247]→[8.5247:5264](∅→∅),
[8.5264]→[8.3199:3257](∅→∅),
[8.3257]→[8.5329:5382](∅→∅),
[8.5329]→[8.5329:5382](∅→∅),
[8.5382]→[8.10255:10290](∅→∅),
[8.10290]→[8.5416:5497](∅→∅),
[8.5416]→[8.5416:5497](∅→∅),
[8.5497]→[8.3258:3333](∅→∅),
[8.3333]→[8.10291:10326](∅→∅),
[8.5579]→[8.10291:10326](∅→∅),
[8.10326]→[8.5613:5671](∅→∅),
[8.5613]→[8.5613:5671](∅→∅),
[8.5671]→[8.10327:10333](∅→∅) − for i in (25..50).rev() {
− let (k, v) = cursor.prev(&txn).unwrap().unwrap();
− debug!("b {:?} {:?}", i, k);
− assert_eq!(*k, i);
− assert_eq!(v.0[0], i);
− }
− for i in 24..75 {
− let (k, v) = cursor.next(&txn).unwrap().unwrap();
− debug!("c {:?} {:?}", i, k);
− assert_eq!(*k, i);
− assert_eq!(v.0[0], i);
− }
− for i in (0..75).rev() {
− let (k, v) = cursor.prev(&txn).unwrap().unwrap();
− debug!("d {:?} {:?}", i, k);
− assert_eq!(*k, i);
− assert_eq!(v.0[0], i);
− }
− debug(&txn, &[&db], "debug", true);
− let i0 = 30;
− for (kv, n) in rev_iter(&txn, &db, Some((&i0, None)))
− .unwrap()
− .zip((0..=i0).rev())
− {
− let (k, _v) = kv.unwrap();
− assert_eq!(*k, n);
− debug!("k = {:?}", k);
− }
− let i0 = 40;
− for (kv, n) in iter(&txn, &db, Some((&i0, None))).unwrap().zip(i0..) {
− let (k, _v) = kv.unwrap();
− assert_eq!(*k, n);
− debug!("k = {:?}", k);
− }
+ }
+
+ #[test]
+ fn iterators() {
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(40960, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db = create_db_::<MutTxn<&Env, ()>, u64, A, P<u64, A>>(&mut txn).unwrap();
+ for i in 0..100 {
+ let a = A([i; 100]);
+ put(&mut txn, &mut db, &i, &a).unwrap();
+ }
+ let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ debug(&txn, &[&db], "debug", true);
+ for i in 0..50 {
+ let (k, v) = cursor.next(&txn).unwrap().unwrap();
+ debug!("a {:?} {:?}", i, k);
+ assert_eq!(*k, i);
+ assert_eq!(v.0[0], i);
+ }
+ for i in (25..50).rev() {
+ let (k, v) = cursor.prev(&txn).unwrap().unwrap();
+ debug!("b {:?} {:?}", i, k);
+ assert_eq!(*k, i);
+ assert_eq!(v.0[0], i);
+ }
+ for i in 24..75 {
+ let (k, v) = cursor.next(&txn).unwrap().unwrap();
+ debug!("c {:?} {:?}", i, k);
+ assert_eq!(*k, i);
+ assert_eq!(v.0[0], i);
+ }
+ for i in (0..75).rev() {
+ let (k, v) = cursor.prev(&txn).unwrap().unwrap();
+ debug!("d {:?} {:?}", i, k);
+ assert_eq!(*k, i);
+ assert_eq!(v.0[0], i);
+ }
+ debug(&txn, &[&db], "debug", true);
+ let i0 = 30;
+ for (kv, n) in rev_iter(&txn, &db, Some((&i0, None)))
+ .unwrap()
+ .zip((0..=i0).rev())
+ {
+ let (k, _v) = kv.unwrap();
+ assert_eq!(*k, n);
+ debug!("k = {:?}", k);
+ }
+ let i0 = 40;
+ for (kv, n) in iter(&txn, &db, Some((&i0, None))).unwrap().zip(i0..) {
+ let (k, _v) = kv.unwrap();
+ assert_eq!(*k, n);
+ debug!("k = {:?}", k);
+ }
replacement in sanakirja/src/tests.rs at line 1380
[8.10334]→[8.3334:3401](∅→∅),
[8.3401]→[8.10408:10479](∅→∅),
[8.10408]→[8.10408:10479](∅→∅) − let mut it = rev_iter(&txn, &db, Some((&100, None))).unwrap();
− let (k, _v) = it.next().unwrap().unwrap();
− assert_eq!(*k, 99);
+ let mut it = rev_iter(&txn, &db, Some((&100, None))).unwrap();
+ let (k, _v) = it.next().unwrap().unwrap();
+ assert_eq!(*k, 99);
replacement in sanakirja/src/tests.rs at line 1384
[8.10480]→[8.10480:10602](∅→∅),
[8.10602]→[8.41864:41932](∅→∅),
[8.41932]→[8.10678:10882](∅→∅),
[8.10678]→[8.10678:10882](∅→∅) − let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
− for i in 0..100 {
− debug!("i = {:?}", i);
− let (&k, v) = cursor.set(&txn, &i, None).unwrap().unwrap();
− debug!("kv = {:?} {:?}", k, v);
− assert_eq!(i, k);
− let (&k1, v1) = cursor.next(&txn).unwrap().unwrap();
− debug!("next = {:?} {:?}", k1, v1);
− assert_eq!(i, k1);
− }
+ let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ for i in 0..100 {
+ debug!("i = {:?}", i);
+ let (&k, v) = cursor.set(&txn, &i, None).unwrap().unwrap();
+ debug!("kv = {:?} {:?}", k, v);
+ assert_eq!(i, k);
+ let (&k1, v1) = cursor.next(&txn).unwrap().unwrap();
+ debug!("next = {:?} {:?}", k1, v1);
+ assert_eq!(i, k1);
+ }
replacement in sanakirja/src/tests.rs at line 1395
[8.10883]→[8.10883:11005](∅→∅),
[8.11005]→[8.41933:42001](∅→∅),
[8.42001]→[8.11081:11279](∅→∅),
[8.11081]→[8.11081:11279](∅→∅) − let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
− for i in 0..100 {
− debug!("i = {:?}", i);
− let (&k, v) = cursor.set(&txn, &i, None).unwrap().unwrap();
− debug!("kv = {:?} {:?}", k, v);
− assert_eq!(i, k);
− let (&k1, v1) = cursor.prev(&txn).unwrap().unwrap();
− debug!("prev = {:?} {:?}", k1, v1);
− assert_eq!(i, k1);
+ let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
+ for i in 0..100 {
+ debug!("i = {:?}", i);
+ let (&k, v) = cursor.set(&txn, &i, None).unwrap().unwrap();
+ debug!("kv = {:?} {:?}", k, v);
+ assert_eq!(i, k);
+ let (&k1, v1) = cursor.prev(&txn).unwrap().unwrap();
+ debug!("prev = {:?} {:?}", k1, v1);
+ assert_eq!(i, k1);
+ }
replacement in sanakirja/src/tests.rs at line 1410
[8.11316]→[8.11316:11522](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, A> = create_db(&mut txn).unwrap();
replacement in sanakirja/src/tests.rs at line 1416
[8.11523]→[8.3402:3420](∅→∅),
[8.3420]→[8.11545:11724](∅→∅),
[8.11545]→[8.11545:11724](∅→∅) − let n = 6u64;
− let mut values = Vec::with_capacity(n as usize);
− let a = A([0; 100]);
− for i in 0..n {
− if put(&mut txn, &mut db, &i, &a).unwrap() {
− values.push(i);
+ let n = 6u64;
+ let mut values = Vec::with_capacity(n as usize);
+ let a = A([0; 100]);
+ for i in 0..n {
+ if put(&mut txn, &mut db, &i, &a).unwrap() {
+ values.push(i);
+ }
replacement in sanakirja/src/tests.rs at line 1424
[8.11734]→[8.11734:11740](∅→∅),
[8.11740]→[8.1346:1387](∅→∅) − }
− debug(&txn, &[&db], "debug0", true);
+ debug(&txn, &[&db], "debug0", true);
replacement in sanakirja/src/tests.rs at line 1426
[8.11796]→[8.11796:11890](∅→∅) − let db2 = fork_db(&mut txn, &db).unwrap();
− del(&mut txn, &mut db, &1, None).unwrap();
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ del(&mut txn, &mut db, &1, None).unwrap();
replacement in sanakirja/src/tests.rs at line 1429
[8.11891]→[8.1388:1435](∅→∅),
[8.1435]→[8.11959:12086](∅→∅),
[8.11959]→[8.11959:12086](∅→∅),
[8.12135]→[8.12135:12554](∅→∅) − debug(&txn, &[&db, &db2], "debug1", true);
− let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− add_refs(&txn, &db2, &mut refs).unwrap();
− let mut err = 0;
− for (p, r) in refs.iter() {
− println!("{:?} {:?}", p, r);
− if *r >= 2 {
− if txn.rc(*p).unwrap() != *r as u64 {
− error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
− err += 1;
− }
− } else {
− if txn.rc(*p).unwrap() != 0 {
− error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
− err += 1;
+ debug(&txn, &[&db, &db2], "debug1", true);
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ add_refs(&txn, &db2, &mut refs).unwrap();
+ let mut err = 0;
+ for (p, r) in refs.iter() {
+ println!("{:?} {:?}", p, r);
+ if *r >= 2 {
+ if txn.rc(*p).unwrap() != *r as u64 {
+ error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
+ err += 1;
+ }
+ } else {
+ if txn.rc(*p).unwrap() != 0 {
+ error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
+ err += 1;
+ }
edit in sanakirja/src/tests.rs at line 1448
+ assert_eq!(err, 0);
+ txn.commit().unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ add_free_refs_mut(&txn, &mut refs).unwrap();
+ check_refs(&txn, &refs);
+ check_free_mut(&mut txn, &refs);
+ debug!("{:?}", refs);
replacement in sanakirja/src/tests.rs at line 1460
[8.3802]→[8.3802:4010](∅→∅),
[8.4010]→[8.3421:3462](∅→∅),
[8.3462]→[8.4059:4230](∅→∅),
[8.4059]→[8.4059:4230](∅→∅) − env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(409600000, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
− let n = 1000u64;
− let i0 = 10u64;
− let mut values = Vec::with_capacity(n as usize);
− for i in 0..n {
− put(&mut txn, &mut db, &i, &i).unwrap();
− if i != i0 {
− values.push(i);
+ unsafe {
+ env_logger::try_init().unwrap_or(());
+ let env = Env::new_anon(409600000, 1).unwrap();
+ let mut txn = Env::mut_txn_begin(&env).unwrap();
+ let mut db: Db<u64, u64> = create_db(&mut txn).unwrap();
+ let n = 1000u64;
+ let i0 = 10u64;
+ let mut values = Vec::with_capacity(n as usize);
+ for i in 0..n {
+ put(&mut txn, &mut db, &i, &i).unwrap();
+ if i != i0 {
+ values.push(i);
+ }
replacement in sanakirja/src/tests.rs at line 1474
[8.4240]→[8.4240:4338](∅→∅),
[8.4338]→[8.1523:1570](∅→∅),
[8.1570]→[8.4399:4433](∅→∅),
[8.4399]→[8.4399:4433](∅→∅),
[8.4433]→[8.1571:1612](∅→∅) − }
− let db2 = fork_db(&mut txn, &db).unwrap();
− put(&mut txn, &mut db, &n, &n).unwrap();
− debug(&txn, &[&db, &db2], "debug1", true);
− drop(&mut txn, db2).unwrap();
− debug(&txn, &[&db], "debug2", true);
+ let db2 = fork_db(&mut txn, &db).unwrap();
+ put(&mut txn, &mut db, &n, &n).unwrap();
+ debug(&txn, &[&db, &db2], "debug1", true);
+ drop(&mut txn, db2).unwrap();
+ debug(&txn, &[&db], "debug2", true);
replacement in sanakirja/src/tests.rs at line 1480
[8.4489]→[8.4489:4891](∅→∅) − let mut refs = BTreeMap::new();
− add_refs(&txn, &db, &mut refs).unwrap();
− let mut err = 0;
− for (p, r) in refs.iter() {
− println!("{:?} {:?}", p, r);
− if *r >= 2 {
− error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
− err += 1;
− } else {
− if txn.rc(*p).unwrap() != 0 {
− error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
+ let mut refs = BTreeMap::new();
+ add_refs(&txn, &db, &mut refs).unwrap();
+ let mut err = 0;
+ for (p, r) in refs.iter() {
+ println!("{:?} {:?}", p, r);
+ if *r >= 2 {
+ error!("{:?} {:?} {:?}", p, txn.rc(*p).unwrap(), *r);
edit in sanakirja/src/tests.rs at line 1488
+ } else {
+ if txn.rc(*p).unwrap() != 0 {
+ error!("{:?} {:?} 0", p, txn.rc(*p).unwrap());
+ err += 1;
+ }
edit in sanakirja/src/tests.rs at line 1495
[8.4941]→[8.4941:4947](∅→∅),
[8.4947]→[8.4947:4971](∅→∅),
[8.4971]→[8.4971:4973](∅→∅),
[8.1763]→[8.12579:12683](∅→∅),
[8.12683]→[8.1436:1485](∅→∅),
[8.1485]→[8.6230:6259](∅→∅),
[8.6259]→[8.1485:1522](∅→∅),
[8.1485]→[8.1485:1522](∅→∅),
[8.1522]→[8.12716:12742](∅→∅),
[8.12716]→[8.12716:12742](∅→∅) − }
− assert_eq!(err, 0);
− }
− assert_eq!(err, 0);
− txn.commit().unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
− debug!("{:?}", refs);
resolve order conflict in sanakirja/src/tests.rs at line 1495
edit in sanakirja/src/tests.rs at line 1495
edit in sanakirja/src/tests.rs at line 1498
[8.709]→[8.709:735](∅→∅),
[8.735]→[8.735:1140](∅→∅),
[8.1140]→[8.1264:1304](∅→∅),
[8.1304]→[8.1140:1219](∅→∅),
[8.4884]→[8.1140:1219](∅→∅),
[8.1140]→[8.1140:1219](∅→∅),
[8.1219]→[8.4885:4922](∅→∅),
[8.4922]→[8.1219:1277](∅→∅),
[8.1219]→[8.1219:1277](∅→∅),
[8.7458]→[8.1011:1060](∅→∅),
[8.1060]→[8.5044:5073](∅→∅),
[8.5073]→[8.1060:1097](∅→∅),
[8.1060]→[8.1060:1097](∅→∅),
[8.1097]→[8.513:539](∅→∅),
[8.513]→[8.513:539](∅→∅),
[8.1952]→[8.113:154](∅→∅) −
− #[test]
− fn iterators() {
− env_logger::try_init().unwrap_or(());
− let env = Env::new_anon(40960, 1).unwrap();
− let mut txn = Env::mut_txn_begin(&env).unwrap();
− let mut db = create_db_::<MutTxn<&Env, ()>, u64, A, P<u64, A>>(&mut txn).unwrap();
− for i in 0..100 {
− let a = A([i; 100]);
− put(&mut txn, &mut db, &i, &a).unwrap();
− }
− let mut cursor = btree::cursor::Cursor::new(&txn, &db).unwrap();
− debug(&txn, &[&db], "debug", true);
− for i in 0..50 {
− let (k, v) = cursor.next(&txn).unwrap().unwrap();
− debug!("a {:?} {:?}", i, k);
− assert_eq!(*k, i);
− assert_eq!(v.0[0], i);
− add_free_refs_mut(&txn, &mut refs).unwrap();
− check_refs(&txn, &refs);
− check_free_mut(&mut txn, &refs);
− debug!("{:?}", refs);
− debug(&txn, &[&db], "debug0", true);
resolve order conflict in sanakirja/src/tests.rs at line 1498
replacement in sanakirja/src/lib.rs at line 107
[8.2997]→[8.0:67](∅→∅),
[8.67]→[6.5069:5194](∅→∅) − pub use environment::{Commit, Env, MutTxn, RootDb, Txn, RootPage};
− pub use sanakirja_core::{btree, direct_repr, LoadPage, AllocPage, Storable, UnsizedStorable, MutPage, CowPage, Page, Slice};
+ pub use environment::{Commit, Env, MutTxn, RootDb, RootPage, Txn};
+ pub use sanakirja_core::{
+ btree, direct_repr, AllocPage, CowPage, LoadPage, MutPage, Page, Slice, Storable,
+ UnsizedStorable,
+ };
edit in sanakirja/src/lib.rs at line 143
+
+ /// A 64-bit unsigned integer in little-endian ordering.
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+ pub struct L64(pub u64);
+
+ impl serde::Serialize for L64 {
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ serializer.serialize_u64(u64::from_le(self.0))
+ }
+ }
+
+ use serde::de::{self, Visitor};
+
+ struct L64Visitor;
+
+ impl<'de> Visitor<'de> for L64Visitor {
+ type Value = L64;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+ formatter.write_str("an unsigned, little-endian integer")
+ }
+
+ fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ log::debug!("visit u64 {:?}", value);
+ Ok(L64(value.to_le()))
+ }
+ }
+
+ impl<'de> serde::Deserialize<'de> for L64 {
+ fn deserialize<D>(deserializer: D) -> Result<L64, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ deserializer.deserialize_u64(L64Visitor)
+ }
+ }
+
+ impl From<u64> for L64 {
+ fn from(u: u64) -> Self {
+ L64(u.to_le())
+ }
+ }
+
+ impl From<L64> for u64 {
+ fn from(u: L64) -> Self {
+ u64::from_le(u.0)
+ }
+ }
+
+ impl Ord for L64 {
+ fn cmp(&self, x: &Self) -> std::cmp::Ordering {
+ u64::from_le(self.0).cmp(&u64::from_le(x.0))
+ }
+ }
+
+ impl PartialOrd for L64 {
+ fn partial_cmp(&self, x: &Self) -> Option<std::cmp::Ordering> {
+ u64::from_le(self.0).partial_cmp(&u64::from_le(x.0))
+ }
+ }
+
+ impl From<usize> for L64 {
+ fn from(u: usize) -> Self {
+ L64((u as u64).to_le())
+ }
+ }
+
+ impl From<L64> for usize {
+ fn from(u: L64) -> Self {
+ u64::from_le(u.0) as usize
+ }
+ }
+
+ impl L64 {
+ /// Convert to machine 64-bit integers
+ pub fn as_u64(&self) -> u64 {
+ u64::from_le(self.0)
+ }
+ /// Convert to usize
+ pub fn as_usize(&self) -> usize {
+ u64::from_le(self.0) as usize
+ }
+ }
+
+ impl std::fmt::Display for L64 {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+ self.0.fmt(fmt)
+ }
+ }
+
+ impl std::ops::Add<L64> for L64 {
+ type Output = Self;
+ fn add(self, x: L64) -> L64 {
+ L64((u64::from_le(self.0) + u64::from_le(x.0)).to_le())
+ }
+ }
+
+ impl std::ops::Add<usize> for L64 {
+ type Output = Self;
+ fn add(self, x: usize) -> L64 {
+ L64((u64::from_le(self.0) + x as u64).to_le())
+ }
+ }
+
+ impl std::ops::SubAssign<usize> for L64 {
+ fn sub_assign(&mut self, x: usize) {
+ self.0 = ((u64::from_le(self.0)) - x as u64).to_le()
+ }
+ }
+
+ #[allow(trivial_casts)]
+ impl L64 {
+ /// Read an L64 from its binary representation.
+ pub fn from_slice_le(s: &[u8]) -> Self {
+ let mut u = 0u64;
+ assert!(s.len() >= 8);
+ unsafe { std::ptr::copy_nonoverlapping(s.as_ptr(), &mut u as *mut u64 as *mut u8, 8) }
+ L64(u)
+ }
+ /// Write an L64 as its binary representation.
+ pub fn to_slice_le(&self, s: &mut [u8]) {
+ assert!(s.len() >= 8);
+ unsafe {
+ std::ptr::copy_nonoverlapping(&self.0 as *const u64 as *const u8, s.as_mut_ptr(), 8)
+ }
+ }
+ }
+
+ direct_repr!(L64);
+ impl debug::Check for L64 {}
edit in sanakirja/src/environment/muttxn.rs at line 2
replacement in sanakirja/src/environment/muttxn.rs at line 30
[8.7288]→[8.1513:1560](∅→∅) − pub(crate) rc: Option<btree::Db<u64, ()>>,
+ pub(crate) rc: Option<btree::Db<L64, ()>>,
replacement in sanakirja/src/environment/muttxn.rs at line 33
[8.80540]→[8.80540:80575](∅→∅),
[8.80575]→[8.453:504](∅→∅) − /// have not been freed since.
− pub(crate) occupied_owned_pages: Vec<MutPage>,
+ /// have not been freed since. The boolean indicates whether this
+ /// was allocated with a dirty bit or not.
+ pub(crate) occupied_owned_pages: Vec<(MutPage, bool)>,
replacement in sanakirja/src/environment/muttxn.rs at line 214
[8.8542]→[8.8542:8624](∅→∅) − let free_db: btree::Db<u64, ()> = btree::Db::from_page(txn.free);
+ let free_db: btree::Db<L64, ()> = btree::Db::from_page(txn.free);
replacement in sanakirja/src/environment/muttxn.rs at line 218
[8.8770]→[8.664:699](∅→∅) replacement in sanakirja/src/environment/muttxn.rs at line 229
[8.3082]→[8.3082:3116](∅→∅) − fn clear_dirty(p: &mut MutPage) {
+ unsafe fn clear_dirty(p: &mut MutPage) {
replacement in sanakirja/src/environment/muttxn.rs at line 234
[8.3175]→[8.3175:3209](∅→∅) − fn clear_dirty(p: &mut MutPage) {
+ unsafe fn clear_dirty(p: &mut MutPage) {
replacement in sanakirja/src/environment/muttxn.rs at line 252
[8.11310]→[8.11310:11433](∅→∅) − let mut free_db: btree::Db<u64, ()> = if self.free == 0 {
− btree::create_db(&mut self)?
+ let mut free_db: btree::Db<L64, ()> = if self.free == 0 {
+ unsafe { btree::create_db(&mut self)? }
replacement in sanakirja/src/environment/muttxn.rs at line 255
[8.11458]→[8.11458:11510](∅→∅) − btree::Db::from_page(self.free)
+ unsafe { btree::Db::from_page(self.free) }
replacement in sanakirja/src/environment/muttxn.rs at line 274
− btree::del(&mut self, &mut free_db, &p.to_le(), None)?;
+ btree::del(&mut self, &mut free_db, &L64(p.to_le()), None)?;
replacement in sanakirja/src/environment/muttxn.rs at line 285
[4.1095]→[4.1095:1178](∅→∅) − btree::put(&mut self, &mut free_db, &p.to_le(), &())?;
+ btree::put(&mut self, &mut free_db, &L64(p.to_le()), &())?;
replacement in sanakirja/src/environment/muttxn.rs at line 290
[4.1345]→[4.1345:1428](∅→∅) − btree::put(&mut self, &mut free_db, &p.to_le(), &())?;
+ btree::put(&mut self, &mut free_db, &L64(p.to_le()), &())?;
replacement in sanakirja/src/environment/muttxn.rs at line 303
[8.13332]→[8.13332:13366](∅→∅),
[8.13366]→[8.13366:13581](∅→∅) − for p in occ.iter_mut() {
− if let Some(ref free_db) = free_db {
− if let Some((pp, ())) = btree::get(&self, free_db, &p.0.offset, None)? {
− if *pp == p.0.offset {
− continue;
+ for (p, uses_dirty) in occ.iter_mut() {
+ if *uses_dirty {
+ if let Some(ref free_db) = free_db {
+ if let Some((pp, ())) =
+ btree::get(&self, free_db, &L64(p.0.offset.to_le()), None)?
+ {
+ if u64::from_le(pp.0) == p.0.offset {
+ continue;
+ }
edit in sanakirja/src/environment/muttxn.rs at line 314
+ unsafe {
+ trace!(
+ "commit page {:x}: {:?}",
+ p.0.offset,
+ std::slice::from_raw_parts(p.0.data, 32)
+ );
+ }
+ unsafe {
+ clear_dirty(p);
+ }
edit in sanakirja/src/environment/muttxn.rs at line 325
[8.9700]→[8.9700:9721](∅→∅),
[8.9721]→[8.3460:3484](∅→∅),
[8.3484]→[8.9745:9903](∅→∅),
[8.9745]→[8.9745:9903](∅→∅),
[8.3265]→[8.85146:85160](∅→∅),
[8.9903]→[8.85146:85160](∅→∅),
[8.13621]→[8.85146:85160](∅→∅),
[8.85146]→[8.85146:85160](∅→∅),
[8.85160]→[8.13622:13650](∅→∅) − unsafe {
− trace!(
− "commit page {:x}: {:?}",
− p.0.offset,
− std::slice::from_raw_parts(p.0.data, 32)
− );
− }
− clear_dirty(p);
replacement in sanakirja/src/environment/muttxn.rs at line 342
[8.14091]→[8.14091:14141](∅→∅) − globptr.free_db = free_db.db.to_le();
+ let free: u64 = free_db.db.into();
+ globptr.free_db = free.to_le();
replacement in sanakirja/src/environment/muttxn.rs at line 347
− globptr.rc_db = rc_db.db.to_le();
+ let rc: u64 = rc_db.db.into();
+ globptr.rc_db = rc.to_le();
replacement in sanakirja/src/environment/muttxn.rs at line 359
[8.14598]→[8.14598:14622](∅→∅) replacement in sanakirja/src/environment/muttxn.rs at line 452
[8.2423]→[8.17561:17611](∅→∅),
[8.17561]→[8.17561:17611](∅→∅) − let db: btree::Db<u64, ()> = unsafe {
+ let db: btree::Db<L64, ()> = unsafe {
replacement in sanakirja/src/environment/muttxn.rs at line 466
[8.18156]→[8.18156:18204](∅→∅) − btree::Db::from_page(p.free_db)
+ btree::Db::from_page(u64::from_le(p.free_db))
replacement in sanakirja/src/environment/muttxn.rs at line 468
[8.18219]→[8.18219:18320](∅→∅) − if let Some((&f_, ())) = btree::get(self, &db, &f, None)? {
− if f_ != f {
+ if let Some((&f_, ())) = btree::get(self, &db, &L64(f.to_le()), None)? {
+ if f_.as_u64() != f {
replacement in sanakirja/src/environment/muttxn.rs at line 478
[8.87011]→[8.1117:1186](∅→∅),
[8.1186]→[8.87091:87180](∅→∅),
[8.87091]→[8.87091:87180](∅→∅) − impl<E: Borrow<Env>, T> sanakirja_core::AllocPage for MutTxn<E, T> {
− /// Allocate a single page.
− fn alloc_page(&mut self) -> Result<MutPage, Error> {
+ impl<E: Borrow<Env>, T> MutTxn<E, T> {
+ unsafe fn alloc_page_(&mut self, dirty: bool) -> Result<MutPage, Error> {
replacement in sanakirja/src/environment/muttxn.rs at line 488
[8.37753]→[8.37753:37811](∅→∅) − .push(MutPage(CowPage { data, offset }));
+ .push((MutPage(CowPage { data, offset }), dirty));
replacement in sanakirja/src/environment/muttxn.rs at line 497
[8.38052]→[8.18632:18694](∅→∅) − .push(MutPage(CowPage { data, offset }));
+ .push((MutPage(CowPage { data, offset }), dirty));
replacement in sanakirja/src/environment/muttxn.rs at line 506
[8.4198]→[8.4198:4260](∅→∅) − .push(MutPage(CowPage { data, offset }));
+ .push((MutPage(CowPage { data, offset }), dirty));
edit in sanakirja/src/environment/muttxn.rs at line 511
edit in sanakirja/src/environment/muttxn.rs at line 513
+ impl<E: Borrow<Env>, T> sanakirja_core::AllocPage for MutTxn<E, T> {
+ /// Allocate a single page.
+ unsafe fn alloc_page(&mut self) -> Result<MutPage, Error> {
+ self.alloc_page_(true)
+ }
+
+ /// Allocate a single page.
+ unsafe fn alloc_page_no_dirty(&mut self) -> Result<MutPage, Error> {
+ self.alloc_page_(false)
+ }
+
replacement in sanakirja/src/environment/muttxn.rs at line 525
− fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Error> {
+ unsafe fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Error> {
replacement in sanakirja/src/environment/muttxn.rs at line 543
+ if a < b || !self.free_for_all(b)? {
replacement in sanakirja/src/environment/muttxn.rs at line 610
[8.3615]→[8.3615:3672](∅→∅) − .push(MutPage(CowPage { data, offset }))
+ .push((MutPage(CowPage { data, offset }), false))
replacement in sanakirja/src/environment/muttxn.rs at line 625
[8.16374]→[8.19922:19963](∅→∅) − curs.set(self, &off, None)?;
+ curs.set(self, &L64(off.to_le()), None)?;
replacement in sanakirja/src/environment/muttxn.rs at line 627
[8.19070]→[8.38483:38524](∅→∅),
[8.20029]→[8.38483:38524](∅→∅),
[8.38483]→[8.38483:38524](∅→∅),
[8.38524]→[8.19071:19103](∅→∅) − if *rc & !0xfff == off {
− *rc & 0xfff
+ let rc = rc.as_u64();
+ if rc & !0xfff == off {
+ rc & 0xfff
replacement in sanakirja/src/environment/muttxn.rs at line 641
[8.19214]→[8.19214:19279](∅→∅) − btree::put(self, &mut rc_, &(off | (rc + 1)), &())?;
+ btree::put(self, &mut rc_, &L64((off | (rc + 1)).to_le()), &())?;
replacement in sanakirja/src/environment/muttxn.rs at line 645
[8.19361]→[8.19361:19468](∅→∅) − let mut rc = btree::create_db(self)?;
− btree::put(self, &mut rc, &(off | 2), &())?;
+ let mut rc = unsafe { btree::create_db(self)? };
+ btree::put(self, &mut rc, &L64((off | 2).to_le()), &())?;
replacement in sanakirja/src/environment/muttxn.rs at line 652
[8.89188]→[8.19519:19581](∅→∅) − fn decr_rc(&mut self, off: u64) -> Result<usize, Error> {
+ unsafe fn decr_rc(&mut self, off: u64) -> Result<usize, Error> {
replacement in sanakirja/src/environment/muttxn.rs at line 660
[8.19705]→[8.1768:1836](∅→∅),
[8.89188]→[8.1768:1836](∅→∅) − fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Error> {
+ unsafe fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Error> {
replacement in sanakirja/src/environment/muttxn.rs at line 680
[8.16443]→[8.42107:42148](∅→∅) − curs.set(self, &off, None)?;
+ curs.set(self, &L64(off.to_le()), None)?;
replacement in sanakirja/src/environment/muttxn.rs at line 685
[8.38994]→[8.38994:39059](∅→∅) − if *rc & !0xfff == off {
− *rc
+ let rc = rc.as_u64();
+ if rc & !0xfff == off {
+ rc
replacement in sanakirja/src/environment/muttxn.rs at line 699
[8.1705]→[8.39211:39267](∅→∅),
[8.2098]→[8.39211:39267](∅→∅),
[8.20682]→[8.39211:39267](∅→∅),
[8.39211]→[8.39211:39267](∅→∅) − btree::del(self, &mut rc_, &rc, None)?;
+ btree::del(self, &mut rc_, &L64(rc.to_le()), None)?;
replacement in sanakirja/src/environment/muttxn.rs at line 701
[8.971]→[8.971:1036](∅→∅) − btree::put(self, &mut rc_, &(rc - 1), &())?;
+ btree::put(self, &mut rc_, &L64((rc - 1).to_le()), &())?;
replacement in sanakirja/src/environment/muttxn.rs at line 727
− pub unsafe fn root_page(&mut self) -> &[u8; 4064] {
+ pub unsafe fn root_page(&self) -> &[u8; 4064] {
replacement in sanakirja/src/environment/muttxn.rs at line 737
[8.20977]→[8.39799:39867](∅→∅),
[8.90843]→[8.39799:39867](∅→∅),
[8.39867]→[8.117:148](∅→∅),
[8.148]→[8.3832:3877](∅→∅),
[8.3877]→[8.192:202](∅→∅),
[8.192]→[8.192:202](∅→∅),
[8.202]→[8.90908:90925](∅→∅),
[8.39867]→[8.90908:90925](∅→∅),
[8.90908]→[8.90908:90925](∅→∅),
[8.90925]→[8.397:457](∅→∅),
[8.457]→[8.39868:39914](∅→∅),
[8.90984]→[8.39868:39914](∅→∅),
[8.39914]→[8.91027:91037](∅→∅),
[8.91027]→[8.91027:91037](∅→∅) − fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
− if off > self.length {
− return Err(Error::Corrupt(off));
− }
− unsafe {
− let data = self.env.borrow().find_offset(off)?;
− Ok(CowPage { data, offset: off })
− }
+ unsafe fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
+ let data = self.env.borrow().find_offset(off)?;
+ Ok(CowPage { data, offset: off })
replacement in sanakirja/src/environment/muttxn.rs at line 744
[8.91142]→[8.2581:2653](∅→∅),
[8.2653]→[8.91357:91440](∅→∅),
[8.91357]→[8.91357:91440](∅→∅) − if let Some((rc, _)) = btree::get(self, rc, &page, None)? {
− if *rc & !0xfff == page {
− let r = *rc & 0xfff;
+ if let Some((rc, _)) = btree::get(self, rc, &L64(page.to_le()), None)? {
+ let rc = rc.as_u64();
+ if rc & !0xfff == page {
+ let r = rc & 0xfff;
replacement in sanakirja/src/environment/muttxn.rs at line 782
[8.5081]→[8.12946:13005](∅→∅),
[8.13005]→[8.21218:21299](∅→∅),
[8.21299]→[8.13082:13119](∅→∅),
[8.13082]→[8.13082:13119](∅→∅) − *(maps[0]
− .ptr
− .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
− as *mut u64)
+ u64::from_le(
+ *(maps[0]
+ .ptr
+ .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
+ as *mut u64),
+ )
replacement in sanakirja/src/environment/muttxn.rs at line 806
[8.21687]→[8.21687:21747](∅→∅) − Some(sanakirja_core::btree::Db_::from_page(db))
+ Some(unsafe { sanakirja_core::btree::Db_::from_page(db) })
edit in sanakirja/src/environment/mod.rs at line 13
[8.5673]→[8.1326:1377](∅→∅),
[8.1326]→[8.1326:1377](∅→∅) − #[cfg(not(feature = "mmap"))]
− use std::path::Path;
replacement in sanakirja/src/environment/mod.rs at line 52
− fn flush_range(&self, a: usize, b: usize) -> Result<(), Error> {
+ fn flush_range(&self, _: usize, _: usize) -> Result<(), Error> {
replacement in sanakirja/src/environment/mod.rs at line 174
[8.20157]→[8.109:155](∅→∅) − if g.version != CURRENT_VERSION {
+ if u16::from_le(g.version) != CURRENT_VERSION {
edit in sanakirja/src/environment/mod.rs at line 402
[8.431]→[8.431:442](∅→∅),
[8.442]→[8.5678:5681](∅→∅),
[8.105581]→[8.5678:5681](∅→∅),
[8.5681]→[8.443:529](∅→∅) − Ok(())
− }
−
− #[cfg(not(feature = "mmap"))]
− fn fallocate(&self, length: u64) -> Result<(), Error> {
replacement in sanakirja/src/environment/mod.rs at line 564
[8.106393]→[8.39945:40013](∅→∅) − fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
+ unsafe fn load_page(&self, off: u64) -> Result<CowPage, Self::Error> {
replacement in sanakirja/src/environment/mod.rs at line 622
[8.17729]→[8.31500:31564](∅→∅) − Some(sanakirja_core::btree::Db_::from_page(db))
+ Some(sanakirja_core::btree::Db_::from_page(u64::from_le(db)))
replacement in sanakirja/src/environment/mod.rs at line 638
[8.2826]→[8.2826:2848](∅→∅),
[8.2848]→[8.4328:4435](∅→∅) − *(maps[0]
− .ptr
− .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n) as *mut u64)
+ u64::from_le(
+ *(maps[0]
+ .ptr
+ .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
+ as *mut u64),
+ )
edit in sanakirja/src/debug.rs at line 8
replacement in sanakirja/src/debug.rs at line 30
[8.663]→[8.21289:21384](∅→∅) − print_page::<T, K, V, PP>(t, &mut h, &mut buf, &t.load_page(db.db).unwrap(), recurse);
+ print_page::<T, K, V, PP>(
+ t,
+ &mut h,
+ &mut buf,
+ &unsafe { t.load_page(db.db.into()) }.unwrap(),
+ recurse,
+ );
replacement in sanakirja/src/debug.rs at line 102
[8.2307]→[8.2307:2354](∅→∅) − pages.push(txn.load_page(l).unwrap());
+ pages.push(unsafe { txn.load_page(l).unwrap() });
replacement in sanakirja/src/debug.rs at line 127
[8.2906]→[8.2906:2957](∅→∅) − pages.push(txn.load_page(r).unwrap());
+ pages.push(unsafe { txn.load_page(r).unwrap() });
replacement in sanakirja/src/debug.rs at line 150
[8.2072]→[8.10545:10701](∅→∅) − impl<K: Check + Ord + UnsizedStorable + ?Sized, V: Check + Ord + UnsizedStorable + ?Sized, P: BTreePage<K, V> + std::fmt::Debug> Check
− for Db_<K, V, P>
+ impl<
+ K: Check + Ord + UnsizedStorable + ?Sized,
+ V: Check + Ord + UnsizedStorable + ?Sized,
+ P: BTreePage<K, V> + std::fmt::Debug,
+ > Check for Db_<K, V, P>
replacement in sanakirja/src/debug.rs at line 167
[8.11035]→[8.11035:11070](∅→∅) + match pages.entry(p.into()) {
replacement in sanakirja/src/debug.rs at line 171
[8.11192]→[8.11192:11239](∅→∅) − let p = txn.load_page(p)?;
+ let p = unsafe { txn.load_page(p.into())? };
replacement in sanakirja/src/debug.rs at line 173
[8.11292]→[8.11292:11352](∅→∅) − let l = P::left_child(p.as_page(), &c);
+ let l: u64 = P::left_child(p.as_page(), &c);
replacement in sanakirja/src/debug.rs at line 175
[8.11383]→[8.11383:11422](∅→∅) + stack.push(core::num::NonZeroU64::new(l).unwrap());
replacement in sanakirja/src/debug.rs at line 192
[8.12222]→[8.12222:12265](∅→∅) + stack.push(core::num::NonZeroU64::new(r).unwrap())
replacement in sanakirja/src/debug.rs at line 205
[8.12484]→[8.2072:2109](∅→∅),
[8.2072]→[8.2072:2109](∅→∅) − type B = btree::page::Page<u64, ()>;
+ type B = btree::page::Page<L64, ()>;
replacement in sanakirja/src/debug.rs at line 211
[8.2230]→[8.2230:2313](∅→∅) − let db_free = if txn.free > 0 {
− let db_free = Db::from_page(txn.free);
+ let db_free: Option<Db<L64, ()>> = if txn.free > 0 {
+ let db_free = unsafe { Db::from_page(txn.free) };
replacement in sanakirja/src/debug.rs at line 215
[8.2464]→[8.2464:2507](∅→∅) − assert!(refs.get(k).is_none())
+ assert!(refs.get(&k.as_u64()).is_none())
replacement in sanakirja/src/debug.rs at line 233
[8.2907]→[8.2907:3009](∅→∅) − if let Some((x, _)) = get(txn, f, &page, None).unwrap() {
− if *x == page {
+ if let Some((x, _)) = get(txn, f, &L64(page.to_le()), None).unwrap() {
+ if x.as_u64() == page {
replacement in sanakirja/src/debug.rs at line 252
[8.3332]→[8.3332:3395](∅→∅) − let (db_free, length): (Option<Db<u64, ()>>, _) = unsafe {
+ let (db_free, length): (Option<Db<L64, ()>>, _) = unsafe {
replacement in sanakirja/src/debug.rs at line 274
[8.4093]→[8.4093:4195](∅→∅) − if let Some((x, _)) = get(txn, f, &page, None).unwrap() {
− if *x == page {
+ if let Some((x, _)) = get(txn, f, &L64(page.to_le()), None).unwrap() {
+ if x.as_u64() == page {
replacement in sanakirja/src/debug.rs at line 300
[8.5761]→[8.5761:5833](∅→∅) − let free_db: Db<u64, ()> = btree::Db::from_page(p.free_db);
+ let free_db: Db<L64, ()> = btree::Db::from_page(u64::from_le(p.free_db));
replacement in sanakirja/src/debug.rs at line 305
[8.5973]→[8.5973:6041](∅→∅) − let rc_db: Db<u64, ()> = btree::Db::from_page(p.rc_db);
+ let rc_db: Db<L64, ()> = btree::Db::from_page(u64::from_le(p.rc_db));
replacement in sanakirja/src/debug.rs at line 318
[8.1817]→[8.1817:1884](∅→∅) − let free_db: Db<u64, ()> = btree::Db::from_page(txn.free);
+ let free_db: Db<L64, ()> = unsafe { btree::Db::from_page(txn.free) };
replacement in sanakirja/Cargo.toml at line 3
[8.108441]→[6.5195:5213](∅→∅) replacement in sanakirja/Cargo.toml at line 32
[8.84]→[6.5214:5281](∅→∅) − sanakirja-core = { path = "../sanakirja-core", version = "1.3.1" }
+ sanakirja-core = { path = "../sanakirja-core", version = "1.4.0" }
edit in sanakirja/Cargo.toml at line 37
replacement in Cargo.toml at line 2
− members = [ "sanakirja-core", "sanakirja", "sanakirja-core-async" ]
+ members = [ "sanakirja-core", "sanakirja", "sanakirja-core-async" ]
+
+ resolver = "2"
+
+ [replace]
+ "sanakirja-core:1.4.0" = { path = "sanakirja-core" }
+ "sanakirja:1.4.0" = { path = "sanakirja" }