mock_circuits.hpp

Go to the documentation of this file.

#pragma once
#include <benchmark/benchmark.h>
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/goblin/mock_circuits.hpp"
#include "barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp"
#include "barretenberg/stdlib/hash/keccak/keccak.hpp"
#include "barretenberg/stdlib/hash/sha256/sha256.hpp"
#include "barretenberg/ultra_honk/ultra_prover.hpp"
 
namespace bb::mock_circuits {
 
template <typename Builder>
void generate_basic_arithmetic_circuit_with_target_gates(Builder& builder, size_t target_gate_count)
{
    stdlib::recursion::honk::DefaultIO<Builder>::add_default(builder);
 
    stdlib::field_t a(stdlib::witness_t(&builder, fr::random_element()));
    stdlib::field_t b(stdlib::witness_t(&builder, fr::random_element()));
    stdlib::field_t c(&builder);
    // Ensure the circuit is filled but finalisation doesn't make the circuit size go to the next power of two
    const size_t GATE_COUNT_BUFFER = 1000; // Since we're using an estimate, let's add an error term in case.
    size_t current_gates = builder.get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false);
 
    if (target_gate_count <= current_gates + GATE_COUNT_BUFFER) {
        throw_or_abort("Target gate count is too low.");
    }
 
    size_t passes = (target_gate_count - current_gates - GATE_COUNT_BUFFER) / 4;
 
    for (size_t i = 0; i < passes; ++i) {
        c = a + b;
        c = a * c;
        a = b * b;
        b = c * c;
    }
 
    size_t est_gate_count = builder.get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false);
    BB_ASSERT_LTE(est_gate_count,
                  target_gate_count - GATE_COUNT_BUFFER,
                  "Check that the finalized gate count won't exceed the desired gate count.");
}
 
template <typename Builder> void generate_basic_arithmetic_circuit(Builder& builder, size_t log2_num_gates)
{
    generate_basic_arithmetic_circuit_with_target_gates(builder, 1UL << log2_num_gates);
}
 
template <typename Prover>
Prover get_prover(void (*test_circuit_function)(typename Prover::Flavor::CircuitBuilder&, size_t),
                  size_t num_iterations)
{
    using Flavor = typename Prover::Flavor;
    using Builder = typename Flavor::CircuitBuilder;
 
    Builder builder;
    test_circuit_function(builder, num_iterations);
 
    BB_BENCH_NAME("creating prover");
 
    auto prover_instance = std::make_shared<ProverInstance_<Flavor>>(builder);
    auto verification_key = std::make_shared<typename Flavor::VerificationKey>(prover_instance->get_precomputed());
    return Prover(prover_instance, verification_key);
};
 
template <typename Prover>
void construct_proof_with_specified_num_iterations(
    benchmark::State& state,
    void (*test_circuit_function)(typename Prover::Flavor::CircuitBuilder&, size_t),
    size_t num_iterations)
{
    bb::srs::init_file_crs_factory(bb::srs::bb_crs_path());
 
    for (auto _ : state) {
        // Construct circuit and prover; don't include this part in measurement
        state.PauseTiming();
        Prover prover = get_prover<Prover>(test_circuit_function, num_iterations);
        state.ResumeTiming();
 
        // Construct proof
        auto proof = prover.construct_proof();
    }
}
 
} // namespace bb::mock_circuits