Merge branch 'master' into saleel/profiler-improvements

AztecProtocol · Dec 13, 2024 · afb1098 · afb1098
2 parents 9defad0 + 934107f
commit afb1098
Show file tree

Hide file tree

Showing 74 changed files with 1,190 additions and 520 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -215,7 +215,7 @@ jobs:
       - run: "echo Full E2E tests enabled."
 
   network-test-gate:
-    needs: [build, configure]
+    needs: [build, yarn-project-test, configure]
     if: github.ref_name == 'master' || contains(github.event.pull_request.labels.*.name, 'network-all')
     runs-on: ubuntu-20.04
     steps:
@@ -684,7 +684,7 @@ jobs:
         run: sudo shutdown -P 60 ; earthly-ci --no-output ./yarn-project/+network-test --test=./test-transfer.sh
 
   network-full-test:
-    needs: [network-test-gate, configure]
+    needs: [network-test-gate, network-transfer-test, configure]
     runs-on: ${{ needs.configure.outputs.username }}-x86
     strategy:
       max-parallel: 1

diff --git a/.noir-sync-commit b/.noir-sync-commit
@@ -1 +1 @@
-b88db67a4fa92f861329105fb732a7b1309620fe
+eb975ab28fb056cf92859377c02f2bb1a608eda3
diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/execution_trace/mega_execution_trace.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/execution_trace/mega_execution_trace.hpp
@@ -59,7 +59,7 @@ template <typename T> struct MegaTraceBlockData {
         };
     }
 
-    auto get_gate_blocks()
+    auto get_gate_blocks() const
     {
         return RefArray{
             busread, arithmetic, delta_range, elliptic, aux, poseidon2_external, poseidon2_internal, lookup

diff --git a/...etenberg/cpp/src/barretenberg/plonk_honk_shared/execution_trace/ultra_execution_trace.hpp b/...etenberg/cpp/src/barretenberg/plonk_honk_shared/execution_trace/ultra_execution_trace.hpp
@@ -31,7 +31,7 @@ template <typename T> struct UltraTraceBlockData {
                          lookup,     poseidon2_external, poseidon2_internal, overflow };
     }
 
-    auto get_gate_blocks()
+    auto get_gate_blocks() const
     {
         return RefArray{ arithmetic, delta_range, elliptic, aux, lookup, poseidon2_external, poseidon2_internal };
     }

diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.cpp
@@ -30,6 +30,142 @@ template <IsUltraFlavor Flavor> size_t DeciderProvingKey_<Flavor>::compute_dyadi
     return circuit.get_circuit_subgroup_size(total_num_gates);
 }
 
