Add benchmark for simple transaction

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
-members = [
+members = [ 
+    "benchmarks",
     "miden-lib",
     "miden-tx",
     "mock",

Makefile.toml

@@ -94,7 +94,26 @@ description = "Build using no-std"
 command = "cargo"
 args = ["build", "--no-default-features", "--target", "wasm32-unknown-unknown", "--workspace", "--exclude", "miden-mock"]
 
-# --- utilities ----------------------------------------------------------------------------------------
+# --- benchmarking --------------------------------------------------------------------------------
+[tasks.bench-all]
+description = "Run all available transaction benchmarks"
+workspace = false
+command = "cargo"
+args = ["run", "--bin", "benchmarks", "--features", "executable", "all"]
+
+[tasks.bench-tx]
+description = "Run the transaction benchmark with default transaction script and notes"
+workspace = false
+command = "cargo"
+args = ["run", "--bin", "benchmarks", "--features", "executable", "simple"]
+
+[tasks.bench-p2id]
+description = "Run the transaction benchmark which consumes a P2ID note into a basic wallet"
+workspace = false
+command = "cargo"
+args = ["run", "--bin", "benchmarks", "--features", "executable", "p2id"]
+
+# --- utilities -----------------------------------------------------------------------------------
 [tasks.watch]
 description = "Watch for changes and rebuild"
 workspace = false

benchmarks/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "benchmarks"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+exclude.workspace = true
+
+[[bin]]
+name = "benchmarks"
+path = "src/main.rs"
+required-features = ["executable"]
+
+[features]
+default = ["std"]
+std = ["miden-lib/std", "miden-objects/std", "miden-tx/std", "vm-processor/std", "mock/std", "serde_json/std"]
+executable = ["std"]
+
+[dependencies]
+clap = { version = "4.4", features = ["derive"] }
+miden-lib = { package = "miden-lib", path = "../miden-lib", version = "0.3", default-features = false }
+miden-objects = { package = "miden-objects", path = "../objects", version = "0.3", default-features = false }
+miden-tx = { package = "miden-tx", path = "../miden-tx", version = "0.3", default-features = false }
+mock = { package = "miden-mock", path = "../mock", features = ["std"], default-features = false, optional = true}
+vm-processor = { workspace = true }
+serde_json = { package = "serde_json", version = "1.0", default-features = false, optional = true }

benchmarks/src/benchmarks.rs

@@ -0,0 +1,140 @@
+use miden_lib::notes::create_p2id_note;
+use miden_lib::transaction::ToTransactionKernelInputs;
+use miden_lib::utils::Serializable;
+use miden_objects::{
+    accounts::AccountId,
+    assembly::ProgramAst,
+    assets::{Asset, FungibleAsset},
+    crypto::dsa::rpo_falcon512::SecretKey,
+    crypto::rand::RpoRandomCoin,
+    notes::NoteType,
+    transaction::TransactionArgs,
+    Felt,
+};
+use miden_tx::{TransactionExecutor, TransactionHost};
+use vm_processor::{ExecutionOptions, RecAdviceProvider, Word};
+
+use crate::{
+    utils::{
+        get_account_with_default_account_code, write_cycles_to_json, MockDataStore, String,
+        ToString, Vec, ACCOUNT_ID_FUNGIBLE_FAUCET_ON_CHAIN,
+        ACCOUNT_ID_REGULAR_ACCOUNT_UPDATABLE_CODE_OFF_CHAIN, ACCOUNT_ID_SENDER,
+        DEFAULT_AUTH_SCRIPT,
+    },
+    Path,
+};
+
+// BENCHMARKS
+// ================================================================================================
+
+/// Runs the default transaction with empty transaction script and two default notes.
+pub fn benchmark_default_tx(path: &Path) -> Result<(), String> {
+    let data_store = MockDataStore::default();
+    let mut executor = TransactionExecutor::new(data_store.clone()).with_tracing();
+
+    let account_id = data_store.account.id();
+    executor.load_account(account_id).map_err(|e| e.to_string())?;
+
+    let block_ref = data_store.block_header.block_num();
+    let note_ids = data_store.notes.iter().map(|note| note.id()).collect::<Vec<_>>();
+
+    let transaction = executor
+        .prepare_transaction(account_id, block_ref, &note_ids, data_store.tx_args().clone())
+        .map_err(|e| e.to_string())?;
+
+    let (stack_inputs, advice_inputs) = transaction.get_kernel_inputs();
+    let advice_recorder: RecAdviceProvider = advice_inputs.into();
+    let mut host = TransactionHost::new(transaction.account().into(), advice_recorder);
+
+    vm_processor::execute(
+        transaction.program(),
+        stack_inputs,
+        &mut host,
+        ExecutionOptions::default().with_tracing(),
+    )
+    .map_err(|e| e.to_string())?;
+
+    #[cfg(feature = "std")]
+    write_cycles_to_json(path, crate::Benchmark::Simple, host.tx_progress())?;
+
+    Ok(())
+}
+
+/// Runs the transaction which consumes a P2ID note into a basic wallet.
+pub fn benchmark_p2id(path: &Path) -> Result<(), String> {
+    // Create assets
+    let faucet_id = AccountId::try_from(ACCOUNT_ID_FUNGIBLE_FAUCET_ON_CHAIN).unwrap();
+    let fungible_asset: Asset = FungibleAsset::new(faucet_id, 100).unwrap().into();
+
+    // Create sender and target account
+    let sender_account_id = AccountId::try_from(ACCOUNT_ID_SENDER).unwrap();
+
+    let target_account_id =
+        AccountId::try_from(ACCOUNT_ID_REGULAR_ACCOUNT_UPDATABLE_CODE_OFF_CHAIN).unwrap();
+    let sec_key = SecretKey::new();
+    let target_pub_key: Word = sec_key.public_key().into();
+    let mut pk_sk_bytes = sec_key.to_bytes();
+    pk_sk_bytes.append(&mut target_pub_key.to_bytes());
+    let target_sk_pk_felt: Vec<Felt> =
+        pk_sk_bytes.iter().map(|a| Felt::new(*a as u64)).collect::<Vec<Felt>>();
+    let target_account =
+        get_account_with_default_account_code(target_account_id, target_pub_key, None);
+
+    // Create the note
+    let note = create_p2id_note(
+        sender_account_id,
+        target_account_id,
+        vec![fungible_asset],
+        NoteType::Public,
+        RpoRandomCoin::new([Felt::new(1), Felt::new(2), Felt::new(3), Felt::new(4)]),
+    )
+    .unwrap();
+
+    let data_store =
+        MockDataStore::with_existing(Some(target_account.clone()), Some(vec![note.clone()]));
+
+    let mut executor = TransactionExecutor::new(data_store.clone()).with_tracing();
+    executor.load_account(target_account_id).unwrap();
+
+    let block_ref = data_store.block_header.block_num();
+    let note_ids = data_store.notes.iter().map(|note| note.id()).collect::<Vec<_>>();
+
+    let tx_script_code = ProgramAst::parse(DEFAULT_AUTH_SCRIPT).unwrap();
+
+    let tx_script_target = executor
+        .compile_tx_script(
+            tx_script_code.clone(),
+            vec![(target_pub_key, target_sk_pk_felt)],
+            vec![],
+        )
+        .unwrap();
+    let tx_args_target = TransactionArgs::with_tx_script(tx_script_target);
+
+    // execute transaction
+    let transaction = executor
+        .prepare_transaction(target_account_id, block_ref, &note_ids, tx_args_target)
+        .map_err(|e| e.to_string())?;
+
+    let (stack_inputs, advice_inputs) = transaction.get_kernel_inputs();
+    let advice_recorder: RecAdviceProvider = advice_inputs.into();
+    let mut host = TransactionHost::new(transaction.account().into(), advice_recorder);
+
+    vm_processor::execute(
+        transaction.program(),
+        stack_inputs,
+        &mut host,
+        ExecutionOptions::default().with_tracing(),
+    )
+    .map_err(|e| e.to_string())?;
+
+    #[cfg(feature = "std")]
+    write_cycles_to_json(path, crate::Benchmark::P2ID, host.tx_progress())?;
+
+    Ok(())
+}
+
+/// Runs all available benchmarks.
+pub fn benchmark_all(path: &Path) -> Result<(), String> {
+    benchmark_default_tx(path)?;
+    benchmark_p2id(path)
+}

benchmarks/src/main.rs

@@ -0,0 +1,78 @@
+use clap::Parser;
+use std::{
+    fs::{read_to_string, write, File},
+    io::Write,
+    path::Path,
+};
+
+mod benchmarks;
+use benchmarks::*;
+
+mod utils;
+
+/// Root CLI struct
+#[derive(Debug, Parser)]
+#[clap(
+    name = "Benchmark",
+    about = "Benchmark execution CLI",
+    version,
+    rename_all = "kebab-case"
+)]
+pub struct Cli {
+    #[clap(subcommand)]
+    bench_program: Benchmark,
+}
+
+/// CLI actions
+#[derive(Debug, Parser)]
+pub enum Benchmark {
+    Simple,
+    P2ID,
+    All,
+}
+
+impl core::fmt::Display for Benchmark {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Benchmark::Simple => write!(f, "simple"),
+            Benchmark::P2ID => write!(f, "p2id"),
+            Benchmark::All => write!(f, "all"),
+        }
+    }
+}
+
+/// CLI entry point
+impl Cli {
+    pub fn execute(&self) -> Result<(), String> {
+        match &self.bench_program {
+            Benchmark::Simple => {
+                let path = Path::new("benchmarks/src/results/bench_simple.json");
+                let mut file = File::create(path).map_err(|e| e.to_string())?;
+                file.write_all(b"{}").map_err(|e| e.to_string())?;
+                benchmark_default_tx(path)
+            },
+            Benchmark::P2ID => {
+                let path = Path::new("benchmarks/src/results/bench_p2id.json");
+                let mut file = File::create(path).map_err(|e| e.to_string())?;
+                file.write_all(b"{}").map_err(|e| e.to_string())?;
+                benchmark_p2id(path)
+            },
+            Benchmark::All => {
+                let path = Path::new("benchmarks/src/results/bench_all.json");
+                let mut file = File::create(path).map_err(|e| e.to_string())?;
+                file.write_all(b"{}").map_err(|e| e.to_string())?;
+                benchmark_all(path)
+            },
+        }
+    }
+}
+
+fn main() {
+    // read command-line args
+    let cli = Cli::parse();
+
+    // execute cli action
+    if let Err(error) = cli.execute() {
+        std::println!("{}", error);
+    }
+}

