use bincode for faster writing prover input info (#2074)

Added another flag to allow fast serialization of 'prover_input_info'
into a binary file

Author: Stavbe

cairo-vm-cli/src/main.rs

@@ -69,9 +69,10 @@ struct Args {
         conflicts_with_all = ["proof_mode", "air_private_input", "air_public_input"]
     )]
     cairo_pie_output: Option<String>,
-    #[arg(long = "prover_input_info",
-    requires_all = ["proof_mode"])]
+    #[arg(long = "prover_input_info", requires_all = ["proof_mode"])]
     prover_input_info: Option<String>,
+    #[arg(long = "prover_input_info_json", requires_all = ["proof_mode"])]
+    prover_input_info_json: Option<String>,
     #[arg(long = "merge_extra_segments")]
     merge_extra_segments: bool,
     #[arg(long = "allow_missing_builtins")]
@@ -175,7 +176,8 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
 
     let trace_enabled = args.trace_file.is_some()
         || args.air_public_input.is_some()
-        || args.prover_input_info.is_some();
+        || args.prover_input_info.is_some()
+        || args.prover_input_info_json.is_some();
 
     let cairo_layout_params = match args.cairo_layout_params_file {
         Some(file) => Some(CairoLayoutParams::from_file(&file)?),
@@ -191,7 +193,8 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         secure_run: args.secure_run,
         allow_missing_builtins: args.allow_missing_builtins,
         dynamic_layout_params: cairo_layout_params,
-        disable_trace_padding: args.prover_input_info.is_some(),
+        disable_trace_padding: args.prover_input_info.is_some()
+            || args.prover_input_info_json.is_some(),
     };
 
     let mut cairo_runner = match if args.run_from_cairo_pie {
@@ -242,13 +245,22 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         memory_writer.flush()?;
     }
 
-    if let Some(prover_input_info_path) = args.prover_input_info {
+    if let Some(path) = args.prover_input_info {
+        let prover_input_info = cairo_runner.get_prover_input_info().map_err(|error| {
+            eprintln!("{error}");
+            CairoRunError::Runner(error)
+        })?;
+        let bytes = prover_input_info.serialize()?;
+        std::fs::write(path, bytes)?;
+    }
+
+    if let Some(path) = args.prover_input_info_json {
         let prover_input_info = cairo_runner.get_prover_input_info().map_err(|error| {
             eprintln!("{error}");
             CairoRunError::Runner(error)
         })?;
         let json = prover_input_info.serialize_json()?;
-        std::fs::write(prover_input_info_path, json)?;
+        std::fs::write(path, json)?;
     }
 
     if let Some(file_path) = args.air_public_input {

vm/Cargo.toml

@@ -47,7 +47,7 @@ num-integer = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 hex = { workspace = true }
-bincode = { workspace = true }
+bincode = { workspace = true , features = ["alloc"]}
 starknet-crypto = { workspace = true }
 sha3 = { workspace = true }
 indoc = { workspace = true }

vm/src/vm/runners/cairo_runner.rs

@@ -1551,7 +1551,7 @@ impl CairoRunner {
 //* ----------------------
 /// This struct contains all relevant data for the prover.
 /// All addresses are relocatable.
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, PartialEq)]
 pub struct ProverInputInfo {
     /// A vector of trace entries, i.e. pc, ap, fp, where pc is relocatable.
     pub relocatable_trace: Vec<TraceEntry>,
@@ -1567,13 +1567,19 @@ impl ProverInputInfo {
     pub fn serialize_json(&self) -> Result<String, ProverInputInfoError> {
         serde_json::to_string_pretty(&self).map_err(ProverInputInfoError::from)
     }
+    pub fn serialize(&self) -> Result<Vec<u8>, ProverInputInfoError> {
+        bincode::serde::encode_to_vec(self, bincode::config::standard())
+            .map_err(ProverInputInfoError::from)
+    }
 }
 
 // TODO(Stav): add TraceNotEnabled error.
 #[derive(Debug, Error)]
 pub enum ProverInputInfoError {
-    #[error("Failed to (de)serialize data")]
-    Serde(#[from] serde_json::Error),
+    #[error("Failed to (de)serialize data using bincode")]
+    SerdeBincode(#[from] bincode::error::EncodeError),
+    #[error("Failed to (de)serialize data using json")]
+    SerdeJson(#[from] serde_json::Error),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -5708,25 +5714,29 @@ mod tests {
         };
         let runner = crate::cairo_run::cairo_run(program_content, &config, &mut crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor::new_empty()).unwrap();
         let prover_input_info = runner.get_prover_input_info().unwrap();
-        let serialized_prover_input_info = prover_input_info.serialize_json().unwrap();
-        let deserialized_prover_input_info: ProverInputInfo =
-            serde_json::from_str(&serialized_prover_input_info).unwrap();
-        // Check that the deserialized prover input info is equal to the original one.
-        assert_eq!(
-            prover_input_info.relocatable_memory,
-            deserialized_prover_input_info.relocatable_memory
-        );
-        assert_eq!(
-            prover_input_info.relocatable_trace,
-            deserialized_prover_input_info.relocatable_trace
-        );
-        assert_eq!(
-            prover_input_info.builtins_segments,
-            deserialized_prover_input_info.builtins_segments
+
+        // Using bincode.
+        let serialized_prover_input_info = prover_input_info.serialize().unwrap();
+        let (deserialized_prover_input_info, _): (ProverInputInfo, usize) =
+            bincode::serde::decode_from_slice(
+                &serialized_prover_input_info,
+                bincode::config::standard(),
+            )
+            .unwrap();
+
+        assert!(
+            prover_input_info == deserialized_prover_input_info,
+            "Deserialized ProverInputInfo with bincode does not match the original one."
         );
-        assert_eq!(
-            prover_input_info.public_memory_offsets,
-            deserialized_prover_input_info.public_memory_offsets
+
+        // Using json.
+        let serialized_prover_input_info_json = prover_input_info.serialize_json().unwrap();
+        let deserialized_prover_input_info_json: ProverInputInfo =
+            serde_json::from_str(&serialized_prover_input_info_json).unwrap();
+
+        assert!(
+            prover_input_info == deserialized_prover_input_info_json,
+            "Deserialized ProverInputInfo with json does not match the original one."
         );
     }
 }