Merge pull request #222 from anoma/xuyang/update_compliance_bench

update compliance bench

Author: XuyangSong

arm_circuits/compliance/README.md

@@ -1,38 +1,45 @@
 # Compliance Circuit
 
 This crate contains the RISC Zero compliance circuit and its local benchmark.
-Succinct STARK proofs are generated in the benchmark by default.
+Succinct STARK proofs are generated by default.
 
-## Benchmark
+## Benchmark Cases
 
-Run the local proving benchmark with:
+| Case | Description |
+|------|-------------|
+| `empty_table` | No precomputed kind table — circuit falls back to `hash_to_curve` per proof |
+| `file_table`  | Loads `kind_table.json` — resolves kind points via table lookup |
+
+The trailing number in each benchmark name is the **batch size** (number of consumed/created resources).
+
+## Running
+
+Local (CPU):
 
 ```bash
 cargo bench --features prove --bench compliance
 ```
 
-Run the CUDA prover benchmark with:
+CUDA:
 
 ```bash
 cargo bench --features prove,cuda --bench compliance
 ```
 
-For faster iteration without real proof generation:
+Fast iteration without real proof generation:
 
 ```bash
 RISC0_DEV_MODE=1 cargo bench --features prove -p compliance
 ```
 
-The benchmark measures two cases:
+## Results
 
-- `compliance/empty_table/prove`: no precomputed kind table, so the circuit falls back to `hash_to_curve`.
-- `compliance/file_table/prove`: loads `kind_table.json` and resolves kind points via table lookup.
+| num | `empty_table` | `file_table` |
+|------:|:-------------:|:------------:|
+|     1 |    2.125 s    |   808.7 ms   |
+|     2 |    3.084 s    |   844.7 ms   |
+|     4 |    6.320 s    |   1.235 s    |
+|     8 |   11.464 s    |   1.288 s    |
 
-## Current Results
-
-```text
-compliance/empty_table/prove
-                        time:   [2.7347 s 2.7424 s 2.7538 s]
-compliance/file_table/prove
-                        time:   [1.0015 s 1.0039 s 1.0067 s]
-```
+`file_table` amortizes the `hash_to_curve` cost across the batch, keeping proving
+time nearly flat up to 8 proofs. `empty_table` scales roughly linearly with batch size.

arm_circuits/compliance/benches/prove.rs

@@ -5,6 +5,9 @@
 /// - `file_table`:  kind points are pre-computed in `kind_table.json`; the circuit
 ///                  resolves them via a table lookup, skipping `hash_to_curve`.
 ///
+/// Each configuration is benchmarked with 1, 2, 4, and 8 consumed/created
+/// resources to measure scaling behaviour.
+///
 /// # Running on CPU
 ///
 /// ```sh
@@ -27,14 +30,15 @@
 /// ```
 use anoma_rm_risc0::compliance::{ComplianceWitness, INITIAL_ROOT};
 use anoma_rm_risc0::constants::{global_kind_table, init_kind_table_from_file};
-use anoma_rm_risc0::merkle_path::MerklePath;
 use anoma_rm_risc0::nullifier_key::NullifierKey;
-use anoma_rm_risc0::resource::Resource;
+use anoma_rm_risc0::resource::{ConsumedResourceWitness, Resource};
 use compliance_methods::COMPLIANCE_GUEST_ELF;
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use risc0_zkvm::{default_prover, Digest, ExecutorEnv, ProverOpts};
 use std::time::Duration;
 
