chore(dsl): Update backend gateCount command to query a Program in a single request

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

@@ -296,19 +296,43 @@ void prove(const std::string& bytecodePath, const std::string& witnessPath, cons
  * @brief Computes the number of Barretenberg specific gates needed to create a proof for the specific ACIR circuit
  *
  * Communication:
- * - stdout: The number of gates is written to stdout
+ * - stdout: A JSON string of the number of ACIR opcodes and final backend circuit size
  *
  * @param bytecodePath Path to the file containing the serialized circuit
  */
 void gateCount(const std::string& bytecodePath)
 {
-    auto constraint_system = get_constraint_system(bytecodePath);
-    acir_proofs::AcirComposer acir_composer(0, verbose);
-    acir_composer.create_circuit(constraint_system);
-    auto gate_count = acir_composer.get_total_circuit_size();
+    // All circuit reports will be built into the string below
+    std::string functions_string = "{\"functions\": [\n  ";
+    auto constraint_systems = get_constraint_systems(bytecodePath);
+    size_t i = 0;
+    for (auto constraint_system : constraint_systems) {
+        acir_proofs::AcirComposer acir_composer(0, verbose);
+        acir_composer.create_circuit(constraint_system);
+        auto circuit_size = acir_composer.get_total_circuit_size();
+
+        // Build individual circuit report
+        auto result_string = format("{\n        \"acir_opcodes\": ",
+                                    constraint_system.num_acir_opcodes,
+                                    ",\n        \"circuit_size\": ",
+                                    circuit_size,
+                                    "\n  }");
+
+        // Attach a comma if we still circuit reports to generate
+        if (i != (constraint_systems.size() - 1)) {
+            result_string = format(result_string, ",");
+        }
 
-    writeUint64AsRawBytesToStdout(static_cast<uint64_t>(gate_count));
-    vinfo("gate count: ", gate_count);
+        functions_string = format(functions_string, result_string);
+
+        i++;
+    }
+    functions_string = format(functions_string, "\n]}");
+
+    const char* jsonData = functions_string.c_str();
+    size_t length = strlen(jsonData);
+    std::vector<uint8_t> data(jsonData, jsonData + length);
+    writeRawBytesToStdout(data);
 }
 
 /**

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

@@ -32,6 +32,8 @@ struct AcirFormat {
     // to be able to verify SNARKs on Ethereum.
     bool recursive;
 
+    uint32_t num_acir_opcodes;
+
     std::vector<uint32_t> public_inputs;
 
     std::vector<LogicConstraint> logic_constraints;

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

@@ -477,6 +477,7 @@ AcirFormat circuit_serde_to_acir_format(Program::Circuit const& circuit)
     // `varnum` is the true number of variables, thus we add one to the index which starts at zero
     af.varnum = circuit.current_witness_index + 1;
     af.recursive = circuit.recursive;
+    af.num_acir_opcodes = static_cast<uint32_t>(circuit.opcodes.size());
     af.public_inputs = join({ map(circuit.public_parameters.value, [](auto e) { return e.value; }),
                               map(circuit.return_values.value, [](auto e) { return e.value; }) });
     std::map<uint32_t, BlockConstraint> block_id_to_block_constraint;

noir-projects/gates_report.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -eu
+
+# TODO(https://github.com/noir-lang/noir/issues/4962): This script is still yet to be integrated with noir-lang/noir-gates-diff 
+# The script needs some slight updating as `nargo info` expects a complete JSON object, while this script expects a single object field
+# representing a list of circuit reports for a program. 
+# The ACIR tests in barretenberg also expect every target bytecode to have the name `acir.gz` while this script expects the same name of the package
+echo "Compile noir-protocol-circuits for gates report..."
+cd noir-protocol-circuits
+PROTOCOL_CIRCUITS_DIR=$PWD
+
+# Compile programs into artifacts that the backend expects
+NARGO=${NARGO:-../../noir/noir-repo/target/release/nargo}
+$NARGO compile --only-acir
+
+BB_BIN=${BB_BIN:-../../barretenberg/cpp/build/bin/bb}
+
+echo "{\"programs\": [" > gates_report.json
+
+# Bound for checking where to place last parentheses 
+NUM_ARTIFACTS=$(ls -1q "$PROTOCOL_CIRCUITS_DIR/target"/*.gz | wc -l)
+
+ITER="1"
+for pathname in "$PROTOCOL_CIRCUITS_DIR/target"/*.gz; do    
+    ARTIFACT_NAME=$(basename -s .gz "$pathname")
+
+    echo "{\"package_name\": \"$ARTIFACT_NAME\"," >> gates_report.json
+    $BB_BIN gates -b "./target/$ARTIFACT_NAME.gz" >> gates_report.json
+
+    if (($ITER == $NUM_ARTIFACTS)); then
+        echo "}" >> gates_report.json
+    else 
+        echo "}, " >> gates_report.json
+    fi
+
+    ITER=$(( $ITER + 1 ))
+done
+
+echo "]}" >> gates_report.json 

noir/noir-repo/tooling/backend_interface/Cargo.toml

@@ -13,6 +13,7 @@ license.workspace = true
 acvm.workspace = true
 dirs.workspace = true
 thiserror.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 bb_abstraction_leaks.workspace = true
 tracing.workspace = true

noir/noir-repo/tooling/backend_interface/src/cli/gates.rs

@@ -1,3 +1,4 @@
+use serde::Deserialize;
 use std::path::{Path, PathBuf};
 
 use crate::BackendError;
@@ -12,8 +13,19 @@ pub(crate) struct GatesCommand {
     pub(crate) bytecode_path: PathBuf,
 }
 
+#[derive(Deserialize)]
+struct GatesResponse {
+    functions: Vec<CircuitReport>,
+}
+
+#[derive(Deserialize)]
+pub struct CircuitReport {
+    pub acir_opcodes: u32,
+    pub circuit_size: u32,
+}
+
 impl GatesCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<u32, BackendError> {
+    pub(crate) fn run(self, binary_path: &Path) -> Result<Vec<CircuitReport>, BackendError> {
         let output = std::process::Command::new(binary_path)
             .arg("gates")
             .arg("-c")
@@ -25,19 +37,11 @@ impl GatesCommand {
         if !output.status.success() {
             return Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)));
         }
-        // Note: barretenberg includes the newline, so that subsequent prints to stdout
-        // are not on the same line as the gates output.
-
-        const EXPECTED_BYTES: usize = 8;
-        let gates_bytes: [u8; EXPECTED_BYTES] =
-            output.stdout.as_slice().try_into().map_err(|_| {
-                BackendError::UnexpectedNumberOfBytes(EXPECTED_BYTES, output.stdout.clone())
-            })?;
 
-        // Convert bytes to u64 in little-endian format
-        let value = u64::from_le_bytes(gates_bytes);
+        let gates_info: GatesResponse =
+            serde_json::from_slice(&output.stdout).expect("Backend should return valid json");
 
-        Ok(value as u32)
+        Ok(gates_info.functions)
     }
 }
 
@@ -58,7 +62,9 @@ fn gate_command() -> Result<(), BackendError> {
 
     let output = gate_command.run(backend.binary_path())?;
     // Mock backend always returns zero gates.
-    assert_eq!(output, 0);
+    assert_eq!(output.len(), 1);
+    assert_eq!(output[0].acir_opcodes, 0);
+    assert_eq!(output[0].circuit_size, 0);
 
     Ok(())
 }

noir/noir-repo/tooling/backend_interface/src/cli/mod.rs

@@ -18,6 +18,8 @@ pub(crate) use version::VersionCommand;
 pub(crate) use vk_as_fields::VkAsFieldsCommand;
 pub(crate) use write_vk::WriteVkCommand;
 
+pub(crate) use gates::CircuitReport;
+
 #[test]
 fn no_command_provided_works() -> Result<(), crate::BackendError> {
     // This is a simple test to check that the binaries work

noir/noir-repo/tooling/backend_interface/src/proof_system.rs

@@ -11,13 +11,16 @@ use tempfile::tempdir;
 use tracing::warn;
 
 use crate::cli::{
-    GatesCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand, VkAsFieldsCommand,
-    WriteVkCommand,
+    CircuitReport, GatesCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand,
+    VkAsFieldsCommand, WriteVkCommand,
 };
 use crate::{Backend, BackendError};
 
 impl Backend {
-    pub fn get_exact_circuit_size(&self, program: &Program) -> Result<u32, BackendError> {
+    pub fn get_exact_circuit_sizes(
+        &self,
+        program: &Program,
+    ) -> Result<Vec<CircuitReport>, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
 

noir/noir-repo/tooling/nargo_cli/src/cli/info_cmd.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use acvm::acir::circuit::{ExpressionWidth, Program};
+use acvm::acir::circuit::ExpressionWidth;
 use backend_interface::BackendError;
 use clap::Args;
 use iter_extended::vecmap;
@@ -287,24 +287,25 @@ impl From<ContractInfo> for Vec<Row> {
 
 fn count_opcodes_and_gates_in_program(
     backend: &Backend,
-    compiled_program: CompiledProgram,
+    mut compiled_program: CompiledProgram,
     package: &Package,
     expression_width: ExpressionWidth,
 ) -> Result<ProgramInfo, CliError> {
+    // Unconstrained functions do not matter to a backend circuit count so we clear them
+    // before sending a serialized program to the backend
+    compiled_program.program.unconstrained_functions.clear();
+
+    let program_circuit_sizes = backend.get_exact_circuit_sizes(&compiled_program.program)?;
     let functions = compiled_program
         .program
         .functions
         .into_par_iter()
         .enumerate()
-        .map(|(i, function)| -> Result<_, BackendError> {
+        .map(|(i, _)| -> Result<_, BackendError> {
             Ok(FunctionInfo {
                 name: compiled_program.names[i].clone(),
-                acir_opcodes: function.opcodes.len(),
-                // Unconstrained functions do not matter to a backend circuit count so we pass nothing here
-                circuit_size: backend.get_exact_circuit_size(&Program {
-                    functions: vec![function],
-                    unconstrained_functions: Vec::new(),
-                })?,
+                acir_opcodes: program_circuit_sizes[i].acir_opcodes as usize,
+                circuit_size: program_circuit_sizes[i].circuit_size,
             })
         })
         .collect::<Result<_, _>>()?;
@@ -325,7 +326,7 @@ fn count_opcodes_and_gates_in_contract(
                 name: function.name,
                 // TODO(https://github.com/noir-lang/noir/issues/4720)
                 acir_opcodes: function.bytecode.functions[0].opcodes.len(),
-                circuit_size: backend.get_exact_circuit_size(&function.bytecode)?,
+                circuit_size: backend.get_exact_circuit_sizes(&function.bytecode)?[0].circuit_size,
             })
         })
         .collect::<Result<_, _>>()?;