Optimize iterators and Arena::alloc logic

* Add remaining API

* Optimize `Arena::alloc` logic

* Implement `Iterator` trait for `MapIterator` and `SetIterator`

Author: al8n

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.7.0
+
+- Implement `Iterator` for `MapIterator` and `SetIterator`.
+- Optimize `Arena::alloc` logic.
+
 ## 0.6.0
 
 - Change mmap related API

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "skl"
-version = "0.6.0"
+version = "0.7.1"
 edition = "2021"
 rust-version = "1.56.0"
 repository = "https://github.com/al8n/skl-rs"

README.md

@@ -28,14 +28,14 @@
 
     ```toml
     [dependencies]
-    skl = "0.6"
+    skl = "0.7"
     ```
 
 - Enable memory map backend
 
     ```toml
     [dependencies]
-    skl = { version = "0.6", features = ["memmap"] }
+    skl = { version = "0.7", features = ["memmap"] }
     ```
 
 ## Features

examples/mmap.rs

@@ -11,7 +11,7 @@ pub fn new_value(i: usize) -> Vec<u8> {
 fn main() {
   const N: usize = 1000;
 
-  let l = Arc::new(SkipMap::mmap_mut(1 << 20, "test.wal", true).unwrap());
+  let l = Arc::new(SkipMap::mmap_mut("test.wal", 1 << 20, true).unwrap());
   let wg = Arc::new(());
   for i in 0..N {
     let w = wg.clone();

integration/src/bin/test-mmap.rs

@@ -7,7 +7,7 @@ fn main() {
   let p = dir.path().join("test_mmap");
   {
     const N: usize = 10;
-    let l = Arc::new(SkipMap::mmap_mut(1 << 20, &p, true).unwrap());
+    let l = Arc::new(SkipMap::mmap_mut(&p, 1 << 20, true).unwrap());
     for i in 0..N {
       let l = l.clone();
       std::thread::spawn(move || {
@@ -29,7 +29,7 @@ fn main() {
 
   {
     const N2: usize = 10;
-    let l = Arc::new(SkipMap::mmap(&p, false).unwrap());
+    let l = Arc::new(SkipMap::<u64>::mmap(&p, false).unwrap());
     assert_eq!(N2, l.len());
     for i in 0..N2 {
       let l = l.clone();

src/arena.rs

@@ -69,6 +69,12 @@ impl Arena {
   pub const fn capacity(&self) -> usize {
     self.cap
   }
+
+  /// Returns the number of bytes remaining bytes can be allocated by the arena.
+  #[inline]
+  pub fn remaining(&self) -> usize {
+    self.cap.saturating_sub(self.size())
+  }
 }
 
 impl Arena {
@@ -199,25 +205,27 @@ impl Arena {
     align: u32,
     overflow: u32,
   ) -> Result<(u32, u32), ArenaError> {
-    // Verify that the arena isn't already full.
-    let orig_size = self.n.load(Ordering::Acquire);
-    if orig_size > self.cap as u64 {
-      return Err(ArenaError);
-    }
-
     // Pad the allocation with enough bytes to ensure the requested alignment.
     let padded = size as u64 + align as u64 - 1;
 
-    let new_size = self.n.fetch_add(padded, Ordering::AcqRel) + padded;
+    let res = self
+      .n
+      .fetch_update(Ordering::Release, Ordering::Acquire, |orig| {
+        if orig + padded + overflow as u64 > self.cap as u64 {
+          return None;
+        }
+        Some(orig + padded)
+      });
 
-    if new_size + overflow as u64 > self.cap as u64 {
-      return Err(ArenaError);
+    match res {
+      Ok(new_size) => {
+        // Return the aligned offset.
+        let new_size = new_size + padded;
+        let offset = (new_size as u32 - size) & !(align - 1);
+        Ok((offset, padded as u32))
+      }
+      Err(_) => Err(ArenaError),
     }
-
-    // Return the aligned offset.
-    let offset = (new_size as u32 - size) & !(align - 1);
-
-    Ok((offset, padded as u32))
   }
 
   /// ## Safety:

src/lib.rs

@@ -26,12 +26,38 @@ pub mod map;
 pub mod set;
 
 pub use arena::{Arena, ArenaError};
-pub use map::{MapIterator, MapRange, SkipMap};
-pub use set::{SetIterator, SetRange, SkipSet};
+pub use map::{MapIterator, SkipMap};
+pub use set::{SetIterator, SkipSet};
 
 const MAX_HEIGHT: usize = 20;
 const NODE_ALIGNMENT_FACTOR: usize = mem::align_of::<u64>();
 
+#[cfg(feature = "std")]
+fn random_height() -> u32 {
+  use rand::{thread_rng, Rng};
+  let mut rng = thread_rng();
+  let rnd: u32 = rng.gen();
+  let mut h = 1;
+
+  while h < MAX_HEIGHT && rnd <= PROBABILITIES[h] {
+    h += 1;
+  }
+  h as u32
+}
+
+#[cfg(not(feature = "std"))]
+fn random_height() -> u32 {
+  use rand::{rngs::OsRng, Rng};
+
+  let rnd: u32 = OsRng.gen();
+  let mut h = 1;
+
+  while h < MAX_HEIGHT && rnd <= PROBABILITIES[h] {
+    h += 1;
+  }
+  h as u32
+}
+
 /// Precompute the skiplist probabilities so that only a single random number
 /// needs to be generated and so that the optimal pvalue can be used (inverse
 /// of Euler's number).