benchmarks/src/results/bench_all.json

@@ -0,0 +1,27 @@
+{
+  "p2id": {
+    "epilogue": 270,
+    "note_execution": [
+      {
+        "0xb9fa30eb43d80d579be02dc004338e06b5ad565e81e0bac11a94ab01abfdd40a": 881
+      }
+    ],
+    "notes_processing": 918,
+    "prologue": 2002,
+    "tx_script_processing": 88207
+  },
+  "simple": {
+    "epilogue": 2220,
+    "note_execution": [
+      {
+        "0x8a55c3531cdd5725aa805475093ed3006c6773b71a008e8ca840da8364a67cd6": 713
+      },
+      {
+        "0xae832786b774651bb0e5b71615fcf9f01427c054a8919cda6d2fd4a0c8948167": 390
+      }
+    ],
+    "notes_processing": 1149,
+    "prologue": 3642,
+    "tx_script_processing": 30
+  }
+}

benchmarks/src/results/bench_p2id.json

@@ -0,0 +1,13 @@
+{
+  "p2id": {
+    "epilogue": 270,
+    "note_execution": [
+      {
+        "0xb9fa30eb43d80d579be02dc004338e06b5ad565e81e0bac11a94ab01abfdd40a": 881
+      }
+    ],
+    "notes_processing": 918,
+    "prologue": 2002,
+    "tx_script_processing": 88207
+  }
+}

benchmarks/src/results/bench_simple.json

@@ -0,0 +1,16 @@
+{
+  "simple": {
+    "epilogue": 2220,
+    "note_execution": [
+      {
+        "0x8a55c3531cdd5725aa805475093ed3006c6773b71a008e8ca840da8364a67cd6": 713
+      },
+      {
+        "0xae832786b774651bb0e5b71615fcf9f01427c054a8919cda6d2fd4a0c8948167": 390
+      }
+    ],
+    "notes_processing": 1149,
+    "prologue": 3642,
+    "tx_script_processing": 30
+  }
+}