Merge branch 'master' into md/02-16-feat_avm_storage

.circleci/config.yml

@@ -1124,7 +1124,7 @@ jobs:
             build docs
 
             echo "Deploying docs"
-            docs/deploy_netlify.sh $CIRCLE_BRANCH $CIRCLE_PULL_REQUEST
+            docs/deploy_netlify.sh $BRANCH $PULL_REQUEST
 
   yellow-paper:
     machine:

avm-transpiler/src/transpile.rs

@@ -244,6 +244,7 @@ fn handle_foreign_call(
             destinations,
             inputs,
         ),
+        "nullifierExists" => handle_nullifier_exists(avm_instrs, destinations, inputs),
         "keccak256" | "sha256" => {
             handle_2_field_hash_instruction(avm_instrs, function, destinations, inputs)
         }
@@ -382,6 +383,40 @@ fn emit_storage_read(
     })
 }
 
+/// Handle an AVM NULLIFIEREXISTS instruction
+/// (a nullifierExists brillig foreign call was encountered)
+/// Adds the new instruction to the avm instructions list.
+fn handle_nullifier_exists(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    if destinations.len() != 1 || inputs.len() != 1 {
+        panic!("Transpiler expects ForeignCall::CHECKNULLIFIEREXISTS to have 1 destinations and 1 input, got {} and {}", destinations.len(), inputs.len());
+    }
+    let nullifier_offset_operand = match &inputs[0] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!("Transpiler does not know how to handle ForeignCall::EMITNOTEHASH with HeapArray/Vector inputs"),
+    };
+    let exists_offset_operand = match &destinations[0] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!("Transpiler does not know how to handle ForeignCall::EMITNOTEHASH with HeapArray/Vector inputs"),
+    };
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::NULLIFIEREXISTS,
+        indirect: Some(ALL_DIRECT),
+        operands: vec![
+            AvmOperand::U32 {
+                value: nullifier_offset_operand,
+            },
+            AvmOperand::U32 {
+                value: exists_offset_operand,
+            },
+        ],
+        ..Default::default()
+    });
+}
+
 /// Two field hash instructions represent instruction's that's outputs are larger than a field element
 ///
 /// This includes:

barretenberg/cpp/scripts/analyze_client_ivc_bench.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+
+PREFIX = Path("build-op-count-time")
+IVC_BENCH_JSON = Path("client_ivc_bench.json")
+BENCHMARK = "ClientIVCBench/Full/6"
+
+# Single out an independent set of functions accounting for most of BENCHMARK's real_time
+to_keep = [
+    "construct_mock_function_circuit(t)",
+    "construct_mock_folding_kernel(t)",
+    "UltraComposer::create_prover_instance(t)",
+    "ProtogalaxyProver::fold_instances(t)",
+    "Decider::construct_proof(t)",
+    "ECCVMComposer::create_prover(t)",
+    "GoblinTranslatorComposer::create_prover(t)",
+    "ECCVMProver::construct_proof(t)",
+    "GoblinTranslatorProver::construct_proof(t)",
+    "Goblin::merge(t)"
+]
+with open(PREFIX/IVC_BENCH_JSON, "r") as read_file:
+    read_result = json.load(read_file)
+    for _bench in read_result["benchmarks"]:
+        if _bench["name"] == BENCHMARK:
+            bench = _bench
+bench_components = dict(filter(lambda x: x[0] in to_keep, bench.items()))
+
+# For each kept time, get the proportion over all kept times.
+sum_of_kept_times_ms = sum(float(time)
+                           for _, time in bench_components.items())/1e6
+MAX_LABEL_LENGTH = max(len(label) for label in to_keep)
+column = {"function": "function", "ms": "ms", "%": "% sum"}
+print(
+    f"{column['function']:<{MAX_LABEL_LENGTH}}{column['ms']:>8}  {column['%']:>8}")
+for key in to_keep:
+    time_ms = bench[key]/1e6
+    print(f"{key:<{MAX_LABEL_LENGTH}}{time_ms:>8.0f}  {time_ms/sum_of_kept_times_ms:>8.2%}")
+
+# Validate that kept times account for most of the total measured time.
+total_time_ms = bench["real_time"]
+totals = '\nTotal time accounted for: {:.0f}ms/{:.0f}ms = {:.2%}'
+totals = totals.format(
+    sum_of_kept_times_ms, total_time_ms, sum_of_kept_times_ms/total_time_ms)
+print(totals)

