feat(apollo_starknet_os_program): compile programs asynchronously

Author: dorimedini-starkware

Cargo.lock

@@ -20,3 +20,4 @@ thiserror.workspace = true
 [build-dependencies]
 apollo_infra_utils.workspace = true
 cairo-vm.workspace = true
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/apollo_starknet_os_program/Cargo.toml

@@ -5,26 +5,34 @@ use apollo_infra_utils::compile_time_cargo_manifest_dir;
 
 /// Build script for the `apollo_starknet_os_program` crate.
 /// Recompiles the OS program if the source files change.
-fn main() {
+#[tokio::main]
+async fn main() {
     let out_dir = PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR not set."));
 
-    println!("cargo::warning=Compiling Starknet OS program...");
-    let starknet_os_bytes = compile_starknet_os();
-    println!("cargo::warning=Done. Writing compiled bytes to output directory.");
-    let starknet_os_bytes_path = out_dir.join("starknet_os_bytes");
-    std::fs::write(&starknet_os_bytes_path, &starknet_os_bytes)
-        .expect("Failed to write the compiled OS bytes to the output directory.");
-
-    println!("cargo::warning=Compiling Starknet aggregator program...");
-    let starknet_aggregator_bytes = compile_starknet_aggregator();
-    println!("cargo::warning=Done. Writing compiled bytes to output directory.");
-    let starknet_aggregator_bytes_path = out_dir.join("starknet_aggregator_bytes");
-    std::fs::write(&starknet_aggregator_bytes_path, &starknet_aggregator_bytes)
-        .expect("Failed to write the compiled aggregator bytes to the output directory.");
+    let mut task_set = tokio::task::JoinSet::new();
+    task_set.spawn(compile_and_output_program(
+        out_dir.clone(),
+        "starkware/starknet/core/os/os.cairo",
+        "starknet_os",
+    ));
+    task_set.spawn(compile_and_output_program(
+        out_dir,
+        "starkware/starknet/core/aggregator/main.cairo",
+        "starknet_aggregator",
+    ));
+    task_set.join_all().await;
 }
 
-fn compile_program(path_to_main_file: PathBuf) -> Vec<u8> {
-    match compile_cairo0_program(path_to_main_file, cairo_root_path()) {
+async fn compile_and_output_program(
+    out_dir: PathBuf,
+    path_to_main_file_from_cairo_root: &str,
+    program_name: &str,
+) {
+    println!("cargo::warning=Compiling {program_name} program...");
+    let bytes = match compile_cairo0_program(
+        cairo_root_path().join(path_to_main_file_from_cairo_root),
+        cairo_root_path(),
+    ) {
         Ok(bytes) => bytes,
         Err(Cairo0CompilerError::Cairo0CompilerVersion(error)) => {
             panic!(
@@ -35,19 +43,18 @@ fn compile_program(path_to_main_file: PathBuf) -> Vec<u8> {
             )
         }
         Err(other_error) => {
-            panic!("Failed to compile the program. Error:\n{other_error}.")
+            panic!("Failed to compile the {program_name} program. Error:\n{other_error}.")
         }
-    }
+    };
+    println!(
+        "cargo::warning=Done compiling {program_name}. Writing compiled bytes to output directory."
+    );
+    let bytes_path = out_dir.join(format!("{program_name}_bytes"));
+    std::fs::write(&bytes_path, &bytes).unwrap_or_else(|error| {
+        panic!("Failed to write the compiled {program_name} bytes to {bytes_path:?}: {error}.")
+    });
 }
 
 fn cairo_root_path() -> PathBuf {
     PathBuf::from(compile_time_cargo_manifest_dir!()).join("src/cairo")
 }
-
-fn compile_starknet_os() -> Vec<u8> {
-    compile_program(cairo_root_path().join("starkware/starknet/core/os/os.cairo"))
-}
-
-fn compile_starknet_aggregator() -> Vec<u8> {
-    compile_program(cairo_root_path().join("starkware/starknet/core/aggregator/main.cairo"))
-}