+template <IsUltraFlavor Flavor> void DeciderProvingKey_<Flavor>::allocate_wires()
+{
+    PROFILE_THIS_NAME("allocate_wires");
+
+    for (auto& wire : proving_key.polynomials.get_wires()) {
+        wire = Polynomial::shiftable(proving_key.circuit_size);
+    }
+}
+
+template <IsUltraFlavor Flavor> void DeciderProvingKey_<Flavor>::allocate_permutation_argument_polynomials()
+{
+    PROFILE_THIS_NAME("allocate_permutation_argument_polynomials");
+
+    for (auto& sigma : proving_key.polynomials.get_sigmas()) {
+        sigma = Polynomial(proving_key.circuit_size);
+    }
+    for (auto& id : proving_key.polynomials.get_ids()) {
+        id = Polynomial(proving_key.circuit_size);
+    }
+    proving_key.polynomials.z_perm = Polynomial::shiftable(proving_key.circuit_size);
+}
+
+template <IsUltraFlavor Flavor> void DeciderProvingKey_<Flavor>::allocate_lagrange_polynomials()
+{
+    PROFILE_THIS_NAME("allocate_lagrange_polynomials");
+
+    // First and last lagrange polynomials (in the full circuit size)
+    proving_key.polynomials.lagrange_first = Polynomial(
+        /* size=*/1, /*virtual size=*/dyadic_circuit_size, /*start_index=*/0);
+
+    // Even though lagrange_last has a single non-zero element, we cannot set its size to 0 as different
+    // keys being folded might have lagrange_last set at different indexes and folding does not work
+    // correctly unless the polynomial is allocated in the correct range to accomodate this
+    proving_key.polynomials.lagrange_last = Polynomial(
+        /* size=*/dyadic_circuit_size, /*virtual size=*/dyadic_circuit_size, /*start_index=*/0);
+}
+
+template <IsUltraFlavor Flavor> void DeciderProvingKey_<Flavor>::allocate_selectors(const Circuit& circuit)
+{
+    PROFILE_THIS_NAME("allocate_selectors");
+
+    // Define gate selectors over the block they are isolated to
+    for (auto [selector, block] :
+         zip_view(proving_key.polynomials.get_gate_selectors(), circuit.blocks.get_gate_blocks())) {
+
+        // TODO(https://github.com/AztecProtocol/barretenberg/issues/914): q_arith is currently used
+        // in aux block.
+        if (&block == &circuit.blocks.arithmetic) {
+            size_t arith_size = circuit.blocks.aux.trace_offset - circuit.blocks.arithmetic.trace_offset +
+                                circuit.blocks.aux.get_fixed_size(is_structured);
+            selector = Polynomial(arith_size, proving_key.circuit_size, circuit.blocks.arithmetic.trace_offset);
+        } else {
+            selector = Polynomial(block.get_fixed_size(is_structured), proving_key.circuit_size, block.trace_offset);
+        }
+    }
+
+    // Set the other non-gate selector polynomials (e.g. q_l, q_r, q_m etc.) to full size
+    for (auto& selector : proving_key.polynomials.get_non_gate_selectors()) {
+        selector = Polynomial(proving_key.circuit_size);
+    }
+}
+
+template <IsUltraFlavor Flavor>
+void DeciderProvingKey_<Flavor>::allocate_table_lookup_polynomials(const Circuit& circuit)
+{
+    PROFILE_THIS_NAME("allocate_table_lookup_polynomials");
+
+    const size_t max_tables_size = std::min(static_cast<size_t>(MAX_LOOKUP_TABLES_SIZE), dyadic_circuit_size - 1);
+    size_t table_offset = dyadic_circuit_size - max_tables_size;
+    ASSERT(dyadic_circuit_size > max_tables_size);
+
+    // Allocate the polynomials containing the actual table data
+    if constexpr (IsUltraFlavor<Flavor>) {
+        for (auto& poly : proving_key.polynomials.get_tables()) {
+            poly = Polynomial(max_tables_size, dyadic_circuit_size, table_offset);
+        }
+    }
+
+    // Allocate the read counts and tags polynomials
+    proving_key.polynomials.lookup_read_counts = Polynomial(max_tables_size, dyadic_circuit_size, table_offset);
+    proving_key.polynomials.lookup_read_tags = Polynomial(max_tables_size, dyadic_circuit_size, table_offset);
+    ZoneScopedN("allocating lookup and databus inverses");
+
+    // Allocate the log derivative lookup argument inverse polynomial
+    const size_t lookup_offset = static_cast<size_t>(circuit.blocks.lookup.trace_offset);
+    const size_t lookup_inverses_start = std::min(lookup_offset, table_offset);
+    const size_t lookup_inverses_end =
+        std::min(dyadic_circuit_size,
+                 std::max(lookup_offset + circuit.blocks.lookup.get_fixed_size(is_structured),
+                          table_offset + MAX_LOOKUP_TABLES_SIZE));
+    proving_key.polynomials.lookup_inverses =
+        Polynomial(lookup_inverses_end - lookup_inverses_start, dyadic_circuit_size, lookup_inverses_start);
+}
+
+template <IsUltraFlavor Flavor>
+void DeciderProvingKey_<Flavor>::allocate_ecc_op_polynomials(const Circuit& circuit)
+    requires IsMegaFlavor<Flavor>
+{
+    PROFILE_THIS_NAME("allocate_ecc_op_polynomials");
+
+    // Allocate the ecc op wires and selector
+    const size_t ecc_op_block_size = circuit.blocks.ecc_op.get_fixed_size(is_structured);
+    const size_t op_wire_offset = circuit.blocks.ecc_op.trace_offset;
+    for (auto& wire : proving_key.polynomials.get_ecc_op_wires()) {
+        wire = Polynomial(ecc_op_block_size, proving_key.circuit_size, op_wire_offset);
+    }
+    proving_key.polynomials.lagrange_ecc_op = Polynomial(ecc_op_block_size, proving_key.circuit_size, op_wire_offset);
+}
+
+template <IsUltraFlavor Flavor>
+void DeciderProvingKey_<Flavor>::allocate_databus_polynomials(const Circuit& circuit)
+    requires HasDataBus<Flavor>
+{
+    proving_key.polynomials.calldata = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.calldata_read_counts = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.calldata_read_tags = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.secondary_calldata = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.secondary_calldata_read_counts = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.secondary_calldata_read_tags = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.return_data = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.return_data_read_counts = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+    proving_key.polynomials.return_data_read_tags = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+
+    proving_key.polynomials.databus_id = Polynomial(MAX_DATABUS_SIZE, proving_key.circuit_size);
+
+    // Allocate log derivative lookup argument inverse polynomials
+    const size_t q_busread_end =
+        circuit.blocks.busread.trace_offset + circuit.blocks.busread.get_fixed_size(is_structured);
+    proving_key.polynomials.calldata_inverses =
+        Polynomial(std::max(circuit.get_calldata().size(), q_busread_end), dyadic_circuit_size);
+    proving_key.polynomials.secondary_calldata_inverses =
+        Polynomial(std::max(circuit.get_secondary_calldata().size(), q_busread_end), dyadic_circuit_size);
+    proving_key.polynomials.return_data_inverses =
+        Polynomial(std::max(circuit.get_return_data().size(), q_busread_end), dyadic_circuit_size);
+}
+
 /**
  * @brief
  * @details
@@ -39,7 +175,7 @@ template <IsUltraFlavor Flavor> size_t DeciderProvingKey_<Flavor>::compute_dyadi
  */
 template <IsUltraFlavor Flavor>
 void DeciderProvingKey_<Flavor>::construct_databus_polynomials(Circuit& circuit)
-    requires IsMegaFlavor<Flavor>
+    requires HasDataBus<Flavor>
 {
     auto& calldata_poly = proving_key.polynomials.calldata;
     auto& calldata_read_counts = proving_key.polynomials.calldata_read_counts;
@@ -51,9 +187,9 @@ void DeciderProvingKey_<Flavor>::construct_databus_polynomials(Circuit& circuit)
     auto& return_data_read_counts = proving_key.polynomials.return_data_read_counts;
     auto& return_data_read_tags = proving_key.polynomials.return_data_read_tags;
 
-    auto calldata = circuit.get_calldata();
-    auto secondary_calldata = circuit.get_secondary_calldata();
-    auto return_data = circuit.get_return_data();
+    const auto& calldata = circuit.get_calldata();
+    const auto& secondary_calldata = circuit.get_secondary_calldata();
+    const auto& return_data = circuit.get_return_data();
 
     // Note: We do not utilize a zero row for databus columns
     for (size_t idx = 0; idx < calldata.size(); ++idx) {
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		b88db67a4fa92f861329105fb732a7b1309620fe
		eb975ab28fb056cf92859377c02f2bb1a608eda3