@aztec/simulator 1.2.1 → 2.0.0-nightly.20250813

package/src/public/test_executor_metrics.ts

@@ -16,14 +16,26 @@ export interface PublicEnqueuedCallMetrics {
 }
 
 export interface PublicTxMetrics {
+  // TS simulation
   totalDurationMs: number;
   manaUsed: number;
   totalInstructionsExecuted: number;
-  txHashMs: number | undefined;
   nonRevertiblePrivateInsertionsUs: number | undefined;
   revertiblePrivateInsertionsUs: number | undefined;
   enqueuedCalls: PublicEnqueuedCallMetrics[];
   revertedCode: RevertCode | undefined;
+  // Proving
+  proverSimulationStepMs: number | undefined;
+  proverProvingStepMs: number | undefined;
+  proverTraceGenerationStepMs: number | undefined;
+  // Proving (detail)
+  traceGenerationInteractionsMs: number | undefined;
+  traceGenerationTracesMs: number | undefined;
+  provingSumcheckMs: number | undefined;
+  provingPcsMs: number | undefined;
+  provingLogDerivativeInverseMs: number | undefined;
+  provingLogDerivativeInverseCommitmentsMs: number | undefined;
+  provingWireCommitmentsMs: number | undefined;
 }
 
 const NUM_SPACES = 4;
@@ -40,6 +52,32 @@ export enum PublicTxMetricsFilter {
   TOTALS,
   DURATIONS,
   INSTRUCTIONS,
+  PROVING,
+}
+
+function createEmptyTxMetrics(): PublicTxMetrics {
+  return {
+    // TS simulation
+    totalDurationMs: 0,
+    manaUsed: 0,
+    totalInstructionsExecuted: 0,
+    nonRevertiblePrivateInsertionsUs: undefined,
+    revertiblePrivateInsertionsUs: undefined,
+    enqueuedCalls: [],
+    revertedCode: undefined,
+    // Proving
+    proverSimulationStepMs: undefined,
+    proverProvingStepMs: undefined,
+    proverTraceGenerationStepMs: undefined,
+    // Proving (detail)
+    traceGenerationInteractionsMs: undefined,
+    traceGenerationTracesMs: undefined,
+    provingSumcheckMs: undefined,
+    provingPcsMs: undefined,
+    provingLogDerivativeInverseMs: undefined,
+    provingLogDerivativeInverseCommitmentsMs: undefined,
+    provingWireCommitmentsMs: undefined,
+  };
 }
 
 export class TestExecutorMetrics implements ExecutorMetricsInterface {
@@ -56,16 +94,7 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
   startRecordingTxSimulation(txLabel: string) {
     assert(!this.currentTxLabel, 'Cannot start recording tx simulation when another is live');
     assert(!this.txMetrics.has(txLabel), 'Cannot start recording metrics for tx with duplicate label');
-    this.txMetrics.set(txLabel, {
-      totalDurationMs: 0,
-      manaUsed: 0,
-      totalInstructionsExecuted: 0,
-      txHashMs: undefined,
-      nonRevertiblePrivateInsertionsUs: undefined,
-      revertiblePrivateInsertionsUs: undefined,
-      enqueuedCalls: [],
-      revertedCode: undefined,
-    });
+    this.txMetrics.set(txLabel, createEmptyTxMetrics());
     this.currentTxLabel = txLabel;
     this.txTimer = new Timer();
   }
@@ -124,13 +153,6 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
     });
   }
 
-  recordTxHashComputation(durationMs: number) {
-    assert(this.currentTxLabel, 'Cannot record tx hash computation time when no tx is live');
-    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
-    assert(txMetrics.txHashMs === undefined, 'Cannot RE-record tx hash computation time');
-    txMetrics.txHashMs = durationMs;
-  }
-
   recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
     assert(this.currentTxLabel, 'Cannot record private effects insertion when no tx is live');
     const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
@@ -149,6 +171,18 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
     }
   }
 
+  recordProverMetrics(txLabel: string, metrics: Partial<PublicTxMetrics>) {
+    if (!this.txMetrics.has(txLabel)) {
+      this.txMetrics.set(txLabel, createEmptyTxMetrics());
+    }
+    const txMetrics = this.txMetrics.get(txLabel)!;
+    for (const [key, value] of Object.entries(metrics)) {
+      if (key in txMetrics) {
+        txMetrics[key as keyof PublicTxMetrics] = value as any;
+      }
+    }
+  }
+
   prettyPrint(filter: PublicTxMetricsFilter = PublicTxMetricsFilter.ALL) {
     this.logger.info(this.toPrettyString(filter));
   }
