Skip to content

Commit ccec202

Browse files
folkertdevfolkertdev
committed
move build_c_file and build_rust_file into SupportedArchitectureTest 
1 parent 1697f36 commit ccec202

File tree

2 files changed

+143
-143
lines changed
  • library/stdarch/crates/intrinsic-test/src

2 files changed

+143
-143
lines changed

‎library/stdarch/crates/intrinsic-test/src/arm/mod.rs‎

Lines changed: 1 addition & 140 deletions
Original file line numberDiff line numberDiff line change
@@ -5,19 +5,11 @@ mod intrinsic;
55
mod json_parser;
66
mod types;
77

8-
use std::fs::File;
9-
10-
use rayon::prelude::*;
11-
8+
use crate::common::SupportedArchitectureTest;
129
use crate::common::cli::ProcessedCli;
1310
use crate::common::compile_c::CppCompilation;
14-
use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
15-
use crate::common::gen_rust::{
16-
compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
17-
};
1811
use crate::common::intrinsic::Intrinsic;
1912
use crate::common::intrinsic_helpers::TypeKind;
20-
use crate::common::{SupportedArchitectureTest, chunk_info};
2113
use intrinsic::ArmIntrinsicType;
2214
use json_parser::get_neon_intrinsics;
2315

@@ -76,135 +68,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
7668
fn cpp_compilation(&self) -> Option<CppCompilation> {
7769
compile::build_cpp_compilation(&self.cli_options)
7870
}
79-
80-
fn build_c_file(&self) -> bool {
81-
let c_target = "aarch64";
82-
83-
let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
84-
85-
let cpp_compiler_wrapped = self.cpp_compilation();
86-
87-
std::fs::create_dir_all("c_programs").unwrap();
88-
self.intrinsics()
89-
.par_chunks(chunk_size)
90-
.enumerate()
91-
.map(|(i, chunk)| {
92-
let c_filename = format!("c_programs/mod_{i}.cpp");
93-
let mut file = File::create(&c_filename).unwrap();
94-
write_mod_cpp(
95-
&mut file,
96-
Self::NOTICE,
97-
c_target,
98-
Self::PLATFORM_C_HEADERS,
99-
chunk,
100-
)
101-
.unwrap();
102-
103-
// compile this cpp file into a .o file.
104-
//
105-
// This is done because `cpp_compiler_wrapped` is None when
106-
// the --generate-only flag is passed
107-
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
108-
let output = cpp_compiler
109-
.compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
110-
assert!(output.status.success(), "{output:?}");
111-
}
112-
113-
Ok(())
114-
})
115-
.collect::<Result<(), std::io::Error>>()
116-
.unwrap();
117-
118-
let mut file = File::create("c_programs/main.cpp").unwrap();
119-
write_main_cpp(
120-
&mut file,
121-
c_target,
122-
Self::PLATFORM_C_DEFINITIONS,
123-
self.intrinsics().iter().map(|i| i.name.as_str()),
124-
)
125-
.unwrap();
126-
127-
// This is done because `cpp_compiler_wrapped` is None when
128-
// the --generate-only flag is passed
129-
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
130-
// compile this cpp file into a .o file
131-
info!("compiling main.cpp");
132-
let output = cpp_compiler
133-
.compile_object_file("main.cpp", "intrinsic-test-programs.o")
134-
.unwrap();
135-
assert!(output.status.success(), "{output:?}");
136-
137-
let object_files = (0..chunk_count)
138-
.map(|i| format!("mod_{i}.o"))
139-
.chain(["intrinsic-test-programs.o".to_owned()]);
140-
141-
let output = cpp_compiler
142-
.link_executable(object_files, "intrinsic-test-programs")
143-
.unwrap();
144-
assert!(output.status.success(), "{output:?}");
145-
}
146-
147-
true
148-
}
149-
150-
fn build_rust_file(&self) -> bool {
151-
std::fs::create_dir_all("rust_programs/src").unwrap();
152-
153-
let architecture = if self.cli_options.target.contains("v7") {
154-
"arm"
155-
} else {
156-
"aarch64"
157-
};
158-
159-
let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
160-
161-
let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
162-
write_bin_cargo_toml(&mut cargo, chunk_count).unwrap();
163-
164-
let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
165-
write_main_rs(
166-
&mut main_rs,
167-
chunk_count,
168-
Self::PLATFORM_RUST_CFGS,
169-
"",
170-
self.intrinsics.iter().map(|i| i.name.as_str()),
171-
)
172-
.unwrap();
173-
174-
let target = &self.cli_options.target;
175-
let toolchain = self.cli_options.toolchain.as_deref();
176-
let linker = self.cli_options.linker.as_deref();
177-
178-
self.intrinsics
179-
.par_chunks(chunk_size)
180-
.enumerate()
181-
.map(|(i, chunk)| {
182-
std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
183-
184-
let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
185-
trace!("generating `{rust_filename}`");
186-
let mut file = File::create(rust_filename)?;
187-
188-
write_lib_rs(
189-
&mut file,
190-
architecture,
191-
Self::NOTICE,
192-
Self::PLATFORM_RUST_CFGS,
193-
Self::PLATFORM_RUST_DEFINITIONS,
194-
chunk,
195-
)?;
196-
197-
let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
198-
trace!("generating `{toml_filename}`");
199-
let mut file = File::create(toml_filename).unwrap();
200-
201-
write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
202-
203-
Ok(())
204-
})
205-
.collect::<Result<(), std::io::Error>>()
206-
.unwrap();
207-
208-
compile_rust_programs(toolchain, target, linker)
209-
}
21071
}

