Skip to content

Commit f1b4075

Browse files
madhav-madhusoodananAmanieu
madhav-madhusoodanan
authored and
Amanieu
committed
fix: moved common code (that required no architecture-specific
modifications) outside the IntrinsicDefinition trait
1 parent 9eb5e44 commit f1b4075

File tree

5 files changed

+243
-268
lines changed

5 files changed

+243
-268
lines changed

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

Lines changed: 0 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -92,57 +92,4 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
9292
close = if self.results.is_simd() { ")" } else { "" },
9393
)
9494
}
95-
96-
fn generate_loop_c(
97-
&self,
98-
indentation: Indentation,
99-
additional: &str,
100-
passes: u32,
101-
_target: &str,
102-
) -> String {
103-
let body_indentation = indentation.nested();
104-
format!(
105-
"{indentation}for (int i=0; i<{passes}; i++) {{\n\
106-
{loaded_args}\
107-
{body_indentation}auto __return_value = {intrinsic_call}({args});\n\
108-
{print_result}\n\
109-
{indentation}}}",
110-
loaded_args = self.arguments.load_values_c(body_indentation),
111-
intrinsic_call = self.name,
112-
args = self.arguments.as_call_param_c(),
113-
print_result = self.print_result_c(body_indentation, additional)
114-
)
115-
}
116-
117-
fn generate_loop_rust(
118-
&self,
119-
indentation: Indentation,
120-
additional: &str,
121-
passes: u32,
122-
) -> String {
123-
let constraints = self.arguments.as_constraint_parameters_rust();
124-
let constraints = if !constraints.is_empty() {
125-
format!("::<{constraints}>")
126-
} else {
127-
constraints
128-
};
129-
130-
let return_value = self.format_f16_return_value();
131-
let indentation2 = indentation.nested();
132-
let indentation3 = indentation2.nested();
133-
134-
format!(
135-
"{indentation}for i in 0..{passes} {{\n\
136-
{indentation2}unsafe {{\n\
137-
{loaded_args}\
138-
{indentation3}let __return_value = {intrinsic_call}{const}({args});\n\
139-
{indentation3}println!(\"Result {additional}-{{}}: {{:?}}\", i + 1, {return_value});\n\
140-
{indentation2}}}\n\
141-
{indentation}}}",
142-
loaded_args = self.arguments.load_values_rust(indentation3),
143-
intrinsic_call = self.name,
144-
const = constraints,
145-
args = self.arguments.as_call_param_rust(),
146-
)
147-
}
14895
}

‎crates/intrinsic-test/src/common/gen_c.rs

Lines changed: 104 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,14 @@ use rayon::prelude::*;
33
use std::collections::BTreeMap;
44
use std::process::Command;
55

6+
use super::argument::Argument;
7+
use super::indentation::Indentation;
8+
use super::intrinsic::IntrinsicDefinition;
9+
use super::intrinsic_helpers::IntrinsicTypeDefinition;
10+
11+
// The number of times each intrinsic will be called.
12+
const PASSES: u32 = 20;
13+
614
pub fn generate_c_program(
715
notices: &str,
816
header_files: &[&str],
@@ -89,3 +97,99 @@ pub fn create_c_filenames(identifiers: &Vec<String>) -> BTreeMap<&String, String
8997
})
9098
.collect::<BTreeMap<&String, String>>()
9199
}
100+
101+
pub fn generate_loop_c<T: IntrinsicTypeDefinition + Sized>(
102+
intrinsic: &dyn IntrinsicDefinition<T>,
103+
indentation: Indentation,
104+
additional: &str,
105+
passes: u32,
106+
_target: &str,
107+
) -> String {
108+
let body_indentation = indentation.nested();
109+
format!(
110+
"{indentation}for (int i=0; i<{passes}; i++) {{\n\
111+
{loaded_args}\
112+
{body_indentation}auto __return_value = {intrinsic_call}({args});\n\
113+
{print_result}\n\
114+
{indentation}}}",
115+
loaded_args = intrinsic.arguments().load_values_c(body_indentation),
116+
intrinsic_call = intrinsic.name(),
117+
args = intrinsic.arguments().as_call_param_c(),
118+
print_result = intrinsic.print_result_c(body_indentation, additional)
119+
)
120+
}
121+
122+
pub fn gen_code_c<T: IntrinsicTypeDefinition>(
123+
intrinsic: &dyn IntrinsicDefinition<T>,
124+
indentation: Indentation,
125+
constraints: &[&Argument<T>],
126+
name: String,
127+
target: &str,
128+
) -> String {
129+
if let Some((current, constraints)) = constraints.split_last() {
130+
let range = current
131+
.constraint
132+
.iter()
133+
.map(|c| c.to_range())
134+
.flat_map(|r| r.into_iter());
135+
136+
let body_indentation = indentation.nested();
137+
range
138+
.map(|i| {
139+
format!(
140+
"{indentation}{{\n\
141+
{body_indentation}{ty} {name} = {val};\n\
142+
{pass}\n\
143+
{indentation}}}",
144+
name = current.name,
145+
ty = current.ty.c_type(),
146+
val = i,
147+
pass = gen_code_c(
148+
intrinsic,
149+
body_indentation,
150+
constraints,
151+
format!("{name}-{i}"),
152+
target,
153+
)
154+
)
155+
})
156+
.join("\n")
157+
} else {
158+
generate_loop_c(intrinsic, indentation, &name, PASSES, target)
159+
}
160+
}
161+
162+
pub fn gen_c_program<T: IntrinsicTypeDefinition>(
163+
intrinsic: &dyn IntrinsicDefinition<T>,
164+
header_files: &[&str],
165+
target: &str,
166+
c_target: &str,
167+
notices: &str,
168+
arch_specific_definitions: &[&str],
169+
) -> String {
170+
let arguments = intrinsic.arguments();
171+
let constraints = arguments
172+
.iter()
173+
.filter(|&i| i.has_constraint())
174+
.collect_vec();
175+
176+
let indentation = Indentation::default();
177+
generate_c_program(
178+
notices,
179+
header_files,
180+
c_target,
181+
arch_specific_definitions,
182+
intrinsic
183+
.arguments()
184+
.gen_arglists_c(indentation, PASSES)
185+
.as_str(),
186+
gen_code_c(
187+
intrinsic,
188+
indentation.nested(),
189+
constraints.as_slice(),
190+
Default::default(),
191+
target,
192+
)
193+
.as_str(),
194+
)
195+
}

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

Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,14 @@ use std::fs::File;
55
use std::io::Write;
66
use std::process::Command;
77

