unify and clean up

Author: ledwards2225

barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp

@@ -379,28 +379,26 @@ void build_constraints_parallel(UltraCircuitBuilder& builder,
     std::vector<TaskBlockSizes> task_sizes;
     std::vector<size_t> task_profile_indices;
 
-    // Helper: given a constraint vector, a handler, and a key function, profile unique keys
-    // and return a map from key to profile index. Does NOT add tasks (that happens in order below).
-    auto profile_grouped = [&](auto& items, auto handler, auto key_fn) -> std::map<decltype(key_fn(items[0])), size_t> {
+    // Helper: profile unique keys in a constraint vector, then add tasks in vector order.
+    // Combines profiling and task collection in a single call per constraint type.
+    auto profile_and_collect = [&](auto& items, auto handler, auto key_fn) {
+        if (items.empty()) {
+            return;
+        }
         using Key = decltype(key_fn(items[0]));
         std::map<Key, size_t> key_to_profile;
+        // Phase 1: profile unique keys
         for (size_t i = 0; i < items.size(); i++) {
             Key k = key_fn(items[i]);
             if (key_to_profile.count(k) == 0) {
                 auto profile = profile_constraint_type(items[i], handler, num_witnesses);
-                size_t profile_idx = profiles.size();
+                key_to_profile[k] = profiles.size();
                 profiles.push_back(profile);
-                key_to_profile[k] = profile_idx;
             }
         }
-        return key_to_profile;
-    };
-
-    // Helper: add tasks for a constraint vector in vector order, looking up each instance's profile.
-    auto collect_tasks = [&](auto& items, auto handler, const auto& key_to_profile, auto key_fn) {
+        // Phase 1b: add tasks in vector order
         for (size_t i = 0; i < items.size(); i++) {
-            auto k = key_fn(items[i]);
-            size_t profile_idx = key_to_profile.at(k);
+            size_t profile_idx = key_to_profile.at(key_fn(items[i]));
             const auto& profile = profiles[profile_idx];
             auto sizes = profile.block_sizes;
             sizes.num_rom_arrays = profile.num_rom_arrays_per_instance;
@@ -466,72 +464,22 @@ void build_constraints_parallel(UltraCircuitBuilder& builder,
     };
     auto ec_add_handler = [](UltraCircuitBuilder& b, const EcAdd& c) { create_ec_add_constraint(b, c); };
 
-    // Profile all types (order doesn't matter here — just building the key→profile maps)
-    auto quad_profiles = !constraints.quad_constraints.empty()
-                             ? profile_grouped(constraints.quad_constraints, quad_handler, const_key)
-                             : decltype(profile_grouped(constraints.quad_constraints, quad_handler, const_key)){};
-    auto big_quad_profiles =
-        !constraints.big_quad_constraints.empty()
-            ? profile_grouped(constraints.big_quad_constraints, big_quad_handler, big_quad_key)
-            : decltype(profile_grouped(constraints.big_quad_constraints, big_quad_handler, big_quad_key)){};
-    auto logic_profiles = !constraints.logic_constraints.empty()
-                              ? profile_grouped(constraints.logic_constraints, logic_handler, logic_key)
-                              : decltype(profile_grouped(constraints.logic_constraints, logic_handler, logic_key)){};
-    auto range_profiles = !constraints.range_constraints.empty()
-                              ? profile_grouped(constraints.range_constraints, range_handler, range_key)
-                              : decltype(profile_grouped(constraints.range_constraints, range_handler, range_key)){};
-    auto aes_profiles = !constraints.aes128_constraints.empty()
-                            ? profile_grouped(constraints.aes128_constraints, aes_handler, aes_key)
-                            : decltype(profile_grouped(constraints.aes128_constraints, aes_handler, aes_key)){};
-    auto sha_profiles = !constraints.sha256_compression.empty()
-                            ? profile_grouped(constraints.sha256_compression, sha_handler, const_key)
-                            : decltype(profile_grouped(constraints.sha256_compression, sha_handler, const_key)){};
-    auto ecdsa_k1_profiles =
-        !constraints.ecdsa_k1_constraints.empty()
-            ? profile_grouped(constraints.ecdsa_k1_constraints, ecdsa_k1_handler, const_key)
-            : decltype(profile_grouped(constraints.ecdsa_k1_constraints, ecdsa_k1_handler, const_key)){};
-    auto ecdsa_r1_profiles =
-        !constraints.ecdsa_r1_constraints.empty()
-            ? profile_grouped(constraints.ecdsa_r1_constraints, ecdsa_r1_handler, const_key)
-            : decltype(profile_grouped(constraints.ecdsa_r1_constraints, ecdsa_r1_handler, const_key)){};
-    auto blake2s_profiles =
-        !constraints.blake2s_constraints.empty()
-            ? profile_grouped(constraints.blake2s_constraints, blake2s_handler, blake2s_key)
-            : decltype(profile_grouped(constraints.blake2s_constraints, blake2s_handler, blake2s_key)){};
-    auto blake3_profiles =
-        !constraints.blake3_constraints.empty()
-            ? profile_grouped(constraints.blake3_constraints, blake3_handler, blake3_key)
-            : decltype(profile_grouped(constraints.blake3_constraints, blake3_handler, blake3_key)){};
-    auto keccak_profiles =
-        !constraints.keccak_permutations.empty()
-            ? profile_grouped(constraints.keccak_permutations, keccak_handler, const_key)
-            : decltype(profile_grouped(constraints.keccak_permutations, keccak_handler, const_key)){};
-    auto pos2_profiles = !constraints.poseidon2_constraints.empty()
-                             ? profile_grouped(constraints.poseidon2_constraints, pos2_handler, pos2_key)
-                             : decltype(profile_grouped(constraints.poseidon2_constraints, pos2_handler, pos2_key)){};
-    auto msm_profiles =
-        !constraints.multi_scalar_mul_constraints.empty()
-            ? profile_grouped(constraints.multi_scalar_mul_constraints, msm_handler, msm_key)
-            : decltype(profile_grouped(constraints.multi_scalar_mul_constraints, msm_handler, msm_key)){};
-    auto ec_add_profiles = !constraints.ec_add_constraints.empty()
-                               ? profile_grouped(constraints.ec_add_constraints, ec_add_handler, const_key)
-                               : decltype(profile_grouped(constraints.ec_add_constraints, ec_add_handler, const_key)){};
-
-    // Collect tasks in the same order as sequential build_constraints
-    collect_tasks(constraints.quad_constraints, quad_handler, quad_profiles, const_key);
-    collect_tasks(constraints.big_quad_constraints, big_quad_handler, big_quad_profiles, big_quad_key);
-    collect_tasks(constraints.logic_constraints, logic_handler, logic_profiles, logic_key);
-    collect_tasks(constraints.range_constraints, range_handler, range_profiles, range_key);
-    collect_tasks(constraints.aes128_constraints, aes_handler, aes_profiles, aes_key);
-    collect_tasks(constraints.sha256_compression, sha_handler, sha_profiles, const_key);
-    collect_tasks(constraints.ecdsa_k1_constraints, ecdsa_k1_handler, ecdsa_k1_profiles, const_key);
-    collect_tasks(constraints.ecdsa_r1_constraints, ecdsa_r1_handler, ecdsa_r1_profiles, const_key);
-    collect_tasks(constraints.blake2s_constraints, blake2s_handler, blake2s_profiles, blake2s_key);
-    collect_tasks(constraints.blake3_constraints, blake3_handler, blake3_profiles, blake3_key);
-    collect_tasks(constraints.keccak_permutations, keccak_handler, keccak_profiles, const_key);
-    collect_tasks(constraints.poseidon2_constraints, pos2_handler, pos2_profiles, pos2_key);
-    collect_tasks(constraints.multi_scalar_mul_constraints, msm_handler, msm_profiles, msm_key);
-    collect_tasks(constraints.ec_add_constraints, ec_add_handler, ec_add_profiles, const_key);
+    // Profile and collect tasks in the same order as sequential build_constraints.
+    // Each call profiles unique keys, then adds tasks in constraint vector order.
+    profile_and_collect(constraints.quad_constraints, quad_handler, const_key);
+    profile_and_collect(constraints.big_quad_constraints, big_quad_handler, big_quad_key);
+    profile_and_collect(constraints.logic_constraints, logic_handler, logic_key);
+    profile_and_collect(constraints.range_constraints, range_handler, range_key);
+    profile_and_collect(constraints.aes128_constraints, aes_handler, aes_key);
+    profile_and_collect(constraints.sha256_compression, sha_handler, const_key);
+    profile_and_collect(constraints.ecdsa_k1_constraints, ecdsa_k1_handler, const_key);
+    profile_and_collect(constraints.ecdsa_r1_constraints, ecdsa_r1_handler, const_key);
+    profile_and_collect(constraints.blake2s_constraints, blake2s_handler, blake2s_key);
+    profile_and_collect(constraints.blake3_constraints, blake3_handler, blake3_key);
+    profile_and_collect(constraints.keccak_permutations, keccak_handler, const_key);
+    profile_and_collect(constraints.poseidon2_constraints, pos2_handler, pos2_key);
+    profile_and_collect(constraints.multi_scalar_mul_constraints, msm_handler, msm_key);
+    profile_and_collect(constraints.ec_add_constraints, ec_add_handler, const_key);
 
     // Phase 2: Prepare the builder's caches from profiles (no constraint execution).
     prepare_builder_from_profiles(builder, profiles);

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp

@@ -59,7 +59,7 @@ template <typename FF_> class CircuitBuilderBase {
     static constexpr uint32_t VARIABLE_CURSOR_DISABLED = UINT32_MAX;
 
     // Deferred assert_equal entries for parallel construction. In cursor mode, assert_equal calls
-    // are recorded per-thread and replayed in deterministic task order after all threads join.
+    // are recorded per-task and replayed in deterministic task order after all threads join.
     // This prevents nondeterministic union-find results when multiple threads assert_equal on
     // the same shared ACIR witness.
     struct DeferredAssertEqual {
@@ -80,8 +80,8 @@ template <typename FF_> class CircuitBuilderBase {
     {
         // Replay in task order (0, 1, 2, ...) for deterministic union-find results
         for (auto& task_buf : deferred_assert_equals_) {
-            for (auto& [a, b, msg] : task_buf) {
-                assert_equal(a, b, msg);
+            for (auto& entry : task_buf) {
+                assert_equal(entry.a_variable_idx, entry.b_variable_idx, entry.msg);
             }
             task_buf.clear();
         }

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.cpp

@@ -584,7 +584,7 @@ plookup::ReadData<uint32_t> UltraCircuitBuilder_<ExecutionTrace>::create_gates_f
         // In cursor mode, defer the lookup gate entry to avoid races on table.lookup_gates
         if (this->get_variable_cursor() != this->VARIABLE_CURSOR_DISABLED) {
             auto tidx = get_parallel_thread_index();
-            deferred_lookup_gates_[tidx].push_back({ multi_table.basic_table_ids[i], read_values.lookup_entries[i] });
+            deferred_lookup_gates_.defer(tidx, { multi_table.basic_table_ids[i], read_values.lookup_entries[i] });
         } else {
             table.lookup_gates.emplace_back(read_values.lookup_entries[i]);
         }
@@ -787,7 +787,7 @@ void UltraCircuitBuilder_<ExecutionTrace>::create_small_range_constraint(const u
     // In cursor mode, defer range constraint to avoid races on range_lists and real_variable_tags
     if (this->get_variable_cursor() != this->VARIABLE_CURSOR_DISABLED) {
         auto tidx = get_parallel_thread_index();
-        deferred_range_constraints_[tidx].push_back({ variable_index, target_range });
+        deferred_range_constraints_.defer(tidx, { variable_index, target_range });
         return;
     }
 
@@ -1567,7 +1567,7 @@ std::array<uint32_t, 2> UltraCircuitBuilder_<ExecutionTrace>::queue_partial_non_
         .hi_1 = hi_1_idx,
     };
     if (this->get_variable_cursor() != this->VARIABLE_CURSOR_DISABLED) {
-        deferred_non_native_field_muls_[get_parallel_thread_index()].emplace_back(cache_entry);
+        deferred_non_native_field_muls_.defer(get_parallel_thread_index(), cache_entry);
     } else {
         cached_partial_non_native_field_multiplications.emplace_back(cache_entry);
     }

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp

@@ -202,74 +202,50 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
     // The set of variables which have been constrained to a particular value via an arithmetic gate
     std::unordered_map<FF, uint32_t> constant_variable_indices;
 
-    // Deferred lookup gate entries for parallel construction. In cursor mode, plookup reads append here
-    // instead of to table.lookup_gates. Replayed after parallel phase via apply_deferred_lookup_gates().
+    /**
+     * @brief Per-thread buffer for deferring operations during parallel construction.
+     * @details Operations that modify shared builder state are buffered per-thread during
+     * execute_parallel and replayed sequentially after all threads join. The replay callback
+     * receives each entry and applies it to the builder.
+     */
+    template <typename Entry> struct DeferredBuffer {
+        std::vector<std::vector<Entry>> thread_buffers;
+
+        void init(size_t num_threads) { thread_buffers.resize(num_threads); }
+
+        void defer(size_t thread_idx, Entry&& entry) { thread_buffers[thread_idx].emplace_back(std::move(entry)); }
+
+        void defer(size_t thread_idx, const Entry& entry) { thread_buffers[thread_idx].push_back(entry); }
+
+        template <typename Callback> void apply(Callback&& callback)
+        {
+            for (auto& buf : thread_buffers) {
+                for (auto& entry : buf) {
+                    callback(entry);
+                }
+                buf.clear();
+            }
+        }
+    };
+
     struct DeferredLookupEntry {
         plookup::BasicTableId table_id;
         plookup::BasicTable::LookupEntry entry;
     };
-    std::vector<std::vector<DeferredLookupEntry>> deferred_lookup_gates_; // per-thread
-
-    // Deferred range constraint entries for parallel construction. In cursor mode, range constraints
-    // buffer here instead of modifying range_lists. Replayed via apply_deferred_range_constraints().
     struct DeferredRangeConstraint {
         uint32_t variable_index;
         uint64_t target_range;
     };
-    std::vector<std::vector<DeferredRangeConstraint>> deferred_range_constraints_; // per-thread
 
-    // Deferred non-native field multiplications for parallel construction. In cursor mode,
-    // these are buffered per-thread to avoid races on the shared vector.
-    std::vector<std::vector<cached_partial_non_native_field_multiplication>> deferred_non_native_field_muls_;
+    DeferredBuffer<DeferredLookupEntry> deferred_lookup_gates_;
+    DeferredBuffer<DeferredRangeConstraint> deferred_range_constraints_;
+    DeferredBuffer<cached_partial_non_native_field_multiplication> deferred_non_native_field_muls_;
 
-    /**
-     * @brief Initialize deferred buffers for N threads.
-     */
     void init_deferred_buffers(size_t num_threads)
     {
-        deferred_lookup_gates_.resize(num_threads);
-        deferred_range_constraints_.resize(num_threads);
-        deferred_non_native_field_muls_.resize(num_threads);
-    }
-
-    /**
-     * @brief Replay all deferred non-native field multiplications into the shared cache.
-     */
-    void apply_deferred_non_native_field_muls()
-    {
-        for (auto& thread_buf : deferred_non_native_field_muls_) {
-            for (auto& entry : thread_buf) {
-                cached_partial_non_native_field_multiplications.emplace_back(entry);
-            }
-            thread_buf.clear();
-        }
-    }
-
-    /**
-     * @brief Replay all deferred lookup gate entries into the appropriate tables.
-     */
-    void apply_deferred_lookup_gates()
-    {
-        for (auto& thread_buf : deferred_lookup_gates_) {
-            for (auto& [table_id, entry] : thread_buf) {
-                auto& table = get_table(table_id);
-                table.lookup_gates.emplace_back(entry);
-            }
-            thread_buf.clear();
-        }
-    }
-
-    /**
-     * @brief Replay all deferred range constraints.
-     */
-    void apply_deferred_range_constraints()
-    {
-        for (auto& thread_buf : deferred_range_constraints_) {
-            for (auto& [variable_index, target_range] : thread_buf) {
-                create_small_range_constraint(variable_index, target_range);
-            }
-            thread_buf.clear();
-        }
+        deferred_lookup_gates_.init(num_threads);
+        deferred_range_constraints_.init(num_threads);
+        deferred_non_native_field_muls_.init(num_threads);
     }
 
     /**
@@ -427,9 +403,14 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
         rom_ram_logic.ram_id_cursors_.clear();
 
         // Replay deferred operations
-        apply_deferred_lookup_gates();
-        apply_deferred_range_constraints();
-        apply_deferred_non_native_field_muls();
+        deferred_lookup_gates_.apply([this](auto& e) {
+            auto& table = get_table(e.table_id);
+            table.lookup_gates.emplace_back(e.entry);
+        });
+        deferred_range_constraints_.apply(
+            [this](auto& e) { create_small_range_constraint(e.variable_index, e.target_range); });
+        deferred_non_native_field_muls_.apply(
+            [this](auto& e) { cached_partial_non_native_field_multiplications.emplace_back(e); });
         this->apply_deferred_assert_equals();
     }