add prefix benchmark

fjall-rs · Nov 28, 2023 · 6cd4da7 · 6cd4da7
1 parent 87f9927
commit 6cd4da7
Show file tree

Hide file tree

Showing 4 changed files with 112 additions and 73 deletions.
diff --git a/benches/lsmt.rs b/benches/lsmt.rs
@@ -102,12 +102,7 @@ fn disk_point_reads(c: &mut Criterion) {
         tree.insert(key, value).unwrap();
     }
 
-    tree.force_memtable_flush()
-        .expect("Flush error")
-        .join()
-        .expect("Join failed")
-        .expect("Flush thread failed");
-
+    tree.wait_for_memtable_flush().expect("Flush thread failed");
     assert_eq!(tree.len().unwrap() as u32, max);
 
     for thread_count in [1_u32, 2, 4, 8] {
@@ -157,11 +152,7 @@ fn cached_retrieve_disk_random(c: &mut Criterion) {
         tree.insert(key, value).unwrap();
     }
 
-    tree.force_memtable_flush()
-        .expect("Flush error")
-        .join()
-        .expect("Join failed")
-        .expect("Flush thread failed");
+    tree.wait_for_memtable_flush().expect("Flush thread failed");
     assert_eq!(tree.len().unwrap() as u32, max);
 
     for thread_count in [1_u32, 2, 4, 8] {
@@ -250,25 +241,21 @@ fn scan_vs_query(c: &mut Criterion) {
     let mut group = c.benchmark_group("scan vs query");
 
     for size in [100_000, 1_000_000, 2_000_000, 5_000_000] {
-        let db = Config::new(tempdir().unwrap()).open().unwrap();
+        let tree = Config::new(tempdir().unwrap()).open().unwrap();
 
         for x in 0..size as u64 {
             let key = x.to_be_bytes().to_vec();
             let value = nanoid::nanoid!().as_bytes().to_vec();
-            db.insert(key, value).expect("Insert error");
+            tree.insert(key, value).expect("Insert error");
         }
 
-        db.force_memtable_flush()
-            .expect("Flush error")
-            .join()
-            .expect("Join failed")
-            .expect("Flush thread failed");
-        assert_eq!(db.len().unwrap(), size);
+        tree.wait_for_memtable_flush().expect("Flush thread failed");
+        assert_eq!(tree.len().unwrap(), size);
 
         group.sample_size(10);
         group.bench_function(format!("scan {}", size), |b| {
             b.iter(|| {
-                let iter = db.iter().unwrap();
+                let iter = tree.iter().unwrap();
                 let iter = iter.into_iter();
                 let count = iter
                     .filter(|x| match x {
@@ -286,7 +273,7 @@ fn scan_vs_query(c: &mut Criterion) {
         });
         group.bench_function(format!("query {}", size), |b| {
             b.iter(|| {
-                let iter = db
+                let iter = tree
                     .range((
                         Included(60000_u64.to_be_bytes().to_vec()),
                         Excluded(61000_u64.to_be_bytes().to_vec()),
@@ -298,7 +285,7 @@ fn scan_vs_query(c: &mut Criterion) {
         });
         group.bench_function(format!("query rev {}", size), |b| {
             b.iter(|| {
-                let iter = db
+                let iter = tree
                     .range((
                         Included(60000_u64.to_be_bytes().to_vec()),
                         Excluded(61000_u64.to_be_bytes().to_vec()),
@@ -311,14 +298,66 @@ fn scan_vs_query(c: &mut Criterion) {
     }
 }
 
+fn scan_vs_prefix(c: &mut Criterion) {
+    let mut group = c.benchmark_group("scan vs prefix");
+
+    for size in [100_000_u64, 1_000_000, 2_000_000, 5_000_000] {
+        let tree = Config::new(tempdir().unwrap()).open().unwrap();
+
+        for _ in 0..size {
+            let key = nanoid::nanoid!();
+            let value = nanoid::nanoid!();
+            tree.insert(key, value).expect("Insert error");
+        }
+
+        let prefix = "hello$$$";
+
+        for _ in 0..1000_u64 {
+            let key = format!("{}:{}", prefix, nanoid::nanoid!());
+            let value = nanoid::nanoid!();
+            tree.insert(key, value).expect("Insert error");
+        }
+
+        tree.wait_for_memtable_flush().expect("Flush thread failed");
+        assert_eq!(tree.len().unwrap() as u64, size + 1000);
+
+        group.sample_size(10);
+        group.bench_function(format!("scan {}", size), |b| {
+            b.iter(|| {
+                let iter = tree.iter().unwrap();
+                let iter = iter.into_iter().filter(|x| match x {
+                    Ok(item) => item.key.starts_with(prefix.as_bytes()),
+                    Err(_) => false,
+                });
+                assert_eq!(iter.count(), 1000);
+            });
+        });
+        group.bench_function(format!("prefix {}", size), |b| {
+            b.iter(|| {
+                let iter = tree.prefix(prefix).unwrap();
+                let iter = iter.into_iter();
+                assert_eq!(iter.count(), 1000);
+            });
+        });
+        group.bench_function(format!("prefix rev {}", size), |b| {
+            b.iter(|| {
+                let iter = tree.prefix(prefix).unwrap();
+                let iter = iter.into_iter();
+                assert_eq!(iter.rev().count(), 1000);
+            });
+        });
+    }
+}
+
 criterion_group!(
     benches,
     // insert,
     memtable_point_reads,
     disk_point_reads,
     cached_retrieve_disk_random,
     full_scan,
-    scan_vs_query
+    scan_vs_query,
+    scan_vs_prefix
 );
 
 criterion_main!(benches);
diff --git a/tests/tree_count.rs b/tests/tree_count.rs
@@ -8,21 +8,21 @@ const ITEM_COUNT: usize = 1_000;
 fn tree_memtable_count() -> lsm_tree::Result<()> {
     let folder = tempdir()?.into_path();
 
-    let db = Config::new(folder).open()?;
+    let tree = Config::new(folder).open()?;
 
     for x in 0..ITEM_COUNT as u64 {
         let key = x.to_be_bytes();
         let value = nanoid::nanoid!();
-        db.insert(key, value)?;
+        tree.insert(key, value)?;
     }
 
-    assert_eq!(db.len()?, ITEM_COUNT);
+    assert_eq!(tree.len()?, ITEM_COUNT);
     assert_eq!(
-        db.iter()?.into_iter().filter(|x| x.is_ok()).count(),
+        tree.iter()?.into_iter().filter(|x| x.is_ok()).count(),
         ITEM_COUNT
     );
     assert_eq!(
-        db.iter()?.into_iter().rev().filter(|x| x.is_ok()).count(),
+        tree.iter()?.into_iter().rev().filter(|x| x.is_ok()).count(),
         ITEM_COUNT
     );
 
@@ -33,23 +33,23 @@ fn tree_memtable_count() -> lsm_tree::Result<()> {
 fn tree_flushed_count() -> lsm_tree::Result<()> {
     let folder = tempdir()?.into_path();
 
-    let db = Config::new(folder).open()?;
+    let tree = Config::new(folder).open()?;
 
     for x in 0..ITEM_COUNT as u64 {
         let key = x.to_be_bytes();
         let value = nanoid::nanoid!();
-        db.insert(key, value)?;
+        tree.insert(key, value)?;
     }
 
-    db.wait_for_memtable_flush()?;
+    tree.wait_for_memtable_flush()?;
 
-    assert_eq!(db.len()?, ITEM_COUNT);
+    assert_eq!(tree.len()?, ITEM_COUNT);
     assert_eq!(
-        db.iter()?.into_iter().filter(|x| x.is_ok()).count(),
+        tree.iter()?.into_iter().filter(|x| x.is_ok()).count(),
         ITEM_COUNT
     );
     assert_eq!(
-        db.iter()?.into_iter().rev().filter(|x| x.is_ok()).count(),
+        tree.iter()?.into_iter().rev().filter(|x| x.is_ok()).count(),
         ITEM_COUNT
     );
 

diff --git a/tests/tree_reload.rs b/tests/tree_reload.rs
@@ -8,43 +8,43 @@ fn tree_reload() -> lsm_tree::Result<()> {
     let folder = tempfile::tempdir()?;
 
     {
-        let db = Config::new(&folder).open()?;
+        let tree = Config::new(&folder).open()?;
 
         for x in 0..ITEM_COUNT as u64 {
             let key = x.to_be_bytes();
             let value = nanoid::nanoid!();
-            db.insert(key, value)?;
+            tree.insert(key, value)?;
         }
 
-        db.wait_for_memtable_flush()?;
+        tree.wait_for_memtable_flush()?;
 
         for x in 0..ITEM_COUNT as u64 {
             let key: [u8; 8] = (x + ITEM_COUNT as u64).to_be_bytes();
             let value = nanoid::nanoid!();
-            db.insert(key, value)?;
+            tree.insert(key, value)?;
         }
 
-        assert_eq!(db.len()?, ITEM_COUNT * 2);
+        assert_eq!(tree.len()?, ITEM_COUNT * 2);
         assert_eq!(
-            db.iter()?.into_iter().filter(Result::is_ok).count(),
+            tree.iter()?.into_iter().filter(Result::is_ok).count(),
             ITEM_COUNT * 2
         );
         assert_eq!(
-            db.iter()?.into_iter().rev().filter(Result::is_ok).count(),
+            tree.iter()?.into_iter().rev().filter(Result::is_ok).count(),
             ITEM_COUNT * 2
         );
     }
 
     {
-        let db = Config::new(&folder).open()?;
+        let tree = Config::new(&folder).open()?;
 
-        assert_eq!(db.len()?, ITEM_COUNT * 2);
+        assert_eq!(tree.len()?, ITEM_COUNT * 2);
         assert_eq!(
-            db.iter()?.into_iter().filter(Result::is_ok).count(),
+            tree.iter()?.into_iter().filter(Result::is_ok).count(),
             ITEM_COUNT * 2
         );
         assert_eq!(
-            db.iter()?.into_iter().rev().filter(Result::is_ok).count(),
+            tree.iter()?.into_iter().rev().filter(Result::is_ok).count(),
             ITEM_COUNT * 2
         );
     }

diff --git a/tests/tree_shadowing.rs b/tests/tree_shadowing.rs
@@ -5,29 +5,29 @@ use test_log::test;
 fn tree_shadowing_upsert() -> lsm_tree::Result<()> {
     let folder = tempfile::tempdir()?.into_path();
 
-    let db = Config::new(folder).open()?;
+    let tree = Config::new(folder).open()?;
 
     let key = "1";
     let value = b"oldvalue";
 
-    assert_eq!(db.len()?, 0);
-    db.insert(key, *value)?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    assert_eq!(tree.len()?, 0);
+    tree.insert(key, *value)?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
-    db.wait_for_memtable_flush()?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    tree.wait_for_memtable_flush()?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
     let value = b"newvalue";
 
-    db.insert(key, *value)?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    tree.insert(key, *value)?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
-    db.wait_for_memtable_flush()?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    tree.wait_for_memtable_flush()?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
     Ok(())
 }
@@ -36,28 +36,28 @@ fn tree_shadowing_upsert() -> lsm_tree::Result<()> {
 fn tree_shadowing_delete() -> lsm_tree::Result<()> {
     let folder = tempfile::tempdir()?.into_path();
 
-    let db = Config::new(folder).open().unwrap();
+    let tree = Config::new(folder).open().unwrap();
 
     let key = "1";
     let value = b"oldvalue";
 
-    assert_eq!(db.len()?, 0);
-    db.insert(key, *value)?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    assert_eq!(tree.len()?, 0);
+    tree.insert(key, *value)?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
-    db.wait_for_memtable_flush()?;
-    assert_eq!(db.len()?, 1);
-    assert_eq!(db.get(key)?.map(|x| x.value), Some(value.to_vec()));
+    tree.wait_for_memtable_flush()?;
+    assert_eq!(tree.len()?, 1);
+    assert_eq!(tree.get(key)?.map(|x| x.value), Some(value.to_vec()));
 
-    db.remove(key)?;
+    tree.remove(key)?;
     eprint!("removed key {:?}", key);
-    assert_eq!(db.len()?, 0);
-    assert!(db.get(key)?.is_none());
+    assert_eq!(tree.len()?, 0);
+    assert!(tree.get(key)?.is_none());
 
-    db.wait_for_memtable_flush()?;
-    assert_eq!(db.len()?, 0);
-    assert!(db.get(key)?.is_none());
+    tree.wait_for_memtable_flush()?;
+    assert_eq!(tree.len()?, 0);
+    assert!(tree.get(key)?.is_none());
 
     Ok(())
 }