combine rust functions into #available_parallelism files

Author: folkertdev

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

@@ -14,7 +14,7 @@ use crate::common::compare::compare_outputs;
 use crate::common::gen_rust::{compile_rust_programs, write_cargo_toml, write_main_rs};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
-use crate::common::write_file::{write_c_testfiles, write_rust_testfiles};
+use crate::common::write_file::write_c_testfiles;
 use compile::compile_c_arm;
 use config::{AARCH_CONFIGURATIONS, F16_FORMATTING_DEF, POLY128_OSTREAM_DEF, build_notices};
 use intrinsic::ArmIntrinsicType;
@@ -81,18 +81,24 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
     }
 
     fn build_rust_file(&self) -> bool {
+        std::fs::create_dir_all("rust_programs/src").unwrap();
+
         let architecture = if self.cli_options.target.contains("v7") {
             "arm"
         } else {
             "aarch64"
         };
 
+        let available_parallelism = std::thread::available_parallelism().unwrap().get();
+        let chunk_size = self.intrinsics.len().div_ceil(available_parallelism);
+
         let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
         write_cargo_toml(&mut cargo, &[]).unwrap();
 
         let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
         write_main_rs(
             &mut main_rs,
+            available_parallelism,
             architecture,
             AARCH_CONFIGURATIONS,
             F16_FORMATTING_DEF,
@@ -104,12 +110,29 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         let toolchain = self.cli_options.toolchain.as_deref();
         let linker = self.cli_options.linker.as_deref();
 
-        write_rust_testfiles(
-            self.intrinsics.par_iter(),
-            architecture,
-            &build_notices("// "),
-        )
-        .unwrap();
+        let notice = &build_notices("// ");
+        self.intrinsics
+            .par_chunks(chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                use std::io::Write;
+
+                let rust_filename = format!("rust_programs/src/mod_{i}.rs");
+                let mut file = File::create(rust_filename).unwrap();
+
+                write!(file, "{notice}")?;
+
+                writeln!(file, "use core_arch::arch::{architecture}::*;")?;
+                writeln!(file, "use crate::{{debug_simd_finish, debug_f16}};")?;
+
+                for intrinsic in chunk {
+                    crate::common::gen_rust::create_rust_test_module(&mut file, intrinsic)?;
+                }
+
+                Ok(())
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
 
         compile_rust_programs(toolchain, target, linker)
     }

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

@@ -47,6 +47,7 @@ pub fn write_cargo_toml(w: &mut impl std::io::Write, binaries: &[String]) -> std
 
 pub fn write_main_rs<'a>(
     w: &mut impl std::io::Write,
+    available_parallelism: usize,
     architecture: &str,
     cfg: &str,
     definitions: &str,
@@ -61,16 +62,17 @@ pub fn write_main_rs<'a>(
 
     writeln!(w, "use core_arch::arch::{architecture}::*;")?;
 
-    for binary in intrinsics.clone() {
-        writeln!(w, "mod {binary};")?;
+    for module in 0..available_parallelism {
+        writeln!(w, "mod mod_{module};")?;
+        writeln!(w, "use mod_{module}::*;")?;
     }
 
     writeln!(w, "fn main() {{")?;
 
     writeln!(w, "    match std::env::args().nth(1).unwrap().as_str() {{")?;
 
     for binary in intrinsics {
-        writeln!(w, "        \"{binary}\" => {binary}::run(),")?;
+        writeln!(w, "        \"{binary}\" => run_{binary}(),")?;
     }
 
     writeln!(
@@ -194,20 +196,13 @@ fn generate_rust_constraint_blocks<'a, T: IntrinsicTypeDefinition + 'a>(
 }
 
 // Top-level function to create complete test program
-pub fn create_rust_test_program<T: IntrinsicTypeDefinition>(
+pub fn create_rust_test_module<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     intrinsic: &dyn IntrinsicDefinition<T>,
-    architecture: &str,
-    notice: &str,
 ) -> std::io::Result<()> {
     let indentation = Indentation::default();
 
-    write!(w, "{notice}")?;
-
-    writeln!(w, "use core_arch::arch::{architecture}::*;")?;
-    writeln!(w, "use crate::{{debug_simd_finish, debug_f16}};")?;
-
-    writeln!(w, "pub fn run() {{")?;
+    writeln!(w, "pub fn run_{}() {{", intrinsic.name())?;
 
     // Define the arrays of arguments.
     let arguments = intrinsic.arguments();

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

@@ -1,6 +1,5 @@
 use std::fs::File;
 
-use super::gen_rust::create_rust_test_program;
 use super::intrinsic::IntrinsicDefinition;
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
@@ -40,29 +39,3 @@ where
         })
         .collect()
 }
-
-pub fn write_rust_testfiles<'a, T, I, E>(
-    intrinsics: I,
-    architecture: &str,
-    notice: &str,
-) -> std::io::Result<()>
-where
-    T: IntrinsicTypeDefinition + Sized + 'a,
-    I: ParallelIterator<Item = &'a E>,
-    E: IntrinsicDefinition<T> + 'a,
-{
-    std::fs::create_dir_all("rust_programs/src")?;
-
-    intrinsics
-        .map(|intrinsic| {
-            let identifier = intrinsic.name().to_owned();
-
-            let rust_filename = format!("rust_programs/src/{identifier}.rs");
-            let mut file = File::create(rust_filename).unwrap();
-
-            create_rust_test_program(&mut file, intrinsic, architecture, notice)?;
-
-            Ok(())
-        })
-        .collect()
-}

crates/intrinsic-test/src/main.rs

@@ -30,14 +30,14 @@ fn main() {
 
     let test_environment = test_environment_result.unwrap();
 
-    info!("building C binaries");
-    if !test_environment.build_c_file() {
-        std::process::exit(2);
-    }
     info!("building Rust binaries");
     if !test_environment.build_rust_file() {
         std::process::exit(3);
     }
+    info!("building C binaries");
+    if !test_environment.build_c_file() {
+        std::process::exit(2);
+    }
     info!("comparing outputs");
     if !test_environment.compare_outputs() {
         std::process::exit(1);