use postcard for faster binary serialization

Author: Stavbe

Cargo.lock

@@ -72,6 +72,9 @@ struct Args {
     #[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 +178,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 +195,7 @@ 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 +246,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 {

cairo-vm-cli/src/main.rs

@@ -61,6 +61,7 @@ anyhow = { workspace = true }
 thiserror = { workspace = true }
 starknet-types-core = { version = "0.1.2", default-features = false, features = ["serde", "curve", "num-traits", "hash"] }
 rust_decimal = { version = "1.35.0", default-features = false }
+postcard = { version = "1.0", features = ["alloc"]}
 
 # only for std
 num-prime = { version = "0.4.3", features = ["big-int"], optional = true }

vm/Cargo.toml

@@ -1500,13 +1500,13 @@ impl CairoRunner {
             .clone();
 
         let relocatable_memory = self
-            .vm
-            .segments
-            .memory
-            .data
-            .iter()
-            .map(|segment| segment.iter().map(|cell| cell.get_value()).collect())
-            .collect();
+        .vm
+        .segments
+        .memory
+        .data
+        .iter()
+        .map(|segment| segment.iter().map(|cell| cell.get_value()).collect())
+        .collect();
 
         let public_memory_offsets = self
             .vm
@@ -1567,13 +1567,18 @@ 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> {
+       postcard::to_allocvec(&self).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 postcard")]
+    SerdePostcard(#[from] postcard::Error),
+    #[error("Failed to (de)serialize data using json")]
+    SerdeJson(#[from] serde_json::Error),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -5699,6 +5704,24 @@ mod tests {
     fn serialize_and_deserialize_prover_input_info(#[case] program_content: &[u8]) {
         use crate::types::layout_name::LayoutName;
 
+        fn compare_prover_input_info(
+            original: &ProverInputInfo,
+            deserialized: &ProverInputInfo,
+        ) {
+            assert_eq!(
+                original.relocatable_memory, deserialized.relocatable_memory
+            );
+            assert_eq!(
+                original.relocatable_trace, deserialized.relocatable_trace
+            );
+            assert_eq!(
+                original.builtins_segments, deserialized.builtins_segments
+            );
+            assert_eq!(
+                original.public_memory_offsets, deserialized.public_memory_offsets
+            );
+        }
+
         let config = crate::cairo_run::CairoRunConfig {
             proof_mode: false,
             relocate_mem: false,
@@ -5708,25 +5731,23 @@ 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();
+
+        // Using postcard.
+        let serialized_prover_input_info = prover_input_info.serialize().unwrap();
+        let deserialized_prover_input_info : ProverInputInfo= postcard::from_bytes(&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
-        );
-        assert_eq!(
-            prover_input_info.public_memory_offsets,
-            deserialized_prover_input_info.public_memory_offsets
+        compare_prover_input_info(&prover_input_info, &deserialized_prover_input_info);
+
+        // 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();
+    
+        // Check that the deserialized prover input info is equal to the original one.
+        compare_prover_input_info(
+            &prover_input_info,
+            &deserialized_prover_input_info_json,
         );
     }
 }