Merge pull request #6 from linksplatform/add_rust_benchmark

Add Rust benchmark

Author: konard

.github/workflows/rust.yml

@@ -0,0 +1,59 @@
+name: Benchmark Rust version
+
+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 --manifest-path rust/Cargo.toml
+      - name: Run benchmark
+        working-directory: rust
+        run: cargo bench --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

@@ -0,0 +1,15 @@
+[package]
+name = "linkspsql"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+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"
+harness = false

rust/benches/bench.rs

@@ -0,0 +1,28 @@
+#![feature(allocator_api)]
+#![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,
+};
+mod create;
+mod delete;
+mod each;
+mod update;
+
+criterion_group!(
+    benches,
+    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(())
+}