clear out debugging code

ledwards2225 · ledwards2225 · commit 2b68b8cafd8d · 2026-04-03T22:33:52.000Z
diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -339,24 +339,7 @@ ConstraintProfile profile_constraint_type(ConstraintType representative, Handler
 void prepare_builder_from_profiles(UltraCircuitBuilder& builder, const std::vector<ConstraintProfile>& profiles)
 {
     // Register all constants from all profiles
-    for (size_t p = 0; p < profiles.size(); p++) {
-        const auto& profile = profiles[p];
-        std::string table_str;
-        for (auto tid : profile.table_ids)
-            table_str += " " + std::to_string(static_cast<int>(tid));
-        info("  profile[",
-             p,
-             "]: blk2=",
-             profile.block_sizes.block_sizes[2],
-             " vars=",
-             profile.block_sizes.num_variables,
-             " constants=",
-             profile.constants.size(),
-             " range_targets=",
-             profile.range_list_targets.size(),
-             " tables=[",
-             table_str,
-             " ]");
+    for (const auto& profile : profiles) {
         for (const auto& value : profile.constants) {
             builder.put_constant_variable(value);
         }
@@ -569,14 +552,11 @@ void build_constraints_parallel(UltraCircuitBuilder& builder,
         }
     }
 
-    info("  Phase 3: executing ", tasks.size(), " tasks with ", num_threads, " threads");
-
     // Phase 3: Execute ALL instances in parallel
     // execute_parallel will set up per-thread ROM/RAM cursors using the num_rom/ram_arrays in task_sizes
     if (!tasks.empty()) {
         builder.execute_parallel(tasks, task_sizes, num_threads);
     }
-    info("  Phase 3: done");
 
     // Phase 4: Block constraints and recursion constraints are processed sequentially.
     for (const auto& [constraint, opcode_indices] :
diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/per_block_gate_count.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/per_block_gate_count.test.cpp
@@ -2170,24 +2170,18 @@ TEST_P(AcirTestParallelEquivalence, SequentialN1N2)
     }
 
     // 1. Build sequentially via create_circuit (uses build_constraints)
-    info("  building sequential...");
     AcirProgram seq_program{ constraints, WitnessVector(witness) };
     auto seq_builder = create_circuit<UltraCircuitBuilder>(seq_program, ProgramMetadata{});
-    info("  sequential done");
 
     // 2. Build via parallel path with N=1
-    info("=== N=1 BUILD START ===");
     AcirFormat n1_constraints = constraints;
     UltraCircuitBuilder n1_builder{ WitnessVector(witness), n1_constraints.public_inputs, false };
     build_constraints_parallel(n1_builder, n1_constraints, ProgramMetadata{}, /*num_threads=*/1);
-    info("=== N=1 BUILD END ===");
 
     // 3. Build via parallel path with N=2
-    info("=== N=2 BUILD START ===");
     AcirFormat n2_constraints = constraints;
     UltraCircuitBuilder n2_builder{ WitnessVector(witness), n2_constraints.public_inputs, false };
     build_constraints_parallel(n2_builder, n2_constraints, ProgramMetadata{}, /*num_threads=*/2);
-    info("=== N=2 BUILD END ===");
 
     // Print block sizes for all three builders
     {
@@ -2205,18 +2199,6 @@ TEST_P(AcirTestParallelEquivalence, SequentialN1N2)
              n1_builder.get_num_variables(),
              " n2=",
              n2_builder.get_num_variables());
-        info("  ecc_fusions: seq_add=",
-             seq_builder.ecc_add_fuse_count_,
-             " seq_dbl=",
-             seq_builder.ecc_dbl_fuse_count_,
-             " n1_add=",
-             n1_builder.ecc_add_fuse_count_,
-             " n1_dbl=",
-             n1_builder.ecc_dbl_fuse_count_,
-             " n2_add=",
-             n2_builder.ecc_add_fuse_count_,
-             " n2_dbl=",
-             n2_builder.ecc_dbl_fuse_count_);
         info("  constants: seq=",
              seq_builder.constant_variable_indices.size(),
              " n1=",
diff --git a/barretenberg/cpp/src/barretenberg/honk/execution_trace/execution_trace_block.hpp b/barretenberg/cpp/src/barretenberg/honk/execution_trace/execution_trace_block.hpp
@@ -322,7 +322,6 @@ template <typename FF, size_t NUM_WIRES_> class ExecutionTraceBlock {
     bool data_freed_ = false;                                      // true after free_data() has been called
     uint32_t trace_offset_ = std::numeric_limits<uint32_t>::max(); // where this block starts in the trace
     std::vector<size_t> wire_cursors_;                             // per-thread wire cursors
-    std::vector<size_t> wire_cursor_starts_;                       // per-thread cursor start positions (task boundary)
 
     size_t wire_active_cursor() const
     {
@@ -378,26 +377,13 @@ template <typename FF, size_t NUM_WIRES_> class ExecutionTraceBlock {
     {
         if (thread_idx >= wire_cursors_.size()) {
             wire_cursors_.resize(thread_idx + 1, Selector<FF>::CURSOR_DISABLED);
-            wire_cursor_starts_.resize(thread_idx + 1, 0);
         }
         wire_cursors_[thread_idx] = start;
-        wire_cursor_starts_[thread_idx] = start;
         for (auto& sel : get_selectors()) {
             sel.enable_cursor_mode(thread_idx, start);
         }
     }
 
-    /**
-     * @brief Get the start position of the current task's region in this block.
-     * @details Returns the position where enable_cursor_mode was last called for this thread.
-     * Used to prevent gate fusion across task boundaries.
-     */
-    size_t wire_cursor_start() const
-    {
-        auto idx = get_parallel_thread_index();
-        return (wire_cursor_starts_.empty() || idx >= wire_cursor_starts_.size()) ? 0 : wire_cursor_starts_[idx];
-    }
-
     // Legacy single-thread interface
     void enable_cursor_mode(size_t start) { enable_cursor_mode(0, start); }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.cpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.cpp
@@ -378,22 +378,10 @@ void UltraCircuitBuilder_<ExecutionTrace>::create_ecc_add_gate(const ecc_add_gat
     // The elliptic curve relation assumes q_sign² = 1 (see elliptic_relation.hpp)
     const FF q_sign = in.is_addition ? FF(1) : FF(-1);
 
-    // Determine whether we can fuse this addition operation into the previous gate in the block.
-    // NOTE: This fusion decision depends on wire VALUES (witness-dependent). In sequential mode this is
-    // deterministic for a given witness. For future work-stealing parallelism where task execution order
-    // may differ, this fusion pattern could vary and must be handled (e.g., by disabling fusion in
-    // parallel mode or by ensuring tasks that chain elliptic ops are never split across threads).
-    //
-    // In cursor mode, use the cursor position (not block.size()) to find the previous gate.
-    // NOTE: This fusion decision depends on wire VALUES (witness-dependent). In sequential mode this is
-    // deterministic for a given witness. For future work-stealing parallelism where task execution order
-    // may differ, this fusion pattern could vary and must be handled (e.g., by disabling fusion in
-    // parallel mode or by ensuring tasks that chain elliptic ops are never split across threads).
-    //
-    // In cursor mode, use cursor position to find the previous gate (not block.size() which returns
-    // the pre-allocated total). We can only fuse if the cursor has advanced (i.e., we've written at
-    // least one gate in this task's region).
-    // Use cursor position in cursor mode, block.size() otherwise.
+    // Determine whether we can fuse this addition into the previous gate in the block.
+    // In cursor mode, use cursor position (not block.size() which returns pre-allocated total).
+    // NOTE: For future work-stealing parallelism where task execution order may differ, fusion
+    // across task boundaries must be handled carefully to maintain determinism.
     size_t cursor = block.wire_active_cursor();
     bool can_fuse_into_previous_gate;
     size_t prev_idx;
@@ -405,9 +393,6 @@ void UltraCircuitBuilder_<ExecutionTrace>::create_ecc_add_gate(const ecc_add_gat
         can_fuse_into_previous_gate =
             block.size() > 0 && block.w_r()[prev_idx] == in.x1 && block.w_o()[prev_idx] == in.y1;
     }
-    if (can_fuse_into_previous_gate) {
-        ecc_add_fuse_count_++;
-    }
 
     if (can_fuse_into_previous_gate) {
         block.q_1().set(prev_idx, q_sign);   // set q_sign of previous gate
@@ -464,10 +449,6 @@ void UltraCircuitBuilder_<ExecutionTrace>::create_ecc_dbl_gate(const ecc_dbl_gat
         can_fuse_into_previous_gate =
             block.size() > 0 && block.w_r()[dbl_prev_idx] == in.x1 && block.w_o()[dbl_prev_idx] == in.y1;
     }
-    if (can_fuse_into_previous_gate) {
-        ecc_dbl_fuse_count_++;
-    }
-
     // If possible, update the previous gate to be the first gate in the pair, otherwise create a new gate
     if (can_fuse_into_previous_gate) {
         block.q_elliptic().set(dbl_prev_idx, 1); // set q_ecc of previous gate to 1
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp
@@ -386,7 +386,7 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
         threads.reserve(num_threads);
 
         for (size_t tid = 0; tid < num_threads; tid++) {
-            threads.emplace_back([this, tid, &tasks, &task_sizes, &offsets, &thread_tasks]() {
+            threads.emplace_back([this, tid, &tasks, &offsets, &thread_tasks]() {
                 set_parallel_thread_index(tid);
 
                 for (size_t i = 0; i < thread_tasks[tid].size(); i++) {
@@ -403,65 +403,9 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
                         rom_ram_logic.enable_ram_cursor(tid, offsets[task_idx].num_ram_arrays);
                     }
 
-                    // Diagnostic: check cursor position at task start
-                    if (task_sizes[task_idx].block_sizes[4] > 0) {
-                        auto block_refs_pre = blocks.get();
-                        size_t pre_cursor = block_refs_pre[4].wire_active_cursor();
-                        size_t expected_start = offsets[task_idx].block_sizes[4];
-                        if (pre_cursor != expected_start) {
-                            info("PRE-TASK MISMATCH task ",
-                                 task_idx,
-                                 " block 4: cursor=",
-                                 pre_cursor,
-                                 " expected_start=",
-                                 expected_start);
-                        }
-                    }
-
                     // Execute the task
                     this->set_current_task_index(task_idx);
                     tasks[task_idx](*this);
-
-                    // Diagnostic: check cursor advancement matches profiled sizes
-                    {
-                        size_t expected_var_end = offsets[task_idx].num_variables + task_sizes[task_idx].num_variables;
-                        size_t actual_var_pos = this->get_variable_cursor();
-                        if (actual_var_pos != expected_var_end) {
-                            info("CURSOR MISMATCH task ",
-                                 task_idx,
-                                 ": var cursor=",
-                                 actual_var_pos,
-                                 " expected=",
-                                 expected_var_end,
-                                 " (diff=",
-                                 static_cast<int64_t>(actual_var_pos) - static_cast<int64_t>(expected_var_end),
-                                 ")");
-                        }
-                        auto block_refs_check = blocks.get();
-                        for (size_t b = 0; b < ExecutionTrace::NUM_BLOCKS; b++) {
-                            size_t offset_b = offsets[task_idx].block_sizes[b];
-                            size_t size_b = task_sizes[task_idx].block_sizes[b];
-                            size_t expected_blk_end = offset_b + size_b;
-                            size_t actual_blk_pos = block_refs_check[b].wire_active_cursor();
-                            if (size_b > 0 && actual_blk_pos != Selector<FF>::CURSOR_DISABLED &&
-                                actual_blk_pos != expected_blk_end) {
-                                info("CURSOR MISMATCH task ",
-                                     task_idx,
-                                     " block ",
-                                     b,
-                                     ": cursor=",
-                                     actual_blk_pos,
-                                     " offset=",
-                                     offset_b,
-                                     " profiled_size=",
-                                     size_b,
-                                     " expected_end=",
-                                     expected_blk_end,
-                                     " actual_produced=",
-                                     actual_blk_pos - offset_b);
-                            }
-                        }
-                    }
                 }
 
                 // Disable all cursors for this thread
@@ -486,16 +430,6 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
         apply_deferred_lookup_gates();
         apply_deferred_range_constraints();
         apply_deferred_non_native_field_muls();
-        {
-            size_t total_deferred = 0;
-            for (size_t t = 0; t < this->deferred_assert_equals_.size(); t++) {
-                if (!this->deferred_assert_equals_[t].empty()) {
-                    info("    task ", t, ": ", this->deferred_assert_equals_[t].size(), " deferred assert_equals");
-                }
-                total_deferred += this->deferred_assert_equals_[t].size();
-            }
-            info("  Replaying ", total_deferred, " deferred assert_equals across ", tasks.size(), " tasks");
-        }
         this->apply_deferred_assert_equals();
     }
 
@@ -505,9 +439,6 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
     // Stores gate index of ROM/RAM reads (required by proving key)
     std::vector<uint32_t> memory_read_records;
 
-    // Diagnostic counters for ECC gate fusion (temporary, for debugging)
-    size_t ecc_add_fuse_count_ = 0;
-    size_t ecc_dbl_fuse_count_ = 0;
     // Stores gate index of RAM writes (required by proving key)
     std::vector<uint32_t> memory_write_records;
     // Range constraints to be batched, keyed by target_range. See create_small_range_constraint() for details.
