Add first version of rust benchmark

Author: Mitron57

.github/workflows/rust.yml

@@ -0,0 +1,61 @@
+name: Benchmark
+
+on:
+  push:
+    branches:
+      - add_rust_benchmark
+
+env:
+  toolchain: nightly-2022-08-22
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:latest
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{env.toolchain}}
+          components: rustfmt, clippy
+          default: true
+      - name: Build benchmark
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --all-features
+      - name: Run benchmark
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: --bench bench -- --output-format bencher | tee out.txt
+      - name: Prepare benchmark results
+        run: |
+          cd rust
+          pip install numpy matplotlib
+          python3 out.py
+      - name: Save benchmark results
+        uses: actions/upload-artifact@v3
+        with:
+          name: Benchmark results
+          path: |
+            rust/Bench1.png
+            rust/Bench2.png

rust/Cargo.toml

@@ -4,12 +4,11 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-tokio = { version = "1.19", features = ["full"] }
-tokio-postgres = "0.7.6"
-criterion = "0.3.6"
-platform-data = "0.1.0-alpha.1"
-doublets = "0.1.0-pre+beta.15"
-async-trait = "0.1.57"
+tokio = { version = "1.29.1", features = ["full"] }
+tokio-postgres = "0.7.8"
+criterion = "0.5.1"
+doublets = { git = "https://github.com/linksplatform/doublets-rs.git" }
+async-trait = "0.1.72"
 
 [[bench]]
 name = "bench"

rust/benches/bench.rs

@@ -1,86 +1,28 @@
 #![feature(allocator_api)]
