Merge branch 'dev'

guduyaogun/.gitignore

@@ -0,0 +1 @@
+/target

guduyaogun/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "guduyaogun"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bench]]
+name = "main"
+harness = false
+
+[dev-dependencies]
+criterion = {version = "0.4"}
+
+[dependencies]
+rayon = "1.6"
+futures = "0.3"
+crossbeam-skiplist = "0.1"
+num_cpus = "1"
+rand = "0.8"

guduyaogun/Readme.md

@@ -0,0 +1,9 @@
+# Concurrent Indexing
+
+为了方便性能对照，项目内有三个Index
+
+- SimpleIndex. 加锁的`BTreeMap`。
+- CSIndex. `crossbeam-skiplist`。
+- SkipMapIndex. 于本次比赛实现的skiplist。
+
+结果是……根本打不过:(

guduyaogun/benches/del_bench.rs

@@ -0,0 +1,69 @@
+use criterion::*;
+
+use guduyaogun::CSIndex;
+use guduyaogun::Index;
+use guduyaogun::IndexOperate;
+use guduyaogun::SimpleIndex;
+use guduyaogun::SkipMapIndex;
+
+pub fn simple_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("simple_index_bench");
+    group.bench_function("del_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SimpleIndex<u32, String> = SimpleIndex::new();
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000);
+                index
+            },
+            |index| {
+                index.delete(&0, &5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn cs_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cs_index_bench");
+    group.bench_function("del_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: CSIndex<u32, String> = CSIndex::new();
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000);
+                index
+            },
+            |index| {
+                index.delete(&0, &5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn skipmap_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("skipmap_index_bench");
+    group.bench_function("del_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SkipMapIndex<u32, String> = SkipMapIndex::new();
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                index
+            },
+            |index| {
+                index.delete(&0, &5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}

guduyaogun/benches/get_bench.rs

@@ -0,0 +1,172 @@
+use criterion::*;
+
+use num_cpus;
+
+use guduyaogun::CSIndex;
+use guduyaogun::Index;
+use guduyaogun::IndexOperate;
+use guduyaogun::SimpleIndex;
+use guduyaogun::SkipMapIndex;
+
+pub fn simple_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("simple_index_bench");
+    group.sample_size(10);
+    group.bench_function("get_multi_threads", |b| {
+        b.iter_batched(
+            || {
+                let index: SimpleIndex<u32, String> = SimpleIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000_000);
+                let threadpool = rayon::ThreadPoolBuilder::new()
+                    .num_threads(num_cpus::get())
+                    .build()
+                    .unwrap();
+                (index, threadpool)
+            },
+            |(index, threadpool)| {
+                threadpool.scope(|s| {
+                    for i in 0..500 {
+                        let index = index.clone();
+                        let start = i * 10_000;
+                        let end = start + 9_999;
+                        s.spawn(move |_| {
+                            index.get(&start, &end);
+                        })
+                    }
+                });
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("get_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SimpleIndex<u32, String> = SimpleIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000_000);
+                index
+            },
+            |index| {
+                for i in 0..500 {
+                    let start = i * 10_000;
+                    let end = start + 9_999;
+                    index.get(&start, &end);
+                }
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn cs_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cs_index_bench");
+    group.sample_size(10);
+    group.bench_function("get_multi_threads", |b| {
+        b.iter_batched(
+            || {
+                let index: CSIndex<u32, String> = CSIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000_000);
+                let threadpool = rayon::ThreadPoolBuilder::new()
+                    .num_threads(num_cpus::get())
+                    .build()
+                    .unwrap();
+                (index, threadpool)
+            },
+            |(index, threadpool)| {
+                threadpool.scope(|s| {
+                    for i in 0..500 {
+                        let index = index.clone();
+                        let start = i * 10_000;
+                        let end = start + 9_999;
+                        s.spawn(move |_| {
+                            index.get(&start, &end);
+                        })
+                    }
+                });
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("get_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: CSIndex<u32, String> = CSIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000_000);
+                index
+            },
+            |index| {
+                for i in 0..500 {
+                    let start = i * 10_000;
+                    let end = start + 9_999;
+                    index.get(&start, &end);
+                }
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn skipmap_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("skipmap_index_bench");
+    group.sample_size(10);
+    group.bench_function("get_multi_threads", |b| {
+        b.iter_batched(
+            || {
+                let index: SkipMapIndex<u32, String> = SkipMapIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                let threadpool = rayon::ThreadPoolBuilder::new()
+                    .num_threads(num_cpus::get())
+                    .build()
+                    .unwrap();
+                (index, threadpool)
+            },
+            |(index, threadpool)| {
+                threadpool.scope(|s| {
+                    for i in 0..500 {
+                        let index = index.clone();
+                        let start = i * 10_000;
+                        let end = start + 9_999;
+                        s.spawn(move |_| {
+                            index.get(&start, &end);
+                        })
+                    }
+                });
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("get_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SkipMapIndex<u32, String> = SkipMapIndex::new();
+                for i in 0..5_000_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                index
+            },
+            |index| {
+                for i in 0..500 {
+                    let start = i * 10_000;
+                    let end = start + 9_999;
+                    index.get(&start, &end);
+                }
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}

guduyaogun/benches/insert_bench.rs

@@ -0,0 +1,67 @@
+use criterion::*;
+
+use guduyaogun::CSIndex;
+use guduyaogun::Index;
+use guduyaogun::IndexOperate;
+use guduyaogun::SimpleIndex;
+use guduyaogun::SkipMapIndex;
+
+pub fn simple_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("simple_index_bench");
+    group.bench_function("insert_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SimpleIndex<u32, String> = SimpleIndex::new();
+                index
+            },
+            |index| {
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn cs_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cs_index_bench");
+    group.bench_function("insert_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: CSIndex<u32, String> = CSIndex::new();
+                index
+            },
+            |index| {
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+pub fn skipmap_index(c: &mut Criterion) {
+    let mut group = c.benchmark_group("skipmap_index_bench");
+    group.bench_function("insert_single_thread", |b| {
+        b.iter_batched(
+            || {
+                let index: SkipMapIndex<u32, String> = SkipMapIndex::new();
+                index
+            },
+            |index| {
+                for i in 0..5_000 {
+                    let _ = index.insert_or_update(i as u32, format!("value{}", i));
+                }
+                assert_eq!(index.len(), 5_000);
+            },
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}

guduyaogun/benches/main.rs

@@ -0,0 +1,22 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+mod del_bench;
+mod get_bench;
+mod insert_bench;
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default();
+    targets =
+    crate::get_bench::simple_index,
+    crate::get_bench::cs_index,
+    crate::get_bench::skipmap_index,
+    crate::del_bench::simple_index,
+    crate::del_bench::cs_index,
+    crate::del_bench::skipmap_index,
+    crate::insert_bench::simple_index,
+    crate::insert_bench::cs_index,
+    crate::insert_bench::skipmap_index,
+);
+
+criterion_main!(benches);