Feature skiplist

Cargo.toml

@@ -11,3 +11,4 @@ readme = "README.md"
 
 [dependencies]
 owned-alloc = "0.2"
+rand = "0.8"

benchmark/Cargo.toml

@@ -8,6 +8,7 @@ publish = false
 lockfree = { path = "../" }
 benchsuite = { path = "benchsuite" }
 thread_local = "*"
+rand = "0.8"
 
 [workspace]
 members = ["benchsuite", "."]
@@ -55,3 +56,7 @@ path = "src/spmc.rs"
 [[bin]]
 name = "mpmc"
 path = "src/mpmc.rs"
+
+[[bin]]
+name = "skiplist"
+path = "src/skiplist.rs"

benchmark/src/skiplist.rs

@@ -0,0 +1,151 @@
+#[macro_use]
+extern crate benchsuite;
+extern crate lockfree;
+extern crate rand;
+
+use benchsuite::exec::Target;
+use lockfree::skiplist::SkipList;
+use std::{
+    collections::BTreeMap,
+    sync::{Arc, Mutex},
+};
+
+type MutexBTreeMapInner = Arc<Mutex<BTreeMap<u8, u8>>>;
+
+type LockfreeInner = Arc<SkipList<u8, u8>>;
+
+fn randomize(mut i: usize) -> usize {
+    i ^= i >> 12;
+    i ^= i << 25;
+    i ^ i >> 27
+}
+
+#[derive(Debug, Clone, Default)]
+struct MutexBTreeMapInsert {
+    inner: MutexBTreeMapInner,
+    seed: usize,
+}
+
+impl Target for MutexBTreeMapInsert {
+    #[inline(always)]
+    fn round(&mut self) {
+        let i = randomize(self.seed);
+
+        self.inner.lock().unwrap().insert(i as u8, i as u8);
+
+        self.seed = i;
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct LockfreeInsert {
+    inner: LockfreeInner,
+    seed: usize,
+}
+
+impl Target for LockfreeInsert {
+    #[inline(always)]
+    fn round(&mut self) {
+        let i = randomize(self.seed);
+
+        self.inner.insert(i as u8, i as u8);
+
+        self.seed = i;
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct MutexBTreeMapGet {
+    inner: MutexBTreeMapInner,
+    seed: usize,
+}
+
+impl Target for MutexBTreeMapGet {
+    #[inline(always)]
+    fn round(&mut self) {
+        let i = randomize(self.seed);
+
+        self.inner.lock().unwrap().get(&(i as u8));
+
+        self.seed = i;
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct LockfreeGet {
+    inner: LockfreeInner,
+    seed: usize,
+}
+
+impl Target for LockfreeGet {
+    #[inline(always)]
+    fn round(&mut self) {
+        let i = randomize(self.seed);
+
+        self.inner.get(&(i as u8));
+
+        self.seed = i;
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct MutexBTreeMapPopFirst {
+    inner: MutexBTreeMapInner,
+}
+
+impl Target for MutexBTreeMapPopFirst {
+    #[inline(always)]
+    fn round(&mut self) {
+        self.inner.lock().unwrap().pop_first();
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+struct LockfreePopFirst {
+    inner: LockfreeInner,
+}
+
+impl Target for LockfreePopFirst {
+    #[inline(always)]
+    fn round(&mut self) {
+        self.inner.pop_first();
+    }
+}
+
+fn main() {
+    let mutex = MutexBTreeMapInner::default();
+    let lockfree = LockfreeInner::default();
+    bench! {
+        levels 1, 2, 4, 8, 16, 32;
+        "mutex btree_map insert" => MutexBTreeMapInsert {
+            inner: mutex.clone(),
+            seed: rand::random::<usize>(),
+        },
+        "lockfree insert" => LockfreeInsert {
+            inner: lockfree.clone(),
+            seed: rand::random::<usize>(),
+        },
+    }
+
+    bench! {
+        levels 1, 2, 4, 8, 16, 32;
+        "mutex btree_map get" => MutexBTreeMapGet {
+            inner: mutex.clone(),
+            seed: rand::random::<usize>(),
+        },
+        "lockfree get" => LockfreeGet {
+            inner: lockfree.clone(),
+            seed: rand::random::<usize>(),
+        },
+    }
+
+    bench! {
+        levels 1, 2, 4, 8, 16, 32;
+        "mutex btree_map pop_first" => MutexBTreeMapPopFirst {
+            inner: mutex.clone(),
+        },
+        "lockfree get pop_first" => LockfreePopFirst {
+            inner: lockfree.clone(),
+        },
+    }
+}

benchmark/src/tls.rs

@@ -53,15 +53,15 @@ thread_local! {
 impl Target for BlockingTarget {
     #[inline(always)]
     fn round(&mut self) {
-        let cell = self.inner.get_or(|| Box::new(Cell::new(0)));
+        let cell = self.inner.get_or(|| *Box::new(Cell::new(0)));
         cell.set(cell.get().wrapping_add(1));
     }
 }
 
 impl Target for BlkCachedTarget {
     #[inline(always)]
     fn round(&mut self) {
-        let cell = self.inner.get_or(|| Box::new(Cell::new(0)));
+        let cell = self.inner.get_or(|| *Box::new(Cell::new(0)));
         cell.set(cell.get().wrapping_add(1));
     }
 }

build-benchmarks.sh

@@ -69,20 +69,26 @@ cargo run --bin mpmc --release >> $FILE || exit 1
 echo '```' >> $FILE
 echo '' >> $FILE
 
-echo '## REQUEST PROGRAM' >> $FILE
-echo '```' >> $FILE
-cargo run --bin request --release >> $FILE || exit 1
-echo '```' >> $FILE
-echo '' >> $FILE
+#	echo '## REQUEST PROGRAM' >> $FILE
+#	echo '```' >> $FILE
+#	cargo run --bin request --release >> $FILE || exit 1
+#	echo '```' >> $FILE
+#	echo '' >> $FILE
 
-echo '## MESSAGE REVERB PROGRAM' >> $FILE
-echo '```' >> $FILE
-cargo run --bin reverb --release >> $FILE || exit 1
-echo '```' >> $FILE
-echo '' >> $FILE
+#	echo '## MESSAGE REVERB PROGRAM' >> $FILE
+#	echo '```' >> $FILE
+#	cargo run --bin reverb --release >> $FILE || exit 1
+#	echo '```' >> $FILE
+#	echo '' >> $FILE
+
+#	echo '## HASH MINING' >> $FILE
+#	echo '```' >> $FILE
+#	cargo run --bin mining --release >> $FILE || exit 1
+#	echo '```' >> $FILE
+#	echo '' >> $FILE
 
-echo '## HASH MINING' >> $FILE
+echo '## SKIPLIST' >> $FILE
 echo '```' >> $FILE
-cargo run --bin mining --release >> $FILE || exit 1
+cargo run --bin skiplist --release >> $FILE || exit 1
 echo '```' >> $FILE
 echo '' >> $FILE

fuzz/Cargo.toml

@@ -46,5 +46,9 @@ path = "fuzz_targets/spmc.rs"
 name = "mpmc"
 path = "fuzz_targets/mpmc.rs"
 
+[[bin]]
+name = "skiplist"
+path = "fuzz_targets/skiplist.rs"
+
 [profile.release]
 lto = "off"

fuzz/fuzz_targets/skiplist.rs

@@ -0,0 +1,51 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+extern crate fuzzsuite;
+extern crate lockfree;
+
+use fuzzsuite::*;
+use lockfree::prelude::*;
+use std::sync::Arc;
+
+#[derive(Debug, Clone, Default)]
+struct SkipListMachine {
+    list: Arc<SkipList<Box<u16>, Box<u16>>>,
+}
+
+impl Spawn for SkipListMachine {
+    fn spawn() -> Self {
+        Self::default()
+    }
+
+    fn fork(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl Machine for SkipListMachine {
+    fn interpret(&mut self, mut byte: u8, bytecode: &mut Bytecode) {
+        loop {
+            match byte % 4 {
+                0 | 1 => {
+                    let val = ((bytecode.next().unwrap_or(0) as u16) << 8)
+                        + bytecode.next().unwrap_or(0) as u16;
+                    self.list.remove(&Box::new(val));
+                    break;
+                },
+
+                2 | 3 => {
+                    let val = ((bytecode.next().unwrap_or(0) as u16) << 8)
+                        + bytecode.next().unwrap_or(0) as u16;
+                    self.list.insert(Box::new(val), Box::new(val));
+                    break;
+                },
+                _ => unreachable!(),
+            }
+        }
+    }
+}
+
+fuzz_target!(|data: &[u8]| {
+    let _ = test::<SkipListMachine>(Bytecode::no_symbols(data));
+});

src/lib.rs

@@ -23,6 +23,7 @@
 //! - `[x]` [Set](set::Set)
 //! - `[x]` [Stack](stack::Stack)
 //! - `[x]` [Queue](queue::Queue)
+//! - `[x]` [SkipList](skiplist::SkipList)
 //! - `[ ]` Deque
 //!
 //! # Performance Guide
@@ -55,6 +56,9 @@ pub mod map;
 /// A lock-free set.
 pub mod set;
 
+/// A lock-free skip list.
+pub mod skiplist;
+
 /// Collection of lock-free FIFO channels. These channels are fully asynchronous
 /// and their receivers do not provide any sort of `wait-for-message` operation.
 /// It would be blocking otherwise, thus not lock-free. If you need such a

src/prelude.rs

@@ -2,5 +2,6 @@ pub use channel::{mpmc, mpsc, spmc, spsc};
 pub use map::Map;
 pub use queue::Queue;
 pub use set::Set;
+pub use skiplist::SkipList;
 pub use stack::Stack;
 pub use tls::ThreadLocal;