-
-use criterion::{criterion_group, criterion_main, Criterion};
-use doublets::{
-    mem::{AllocMem, FileMappedMem},
-    unit, Doublets,
+#![feature(box_syntax)]
+
+use criterion::criterion_group;
+use {
+    create::create_links,
+    criterion::criterion_main,
+    delete::delete_links,
+    each::{each_all, each_concrete, each_identity, each_incoming, each_outgoing},
+    update::update_links,
 };
-use tokio_postgres::{Error, NoTls};
-
-use linkspsql::{make_bench, Client, Cruds};
-
-async fn connect() -> Result<Client, Error> {
-    let (client, connection) = tokio_postgres::connect("", NoTls).await.unwrap();
-    tokio::spawn(async move {
-        if let Err(err) = connection.await {
-            return Err(err);
-        }
-        Ok(())
-    });
-    Client::new(client).await
-}
-
-fn create_thousand_links_without_transaction(c: &mut Criterion) {
-    let runtime = tokio::runtime::Runtime::new().unwrap();
-    let mut client = runtime.block_on(connect()).unwrap();
-    make_bench!(
-        c,
-        "create_thousand_links_without_transaction",
-        client,
-        runtime
-    );
-}
-
-fn create_thousand_links_with_transaction(c: &mut Criterion) {
-    let runtime = tokio::runtime::Runtime::new().unwrap();
-    let mut client = runtime.block_on(connect()).unwrap();
-    make_bench!(
-        c,
-        "create_thousand_links_with_transaction",
-        client,
-        runtime,
-        transaction
-    );
-}
-
-fn doublets_benchmark_ram(c: &mut Criterion) {
-    let allocator = std::alloc::Global;
-    let storage = AllocMem::new(allocator);
-    let mut links = unit::Store::<usize, _>::new(storage).unwrap();
-    c.bench_function("doublets_benchmark_ram", |b| {
-        b.iter(|| {
-            for _ in 1..=1_000_000 {
-                links.create_point().unwrap();
-            }
-        });
-        links.delete_all().unwrap();
-    });
-}
-
-fn doublets_benchmark_file(c: &mut Criterion) {
-    let file = std::fs::File::options()
-        .create(true)
-        .write(true)
-        .read(true)
-        .open("db.links")
-        .unwrap();
-    let storage = FileMappedMem::new(file).unwrap();
-    let mut links = unit::Store::<usize, _>::new(storage).unwrap();
-    c.bench_function("doublets_benchmark_file", |b| {
-        b.iter(|| {
-            for _ in 1..=1_000_000 {
-                links.create_point().unwrap();
-            }
-        });
-        links.delete_all().unwrap();
-    });
-}
+mod create;
+mod delete;
+mod each;
+mod update;
 
 criterion_group!(
     benches,
-    create_thousand_links_without_transaction,
-    create_thousand_links_with_transaction,
-    doublets_benchmark_ram,
-    doublets_benchmark_file,
+    create_links,
+    delete_links,
+    each_identity,
+    each_concrete,
+    each_outgoing,
+    each_incoming,
+    each_all,
+    update_links
 );
 criterion_main!(benches);

rust/benches/create.rs

@@ -0,0 +1,156 @@
+#![feature(allocator_api)]
+
+use {
+    criterion::Criterion,
+    doublets::{
+        mem::{Alloc, FileMapped},
+        split, unit, Doublets,
+    },
+    linkspsql::{benchmark, connect, elapsed, prepare_file, SetupTeardown, BACKGROUND_LINKS},
+    std::{
+        error::Error,
+        time::{Duration, Instant},
+    },
+    tokio::runtime::Runtime,
+};
+
+pub fn create_links(c: &mut Criterion) -> Result<(), Box<dyn Error>> {
+    let runtime = Runtime::new()?;
+    let mut group = c.benchmark_group("Create");
+    let allocator = std::alloc::Global;
+    let united = prepare_file("united.links")?;
+    let split_data = prepare_file("split_data.links")?;
+    let split_index = prepare_file("split_index.links")?;
+    {
+        let mut client = runtime.block_on(connect())?;
+        let mut background = BACKGROUND_LINKS;
+        let _ = client.setup();
+        benchmark! {
+            group,
+            "PSQL_NonTransaction",
+            {
+                for _ in 0..1_000 {
+                    let _ = client.create_point();
+                }
+            },
+            {
+                for index in (background + 1..=background + 1_000).rev() {
+                    let _ = client.delete(index);
+                }
+                background += 1_000;
+            }
+        }
+        let _ = client.teardown();
+    }
+    {
+        let mut client = runtime.block_on(connect())?;
+        let mut background = BACKGROUND_LINKS;
+        let mut transaction = client.transaction()?;
+        let _ = transaction.setup();
+        let _ = transaction.commit();
+        benchmark! {
+            group,
+            "PSQL_Transaction",
+            let mut transaction = client.transaction().unwrap(),
+            {
+                for _ in 0..1_000 {
+                    let _ = transaction.create_point();
+                }
+                let _ = transaction.commit();
+            },
+            {
+                let mut transaction = client.transaction().unwrap();
+                for index in (background + 1..=background + 1_000).rev() {
+                    let _ = transaction.delete(index);
+                }
+                let _ = transaction.commit();
+                background += 1_000;
+            }
+        }
+        let _ = client.transaction()?.teardown();
+    }
+    {
+        let storage = Alloc::new(allocator);
+        let mut links = unit::Store::<usize, _>::new(storage)?;
+        let _ = links.setup();
+        benchmark! {
+            group,
+            "Doublets_United_Volatile",
+            {
+                for _ in 0..1_000 {
+                    let _ = links.create_point();
+                }
+            },
+            {
+                for index in (BACKGROUND_LINKS + 1..=BACKGROUND_LINKS + 1_000).rev() {
+                    let _ = links.delete(index);
+                }
+            }
+        }
+        let _ = links.teardown();
+    }
+    {
+        let storage = FileMapped::new(united)?;
+        let mut links = unit::Store::<usize, _>::new(storage)?;
+        let _ = links.setup();
+        benchmark! {
+            group,
+            "Doublets_United_NonVolatile",
+            {
+                for _ in 0..1_000 {
+                    let _ = links.create_point();
+                }
+            },
+            {
+                for index in (BACKGROUND_LINKS + 1..=BACKGROUND_LINKS + 1_000).rev() {
+                    let _ = links.delete(index);
+                }
+            }
+        }
+        let _ = links.teardown();
+    }
+    {
+        let data = Alloc::new(allocator);
+        let index = Alloc::new(allocator);
+        let mut links = split::Store::<usize, _, _>::new(data, index)?;
+        let _ = links.setup();
+        benchmark! {
+            group,
+            "Doublets_Split_Volatile",
+            {
+                for _ in 0..1_000 {
+                    let _ = links.create_point();
+                }
+            },
+            {
+                for index in (BACKGROUND_LINKS + 1..=BACKGROUND_LINKS + 1_000).rev() {
+                    let _ = links.delete(index);
+                }
+            }
+        }
+        let _ = links.teardown();
+    }
+    {
+        let split_data = FileMapped::new(split_data)?;
+        let split_index = FileMapped::new(split_index)?;
+        let mut links = split::Store::<usize, _, _>::new(split_data, split_index)?;
+        let _ = links.setup();
+        benchmark! {
+            group,
+            "Doublets_Split_NonVolatile",
+            {
+                for _ in 0..1_000 {
+                    let _ = links.create_point();
+                }
+            },
+            {
+                for index in (BACKGROUND_LINKS + 1..=BACKGROUND_LINKS + 1_000).rev() {
+                    let _ = links.delete(index);
+                }
+            }
+        }
+        let _ = links.teardown();
+    }
+    group.finish();
+    Ok(())
+}