calibration

Author: jtguibas

bin/cli/src/main.rs

@@ -23,11 +23,28 @@ use spn_node::{Node, NodeContext, SerialBidder, SerialContext, SerialMonitor, Se
 #[command(author, version, about, long_about = None)]
 enum Args {
     /// Calibrate the prover.
-    Calibrate,
+    Calibrate(CalibrateArgs),
     /// Run the prover with previously benchmarked parameters.  
     Prove(ProveArgs),
 }
 
+/// The arguments for the `calibrate` command.
+#[derive(Debug, Clone, Parser)]
+struct CalibrateArgs {
+    /// The cost per hour of the prover in USD.
+    #[arg(long, help = "Cost per hour in USD, e.g. 0.80")]
+    usd_cost_per_hour: f64,
+    /// The expected utilization rate of the prover.
+    #[arg(long, help = "Expected utilization rate, e.g. 0.5")]
+    utilization_rate: f64,
+    /// The target profit margin of the prover.
+    #[arg(long, help = "Target profit margin, e.g. 0.1")]
+    profit_margin: f64,
+    /// The price of $PROVE in USD.
+    #[arg(long, help = "Price of $PROVE in USD, e.g. 1.00")]
+    prove_price: f64,
+}
+
 /// The arguments for the `prove` command.
 #[derive(Debug, Clone, Parser)]
 struct ProveArgs {
@@ -64,7 +81,7 @@ async fn main() -> Result<()> {
 
     // Run the command.
     match cli {
-        Args::Calibrate => {
+        Args::Calibrate(args) => {
             // Create the ELF.
             const SPN_FIBONACCI_ELF: &[u8] = include_elf!("spn-fibonacci-program");
 
@@ -74,7 +91,8 @@ async fn main() -> Result<()> {
             stdin.write(&n);
 
             // Run the calibrator to get the metrics.
-            let calibrator = SinglePassCalibrator::new(SPN_FIBONACCI_ELF.to_vec(), stdin);
+            println!("Starting calibration...");
+            let calibrator = SinglePassCalibrator::new(SPN_FIBONACCI_ELF.to_vec(), stdin, args.usd_cost_per_hour, args.utilization_rate, args.profit_margin);
             let metrics =
                 calibrator.calibrate().map_err(|e| anyhow!("failed to calibrate: {}", e))?;
 
@@ -91,12 +109,28 @@ async fn main() -> Result<()> {
             // Create table data.
             let data = vec![
                 CalibrationMetricsTable {
-                    name: "Prover Throughput".to_string(),
-                    value: format!("{} gas/second", metrics.throughput),
+                    name: "Cost Per Hour".to_string(),
+                    value: format!("${}", args.usd_cost_per_hour),
+                },
+                CalibrationMetricsTable {
+                    name: "Utilization Rate".to_string(),
+                    value: format!("{}%", args.utilization_rate * 100.0),
+                },
+                CalibrationMetricsTable {
+                    name: "Profit Margin".to_string(),
+                    value: format!("{}%", args.profit_margin * 100.0),
+                },
+                CalibrationMetricsTable {
+                    name: "Price of $PROVE".to_string(),
+                    value: format!("${}", args.prove_price),
+                },
+                CalibrationMetricsTable {
+                    name: "Estimated Throughput".to_string(),
+                    value: format!("{} pgus/second", metrics.pgus_per_second),
                 },
                 CalibrationMetricsTable {
-                    name: "Recommended Bid".to_string(),
-                    value: format!("{} gas per USDC", metrics.bid_amount),
+                    name: "Estimated Bid Price".to_string(),
+                    value: format!("{} $PROVE per 1B PGUs", metrics.pgu_price * args.prove_price),
                 },
             ];
 

crates/calibrator/src/lib.rs

@@ -19,9 +19,9 @@ pub trait Calibrator {
 #[derive(Debug, Clone, Copy, Default)]
 pub struct CalibratorMetrics {
     /// The prover gas per second that the prover can process.
-    pub throughput: f64,
+    pub pgus_per_second: f64,
     /// The recommended bid amount for the prover.
-    pub bid_amount: u64,
+    pub pgu_price: f64,
 }
 
 /// The default implementation of a calibrator.
@@ -31,13 +31,25 @@ pub struct SinglePassCalibrator {
     pub elf: Vec<u8>,
     /// The input stream to use for the calibration.
     pub stdin: SP1Stdin,
+    /// The cost per hour of the instance (USD).
+    pub cost_per_hour: f64,
+    /// The expected average utilization rate of the instance.
+    pub utilization_rate: f64,
+    /// The target profit margin for the prover.
+    pub profit_margin: f64,
 }
 
 impl SinglePassCalibrator {
     /// Create a new [`SinglePassCalibrator`].
     #[must_use]
-    pub fn new(elf: Vec<u8>, stdin: SP1Stdin) -> Self {
-        Self { elf, stdin }
+    pub fn new(
+        elf: Vec<u8>,
+        stdin: SP1Stdin,
+        cost_per_hour: f64,
+        utilization_rate: f64,
+        profit_margin: f64,
+    ) -> Self {
+        Self { elf, stdin, cost_per_hour, utilization_rate, profit_margin }
     }
 }
 
@@ -67,10 +79,26 @@ impl Calibrator for SinglePassCalibrator {
 
         // Calculate duration and throughput.
         let duration = start.elapsed();
-        let throughput = prover_gas as f64 / duration.as_secs_f64();
+        let pgus_per_second = prover_gas as f64 / duration.as_secs_f64();
+
+        // Calculate the price per pgu using a simple economic model..
+        //
+        // The economic model is based on the following assumptions:
+        // - The prover has a consistent cost per hour.
+        // - The prover has a consistent utilization rate.
+        // - The prover wants to maximize its profit.
+        //
+        // The model is based on the following formula:
+        //
+        // bidPricePerPGU = (costPerHour / averageUtilizationRate) * (1 + profitMargin) / maxThroughputPerHour
+        //
+        let pgus_per_hour = pgus_per_second * 3600.0;
+        let utilized_pgus_per_hour = pgus_per_hour * self.utilization_rate;
+        let optimal_pgu_price = self.cost_per_hour / utilized_pgus_per_hour;
+        let pgu_price = optimal_pgu_price * (1.0 + self.profit_margin);
 
         // Return the metrics.
-        Ok(CalibratorMetrics { throughput, bid_amount: 1 })
+        Ok(CalibratorMetrics { pgus_per_second, pgu_price })
     }
 }
 
@@ -92,7 +120,10 @@ mod tests {
         stdin.write(&n);
 
         // Create the calibrator.
-        let calibrator = SinglePassCalibrator::new(elf, stdin);
+        let cost_per_hour = 0.1;
+        let utilization_rate = 0.5;
+        let profit_margin = 0.1;
+        let calibrator = SinglePassCalibrator::new(elf, stdin, cost_per_hour, utilization_rate, profit_margin);
 
         // Calibrate the prover.
         let metrics = calibrator.calibrate().unwrap();