‎library/stdarch/crates/intrinsic-test/src/common/mod.rs‎

Lines changed: 142 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,18 @@
1+
use std::fs::File;
2+
3+
use rayon::prelude::*;
4+
15
use cli::ProcessedCli;
26

37
use crate::common::{
4-
compile_c::CppCompilation, intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition,
8+
compile_c::CppCompilation,
9+
gen_c::{write_main_cpp, write_mod_cpp},
10+
gen_rust::{
11+
compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs,
12+
write_main_rs,
13+
},
14+
intrinsic::Intrinsic,
15+
intrinsic_helpers::IntrinsicTypeDefinition,
516
};
617

718
pub mod argument;
@@ -36,8 +47,136 @@ pub trait SupportedArchitectureTest {
3647

3748
fn cpp_compilation(&self) -> Option<CppCompilation>;
3849

39-
fn build_c_file(&self) -> bool;
40-
fn build_rust_file(&self) -> bool;
50+
fn build_c_file(&self) -> bool {
51+
let c_target = "aarch64";
52+
53+
let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
54+
55+
let cpp_compiler_wrapped = self.cpp_compilation();
56+
57+
std::fs::create_dir_all("c_programs").unwrap();
58+
self.intrinsics()
59+
.par_chunks(chunk_size)
60+
.enumerate()
61+
.map(|(i, chunk)| {
62+
let c_filename = format!("c_programs/mod_{i}.cpp");
63+
let mut file = File::create(&c_filename).unwrap();
64+
write_mod_cpp(
65+
&mut file,
66+
Self::NOTICE,
67+
c_target,
68+
Self::PLATFORM_C_HEADERS,
69+
chunk,
70+
)
71+
.unwrap();
72+
73+
// compile this cpp file into a .o file.
74+
//
75+
// This is done because `cpp_compiler_wrapped` is None when
76+
// the --generate-only flag is passed
77+
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
78+
let output = cpp_compiler
79+
.compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
80+
assert!(output.status.success(), "{output:?}");
81+
}
82+
83+
Ok(())
84+
})
85+
.collect::<Result<(), std::io::Error>>()
86+
.unwrap();
87+
88+
let mut file = File::create("c_programs/main.cpp").unwrap();
89+
write_main_cpp(
90+
&mut file,
91+
c_target,
92+
Self::PLATFORM_C_DEFINITIONS,
93+
self.intrinsics().iter().map(|i| i.name.as_str()),
94+
)
95+
.unwrap();
96+
97+
// This is done because `cpp_compiler_wrapped` is None when
98+
// the --generate-only flag is passed
99+
if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
100+
// compile this cpp file into a .o file
101+
info!("compiling main.cpp");
102+
let output = cpp_compiler
103+
.compile_object_file("main.cpp", "intrinsic-test-programs.o")
104+
.unwrap();
105+
assert!(output.status.success(), "{output:?}");
106+
107+
let object_files = (0..chunk_count)
108+
.map(|i| format!("mod_{i}.o"))
109+
.chain(["intrinsic-test-programs.o".to_owned()]);
110+
111+
let output = cpp_compiler
112+
.link_executable(object_files, "intrinsic-test-programs")
113+
.unwrap();
114+
assert!(output.status.success(), "{output:?}");
115+
}
116+
117+
true
118+
}
119+
120+
fn build_rust_file(&self) -> bool {
121+
std::fs::create_dir_all("rust_programs/src").unwrap();
122+
123+
let architecture = if self.cli_options().target.contains("v7") {
124+
"arm"
125+
} else {
126+
"aarch64"
127+
};
128+
129+
let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
130+
131+
let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
132+
write_bin_cargo_toml(&mut cargo, chunk_count).unwrap();
133+
134+
let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
135+
write_main_rs(
136+
&mut main_rs,
137+
chunk_count,
138+
Self::PLATFORM_RUST_CFGS,
139+
"",
140+
self.intrinsics().iter().map(|i| i.name.as_str()),
141+
)
142+
.unwrap();
143+
144+
let target = &self.cli_options().target;
145+
let toolchain = self.cli_options().toolchain.as_deref();
146+
let linker = self.cli_options().linker.as_deref();
147+
148+
self.intrinsics()
149+
.par_chunks(chunk_size)
150+
.enumerate()
151+
.map(|(i, chunk)| {
152+
std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
153+
154+
let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
155+
trace!("generating `{rust_filename}`");
156+
let mut file = File::create(rust_filename)?;
157+
158+
write_lib_rs(
159+
&mut file,
160+
architecture,
161+
Self::NOTICE,
162+
Self::PLATFORM_RUST_CFGS,
163+
Self::PLATFORM_RUST_DEFINITIONS,
164+
chunk,
165+
)?;
166+
167+
let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
168+
trace!("generating `{toml_filename}`");
169+
let mut file = File::create(toml_filename).unwrap();
170+
171+
write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
172+
173+
Ok(())
174+
})
175+
.collect::<Result<(), std::io::Error>>()
176+
.unwrap();
177+
178+
compile_rust_programs(toolchain, target, linker)
179+
}
41180

42181
fn compare_outputs(&self) -> bool {
43182
if self.cli_options().toolchain.is_some() {

0 commit comments

Comments
 (0)