chore(bb): faster-and-clearer C++ cleanups (reserve / const-ref / std::move / bulk-insert)

Author: AztecBot

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini.hpp

@@ -95,8 +95,9 @@ template <class Fr> inline std::vector<Fr> powers_of_rho(const Fr& rho, const si
  */
 template <class Fr> inline std::vector<Fr> powers_of_evaluation_challenge(const Fr& r, const size_t num_squares)
 {
-    std::vector<Fr> squares = { r };
+    std::vector<Fr> squares;
     squares.reserve(num_squares);
+    squares.emplace_back(r);
     for (size_t j = 1; j < num_squares; j++) {
         squares.emplace_back(squares[j - 1].sqr());
     }

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini_impl.hpp

@@ -183,15 +183,15 @@ std::vector<typename GeminiProver_<Curve>::Polynomial> GeminiProver_<Curve>::com
     const Fr final_eval = last.at(0) + u_last * (last.at(1) - last.at(0));
     Polynomial const_fold(1);
     const_fold.at(0) = final_eval;
-    fold_polynomials.emplace_back(const_fold);
+    fold_polynomials.emplace_back(std::move(const_fold));
 
     // FOLD_{log_n+1}, ..., FOLD_{d_v-1}
     Fr tail = Fr(1);
     for (size_t k = log_n; k < virtual_log_n - 1; ++k) {
         tail *= (Fr(1) - multilinear_challenge[k]); // multiply by (1 - u_k)
         Polynomial next_const(1);
         next_const.at(0) = final_eval * tail;
-        fold_polynomials.emplace_back(next_const);
+        fold_polynomials.emplace_back(std::move(next_const));
     }
 
     return fold_polynomials;
@@ -227,6 +227,7 @@ std::vector<typename GeminiProver_<Curve>::Claim> GeminiProver_<Curve>::construc
     const Fr& r_challenge)
 {
     std::vector<Claim> claims;
+    claims.reserve(log_n + 1);
 
     // Compute evaluation of partially evaluated batch polynomial (positive) A₀₊(r)
     Fr a_0_pos = A_0_pos.evaluate(r_challenge);

barretenberg/cpp/src/barretenberg/commitment_schemes/shplonk/shplemini.hpp

@@ -357,7 +357,9 @@ template <typename Curve, bool HasZK = false, bool HasGeminiMasking = HasZK> cla
         commitments.emplace_back(g1_identity);
         scalars.emplace_back(constant_term_accumulator);
 
-        BatchOpeningClaim<Curve> batch_opening_claim{ commitments, scalars, shplonk_evaluation_challenge };
+        BatchOpeningClaim<Curve> batch_opening_claim{ std::move(commitments),
+                                                      std::move(scalars),
+                                                      shplonk_evaluation_challenge };
         ShpleminiVerifierOutput output = [&]() {
             if constexpr (HasZK) {
                 return ShpleminiVerifierOutput{ batch_opening_claim, consistency_checked };
@@ -603,7 +605,8 @@ template <typename Curve, bool HasZK = false, bool HasGeminiMasking = HasZK> cla
                                             const std::vector<std::array<Fr, 3>>& sumcheck_round_evaluations)
     {
 
-        std::vector<Fr> denominators = {};
+        std::vector<Fr> denominators;
+        denominators.reserve(multilinear_challenge.size());
 
         // The number of Gemini claims is equal to `2 * log_n` and `log_n` is equal to the size of
         // `multilinear_challenge`, as this method is never used with padding.

barretenberg/cpp/src/barretenberg/common/map.hpp

@@ -35,31 +35,4 @@ std::array<OutElem, SIZE> map(std::array<InElem, SIZE> const& in, F&& op)
     return result;
 }
 
-/*
- * Generic map function for mapping a containers element to another type.
- * This version passes the element index as a second argument to the operator function.
- */
-template <template <typename, typename...> typename Cont,
-          typename InElem,
-          typename... Args,
-          typename F,
-          typename OutElem = typename std::invoke_result<F, InElem const&, size_t>::type>
-Cont<OutElem> mapi(Cont<InElem, Args...> const& in, F op)
-{
-    Cont<OutElem> result;
-    for (size_t i = 0; i < in.size(); ++i) {
-        result.push_back(op(in[i], i));
-    }
-    return result;
-}
-
-/*
- * Generic filter function for containers.
- */
-template <typename Cont, typename F> Cont filter(Cont const& in, F op)
-{
-    Cont copy(in);
-    std::remove_if(copy.begin(), copy.end(), op);
-    return copy;
-}
 } // namespace bb::transform

barretenberg/cpp/src/barretenberg/common/ref_vector.hpp

@@ -63,6 +63,7 @@ template <typename T> class RefVector {
     static RefVector from_span(const std::span<T>& span)
     {
         RefVector ret;
+        ret.storage.reserve(span.size());
         for (std::size_t i = 0; i < span.size(); ++i) {
             ret.push_back(span[i]);
         }
@@ -124,6 +125,7 @@ template <typename T> class RefVector {
     template <typename ConvertibleFromT> operator std::vector<ConvertibleFromT>() const
     {
         std::vector<ConvertibleFromT> ret;
+        ret.reserve(storage.size());
         for (T* elem : storage) {
             ret.push_back(*elem);
         }

barretenberg/cpp/src/barretenberg/common/serialize.hpp

@@ -448,6 +448,7 @@ template <typename T> std::vector<T> many_from_buffer(std::vector<uint8_t> const
 {
     const size_t num_elements = buffer.size() / sizeof(T);
     std::vector<T> elements;
+    elements.reserve(num_elements);
     for (size_t i = 0; i < num_elements; ++i) {
         elements.push_back(from_buffer<T>(buffer, i * sizeof(T)));
     }
@@ -462,7 +463,7 @@ template <bool include_size = false, typename T> std::vector<uint8_t> to_buffer(
     if (include_size) {
         write(buf, value);
     } else {
-        for (auto e : value) {
+        for (const auto& e : value) {
             write(buf, e);
         }
     }

barretenberg/cpp/src/barretenberg/common/thread.cpp

@@ -4,6 +4,7 @@
 #include <barretenberg/env/hardware_concurrency.hpp>
 #include <cstdlib>
 #include <string>
+#include <utility>
 
 #ifndef NO_MULTITHREADING
 #include <thread>
@@ -217,7 +218,7 @@ MultithreadData calculate_thread_data(size_t num_iterations, size_t min_iteratio
         end[thread_idx] = (thread_idx == num_threads - 1) ? num_iterations : (thread_idx + 1) * thread_size;
     }
 
-    return MultithreadData{ num_threads, start, end };
+    return MultithreadData{ num_threads, std::move(start), std::move(end) };
 }
 
 /**

barretenberg/cpp/src/barretenberg/common/utils.cpp

@@ -5,6 +5,7 @@ namespace bb::utils {
 std::vector<uint8_t> hex_to_bytes(const std::string& hex)
 {
     std::vector<uint8_t> bytes;
+    bytes.reserve(hex.length() / 2);
 
     for (unsigned int i = 0; i < hex.length(); i += 2) {
         std::string byteString = hex.substr(i, 2);

barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.cpp

@@ -22,7 +22,7 @@ namespace bb::crypto {
  */
 template <typename Curve>
 typename Curve::AffineElement pedersen_commitment_base<Curve>::commit_native(const std::vector<Fq>& inputs,
-                                                                             const GeneratorContext context)
+                                                                             const GeneratorContext& context)
 {
     const auto generators = context.generators->get(inputs.size(), context.offset, context.domain_separator);
     Element result = Group::point_at_infinity;

barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.hpp

@@ -31,7 +31,7 @@ template <typename Curve> class pedersen_commitment_base {
     using Group = typename Curve::Group;
     using GeneratorContext = typename crypto::GeneratorContext<Curve>;
 
-    static AffineElement commit_native(const std::vector<Fq>& inputs, GeneratorContext context = {});
+    static AffineElement commit_native(const std::vector<Fq>& inputs, const GeneratorContext& context = {});
 };
 
 using pedersen_commitment = pedersen_commitment_base<curve::Grumpkin>;