move build_c_file and build_rust_file into SupportedArchitectureTest

This commit is contained in:
Folkert de Vries 2025-09-07 13:35:30 +02:00
parent 1697f36225
commit ccec202727
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
2 changed files with 143 additions and 143 deletions

View file

@ -5,19 +5,11 @@ mod intrinsic;
mod json_parser;
mod types;
use std::fs::File;
use rayon::prelude::*;
use crate::common::SupportedArchitectureTest;
use crate::common::cli::ProcessedCli;
use crate::common::compile_c::CppCompilation;
use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
use crate::common::gen_rust::{
compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
};
use crate::common::intrinsic::Intrinsic;
use crate::common::intrinsic_helpers::TypeKind;
use crate::common::{SupportedArchitectureTest, chunk_info};
use intrinsic::ArmIntrinsicType;
use json_parser::get_neon_intrinsics;
@ -76,135 +68,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
fn cpp_compilation(&self) -> Option<CppCompilation> {
compile::build_cpp_compilation(&self.cli_options)
}
fn build_c_file(&self) -> bool {
let c_target = "aarch64";
let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
let cpp_compiler_wrapped = self.cpp_compilation();
std::fs::create_dir_all("c_programs").unwrap();
self.intrinsics()
.par_chunks(chunk_size)
.enumerate()
.map(|(i, chunk)| {
let c_filename = format!("c_programs/mod_{i}.cpp");
let mut file = File::create(&c_filename).unwrap();
write_mod_cpp(
&mut file,
Self::NOTICE,
c_target,
Self::PLATFORM_C_HEADERS,
chunk,
)
.unwrap();
// compile this cpp file into a .o file.
//
// This is done because `cpp_compiler_wrapped` is None when
// the --generate-only flag is passed
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
let output = cpp_compiler
.compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
assert!(output.status.success(), "{output:?}");
}
Ok(())
})
.collect::<Result<(), std::io::Error>>()
.unwrap();
let mut file = File::create("c_programs/main.cpp").unwrap();
write_main_cpp(
&mut file,
c_target,
Self::PLATFORM_C_DEFINITIONS,
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
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
// compile this cpp file into a .o file
info!("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:?}");
}
true
}
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 (chunk_size, chunk_count) = chunk_info(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();
let target = &self.cli_options.target;
let toolchain = self.cli_options.toolchain.as_deref();
let linker = self.cli_options.linker.as_deref();
self.intrinsics
.par_chunks(chunk_size)
.enumerate()
.map(|(i, chunk)| {
std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
trace!("generating `{rust_filename}`");
let mut file = File::create(rust_filename)?;
write_lib_rs(
&mut file,
architecture,
Self::NOTICE,
Self::PLATFORM_RUST_CFGS,
Self::PLATFORM_RUST_DEFINITIONS,
chunk,
)?;
let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
trace!("generating `{toml_filename}`");
let mut file = File::create(toml_filename).unwrap();
write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
Ok(())
})
.collect::<Result<(), std::io::Error>>()
.unwrap();
compile_rust_programs(toolchain, target, linker)
}
}

View file

@ -1,7 +1,18 @@
use std::fs::File;
use rayon::prelude::*;
use cli::ProcessedCli;
use crate::common::{
compile_c::CppCompilation, intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition,
compile_c::CppCompilation,
gen_c::{write_main_cpp, write_mod_cpp},
gen_rust::{
compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs,
write_main_rs,
},
intrinsic::Intrinsic,
intrinsic_helpers::IntrinsicTypeDefinition,
};
pub mod argument;
@ -36,8 +47,136 @@ pub trait SupportedArchitectureTest {
fn cpp_compilation(&self) -> Option<CppCompilation>;
fn build_c_file(&self) -> bool;
fn build_rust_file(&self) -> bool;
fn build_c_file(&self) -> bool {
let c_target = "aarch64";
let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
let cpp_compiler_wrapped = self.cpp_compilation();
std::fs::create_dir_all("c_programs").unwrap();
self.intrinsics()
.par_chunks(chunk_size)
.enumerate()
.map(|(i, chunk)| {
let c_filename = format!("c_programs/mod_{i}.cpp");
let mut file = File::create(&c_filename).unwrap();
write_mod_cpp(
&mut file,
Self::NOTICE,
c_target,
Self::PLATFORM_C_HEADERS,
chunk,
)
.unwrap();
// compile this cpp file into a .o file.
//
// This is done because `cpp_compiler_wrapped` is None when
// the --generate-only flag is passed
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
let output = cpp_compiler
.compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
assert!(output.status.success(), "{output:?}");
}
Ok(())
})
.collect::<Result<(), std::io::Error>>()
.unwrap();
let mut file = File::create("c_programs/main.cpp").unwrap();
write_main_cpp(
&mut file,
c_target,
Self::PLATFORM_C_DEFINITIONS,
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
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
// compile this cpp file into a .o file
info!("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:?}");
}
true
}
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 (chunk_size, chunk_count) = chunk_info(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();
let target = &self.cli_options().target;
let toolchain = self.cli_options().toolchain.as_deref();
let linker = self.cli_options().linker.as_deref();
self.intrinsics()
.par_chunks(chunk_size)
.enumerate()
.map(|(i, chunk)| {
std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
trace!("generating `{rust_filename}`");
let mut file = File::create(rust_filename)?;
write_lib_rs(
&mut file,
architecture,
Self::NOTICE,
Self::PLATFORM_RUST_CFGS,
Self::PLATFORM_RUST_DEFINITIONS,
chunk,
)?;
let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
trace!("generating `{toml_filename}`");
let mut file = File::create(toml_filename).unwrap();
write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
Ok(())
})
.collect::<Result<(), std::io::Error>>()
.unwrap();
compile_rust_programs(toolchain, target, linker)
}
fn compare_outputs(&self) -> bool {
if self.cli_options().toolchain.is_some() {