barretenberg/cpp/scripts/benchmark_client_ivc.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -eu
+
+TARGET="client_ivc_bench"
+FILTER="ClientIVCBench/Full/6$"
+BUILD_DIR=build-op-count-time
+
+# Move above script dir.
+cd $(dirname $0)/..
+
+# Measure the benchmarks with ops time counting
+./scripts/benchmark_remote.sh client_ivc_bench\
+                              "./client_ivc_bench --benchmark_filter=$FILTER\
+                                                  --benchmark_out=$TARGET.json\
+                                                  --benchmark_out_format=json"\
+                              op-count-time\
+                              build-op-count-time
+
+# Retrieve output from benching instance
+cd $BUILD_DIR
+scp $BB_SSH_KEY $BB_SSH_INSTANCE:$BB_SSH_CPP_PATH/build/$TARGET.json .
+
+# Analyze the results
+cd $(dirname $0)/..
+python3 ./scripts/analyze_client_ivc_bench.py

barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt

@@ -2,7 +2,7 @@ add_subdirectory(basics_bench)
 add_subdirectory(decrypt_bench)
 add_subdirectory(goblin_bench)
 add_subdirectory(ipa_bench)
-add_subdirectory(ivc_bench)
+add_subdirectory(client_ivc_bench)
 add_subdirectory(pippenger_bench)
 add_subdirectory(plonk_bench)
 add_subdirectory(protogalaxy_bench)

barretenberg/cpp/src/barretenberg/benchmark/client_ivc_bench/CMakeLists.txt

@@ -0,0 +1 @@
+barretenberg_module(client_ivc_bench client_ivc stdlib_recursion stdlib_sha256 crypto_merkle_tree stdlib_primitives)

barretenberg/cpp/src/barretenberg/benchmark/ivc_bench/ivc.bench.cpp → barretenberg/cpp/src/barretenberg/benchmark/client_ivc_bench/client_ivc.bench.cpp

@@ -1,10 +1,8 @@
 
 #include <benchmark/benchmark.h>
 
-#include "barretenberg/benchmark/ultra_bench/mock_proofs.hpp"
 #include "barretenberg/client_ivc/client_ivc.hpp"
 #include "barretenberg/common/op_count_google_bench.hpp"
-#include "barretenberg/goblin/goblin.hpp"
 #include "barretenberg/goblin/mock_circuits.hpp"
 #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
 #include "barretenberg/ultra_honk/ultra_composer.hpp"
