chonk_batch_verifier.hpp

Go to the documentation of this file.

#pragma once
#ifndef __wasm__
#include "barretenberg/eccvm/eccvm_verifier.hpp"
#include "barretenberg/flavor/mega_zk_flavor.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "batch_verifier_types.hpp"
 
#include <atomic>
#include <condition_variable>
#include <deque>
#include <functional>
#include <mutex>
#include <optional>
#include <thread>
#include <unordered_set>
#include <vector>
 
namespace bb {
 
class ChonkBatchVerifier {
  public:
    using ResultCallback = std::function<void(VerifyResult)>;
    static constexpr size_t MAX_QUEUE_SIZE = 1024;
 
    struct ReduceResult {
        using DeferredTripleIpaOpening = typename ECCVMVerifier::DeferredTripleIpaOpening;
 
        uint64_t request_id = 0;
        std::optional<DeferredTripleIpaOpening> triple_ipa_opening;
        bool all_checks_passed = false;
        std::string error_message;
        std::chrono::steady_clock::time_point enqueue_time;
        double reduce_ms = 0;
    };
 
    ChonkBatchVerifier() = default;
    ~ChonkBatchVerifier();
 
    ChonkBatchVerifier(const ChonkBatchVerifier&) = delete;
    ChonkBatchVerifier& operator=(const ChonkBatchVerifier&) = delete;
 
    void start(std::vector<std::shared_ptr<MegaZKFlavor::VKAndHash>> vks,
               uint32_t num_cores,
               uint32_t batch_size,
               ResultCallback on_result);
 
    void enqueue(VerifyRequest request);
 
    void stop();
 
  private:
    void coordinator_loop();
    void dispatch(VerifyResult result);
    std::vector<ReduceResult> parallel_reduce(const std::vector<VerifyRequest>& batch);
    bool batch_check(const std::vector<ReduceResult>& results, const std::vector<size_t>& indices);
    void bisect(std::vector<ReduceResult>& results,
                std::vector<size_t> indices,
                uint32_t depth,
                std::chrono::steady_clock::time_point reduce_start);
    void emit_ok(const std::vector<ReduceResult>& results,
                 const std::vector<size_t>& indices,
                 std::chrono::steady_clock::time_point reduce_start,
                 double pcs_ms,
                 uint32_t depth);
 
    static double ms_since(std::chrono::steady_clock::time_point t)
    {
        return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - t).count();
    }
    static double ms_between(std::chrono::steady_clock::time_point from, std::chrono::steady_clock::time_point to)
    {
        return std::chrono::duration<double, std::milli>(to - from).count();
    }
 
    std::vector<std::shared_ptr<MegaZKFlavor::VKAndHash>> vks_;
    uint32_t num_cores_ = 1;
    uint32_t batch_size_ = 8;
    ResultCallback on_result_;
 
    std::mutex mutex_;
    std::condition_variable cv_;
    std::condition_variable stopped_cv_;
    std::deque<VerifyRequest> queue_;
    std::unordered_set<uint64_t> in_flight_ids_;
    bool running_ = false;
    bool shutdown_ = false;
    bool stopping_ = false;
    std::thread coordinator_thread_;
};
 
} // namespace bb
#endif // __wasm__