8+
use super::argument::Argument;
9+
use super::indentation::Indentation;
10+
use super::intrinsic::{IntrinsicDefinition, format_f16_return_value};
11+
use super::intrinsic_helpers::IntrinsicTypeDefinition;
12+
13+
// The number of times each intrinsic will be called.
14+
const PASSES: u32 = 20;
15+
816
pub fn generate_rust_program(
917
notices: &str,
1018
definitions: &str,
@@ -129,3 +137,105 @@ pub fn create_rust_filenames(identifiers: &Vec<String>) -> BTreeMap<&String, Str
129137
})
130138
.collect::<BTreeMap<&String, String>>()
131139
}
140+
141+
pub fn generate_loop_rust<T: IntrinsicTypeDefinition>(
142+
intrinsic: &dyn IntrinsicDefinition<T>,
143+
indentation: Indentation,
144+
additional: &str,
145+
passes: u32,
146+
) -> String {
147+
let constraints = intrinsic.arguments().as_constraint_parameters_rust();
148+
let constraints = if !constraints.is_empty() {
149+
format!("::<{constraints}>")
150+
} else {
151+
constraints
152+
};
153+
154+
let return_value = format_f16_return_value(intrinsic);
155+
let indentation2 = indentation.nested();
156+
let indentation3 = indentation2.nested();
157+
format!(
158+
"{indentation}for i in 0..{passes} {{\n\
159+
{indentation2}unsafe {{\n\
160+
{loaded_args}\
161+
{indentation3}let __return_value = {intrinsic_call}{const}({args});\n\
162+
{indentation3}println!(\"Result {additional}-{{}}: {{:?}}\", i + 1, {return_value});\n\
163+
{indentation2}}}\n\
164+
{indentation}}}",
165+
loaded_args = intrinsic.arguments().load_values_rust(indentation3),
166+
intrinsic_call = intrinsic.name(),
167+
const = constraints,
168+
args = intrinsic.arguments().as_call_param_rust(),
169+
)
170+
}
171+
172+
pub fn gen_code_rust<T: IntrinsicTypeDefinition>(
173+
intrinsic: &dyn IntrinsicDefinition<T>,
174+
indentation: Indentation,
175+
constraints: &[&Argument<T>],
176+
name: String,
177+
) -> String {
178+
if let Some((current, constraints)) = constraints.split_last() {
179+
let range = current
180+
.constraint
181+
.iter()
182+
.map(|c| c.to_range())
183+
.flat_map(|r| r.into_iter());
184+
185+
let body_indentation = indentation.nested();
186+
range
187+
.map(|i| {
188+
format!(
189+
"{indentation}{{\n\
190+
{body_indentation}const {name}: {ty} = {val};\n\
191+
{pass}\n\
192+
{indentation}}}",
193+
name = current.name,
194+
ty = current.ty.rust_type(),
195+
val = i,
196+
pass = gen_code_rust(
197+
intrinsic,
198+
body_indentation,
199+
constraints,
200+
format!("{name}-{i}")
201+
)
202+
)
203+
})
204+
.join("\n")
205+
} else {
206+
generate_loop_rust(intrinsic, indentation, &name, PASSES)
207+
}
208+
}
209+
210+
pub fn gen_rust_program<T: IntrinsicTypeDefinition>(
211+
intrinsic: &dyn IntrinsicDefinition<T>,
212+
target: &str,
213+
notice: &str,
214+
definitions: &str,
215+
cfg: &str,
216+
) -> String {
217+
let arguments = intrinsic.arguments();
218+
let constraints = arguments
219+
.iter()
220+
.filter(|i| i.has_constraint())
221+
.collect_vec();
222+
223+
let indentation = Indentation::default();
224+
generate_rust_program(
225+
notice,
226+
definitions,
227+
cfg,
228+
target,
229+
intrinsic
230+
.arguments()
231+
.gen_arglists_rust(indentation.nested(), PASSES)
232+
.as_str(),
233+
gen_code_rust(
234+
intrinsic,
235+
indentation.nested(),
236+
&constraints,
237+
Default::default(),
238+
)
239+
.as_str(),
240+
)
241+
}

0 commit comments

Comments
 (0)