@@ -18,7 +16,7 @@ namespace {
  * @brief Benchmark suite for the aztec client PG-Goblin IVC scheme
  *
  */
-class IvcBench : public benchmark::Fixture {
+class ClientIVCBench : public benchmark::Fixture {
   public:
     using Builder = GoblinUltraCircuitBuilder;
 
@@ -74,7 +72,7 @@ class IvcBench : public benchmark::Fixture {
  * @brief Benchmark the prover work for the full PG-Goblin IVC protocol
  *
  */
-BENCHMARK_DEFINE_F(IvcBench, Full)(benchmark::State& state)
+BENCHMARK_DEFINE_F(ClientIVCBench, Full)(benchmark::State& state)
 {
     ClientIVC ivc;
 
@@ -92,7 +90,7 @@ BENCHMARK_DEFINE_F(IvcBench, Full)(benchmark::State& state)
  * @brief Benchmark only the accumulation rounds
  *
  */
-BENCHMARK_DEFINE_F(IvcBench, Accumulate)(benchmark::State& state)
+BENCHMARK_DEFINE_F(ClientIVCBench, Accumulate)(benchmark::State& state)
 {
     ClientIVC ivc;
 
@@ -107,7 +105,7 @@ BENCHMARK_DEFINE_F(IvcBench, Accumulate)(benchmark::State& state)
  * @brief Benchmark only the Decider component
  *
  */
-BENCHMARK_DEFINE_F(IvcBench, Decide)(benchmark::State& state)
+BENCHMARK_DEFINE_F(ClientIVCBench, Decide)(benchmark::State& state)
 {
     ClientIVC ivc;
 
@@ -125,7 +123,7 @@ BENCHMARK_DEFINE_F(IvcBench, Decide)(benchmark::State& state)
  * @brief Benchmark only the ECCVM component
  *
  */
-BENCHMARK_DEFINE_F(IvcBench, ECCVM)(benchmark::State& state)
+BENCHMARK_DEFINE_F(ClientIVCBench, ECCVM)(benchmark::State& state)
 {
     ClientIVC ivc;
 
@@ -143,7 +141,7 @@ BENCHMARK_DEFINE_F(IvcBench, ECCVM)(benchmark::State& state)
  * @brief Benchmark only the Translator component
  *
  */
-BENCHMARK_DEFINE_F(IvcBench, Translator)(benchmark::State& state)
+BENCHMARK_DEFINE_F(ClientIVCBench, Translator)(benchmark::State& state)
 {
     ClientIVC ivc;
 
@@ -159,7 +157,7 @@ BENCHMARK_DEFINE_F(IvcBench, Translator)(benchmark::State& state)
 }
 
 #define ARGS                                                                                                           \
-    Arg(IvcBench::NUM_ITERATIONS_MEDIUM_COMPLEXITY)                                                                    \
+    Arg(ClientIVCBench::NUM_ITERATIONS_MEDIUM_COMPLEXITY)                                                              \
         ->Arg(1 << 0)                                                                                                  \
         ->Arg(1 << 1)                                                                                                  \
         ->Arg(1 << 2)                                                                                                  \
@@ -168,11 +166,11 @@ BENCHMARK_DEFINE_F(IvcBench, Translator)(benchmark::State& state)
         ->Arg(1 << 5)                                                                                                  \
         ->Arg(1 << 6)
 
-BENCHMARK_REGISTER_F(IvcBench, Full)->Unit(benchmark::kMillisecond)->ARGS;
-BENCHMARK_REGISTER_F(IvcBench, Accumulate)->Unit(benchmark::kMillisecond)->ARGS;
-BENCHMARK_REGISTER_F(IvcBench, Decide)->Unit(benchmark::kMillisecond)->ARGS;
-BENCHMARK_REGISTER_F(IvcBench, ECCVM)->Unit(benchmark::kMillisecond)->ARGS;
-BENCHMARK_REGISTER_F(IvcBench, Translator)->Unit(benchmark::kMillisecond)->ARGS;
+BENCHMARK_REGISTER_F(ClientIVCBench, Full)->Unit(benchmark::kMillisecond)->ARGS;
+BENCHMARK_REGISTER_F(ClientIVCBench, Accumulate)->Unit(benchmark::kMillisecond)->ARGS;
+BENCHMARK_REGISTER_F(ClientIVCBench, Decide)->Unit(benchmark::kMillisecond)->ARGS;
+BENCHMARK_REGISTER_F(ClientIVCBench, ECCVM)->Unit(benchmark::kMillisecond)->ARGS;
+BENCHMARK_REGISTER_F(ClientIVCBench, Translator)->Unit(benchmark::kMillisecond)->ARGS;
 
 } // namespace
 

barretenberg/cpp/src/barretenberg/common/slab_allocator.cpp

@@ -22,7 +22,10 @@ bool allocator_destroyed = false;
 // Slabs that are being manually managed by the user.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 std::unordered_map<void*, std::shared_ptr<void>> manual_slabs;
-
+#ifndef NO_MULTITHREADING
+// The manual slabs unordered map is not thread-safe, so we need to manage access to it when multithreaded.
+std::mutex manual_slabs_mutex;
+#endif
 template <typename... Args> inline void dbg_info(Args... args)
 {
 #if LOGGING == 1
@@ -219,6 +222,9 @@ std::shared_ptr<void> get_mem_slab(size_t size)
 void* get_mem_slab_raw(size_t size)
 {
     auto slab = get_mem_slab(size);
+#ifndef NO_MULTITHREADING
+    std::unique_lock<std::mutex> lock(manual_slabs_mutex);
+#endif
     manual_slabs[slab.get()] = slab;
     return slab.get();
 }
@@ -229,6 +235,9 @@ void free_mem_slab_raw(void* p)
         aligned_free(p);
         return;
     }
+#ifndef NO_MULTITHREADING
+    std::unique_lock<std::mutex> lock(manual_slabs_mutex);
+#endif
     manual_slabs.erase(p);
 }
 } // namespace bb

barretenberg/cpp/src/barretenberg/eccvm/eccvm_composer.cpp

@@ -30,6 +30,8 @@ template <IsECCVMFlavor Flavor>
 ECCVMProver_<Flavor> ECCVMComposer_<Flavor>::create_prover(CircuitConstructor& circuit_constructor,
                                                            const std::shared_ptr<Transcript>& transcript)
 {
+    BB_OP_COUNT_TIME_NAME("ECCVMComposer::create_prover");
+
     compute_proving_key(circuit_constructor);
     compute_witness(circuit_constructor);
     compute_commitment_key(proving_key->circuit_size);

barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.cpp

@@ -282,6 +282,8 @@ template <IsECCVMFlavor Flavor> HonkProof& ECCVMProver_<Flavor>::export_proof()
 
 template <IsECCVMFlavor Flavor> HonkProof& ECCVMProver_<Flavor>::construct_proof()
 {
+    BB_OP_COUNT_TIME_NAME("ECCVMProver::construct_proof");
+
     execute_preamble_round();
 
     execute_wire_commitments_round();

barretenberg/cpp/src/barretenberg/goblin/goblin.hpp

@@ -129,6 +129,7 @@ class Goblin {
      */
     void merge(GoblinUltraCircuitBuilder& circuit_builder)
     {
+        BB_OP_COUNT_TIME_NAME("Goblin::merge");
         // Complete the circuit logic by recursively verifying previous merge proof if it exists
         if (merge_proof_exists) {
             RecursiveMergeVerifier merge_verifier{ &circuit_builder };

barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp

@@ -25,7 +25,7 @@ namespace bb::plonk {
  *
  * @return Pointer to the initialized proving key updated with selector polynomials.
  * */
-std::shared_ptr<plonk::proving_key> StandardComposer::compute_proving_key(const CircuitBuilder& circuit_constructor)
+std::shared_ptr<plonk::proving_key> StandardComposer::compute_proving_key(CircuitBuilder& circuit_constructor)
 {
     if (circuit_proving_key) {
         return circuit_proving_key;
@@ -41,7 +41,7 @@ std::shared_ptr<plonk::proving_key> StandardComposer::compute_proving_key(const
         subgroup_size, circuit_constructor.public_inputs.size(), crs, CircuitType::STANDARD);
 
     // Construct and add to proving key the wire, selector and copy constraint polynomials
-    Trace::generate(circuit_constructor, circuit_proving_key);
+    Trace::populate(circuit_constructor, circuit_proving_key);
 
     // Make all selectors nonzero
     enforce_nonzero_selector_polynomials(circuit_constructor, circuit_proving_key.get());
@@ -62,8 +62,7 @@ std::shared_ptr<plonk::proving_key> StandardComposer::compute_proving_key(const
  *
  * @return Pointer to created circuit verification key.
  * */
-std::shared_ptr<plonk::verification_key> StandardComposer::compute_verification_key(
-    const CircuitBuilder& circuit_constructor)
+std::shared_ptr<plonk::verification_key> StandardComposer::compute_verification_key(CircuitBuilder& circuit_constructor)
 {
     if (circuit_verification_key) {
         return circuit_verification_key;
@@ -89,7 +88,7 @@ std::shared_ptr<plonk::verification_key> StandardComposer::compute_verification_
  *
  * @return The verifier.
  * */
-plonk::Verifier StandardComposer::create_verifier(const CircuitBuilder& circuit_constructor)
+plonk::Verifier StandardComposer::create_verifier(CircuitBuilder& circuit_constructor)
 {
     auto verification_key = compute_verification_key(circuit_constructor);
 
@@ -112,7 +111,7 @@ plonk::Verifier StandardComposer::create_verifier(const CircuitBuilder& circuit_
  *
  * @return Initialized prover.
  * */
-plonk::Prover StandardComposer::create_prover(const CircuitBuilder& circuit_constructor)
+plonk::Prover StandardComposer::create_prover(CircuitBuilder& circuit_constructor)
 {
     compute_proving_key(circuit_constructor);
 

barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.hpp

@@ -56,11 +56,11 @@ class StandardComposer {
         };
         return result;
     }
-    std::shared_ptr<plonk::proving_key> compute_proving_key(const CircuitBuilder& circuit_constructor);
-    std::shared_ptr<plonk::verification_key> compute_verification_key(const CircuitBuilder& circuit_constructor);
+    std::shared_ptr<plonk::proving_key> compute_proving_key(CircuitBuilder& circuit_constructor);
+    std::shared_ptr<plonk::verification_key> compute_verification_key(CircuitBuilder& circuit_constructor);
 
-    plonk::Verifier create_verifier(const CircuitBuilder& circuit_constructor);
-    plonk::Prover create_prover(const CircuitBuilder& circuit_constructor);
+    plonk::Verifier create_verifier(CircuitBuilder& circuit_constructor);
+    plonk::Prover create_prover(CircuitBuilder& circuit_constructor);
 
     /**
      * Create a manifest, which specifies proof rounds, elements and who supplies them.

barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.cpp

@@ -166,7 +166,7 @@ std::shared_ptr<proving_key> UltraComposer::compute_proving_key(CircuitBuilder&
         std::make_shared<plonk::proving_key>(subgroup_size, circuit.public_inputs.size(), crs, CircuitType::ULTRA);
 
     // Construct and add to proving key the wire, selector and copy constraint polynomials
-    Trace::generate(circuit, circuit_proving_key);
+    Trace::populate(circuit, circuit_proving_key);
 
     enforce_nonzero_selector_polynomials(circuit, circuit_proving_key.get());
 

barretenberg/cpp/src/barretenberg/polynomials/pow.hpp

@@ -125,7 +125,6 @@ template <typename FF> struct PowPolynomial {
      */
     BB_PROFILE void compute_values()
     {
-        BB_OP_COUNT_TIME();
         size_t pow_size = 1 << betas.size();
         pow_betas = std::vector<FF>(pow_size);