feat(tools): add cli to measure decorator size in masp package

Author: mooori

Cargo.lock

@@ -0,0 +1,20 @@
+[package]
+name = "objsize"
+description = "Inspect Miden package MAST forest sizes"
+version.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+categories.workspace = true
+keywords.workspace = true
+license.workspace = true
+readme.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+clap.workspace = true
+miden-core.workspace = true
+miden-mast-package.workspace = true

tools/objsize/Cargo.toml

@@ -0,0 +1,230 @@
+use std::{fs, path::PathBuf};
+
+use anyhow::{Context, Result};
+use clap::Args;
+use miden_core::{
+    mast::MastForest,
+    utils::{Deserializable, Serializable},
+};
+use miden_mast_package::{MastArtifact, Package, PackageKind};
+
+#[derive(Debug, Clone, Args)]
+pub struct DecoratorsCommand {
+    /// Path to the input .masp file
+    pub path: PathBuf,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum ArtifactKind {
+    Program,
+    Library,
+}
+
+impl ArtifactKind {
+    fn from_mast_artifact(mast: &MastArtifact) -> Self {
+        match mast {
+            MastArtifact::Executable(_) => ArtifactKind::Program,
+            MastArtifact::Library(_) => ArtifactKind::Library,
+        }
+    }
+}
+
+impl std::fmt::Display for ArtifactKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Program => write!(f, "program"),
+            Self::Library => write!(f, "library"),
+        }
+    }
+}
+
+pub fn run(command: DecoratorsCommand) -> Result<()> {
+    let input_bytes = fs::read(&command.path)
+        .with_context(|| format!("failed to read input file '{}'", command.path.display()))?;
+    let masp_size = input_bytes.len();
+
+    let package = Package::read_from_bytes(&input_bytes)
+        .with_context(|| format!("failed to decode package '{}'", command.path.display()))?;
+
+    let original_forest = package.mast.mast_forest().clone();
+    let original_forest_size = forest_size(&original_forest);
+
+    let mut stripped_forest = original_forest.clone();
+    stripped_forest.strip_decorators();
+
+    let mut compacted_forest = original_forest.clone();
+    compacted_forest.strip_decorators();
+    compacted_forest.compact();
+
+    let report = Report {
+        input: command.path.display().to_string(),
+        package_kind: package.kind,
+        artifact_kind: ArtifactKind::from_mast_artifact(&package.mast),
+        metric_points: vec![
+            MetricPoint::reference("original masp", masp_size),
+            MetricPoint::baseline("original forest", original_forest_size),
+            MetricPoint::delta(
+                "without decorators",
+                forest_size(&stripped_forest),
+                original_forest_size,
+            ),
+            MetricPoint::delta(
+                "compacted forest",
+                forest_size(&compacted_forest),
+                original_forest_size,
+            ),
+        ],
+    };
+
+    println!("{report}");
+
+    Ok(())
+}
+
+fn forest_size(forest: &MastForest) -> usize {
+    forest.to_bytes().len()
+}
+
+fn bytes_to_kb(bytes: usize) -> f64 {
+    bytes as f64 / 1024.0
+}
+
+#[derive(Debug, Clone)]
+struct Report {
+    input: String,
+    package_kind: PackageKind,
+    artifact_kind: ArtifactKind,
+    metric_points: Vec<MetricPoint>,
+}
+
+#[derive(Debug, Clone)]
+struct MetricPoint {
+    label: &'static str,
+    bytes: usize,
+    delta: Option<i64>,
+    delta_percent: Option<f64>,
+}
+
+impl MetricPoint {
+    fn reference(label: &'static str, bytes: usize) -> Self {
+        Self {
+            label,
+            bytes,
+            delta: None,
+            delta_percent: None,
+        }
+    }
+
+    fn baseline(label: &'static str, bytes: usize) -> Self {
+        Self {
+            label,
+            bytes,
+            delta: Some(0),
+            delta_percent: Some(0.0),
+        }
+    }
+
+    fn delta(label: &'static str, bytes: usize, baseline: usize) -> Self {
+        let delta = i64::try_from(bytes - baseline).unwrap();
+        let delta_percent = if baseline == 0 {
+            0.0
+        } else {
+            (delta as f64 / baseline as f64) * 100.0
+        };
+
+        Self {
+            label,
+            bytes,
+            delta: Some(delta),
+            delta_percent: Some(delta_percent),
+        }
+    }
+}
+
+fn format_delta(row: &MetricPoint) -> String {
+    match row.delta {
+        Some(delta) => {
+            let delta_kb = delta as f64 / 1024.0;
+            if delta_kb.abs() < 0.01 {
+                "0.00".to_string()
+            } else if delta_kb > 0.0 {
+                format!("+{delta_kb:.2}")
+            } else {
+                format!("{delta_kb:.2}")
+            }
+        }
+        None => "-".to_string(),
+    }
+}
+
+fn format_delta_percent(row: &MetricPoint) -> String {
+    match row.delta_percent {
+        Some(percent) => format!("{percent:+.2}%"),
+        None => "-".to_string(),
+    }
+}
+
+impl std::fmt::Display for Report {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Input: {}", self.input)?;
+        writeln!(f, "Package kind: {}", self.package_kind)?;
+        writeln!(f, "Artifact: {}", self.artifact_kind)?;
+        writeln!(f)?;
+
+        let kb_strings: Vec<String> = self
+            .metric_points
+            .iter()
+            .map(|row| format!("{:.2}", bytes_to_kb(row.bytes)))
+            .collect();
+        let delta_strings: Vec<String> = self.metric_points.iter().map(format_delta).collect();
+        let delta_percent_strings: Vec<String> =
+            self.metric_points.iter().map(format_delta_percent).collect();
+
+        let metric_width = self
+            .metric_points
+            .iter()
+            .map(|row| row.label.len())
+            .chain(std::iter::once("Metric".len()))
+            .max()
+            .unwrap_or("Metric".len());
+        let kb_width = kb_strings
+            .iter()
+            .map(String::len)
+            .chain(std::iter::once("KB".len()))
+            .max()
+            .unwrap_or("KB".len());
+        let delta_width = delta_strings
+            .iter()
+            .map(String::len)
+            .chain(std::iter::once("Delta".len()))
+            .max()
+            .unwrap_or("Delta".len());
+        let delta_percent_width = delta_percent_strings
+            .iter()
+            .map(String::len)
+            .chain(std::iter::once("Delta %".len()))
+            .max()
+            .unwrap_or("Delta %".len());
+
+        writeln!(
+            f,
+            "{:<metric_width$}  {:>kb_width$}  {:>delta_width$}  {:>delta_percent_width$}",
+            "Metric", "KB", "Delta", "Delta %",
+        )?;
+
+        for ((row, kb), (delta, delta_percent)) in self
+            .metric_points
+            .iter()
+            .zip(kb_strings.iter())
+            .zip(delta_strings.iter().zip(delta_percent_strings.iter()))
+        {
+            writeln!(
+                f,
+                "{:<metric_width$}  {:>kb_width$}  {:>delta_width$}  {:>delta_percent_width$}",
+                row.label, kb, delta, delta_percent,
+            )?;
+        }
+
+        Ok(())
+    }
+}

tools/objsize/src/decorators.rs

@@ -0,0 +1,32 @@
+mod decorators;
+
+use anyhow::Result;
+use clap::{Parser, Subcommand};
+
+#[derive(Debug, Parser)]
+#[command(
+    name = "objsize",
+    bin_name = "objsize",
+    version,
+    about = "Inspect Miden compilation artifact sizes",
+    long_about = None,
+    arg_required_else_help = true,
+)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Debug, Subcommand)]
+enum Commands {
+    /// Compare serialized MAST forest sizes after stripping decorators.
+    Decorators(decorators::DecoratorsCommand),
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Decorators(command) => decorators::run(command),
+    }
+}