feat: parallelizing the execution of C++ and Rust test-files

Author: madhav-madhusoodanan

crates/intrinsic-test/src/common/compare.rs

@@ -12,50 +12,71 @@ fn runner_command(runner: &str) -> Command {
 }
 
 pub fn compare_outputs(intrinsic_name_list: &Vec<String>, runner: &str, target: &str) -> bool {
-    let (c, rust) = rayon::join(
-        || {
+    let available_parallelism = std::thread::available_parallelism().unwrap().get();
+    let c_outputs = (0..available_parallelism)
+        .into_par_iter()
+        .map(|i| {
             runner_command(runner)
-                .arg("./intrinsic-test-programs")
+                .arg(format!("./intrinsic-test-programs_{i}"))
                 .current_dir("c_programs")
                 .output()
-        },
-        || {
+        })
+        .collect::<Vec<_>>();
+
+    let rust_outputs = (0..available_parallelism)
+        .into_par_iter()
+        .map(|i| {
             runner_command(runner)
-                .arg(format!("./target/{target}/release/intrinsic-test-programs"))
+                .arg(format!(
+                    "./target/{target}/release/intrinsic-test-programs-{i}"
+                ))
                 .current_dir("rust_programs")
                 .output()
-        },
-    );
-    let (c, rust) = match (c, rust) {
-        (Ok(c), Ok(rust)) => (c, rust),
+        })
+        .collect::<Vec<_>>();
+
+    let c_error = c_outputs.iter().filter(|elem| elem.is_err()).next();
+    let rust_error = rust_outputs.iter().filter(|elem| elem.is_err()).next();
+    match (c_error, rust_error) {
+        (None, None) => (),
         failure => panic!("Failed to run: {failure:#?}"),
     };
 
-    if !c.status.success() {
-        error!(
-            "Failed to run C program.\nstdout: {stdout}\nstderr: {stderr}",
-            stdout = std::str::from_utf8(&c.stdout).unwrap_or(""),
-            stderr = std::str::from_utf8(&c.stderr).unwrap_or(""),
-        );
-    }
+    let c_stdout = c_outputs
+        .into_iter()
+        .map(|c_elem| {
+            let c = c_elem.unwrap();
+            let c_stdout = std::str::from_utf8(&c.stdout).unwrap_or("").to_string();
+            if !c.status.success() {
+                error!(
+                    "Failed to run C program.\nstdout: {c_stdout}\nstderr: {stderr}",
+                    stderr = std::str::from_utf8(&c.stderr).unwrap_or(""),
+                );
+            }
+            c_stdout
+        })
+        .collect_vec()
+        .join("\n");
 
-    if !rust.status.success() {
-        error!(
-            "Failed to run Rust program.\nstdout: {stdout}\nstderr: {stderr}",
-            stdout = std::str::from_utf8(&rust.stdout).unwrap_or(""),
-            stderr = std::str::from_utf8(&rust.stderr).unwrap_or(""),
-        );
-    }
+    let rust_stdout = rust_outputs
+        .into_iter()
+        .map(|rust_elem| {
+            let rust = rust_elem.unwrap();
+            let rust_stdout = std::str::from_utf8(&rust.stdout).unwrap_or("").to_string();
+            if !rust.status.success() {
+                error!(
+                    "Failed to run Rust program.\nstdout: {rust_stdout}\nstderr: {stderr}",
+                    stderr = std::str::from_utf8(&rust.stderr).unwrap_or(""),
+                );
+            }
+            rust_stdout
+        })
+        .collect_vec()
+        .join("\n");
 
     info!("Completed running C++ and Rust test binaries");
-    let c = std::str::from_utf8(&c.stdout)
-        .unwrap()
-        .to_lowercase()
-        .replace("-nan", "nan");
-    let rust = std::str::from_utf8(&rust.stdout)
-        .unwrap()
-        .to_lowercase()
-        .replace("-nan", "nan");
+    let c = c_stdout.to_lowercase().replace("-nan", "nan");
+    let rust = rust_stdout.to_lowercase().replace("-nan", "nan");
 
     let c_output_map = c
         .split(INTRINSIC_DELIMITER)

crates/intrinsic-test/src/common/gen_rust.rs

@@ -39,6 +39,7 @@ fn write_cargo_toml_header(w: &mut impl std::io::Write, name: &str) -> std::io::
 pub fn write_bin_cargo_toml(
     w: &mut impl std::io::Write,
     module_count: usize,
+    binary_count: usize,
 ) -> std::io::Result<()> {
     write_cargo_toml_header(w, "intrinsic-test-programs")?;
 
@@ -49,6 +50,12 @@ pub fn write_bin_cargo_toml(
         writeln!(w, "mod_{i} = {{ path = \"mod_{i}/\" }}")?;
     }
 
+    for i in 0..binary_count {
+        writeln!(w, "[[bin]]")?;
+        writeln!(w, "name = \"intrinsic-test-programs_{i}\"")?;
+        writeln!(w, "path = \"src/main_{i}.rs\"")?;
+    }
+
     Ok(())
 }
 

crates/intrinsic-test/src/common/mod.rs

@@ -29,7 +29,10 @@ pub mod values;
 
 /// Architectures must support this trait
 /// to be successfully tested.
-pub trait SupportedArchitectureTest {
+pub trait SupportedArchitectureTest
+where
+    Self: Sync + Send,
+{
     type IntrinsicImpl: IntrinsicTypeDefinition + Sync;
 
     fn cli_options(&self) -> &ProcessedCli;
@@ -95,55 +98,88 @@ pub trait SupportedArchitectureTest {
             .collect::<Result<(), String>>()
             .unwrap();
 
-        let mut file = File::create("c_programs/main.cpp").unwrap();
-        write_main_cpp(
-            &mut file,
-            Self::PLATFORM_C_DEFINITIONS,
-            Self::PLATFORM_C_HEADERS,
-            self.intrinsics().iter().map(|i| i.name.as_str()),
-        )
-        .unwrap();
-
-        // This is done because `cpp_compiler_wrapped` is None when
-        // the --generate-only flag is passed
+        let (auto_chunk_size, auto_chunk_count) = auto_chunk(self.intrinsics().len());
+        
+        self.intrinsics()
+            .par_chunks(auto_chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                let mut file = File::create(format!("c_programs/main_{i}.cpp")).unwrap();
+                write_main_cpp(
+                    &mut file,
+                    Self::PLATFORM_C_DEFINITIONS,
+                    Self::PLATFORM_C_HEADERS,
+                    chunk.iter().map(|i| i.name.as_str()),
+                )
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
+
         if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
-            // compile this cpp file into a .o file
-            trace!("compiling main.cpp");
-            let output = cpp_compiler
-                .compile_object_file("main.cpp", "intrinsic-test-programs.o")
-                .unwrap();
-            assert!(output.status.success(), "{output:?}");
-
-            let object_files = (0..chunk_count)
-                .map(|i| format!("mod_{i}.o"))
-                .chain(["intrinsic-test-programs.o".to_owned()]);
-
-            let output = cpp_compiler
-                .link_executable(object_files, "intrinsic-test-programs")
-                .unwrap();
-            assert!(output.status.success(), "{output:?}");
-        }
+            (0..auto_chunk_count)
+                .into_par_iter()
+                .map(|index| {
+                    // This is done because `cpp_compiler_wrapped` is None when
+                    // the --generate-only flag is passed
+                    // compile this cpp file into a .o file
+                    trace!("compiling main_{index}.cpp");
+                    let output = cpp_compiler.compile_object_file(
+                        format!("main_{index}.cpp").as_str(),
+                        format!("main_{index}.o").as_str(),
+                    );
 
-        true
+                    if output.is_err() {
+                        return output;
+                    };
+
+                    let object_files = (0..chunk_count)
+                        .map(|i| format!("mod_{i}.o"))
+                        .chain([format!("main_{index}.o").to_owned()]);
+
+                    let output = cpp_compiler.link_executable(
+                        object_files,
+                        format!("intrinsic-test-programs-{index}").as_str(),
+                    );
+                    trace!("finished compiling main_{index}.cpp");
+
+                    return output;
+                })
+                .inspect(|output| {
+                    assert!(output.is_ok(), "{output:?}");
+                    if let Ok(out) = &output {
+                        assert!(out.status.success(), "{output:?}")
+                    }
+                })
+                .all(|output| output.is_ok())
+        } else {
+            true
+        }
     }
 
     fn build_rust_file(&self) -> bool {
         std::fs::create_dir_all("rust_programs/src").unwrap();
 
         let (chunk_size, chunk_count) = manual_chunk(self.intrinsics().len(), 400);
+        let (auto_chunk_size, auto_chunk_count) = auto_chunk(self.intrinsics().len());
 
         let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
-        write_bin_cargo_toml(&mut cargo, chunk_count).unwrap();
-
-        let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
-        write_main_rs(
-            &mut main_rs,
-            chunk_count,
-            Self::PLATFORM_RUST_CFGS,
-            "",
-            self.intrinsics().iter().map(|i| i.name.as_str()),
-        )
-        .unwrap();
+        write_bin_cargo_toml(&mut cargo, chunk_count, auto_chunk_count).unwrap();
+
+        self.intrinsics()
+            .par_chunks(auto_chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                let mut main_rs = File::create(format!("rust_programs/src/main_{i}.rs")).unwrap();
+                write_main_rs(
+                    &mut main_rs,
+                    chunk_count,
+                    Self::PLATFORM_RUST_CFGS,
+                    "",
+                    chunk.iter().map(|i| i.name.as_str()),
+                )
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
 
         let target = &self.cli_options().target;
         let toolchain = self.cli_options().toolchain.as_deref();
@@ -200,12 +236,12 @@ pub trait SupportedArchitectureTest {
     }
 }
 
-// pub fn chunk_info(intrinsic_count: usize) -> (usize, usize) {
-//     let available_parallelism = std::thread::available_parallelism().unwrap().get();
-//     let chunk_size = intrinsic_count.div_ceil(Ord::min(available_parallelism, intrinsic_count));
+pub fn auto_chunk(intrinsic_count: usize) -> (usize, usize) {
+    let available_parallelism = std::thread::available_parallelism().unwrap().get();
+    let chunk_size = intrinsic_count.div_ceil(Ord::min(available_parallelism, intrinsic_count));
 
-//     (chunk_size, intrinsic_count.div_ceil(chunk_size))
-// }
+    (chunk_size, intrinsic_count.div_ceil(chunk_size))
+}
 
 pub fn manual_chunk(intrinsic_count: usize, chunk_size: usize) -> (usize, usize) {
     (chunk_size, intrinsic_count.div_ceil(chunk_size))