feat: benchmark Protogalaxy rounds

barretenberg/cpp/CMakePresets.json

@@ -58,6 +58,18 @@
         "DISABLE_ASM": "ON"
       }
     },
+    {
+      "name": "clang16-dbg-fast",
+      "displayName": "Optimized debug build with Clang-16",
+      "description": "Build with globally installed Clang-16 in optimized debug mode",
+      "inherits": "clang16-dbg",
+      "environment": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CFLAGS": "-O2 -gdwarf",
+        "CXXFLAGS": "-O2 -gdwarf-4",
+        "LDFLAGS": "-O2 -gdwarf-4"
+      }
+    },
     {
       "name": "asan",
       "displayName": "Debugging build with address sanitizer on Clang-16",
@@ -335,6 +347,11 @@
       "inherits": "default",
       "configurePreset": "clang16-dbg"
     },
+    {
+      "name": "clang16-dbg-fast",
+      "inherits": "default",
+      "configurePreset": "clang16-dbg-fast"
+    },
     {
       "name": "asan",
       "inherits": "default",

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

@@ -6,6 +6,7 @@ add_subdirectory(ivc_bench)
 add_subdirectory(pippenger_bench)
 add_subdirectory(plonk_bench)
 add_subdirectory(protogalaxy_bench)
+add_subdirectory(protogalaxy_rounds_bench)
 add_subdirectory(relations_bench)
 add_subdirectory(widgets_bench)
 add_subdirectory(poseidon2_bench)

barretenberg/cpp/src/barretenberg/benchmark/protogalaxy_bench/protogalaxy.bench.cpp

@@ -7,37 +7,44 @@
 using namespace benchmark;
 
 namespace bb {
-using Flavor = UltraFlavor;
-using Instance = ProverInstance_<Flavor>;
-using Instances = ProverInstances_<Flavor, 2>;
-using ProtoGalaxyProver = ProtoGalaxyProver_<Instances>;
-using Builder = Flavor::CircuitBuilder;
 
 // Fold one instance into an accumulator.
-void fold_one(State& state) noexcept
+template <typename Composer> void fold_one(State& state) noexcept
 {
+    using Flavor = typename Composer::Flavor;
+    using Instance = ProverInstance_<Flavor>;
+    using Instances = ProverInstances_<Flavor, 2>;
+    using ProtoGalaxyProver = ProtoGalaxyProver_<Instances>;
+    using Builder = typename Flavor::CircuitBuilder;
+
     bb::srs::init_crs_factory("../srs_db/ignition");
 
     auto log2_num_gates = static_cast<size_t>(state.range(0));
-    auto composer = UltraComposer();
+    Composer composer;
 
     const auto construct_instance = [&]() {
         Builder builder;
-        bb::mock_proofs::generate_basic_arithmetic_circuit(builder, log2_num_gates);
+        if constexpr (std::same_as<Flavor, GoblinUltraFlavor>) {
+            GoblinMockCircuits::construct_arithmetic_circuit(builder, log2_num_gates);
+        } else {
+            static_assert(std::same_as<Flavor, UltraFlavor>);
+            bb::mock_proofs::generate_basic_arithmetic_circuit(builder, log2_num_gates);
+        }
         return composer.create_instance(builder);
     };
 
     std::shared_ptr<Instance> instance_1 = construct_instance();
     std::shared_ptr<Instance> instance_2 = construct_instance();
 
-    auto folding_prover = composer.create_folding_prover({ instance_1, instance_2 });
+    ProtoGalaxyProver folding_prover = composer.create_folding_prover({ instance_1, instance_2 });
 
     for (auto _ : state) {
         auto proof = folding_prover.fold_instances();
     }
 }
 
-BENCHMARK(fold_one)->/* vary the circuit size */ DenseRange(14, 20)->Unit(kMillisecond);
+BENCHMARK(fold_one<UltraComposer>)->/* vary the circuit size */ DenseRange(14, 20)->Unit(kMillisecond);
+BENCHMARK(fold_one<GoblinUltraComposer>)->/* vary the circuit size */ DenseRange(14, 20)->Unit(kMillisecond);
 } // namespace bb
 
 BENCHMARK_MAIN();

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

@@ -0,0 +1 @@
+barretenberg_module(protogalaxy_rounds_bench ultra_honk protogalaxy stdlib_primitives)

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

@@ -0,0 +1 @@
+barretenberg_module(protogalaxy_round_bench ultra_honk protogalaxy stdlib_primitives)

barretenberg/cpp/src/barretenberg/benchmark/protogalaxy_rounds_bench/protogalaxy_rounds.bench.cpp

@@ -0,0 +1,83 @@
+#include <benchmark/benchmark.h>
+
+#include "barretenberg/benchmark/ultra_bench/mock_proofs.hpp"
+#include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
+#include "barretenberg/ultra_honk/ultra_composer.hpp"
+
+using namespace benchmark;
+
+namespace bb {
+
+template <typename Composer>
+void _bench_round(::benchmark::State& state,
+                  void (*F)(ProtoGalaxyProver_<ProverInstances_<typename Composer::Flavor, 2>>&))
+{
+    using Flavor = typename Composer::Flavor;
+    using Instance = ProverInstance_<Flavor>;
+    using Builder = typename Flavor::CircuitBuilder;
+
+    bb::srs::init_crs_factory("../srs_db/ignition");
+    auto log2_num_gates = static_cast<size_t>(state.range(0));
+    auto composer = Composer();
+
+    const auto construct_instance = [&]() {
+        Builder builder;
+        if constexpr (std::same_as<Flavor, GoblinUltraFlavor>) {
+            GoblinMockCircuits::construct_arithmetic_circuit(builder, log2_num_gates);
+        } else {
+            static_assert(std::same_as<Flavor, UltraFlavor>);
+            bb::mock_proofs::generate_basic_arithmetic_circuit(builder, log2_num_gates);
+        }
+        return composer.create_instance(builder);
+    };
+
+    std::shared_ptr<Instance> instance_1 = construct_instance();
+    std::shared_ptr<Instance> instance_2 = construct_instance();
+
+    auto folding_prover = composer.create_folding_prover({ instance_1, instance_2 });
+
+    // prepare the prover state
+    folding_prover.state.accumulator = instance_1;
+    folding_prover.state.deltas.resize(log2_num_gates);
+    std::fill_n(folding_prover.state.deltas.begin(), log2_num_gates, 0);
+    folding_prover.state.perturbator = Flavor::Polynomial::random(1 << log2_num_gates);
+    folding_prover.transcript = Flavor::Transcript::prover_init_empty();
+    folding_prover.preparation_round();
+
+    for (auto _ : state) {
+        F(folding_prover);
+    }
+}
+
+void bench_round_ultra(::benchmark::State& state, void (*F)(ProtoGalaxyProver_<ProverInstances_<UltraFlavor, 2>>&))
+{
+    _bench_round<UltraComposer>(state, F);
+}
+
+void bench_round_goblin_ultra(::benchmark::State& state,
+                              void (*F)(ProtoGalaxyProver_<ProverInstances_<GoblinUltraFlavor, 2>>&))
+{
+    _bench_round<GoblinUltraComposer>(state, F);
+}
+
+BENCHMARK_CAPTURE(bench_round_ultra, preparation, [](auto& prover) { prover.preparation_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_ultra, perturbator, [](auto& prover) { prover.perturbator_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_ultra, combiner_quotient, [](auto& prover) { prover.combiner_quotient_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_ultra, accumulator_update, [](auto& prover) { prover.accumulator_update_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+
+BENCHMARK_CAPTURE(bench_round_goblin_ultra, preparation, [](auto& prover) { prover.preparation_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_goblin_ultra, perturbator, [](auto& prover) { prover.perturbator_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_goblin_ultra, combiner_quotient, [](auto& prover) { prover.combiner_quotient_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+BENCHMARK_CAPTURE(bench_round_goblin_ultra, accumulator_update, [](auto& prover) { prover.accumulator_update_round(); })
+    -> DenseRange(14, 20) -> Unit(kMillisecond);
+
+} // namespace bb
+
+BENCHMARK_MAIN();

barretenberg/cpp/src/barretenberg/benchmark/ultra_bench/mock_proofs.hpp

@@ -58,6 +58,16 @@ inline UltraProver get_prover(UltraComposer& composer,
     return composer.create_prover(instance);
 }
 
+inline GoblinUltraProver get_prover(GoblinUltraComposer& composer,
+                                    void (*test_circuit_function)(GoblinUltraComposer::CircuitBuilder&, size_t),
+                                    size_t num_iterations)
+{
+    GoblinUltraComposer::CircuitBuilder builder;
+    test_circuit_function(builder, num_iterations);
+    std::shared_ptr<GoblinUltraComposer::Instance> instance = composer.create_instance(builder);
+    return composer.create_prover(instance);
+}
+
 // standard plonk
 inline plonk::Prover get_prover(plonk::StandardComposer& composer,
                                 void (*test_circuit_function)(StandardCircuitBuilder&, size_t),

barretenberg/cpp/src/barretenberg/benchmark/ultra_bench/ultra_honk_rounds.bench.cpp

@@ -21,14 +21,14 @@ enum {
 };
 
 /**
- * @details Benchmark ultrahonk by performing all the rounds, but only measuring one.
+ * @details Benchmark Goblin ultrahonk by performing all the rounds, but only measuring one.
  * Note: As a result the very short rounds take a long time for statistical significance, so recommended to set their
  * iterations to 1.
  * @param state - The google benchmark state.
- * @param prover - The ultrahonk prover.
+ * @param prover - The Goblin ultrahonk prover.
  * @param index - The pass to measure.
  **/
-BB_PROFILE static void test_round_inner(State& state, UltraProver& prover, size_t index) noexcept
+BB_PROFILE static void test_round_inner(State& state, GoblinUltraProver& prover, size_t index) noexcept
 {
     auto time_if_index = [&](size_t target_index, auto&& func) -> void {
         BB_REPORT_OP_COUNT_IN_BENCH(state);
@@ -55,25 +55,23 @@ BB_PROFILE static void test_round_inner(State& state, UltraProver& prover, size_
 }
 BB_PROFILE static void test_round(State& state, size_t index) noexcept
 {
+    auto log2_num_gates = static_cast<size_t>(state.range(0));
     bb::srs::init_crs_factory("../srs_db/ignition");
 
+    GoblinUltraComposer composer;
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/761) benchmark both sparse and dense circuits
+    GoblinUltraProver prover = bb::mock_proofs::get_prover(
+        composer, &bb::mock_proofs::generate_basic_arithmetic_circuit<GoblinUltraCircuitBuilder>, log2_num_gates);
     for (auto _ : state) {
-        state.PauseTiming();
-        UltraComposer composer;
-        // TODO(https://github.com/AztecProtocol/barretenberg/issues/761) benchmark both sparse and dense circuits
-        UltraProver prover = bb::mock_proofs::get_prover(
-            composer, &bb::stdlib::generate_ecdsa_verification_test_circuit<UltraCircuitBuilder>, 10);
         test_round_inner(state, prover, index);
-        state.ResumeTiming();
-        // NOTE: google bench is very finnicky, must end in ResumeTiming() for correctness
     }
 }
 #define ROUND_BENCHMARK(round)                                                                                         \
     static void ROUND_##round(State& state) noexcept                                                                   \
     {                                                                                                                  \
         test_round(state, round);                                                                                      \
     }                                                                                                                  \
-    BENCHMARK(ROUND_##round)->Unit(kMillisecond)
+    BENCHMARK(ROUND_##round)->DenseRange(17, 19)->Unit(kMillisecond)
 
 // Fast rounds take a long time to benchmark because of how we compute statistical significance.
 // Limit to one iteration so we don't spend a lot of time redoing full proofs just to measure this part.

barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.test.cpp

@@ -34,10 +34,10 @@ class ClientIVCTests : public ::testing::Test {
      * @details Currently default sized to 2^16 to match kernel. (Note: op gates will bump size to next power of 2)
      *
      */
-    static Builder create_mock_circuit(ClientIVC& ivc, size_t num_gates = 1 << 15)
+    static Builder create_mock_circuit(ClientIVC& ivc, size_t log2_num_gates = 15)
     {
         Builder circuit{ ivc.goblin.op_queue };
-        GoblinMockCircuits::construct_arithmetic_circuit(circuit, num_gates);
+        GoblinMockCircuits::construct_arithmetic_circuit(circuit, log2_num_gates);
         GoblinMockCircuits::construct_goblin_ecc_op_circuit(circuit);
         return circuit;
     }

barretenberg/cpp/src/barretenberg/flavor/goblin_ultra.hpp

@@ -510,6 +510,21 @@ class GoblinUltraFlavor {
             : NativeTranscript(proof)
         {}
 
+        static std::shared_ptr<Transcript_> prover_init_empty()
+        {
+            auto transcript = std::make_shared<Transcript_>();
+            constexpr uint32_t init{ 42 }; // arbitrary
+            transcript->send_to_verifier("Init", init);
+            return transcript;
+        };
+
+        static std::shared_ptr<Transcript_> verifier_init_empty(const std::shared_ptr<Transcript_>& transcript)
+        {
+            auto verifier_transcript = std::make_shared<Transcript_>(transcript->proof_data);
+            [[maybe_unused]] auto _ = verifier_transcript->template receive_from_prover<uint32_t>("Init");
+            return verifier_transcript;
+        };
+
         void deserialize_full_transcript()
         {
             // take current proof and put them into the struct

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

@@ -38,8 +38,9 @@ class GoblinMockCircuits {
      * @param builder
      * @param num_gates
      */
-    static void construct_arithmetic_circuit(GoblinUltraBuilder& builder, size_t num_gates = 1)
+    static void construct_arithmetic_circuit(GoblinUltraBuilder& builder, size_t log2_num_gates = 0)
     {
+        size_t num_gates = 1 << log2_num_gates;
         // For good measure, include a gate with some public inputs
         {
             FF a = FF::random_element();
@@ -53,17 +54,18 @@ class GoblinMockCircuits {
 
             builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) });
         }
+
         // Add arbitrary arithmetic gates to obtain a total of num_gates-many gates
-        for (size_t i = 0; i < num_gates - 1; ++i) {
-            FF a = FF::random_element();
-            FF b = FF::random_element();
-            FF c = FF::random_element();
-            FF d = a + b + c;
-            uint32_t a_idx = builder.add_variable(a);
-            uint32_t b_idx = builder.add_variable(b);
-            uint32_t c_idx = builder.add_variable(c);
-            uint32_t d_idx = builder.add_variable(d);
+        FF a = FF::random_element();
+        FF b = FF::random_element();
+        FF c = FF::random_element();
+        FF d = a + b + c;
+        uint32_t a_idx = builder.add_variable(a);
+        uint32_t b_idx = builder.add_variable(b);
+        uint32_t c_idx = builder.add_variable(c);
+        uint32_t d_idx = builder.add_variable(d);
 
+        for (size_t i = 0; i < num_gates - 1; ++i) {
             builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) });
         }
     }