feat: Use structured polys to reduce prover memory

barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp

@@ -55,12 +55,61 @@ template <class Flavor>
 typename ExecutionTrace_<Flavor>::TraceData ExecutionTrace_<Flavor>::construct_trace_data(
     Builder& builder, typename Flavor::ProvingKey& proving_key, bool is_structured)
 {
-    ZoneScopedN("construct_trace_data");
-    TraceData trace_data{ builder, proving_key };
-
     // Complete the public inputs execution trace block from builder.public_inputs
     populate_public_inputs_block(builder);
 
+    ZoneScopedN("construct_trace_data");
+    // Allocate the wires and selectors polynomials
+    if constexpr (IsHonkFlavor<Flavor>) {
+        for (auto& wire : proving_key.polynomials.get_wires()) {
+            wire = Polynomial::shiftable(proving_key.circuit_size);
+        }
+        // Define selectors over the block they are isolated to
+        uint32_t offset = Flavor::has_zero_row ? 1 : 0;
+        if constexpr (IsGoblinFlavor<Flavor>) {
+            offset += builder.blocks.ecc_op.get_fixed_size(is_structured);
+        }
+        offset += builder.blocks.pub_inputs.get_fixed_size(is_structured);
+
+        proving_key.polynomials.q_arith =
+            Polynomial(proving_key.circuit_size - offset, proving_key.circuit_size, offset);
+        offset += builder.blocks.arithmetic.get_fixed_size(is_structured);
+
+        proving_key.polynomials.q_delta_range =
+            Polynomial(builder.blocks.delta_range.size(), proving_key.circuit_size, offset);
+        offset += builder.blocks.delta_range.get_fixed_size(is_structured);
+
+        proving_key.polynomials.q_elliptic =
+            Polynomial(builder.blocks.elliptic.size(), proving_key.circuit_size, offset);
+        offset += builder.blocks.elliptic.get_fixed_size(is_structured);
+
+        proving_key.polynomials.q_aux = Polynomial(builder.blocks.aux.size(), proving_key.circuit_size, offset);
+        offset += builder.blocks.aux.get_fixed_size(is_structured);
+
+        proving_key.polynomials.q_lookup = Polynomial(builder.blocks.lookup.size(), proving_key.circuit_size, offset);
+        offset += builder.blocks.lookup.get_fixed_size(is_structured);
+
+        if constexpr (HasDataBus<Flavor>) {
+            proving_key.polynomials.q_busread =
+                Polynomial(builder.blocks.busread.size(), proving_key.circuit_size, offset);
+            offset += builder.blocks.busread.get_fixed_size(is_structured);
+        }
+
+        proving_key.polynomials.q_poseidon2_external =
+            Polynomial(builder.blocks.poseidon2_external.size(), proving_key.circuit_size, offset);
+
+        offset += builder.blocks.poseidon2_external.get_fixed_size(is_structured);
+        proving_key.polynomials.q_poseidon2_internal =
+            Polynomial(builder.blocks.poseidon2_internal.size(), proving_key.circuit_size, offset);
+        offset += builder.blocks.poseidon2_internal.get_fixed_size(is_structured);
+        // Set the other selector polynomials to full size
+        for (auto& selector : proving_key.polynomials.get_non_gate_selectors()) {
+            selector = Polynomial(proving_key.circuit_size);
+        }
+    }
+
+    TraceData trace_data{ builder, proving_key };
+
     uint32_t offset = Flavor::has_zero_row ? 1 : 0; // Offset at which to place each block in the trace polynomials
     // For each block in the trace, populate wire polys, copy cycles and selector polys
 
@@ -134,12 +183,20 @@ void ExecutionTrace_<Flavor>::add_ecc_op_wires_to_proving_key(Builder& builder,
                                                               typename Flavor::ProvingKey& proving_key)
     requires IsGoblinFlavor<Flavor>
 {
-    // Copy the ecc op data from the conventional wires into the op wires over the range of ecc op gates
     auto& ecc_op_selector = proving_key.polynomials.lagrange_ecc_op;
     const size_t op_wire_offset = Flavor::has_zero_row ? 1 : 0;
+    // Allocate the ecc op wires and selector
+    const size_t num_ecc_ops = builder.blocks.ecc_op.size();
+    if constexpr (IsHonkFlavor<Flavor>) {
+        for (auto& wire : proving_key.polynomials.get_ecc_op_wires()) {
+            wire = Polynomial(num_ecc_ops, proving_key.circuit_size, op_wire_offset);
+        }
+        ecc_op_selector = Polynomial(num_ecc_ops, proving_key.circuit_size, op_wire_offset);
+    }
+    // Copy the ecc op data from the conventional wires into the op wires over the range of ecc op gates
     for (auto [ecc_op_wire, wire] :
          zip_view(proving_key.polynomials.get_ecc_op_wires(), proving_key.polynomials.get_wires())) {
-        for (size_t i = 0; i < builder.blocks.ecc_op.size(); ++i) {
+        for (size_t i = 0; i < num_ecc_ops; ++i) {
             size_t idx = i + op_wire_offset;
             ecc_op_wire.at(idx) = wire[idx];
             ecc_op_selector.at(idx) = 1; // construct selector as the indicator on the ecc op block

barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp

@@ -37,7 +37,6 @@ template <class Flavor> class ExecutionTrace_ {
                 for (auto [selector, other_selector] : zip_view(selectors, proving_key.polynomials.get_selectors())) {
                     selector = other_selector.share();
                 }
-                proving_key.polynomials.set_shifted(); // Ensure shifted wires are set correctly
             } else {
                 // Initialize and share the wire and selector polynomials
                 for (size_t idx = 0; idx < NUM_WIRES; ++idx) {

barretenberg/cpp/src/barretenberg/flavor/flavor.hpp

@@ -374,6 +374,9 @@ concept IsGoblinFlavor = IsAnyOf<T, MegaFlavor,
                                     MegaRecursiveFlavor_<UltraCircuitBuilder>,
                                     MegaRecursiveFlavor_<MegaCircuitBuilder>, MegaRecursiveFlavor_<CircuitSimulatorBN254>>;
 
+template <typename T>
+concept HasDataBus = IsGoblinFlavor<T>;
+
 template <typename T>
 concept IsRecursiveFlavor = IsAnyOf<T, UltraRecursiveFlavor_<UltraCircuitBuilder>,
                                        UltraRecursiveFlavor_<MegaCircuitBuilder>,

barretenberg/cpp/src/barretenberg/flavor/flavor.test.cpp

@@ -17,7 +17,7 @@ TEST(Flavor, Getters)
     // set
     size_t coset_idx = 0;
     for (auto& id_poly : proving_key.polynomials.get_ids()) {
-        typename Flavor::Polynomial new_poly(proving_key.circuit_size);
+        id_poly = typename Flavor::Polynomial(proving_key.circuit_size);
         for (size_t i = 0; i < proving_key.circuit_size; ++i) {
             id_poly.at(i) = coset_idx * proving_key.circuit_size + i;
         }

barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp

@@ -68,8 +68,6 @@ template <typename FF, size_t NUM_WIRES, size_t NUM_SELECTORS> class ExecutionTr
     bool has_ram_rom = false;   // does the block contain RAM/ROM gates
     bool is_pub_inputs = false; // is this the public inputs block
 
-    uint32_t fixed_size = 0; // Fixed size for use in structured trace
-
     bool operator==(const ExecutionTraceBlock& other) const = default;
 
     size_t size() const { return std::get<0>(this->wires).size(); }
@@ -104,6 +102,8 @@ template <typename FF, size_t NUM_WIRES, size_t NUM_SELECTORS> class ExecutionTr
         }
     }
 #endif
+  private:
+    uint32_t fixed_size = 0; // Fixed size for use in structured trace
 };
 
 } // namespace bb

barretenberg/cpp/src/barretenberg/plonk_honk_shared/composer/composer_lib.hpp

@@ -11,8 +11,8 @@ namespace bb {
 template <typename Flavor>
 void construct_lookup_table_polynomials(const RefArray<typename Flavor::Polynomial, 4>& table_polynomials,
                                         const typename Flavor::CircuitBuilder& circuit,
-                                        size_t dyadic_circuit_size,
-                                        size_t additional_offset = 0)
+                                        const size_t dyadic_circuit_size,
+                                        const size_t additional_offset = 0)
 {
     // Create lookup selector polynomials which interpolate each table column.
     // Our selector polys always need to interpolate the full subgroup size, so here we offset so as to
@@ -22,8 +22,16 @@ void construct_lookup_table_polynomials(const RefArray<typename Flavor::Polynomi
     //  |          table     randomness
     //  ignored, as used for regular constraints and padding to the next power of 2.
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1033): construct tables and counts at top of trace
-    ASSERT(dyadic_circuit_size > circuit.get_tables_size() + additional_offset);
-    size_t offset = dyadic_circuit_size - circuit.get_tables_size() - additional_offset;
+    const size_t tables_size = circuit.get_tables_size();
+    ASSERT(dyadic_circuit_size > tables_size + additional_offset);
+    size_t offset = dyadic_circuit_size - tables_size - additional_offset;
+
+    // Allocate the table polynomials
+    if constexpr (IsHonkFlavor<Flavor>) {
+        for (auto& poly : table_polynomials) {
+            poly = typename Flavor::Polynomial(tables_size, dyadic_circuit_size, offset);
+        }
+    }
 
     for (const auto& table : circuit.lookup_tables) {
         const fr table_index(table.table_index);
@@ -49,12 +57,17 @@ template <typename Flavor>
 void construct_lookup_read_counts(typename Flavor::Polynomial& read_counts,
                                   typename Flavor::Polynomial& read_tags,
                                   typename Flavor::CircuitBuilder& circuit,
-                                  size_t dyadic_circuit_size)
+                                  const size_t dyadic_circuit_size)
 {
+    const size_t tables_size = circuit.get_tables_size();
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1033): construct tables and counts at top of trace
-    size_t offset = dyadic_circuit_size - circuit.get_tables_size();
+    size_t table_offset = dyadic_circuit_size - tables_size;
+    // Allocate the read counts and tags polynomials
+    if constexpr (IsHonkFlavor<Flavor>) {
+        read_counts = typename Flavor::Polynomial(tables_size, dyadic_circuit_size, table_offset);
+        read_tags = typename Flavor::Polynomial(tables_size, dyadic_circuit_size, table_offset);
+    }
 
-    size_t table_offset = offset; // offset of the present table in the table polynomials
     // loop over all tables used in the circuit; each table contains data about the lookups made on it
     for (auto& table : circuit.lookup_tables) {
         table.initialize_index_map();

barretenberg/cpp/src/barretenberg/plonk_honk_shared/composer/permutation_lib.hpp

@@ -384,6 +384,13 @@ void compute_permutation_argument_polynomials(const typename Flavor::CircuitBuil
             compute_monomial_and_coset_fft_polynomials_from_lagrange<Flavor::NUM_WIRES>("id", key);
         }
     } else if constexpr (IsUltraFlavor<Flavor>) { // any UltraHonk flavor
+        // Allocate sigma and id polynomials
+        for (auto& sigma : key->polynomials.get_sigmas()) {
+            sigma = typename Flavor::Polynomial(key->circuit_size);
+        }
+        for (auto& id : key->polynomials.get_ids()) {
+            id = typename Flavor::Polynomial(key->circuit_size);
+        }
         // Compute Honk-style sigma and ID polynomials from the corresponding mappings
         {
             ZoneScopedN("compute_honk_style_permutation_lagrange_polynomials_from_mapping");

barretenberg/cpp/src/barretenberg/polynomials/polynomial.cpp

@@ -47,6 +47,7 @@ SharedShiftedVirtualZeroesArray<Fr> _clone(const SharedShiftedVirtualZeroesArray
 template <typename Fr>
 void Polynomial<Fr>::allocate_backing_memory(size_t size, size_t virtual_size, size_t start_index)
 {
+    ASSERT(start_index + size <= virtual_size);
     coefficients_ = SharedShiftedVirtualZeroesArray<Fr>{
         start_index,        /* start index, used for shifted polynomials and offset 'islands' of non-zeroes */
         size + start_index, /* end index, actual memory used is (end - start) */
@@ -158,8 +159,9 @@ template <typename Fr> bool Polynomial<Fr>::operator==(Polynomial const& rhs) co
 template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator+=(PolynomialSpan<const Fr> other)
 {
     // Compute the subset that is defined in both polynomials
-    ASSERT(start_index() <= other.start_index);
-    ASSERT(end_index() >= other.end_index());
+    if (other.start_index < start_index() || other.end_index() > end_index()) {
+        *this = expand(std::min(start_index(), other.start_index), std::max(end_index(), other.end_index()));
+    }
     size_t num_threads = calculate_num_threads(other.size());
     size_t range_per_thread = other.size() / num_threads;
     size_t leftovers = other.size() - (range_per_thread * num_threads);
@@ -287,14 +289,15 @@ Fr Polynomial<Fr>::compute_barycentric_evaluation(const Fr& z, const EvaluationD
 template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator-=(PolynomialSpan<const Fr> other)
 {
     // Compute the subset that is defined in both polynomials
-    ASSERT(start_index() <= other.start_index);
-    ASSERT(end_index() >= other.end_index());
-    size_t num_threads = calculate_num_threads(other.size());
-    size_t range_per_thread = other.size() / num_threads;
-    size_t leftovers = other.size() - (range_per_thread * num_threads);
+    if (other.start_index < start_index() || other.end_index() > end_index()) {
+        *this = expand(std::min(start_index(), other.start_index), std::max(end_index(), other.end_index()));
+    }
+    const size_t num_threads = calculate_num_threads(other.size());
+    const size_t range_per_thread = other.size() / num_threads;
+    const size_t leftovers = other.size() - (range_per_thread * num_threads);
     parallel_for(num_threads, [&](size_t j) {
-        size_t offset = j * range_per_thread + other.start_index;
-        size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
+        const size_t offset = j * range_per_thread + other.start_index;
+        const size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
         for (size_t i = offset; i < end; ++i) {
             at(i) -= other[i];
         }
@@ -304,12 +307,12 @@ template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator-=(PolynomialSpan
 
 template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator*=(const Fr scaling_factor)
 {
-    size_t num_threads = calculate_num_threads(size());
-    size_t range_per_thread = size() / num_threads;
-    size_t leftovers = size() - (range_per_thread * num_threads);
+    const size_t num_threads = calculate_num_threads(size());
+    const size_t range_per_thread = size() / num_threads;
+    const size_t leftovers = size() - (range_per_thread * num_threads);
     parallel_for(num_threads, [&](size_t j) {
-        size_t offset = j * range_per_thread;
-        size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
+        const size_t offset = j * range_per_thread;
+        const size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
         for (size_t i = offset; i < end; ++i) {
             data()[i] *= scaling_factor;
         }
@@ -318,24 +321,38 @@ template <typename Fr> Polynomial<Fr>& Polynomial<Fr>::operator*=(const Fr scali
     return *this;
 }
 
-template <typename Fr> Polynomial<Fr> Polynomial<Fr>::full() const
+template <typename Fr>
+Polynomial<Fr> Polynomial<Fr>::expand(const size_t new_start_index, const size_t new_end_index) const
 {
+    ASSERT(new_end_index <= virtual_size());
+    ASSERT(new_start_index <= start_index());
+    ASSERT(new_end_index >= end_index());
+    if (new_start_index == start_index() && new_end_index == end_index()) {
+        return *this;
+    }
     Polynomial result = *this;
-    // Make 0..virtual_size usable
-    result.coefficients_ = _clone(coefficients_, virtual_size() - end_index(), start_index());
+    // Make new_start_index..new_end_index usable
+    result.coefficients_ = _clone(coefficients_, new_end_index - end_index(), start_index() - new_start_index);
     return result;
 }
+
+template <typename Fr> Polynomial<Fr> Polynomial<Fr>::full() const
+{
+    // Make 0..virtual_size usable
+    return expand(0, virtual_size());
+}
 template <typename Fr> void Polynomial<Fr>::add_scaled(PolynomialSpan<const Fr> other, Fr scaling_factor) &
 {
     // Compute the subset that is defined in both polynomials
-    ASSERT(start_index() <= other.start_index);
-    ASSERT(end_index() >= other.end_index());
-    size_t num_threads = calculate_num_threads(other.size());
-    size_t range_per_thread = other.size() / num_threads;
-    size_t leftovers = other.size() - (range_per_thread * num_threads);
+    if (other.start_index < start_index() || other.end_index() > end_index()) {
+        *this = expand(std::min(start_index(), other.start_index), std::max(end_index(), other.end_index()));
+    }
+    const size_t num_threads = calculate_num_threads(other.size());
+    const size_t range_per_thread = other.size() / num_threads;
+    const size_t leftovers = other.size() - (range_per_thread * num_threads);
     parallel_for(num_threads, [&](size_t j) {
-        size_t offset = j * range_per_thread + other.start_index;
-        size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
+        const size_t offset = j * range_per_thread + other.start_index;
+        const size_t end = (j == num_threads - 1) ? offset + range_per_thread + leftovers : offset + range_per_thread;
         for (size_t i = offset; i < end; ++i) {
             at(i) += scaling_factor * other[i];
         }

barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp

@@ -254,6 +254,14 @@ template <typename Fr> class Polynomial {
         return p;
     }
 
+    /**
+     * @brief Expands the polynomial with new start_index and end_index
+     * The value of the polynomial remains the same, but defined memory region differs.
+     *
+     * @return a polynomial with a larger size() but same virtual_size()
+     */
+    Polynomial expand(const size_t new_start_index, const size_t new_end_index) const;
+
     /**
      * @brief Copys the polynomial, but with the whole address space usable.
      * The value of the polynomial remains the same, but defined memory region differs.