bench: replaced sled with kvdb-overlay

Cargo.toml

@@ -342,9 +342,9 @@ name = "zk_from_json"
 harness = false
 path = "bench/zk_from_json.rs"
 [[bench]]
-name = "sled"
+name = "kvdb"
 harness = false
-path = "bench/sled.rs"
+path = "bench/kvdb.rs"
 
 # Crossbeam SkipMap vs Mutex protected HashMap.
 # Uncomment to enable, and add the following to dev-dependencies:

Makefile

@@ -125,7 +125,7 @@ check: $(PROOFS_BIN) contracts
 
 clippy: $(PROOFS_BIN) contracts
 	RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) clippy --target=$(RUST_TARGET) \
-		--release --all-features --workspace --tests
+		--release --all-features --workspace --tests --benches
 
 fix: $(PROOFS_BIN) contracts
 	RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) clippy --target=$(RUST_TARGET) \

bench/sled.rs → bench/kvdb.rs

@@ -19,11 +19,12 @@
 use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
 use darkfi_sdk::crypto::pasta_prelude::*;
 use halo2_proofs::pasta::Fp;
+use kvdb_overlay::Database;
 use rand::rngs::OsRng;
 
-fn sled(c: &mut Criterion) {
-    let db = sled::open("/tmp/db").unwrap();
-    let tree = db.open_tree(b"hello").unwrap();
+fn kvdb(c: &mut Criterion) {
+    let (kvdb, _kvdb_folder) = Database::open_temp().unwrap();
+    let tree = kvdb.open_tree_default("hello").unwrap();
 
     let mut group = c.benchmark_group("inserts");
     for i in 0..10 {
@@ -42,8 +43,8 @@ fn sled(c: &mut Criterion) {
         });
     }
     tree.clear().unwrap();
-    let _ = db.drop_tree(b"hello");
+    let _ = kvdb.drop_tree("hello");
 }
 
-criterion_group!(bench, sled);
+criterion_group!(bench, kvdb);
 criterion_main!(bench);

bench/zk_arith.rs

@@ -32,7 +32,7 @@ use darkfi::{
 
 fn zk_arith(c: &mut Criterion) {
     let bincode = include_bytes!("../proof/arithmetic.zk.bin");
-    let zkbin = ZkBinary::decode(bincode).unwrap();
+    let zkbin = ZkBinary::decode(bincode, true).unwrap();
 
     let a = Fp::from(4);
     let b = Fp::from(110);
@@ -48,7 +48,14 @@ fn zk_arith(c: &mut Criterion) {
     for k in zkbin.k..20 {
         let proving_key = ProvingKey::build(k, &circuit.clone());
         prove_group.bench_with_input(BenchmarkId::from_parameter(k), &k, |b, &_k| {
-            b.iter(|| Proof::create(&proving_key, &[circuit.clone()], &public_inputs, &mut OsRng))
+            b.iter(|| {
+                Proof::create(
+                    &proving_key,
+                    std::slice::from_ref(&circuit),
+                    &public_inputs,
+                    &mut OsRng,
+                )
+            })
         });
     }
     prove_group.finish();
@@ -58,7 +65,8 @@ fn zk_arith(c: &mut Criterion) {
     for k in zkbin.k..20 {
         let proving_key = ProvingKey::build(k, &circuit.clone());
         let proof =
-            Proof::create(&proving_key, &[circuit.clone()], &public_inputs, &mut OsRng).unwrap();
+            Proof::create(&proving_key, std::slice::from_ref(&circuit), &public_inputs, &mut OsRng)
+                .unwrap();
         let verifier_witnesses = empty_witnesses(&zkbin).unwrap();
         let circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
         let verifying_key = VerifyingKey::build(k, &circuit);

bench/zk_from_json.rs

@@ -133,18 +133,21 @@ fn run_benchmark(c: &mut Criterion, name: &str, proof: &str, witness: &str) {
     let mut bincode = Vec::new();
     let mut f = File::open(proof).unwrap();
     f.read_to_end(&mut bincode).unwrap();
-    let zkbin = ZkBinary::decode(&bincode).unwrap();
+    let zkbin = ZkBinary::decode(&bincode, true).unwrap();
 
     let (prover_witnesses, public_inputs) = darkfi::zk::import_witness_json(witness);
     let circuit = ZkCircuit::new(prover_witnesses.clone(), &zkbin);
 
     let proving_key = ProvingKey::build(zkbin.k, &circuit.clone());
     c.bench_function(&format!("prove {}", name), |b| {
-        b.iter(|| Proof::create(&proving_key, &[circuit.clone()], &public_inputs, &mut OsRng))
+        b.iter(|| {
+            Proof::create(&proving_key, std::slice::from_ref(&circuit), &public_inputs, &mut OsRng)
+        })
     });
 
     let proof =
-        Proof::create(&proving_key, &[circuit.clone()], &public_inputs, &mut OsRng).unwrap();
+        Proof::create(&proving_key, std::slice::from_ref(&circuit), &public_inputs, &mut OsRng)
+            .unwrap();
     let verifier_witnesses = empty_witnesses(&zkbin).unwrap();
     let circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
     let verifying_key = VerifyingKey::build(zkbin.k, &circuit);