feat: Add gate profiler for noir circuits

barretenberg/cpp/src/barretenberg/bb/main.cpp

@@ -319,11 +319,21 @@ void gateCount(const std::string& bytecodePath, bool honk_recursion)
         auto circuit_size = acir_composer.get_total_circuit_size();
 
         // Build individual circuit report
+        std::string gates_per_opcode_str;
+        for (size_t j = 0; j < constraint_system.gates_per_opcode.size(); j++) {
+            gates_per_opcode_str += std::to_string(constraint_system.gates_per_opcode[j]);
+            if (j != constraint_system.gates_per_opcode.size() - 1) {
+                gates_per_opcode_str += ",";
+            }
+        }
+
         auto result_string = format("{\n        \"acir_opcodes\": ",
                                     constraint_system.num_acir_opcodes,
                                     ",\n        \"circuit_size\": ",
                                     circuit_size,
-                                    "\n  }");
+                                    ",\n        \"gates_per_opcode\": [",
+                                    gates_per_opcode_str,
+                                    "]\n  }");
 
         // Attach a comma if we still circuit reports to generate
         if (i != (constraint_systems.size() - 1)) {

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

@@ -24,6 +24,44 @@
 
 namespace acir_format {
 
+/**
+ * @brief Indices of the original opcode that originated each constraint in AcirFormat.
+ * @details Contains one array of indices per opcode type. The length of each array is equal to the number of
+ * constraints of that type. The relationship between the opcodes and constraints is assumed to be one to one, except
+ * for block constraints.
+ */
+struct AcirFormatOriginalOpcodeIndices {
+    std::vector<size_t> logic_constraints;
+    std::vector<size_t> range_constraints;
+    std::vector<size_t> aes128_constraints;
+    std::vector<size_t> sha256_constraints;
+    std::vector<size_t> sha256_compression;
+    std::vector<size_t> schnorr_constraints;
+    std::vector<size_t> ecdsa_k1_constraints;
+    std::vector<size_t> ecdsa_r1_constraints;
+    std::vector<size_t> blake2s_constraints;
+    std::vector<size_t> blake3_constraints;
+    std::vector<size_t> keccak_constraints;
+    std::vector<size_t> keccak_permutations;
+    std::vector<size_t> pedersen_constraints;
+    std::vector<size_t> pedersen_hash_constraints;
+    std::vector<size_t> poseidon2_constraints;
+    std::vector<size_t> multi_scalar_mul_constraints;
+    std::vector<size_t> ec_add_constraints;
+    std::vector<size_t> recursion_constraints;
+    std::vector<size_t> honk_recursion_constraints;
+    std::vector<size_t> bigint_from_le_bytes_constraints;
+    std::vector<size_t> bigint_to_le_bytes_constraints;
+    std::vector<size_t> bigint_operations;
+    std::vector<size_t> poly_triple_constraints;
+    std::vector<size_t> quad_constraints;
+    // Multiple opcode indices per block:
+    std::vector<std::vector<size_t>> block_constraints;
+
+    friend bool operator==(AcirFormatOriginalOpcodeIndices const& lhs,
+                           AcirFormatOriginalOpcodeIndices const& rhs) = default;
+};
+
 struct AcirFormat {
     // The number of witnesses in the circuit
     uint32_t varnum;
@@ -72,6 +110,13 @@ struct AcirFormat {
         quad_constraints;
     std::vector<BlockConstraint> block_constraints;
 
+    // Number of gates added to the circuit per original opcode.
+    // Has the same length as the opcode vector.
+    std::vector<size_t> gates_per_opcode = {};
+
+    // Indices of the original opcode that originated each constraint in AcirFormat.
+    AcirFormatOriginalOpcodeIndices original_opcode_indices;
+
     // For serialization, update with any new fields
     MSGPACK_FIELDS(varnum,
                    public_inputs,
@@ -142,15 +187,15 @@ struct AcirProgramStack {
 };
 
 template <typename Builder = bb::UltraCircuitBuilder>
-Builder create_circuit(const AcirFormat& constraint_system,
+Builder create_circuit(AcirFormat& constraint_system,
                        size_t size_hint = 0,
                        WitnessVector const& witness = {},
                        bool honk_recursion = false,
                        std::shared_ptr<bb::ECCOpQueue> op_queue = std::make_shared<bb::ECCOpQueue>());
 
 template <typename Builder>
 void build_constraints(Builder& builder,
-                       AcirFormat const& constraint_system,
+                       AcirFormat& constraint_system,
                        bool has_valid_witness_assignments,
                        bool honk_recursion = false); // honk_recursion means we will honk to recursively verify this
                                                      // circuit. This distinction is needed to not add the default