+const RESOURCE_COUNTS: &[usize] = &[1, 2, 4, 8];
+
 fn do_prove(witness: &ComplianceWitness) {
     let env = ExecutorEnv::builder()
         .write(witness)
@@ -46,32 +50,54 @@ fn do_prove(witness: &ComplianceWitness) {
         .unwrap();
 }
 
-/// Build a compliance witness whose resources use `logic_ref` and `label_ref`,
-/// pulling the current global kind table into the witness.
-fn make_witness(logic_ref: Digest, label_ref: Digest) -> ComplianceWitness {
+/// Build a compliance witness with `count` consumed/created resources.
+/// Each consumed resource gets a unique nonce via its index in the last byte.
+fn make_witness(logic_ref: Digest, label_ref: Digest, count: usize) -> ComplianceWitness {
     let nf_key = NullifierKey::default();
-    let consumed_resource = Resource {
-        logic_ref,
-        label_ref,
-        quantity: 1,
-        value_ref: Digest::default(),
-        is_ephemeral: false,
-        nonce: [0u8; 32],
-        nk_commitment: nf_key.commit(),
-        rand_seed: [0u8; 32],
-    };
-    let nf = consumed_resource.nullifier(&nf_key).unwrap();
-    let created_resource = Resource {
-        nonce: nf.as_bytes().try_into().unwrap(),
-        ..consumed_resource
-    };
+
+    let consumed_data: Vec<ConsumedResourceWitness> = (0..count)
+        .map(|i| {
+            let mut nonce = [0u8; 32];
+            nonce[31] = i as u8;
+            let resource = Resource {
+                logic_ref,
+                label_ref,
+                quantity: 1,
+                value_ref: Digest::default(),
+                is_ephemeral: false,
+                nonce,
+                nk_commitment: nf_key.commit(),
+                rand_seed: [0u8; 32],
+            };
+            ConsumedResourceWitness::from_resource(resource, nf_key.clone())
+        })
+        .collect();
+
+    let nullifiers: Vec<Digest> = consumed_data
+        .iter()
+        .map(|w| w.resource.nullifier(&nf_key).unwrap())
+        .collect();
+
+    let created_resources: Vec<Resource> = (0..count)
+        .map(|i| {
+            let nonce = Resource::derive_nonce_from_nullifiers(i as u32, &nullifiers).unwrap();
+            Resource {
+                logic_ref,
+                label_ref,
+                quantity: 1,
+                value_ref: Digest::default(),
+                is_ephemeral: false,
+                nonce,
+                nk_commitment: nf_key.commit(),
+                rand_seed: [0u8; 32],
+            }
+        })
+        .collect();
+
     ComplianceWitness {
-        consumed_resource,
-        merkle_path: MerklePath::default(),
+        consumed_data,
+        created_resources,
         ephemeral_root: *INITIAL_ROOT,
-        nf_key,
-        created_resource,
-        // Scalar::ONE encoded as big-endian 32 bytes
         rcv: [vec![0u8; 31], vec![1u8]].concat(),
         kind_table: global_kind_table().to_vec(),
     }
@@ -84,17 +110,21 @@ fn bench_empty_table(c: &mut Criterion) {
     group.warm_up_time(Duration::from_secs(1));
     group.measurement_time(Duration::from_secs(1));
 
-    group.bench_function("prove", |b| {
-        b.iter_with_setup(ComplianceWitness::default, |witness| do_prove(&witness));
-    });
+    for &count in RESOURCE_COUNTS {
+        group.bench_with_input(BenchmarkId::new("prove", count), &count, |b, &count| {
+            b.iter_with_setup(
+                || make_witness(Digest::default(), Digest::default(), count),
+                |witness| do_prove(&witness),
+            );
+        });
+    }
 
     group.finish();
 }
 
 /// Precomputed kind table from file: the circuit resolves kind points via table
 /// lookup, skipping `hash_to_curve`. The witness uses the `logic_ref` and
-/// `label_ref` of the first entry in the loaded table so both consumed and
-/// created resources are guaranteed to hit the table.
+/// `label_ref` of the first entry in the loaded table so all resources hit the table.
 fn bench_file_table(c: &mut Criterion) {
     let kind_table_path =
         std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../arm/kind_table.json");
@@ -109,12 +139,14 @@ fn bench_file_table(c: &mut Criterion) {
     group.warm_up_time(Duration::from_secs(1));
     group.measurement_time(Duration::from_secs(1));
 
-    group.bench_function("prove", |b| {
-        b.iter_with_setup(
-            || make_witness(logic_ref, label_ref),
-            |witness| do_prove(&witness),
-        );
-    });
+    for &count in RESOURCE_COUNTS {
+        group.bench_with_input(BenchmarkId::new("prove", count), &count, |b, &count| {
+            b.iter_with_setup(
+                || make_witness(logic_ref, label_ref, count),
+                |witness| do_prove(&witness),
+            );
+        });
+    }
 
     group.finish();
 }