@@ -181,11 +215,46 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
         pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructionsExecuted)}\n`;
       }
       if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
-        pretty += `${INDENT0}Tx hash computation: ${fmtNum(txMetrics.txHashMs!, 'ms')}\n`;
         pretty += `${INDENT0}Private insertions:\n`;
         pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
         pretty += `${INDENT1}Revertible: ${fmtNum(txMetrics.revertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
       }
+      if (filter === PublicTxMetricsFilter.PROVING || filter === PublicTxMetricsFilter.ALL) {
+        let provingPretty = '';
+        if (txMetrics.proverSimulationStepMs !== undefined) {
+          provingPretty += `${INDENT1}Simulation (all): ${fmtNum(txMetrics.proverSimulationStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.proverProvingStepMs !== undefined) {
+          provingPretty += `${INDENT1}Proving (all): ${fmtNum(txMetrics.proverProvingStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.proverTraceGenerationStepMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation (all): ${fmtNum(txMetrics.proverTraceGenerationStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.traceGenerationInteractionsMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation interactions: ${fmtNum(txMetrics.traceGenerationInteractionsMs, 'ms')}\n`;
+        }
+        if (txMetrics.traceGenerationTracesMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation traces: ${fmtNum(txMetrics.traceGenerationTracesMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingSumcheckMs !== undefined) {
+          provingPretty += `${INDENT1}Sumcheck: ${fmtNum(txMetrics.provingSumcheckMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingPcsMs !== undefined) {
+          provingPretty += `${INDENT1}PCS: ${fmtNum(txMetrics.provingPcsMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingLogDerivativeInverseMs !== undefined) {
+          provingPretty += `${INDENT1}Log derivative inverse: ${fmtNum(txMetrics.provingLogDerivativeInverseMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingLogDerivativeInverseCommitmentsMs !== undefined) {
+          provingPretty += `${INDENT1}Log derivative inverse commitments: ${fmtNum(txMetrics.provingLogDerivativeInverseCommitmentsMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingWireCommitmentsMs !== undefined) {
+          provingPretty += `${INDENT1}Wire commitments: ${fmtNum(txMetrics.provingWireCommitmentsMs, 'ms')}\n`;
+        }
+        if (provingPretty.length > 0) {
+          pretty += `${INDENT0}Proving:\n${provingPretty}`;
+        }
+      }
       if (filter !== PublicTxMetricsFilter.TOTALS) {
         // totals exclude enqueued calls
         pretty += this.#enqueuedCallsToPrettyString(txMetrics, filter);
@@ -227,38 +296,95 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
   }
 
   toGithubActionBenchmarkJSON(indent = 2) {
-    const data = [];
-    for (const [txLabel, txMetrics] of this.txMetrics.entries()) {
-      data.push({
-        name: `${txLabel}/totalInstructionsExecuted`,
-        value: txMetrics.totalInstructionsExecuted,
+    const metricsInfo = {
+      totalInstructionsExecuted: {
+        name: 'totalInstructionsExecuted',
         unit: '#instructions',
-      });
-      data.push({
-        name: `${txLabel}/totalDurationMs`,
-        value: txMetrics.totalDurationMs,
+        category: PublicTxMetricsFilter.INSTRUCTIONS,
+      },
+      totalDurationMs: {
+        name: 'totalDurationMs',
         unit: 'ms',
-      });
-      data.push({
-        name: `${txLabel}/manaUsed`,
-        value: txMetrics.manaUsed,
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      manaUsed: {
+        name: 'manaUsed',
         unit: 'mana',
-      });
-      data.push({
-        name: `${txLabel}/txHashMs`,
-        value: txMetrics.txHashMs,
-        unit: 'ms',
-      });
-      data.push({
-        name: `${txLabel}/nonRevertiblePrivateInsertionsUs`,
-        value: txMetrics.nonRevertiblePrivateInsertionsUs,
+        category: PublicTxMetricsFilter.TOTALS,
+      },
+      nonRevertiblePrivateInsertionsUs: {
+        name: 'nonRevertiblePrivateInsertionsUs',
         unit: 'us',
-      });
-      data.push({
-        name: `${txLabel}/revertiblePrivateInsertionsUs`,
-        value: txMetrics.revertiblePrivateInsertionsUs,
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      revertiblePrivateInsertionsUs: {
+        name: 'revertiblePrivateInsertionsUs',
         unit: 'us',
-      });
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      proverSimulationStepMs: {
+        name: 'proverSimulationStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      proverProvingStepMs: {
+        name: 'proverProvingStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      proverTraceGenerationStepMs: {
+        name: 'proverTraceGenerationStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      traceGenerationInteractionsMs: {
+        name: 'traceGenerationInteractionsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      traceGenerationTracesMs: {
+        name: 'traceGenerationTracesMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingSumcheckMs: {
+        name: 'provingSumcheckMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingPcsMs: {
+        name: 'provingPcsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingLogDerivativeInverseMs: {
+        name: 'provingLogDerivativeInverseMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingLogDerivativeInverseCommitmentsMs: {
+        name: 'provingLogDerivativeInverseCommitmentsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingWireCommitmentsMs: {
+        name: 'provingWireCommitmentsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+    };
+
+    const data = [];
+    for (const [txLabel, txMetrics] of this.txMetrics.entries()) {
+      for (const [key, value] of Object.entries(txMetrics)) {
+        if (value !== undefined && key in metricsInfo) {
+          data.push({
+            name: `${txLabel}/${metricsInfo[key as keyof typeof metricsInfo].name}`,
+            value: value,
+            unit: metricsInfo[key as keyof typeof metricsInfo].unit,
+          });
+        }
+      }
     }
     return JSON.stringify(data, null, indent);
   }