Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • llvm/hercules
1 result
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 518 additions and 242 deletions
juno_samples/rodinia/cfd/src/gpu_pre_euler.sch
View file @ 0717de36
gvn(*);
dce(*);
phi-elim(*);
dce(*);
crc(*);
dce(*);
slf(*);
dce(*);
let auto = auto-outline(pre_euler);
gpu(auto.pre_euler);
inline(auto.pre_euler);
inline(auto.pre_euler);
macro simpl!(X) {
ccp(X);
simplify-cfg(X);
lift-dc-math(X);
gvn(X);
phi-elim(X);
crc(X);
slf(X);
dce(X);
infer-schedules(X);
}
simpl!(*);
inline(compute_step_factor, compute_flux, compute_flux_contributions, compute_flux_contribution, time_step);
no-memset(compute_step_factor@res, compute_flux_contributions@res, compute_flux@res, copy_vars@res);
delete-uncalled(*);
gpu(copy_vars, compute_step_factor, compute_flux_contributions, compute_flux, time_step);
sroa[false](auto.pre_euler);
dce(*);
float-collections(*);
dce(*);
simpl!(*);
ip-sroa[true](*);
sroa[true](*);
predication(*);
const-inline(*);
simpl!(*);
fixpoint {
forkify(*);
fork-guard-elim(*);
}
simpl!(*);
unforkify(compute_flux@inner_loop);
gcm(*);
fork-tile[32, 0, false, true](compute_step_factor);
fork-split(compute_step_factor);
fork-tile[32, 0, false, true](compute_flux_contributions);
fork-split(compute_flux_contributions);
fork-tile[32, 0, false, true](compute_flux);
fork-split(compute_flux);
fork-tile[32, 0, false, true](time_step);
fork-split(time_step);
fork-tile[32, 0, false, true](copy_vars);
fork-split(copy_vars);
gcm(*);
juno_samples/rodinia/cfd/src/lib.rs
View file @ 0717de36
......@@ -24,123 +24,193 @@ pub struct CFDInputs {
fn run_euler(
nelr: usize,
iterations: usize,
mut variables: AlignedSlice<f32>,
mut variables: Variables,
areas: &[f32],
elements_surrounding_elements: &[i32],
normals: &[f32],
ff_variable: &[f32],
normals: &Normals,
ff_variable: &Variable,
ff_fc_density_energy: &Float3,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
) -> Vec<f32> {
let mut variables = HerculesMutBox::from(variables.as_mut_slice());
) -> Variables {
let mut v_density = HerculesMutBox::from(variables.density.as_mut_slice());
let mut v_momentum_x = HerculesMutBox::from(variables.momentum.x.as_mut_slice());
let mut v_momentum_y = HerculesMutBox::from(variables.momentum.y.as_mut_slice());
let mut v_momentum_z = HerculesMutBox::from(variables.momentum.z.as_mut_slice());
let mut v_energy = HerculesMutBox::from(variables.energy.as_mut_slice());
let areas = HerculesImmBox::from(areas);
let elements_surrounding_elements = HerculesImmBox::from(elements_surrounding_elements);
let normals = HerculesImmBox::from(normals);
let ff_variable = HerculesImmBox::from(ff_variable);
// TODO: Make hercules box handle structs, for now we'll copy into a vec
let ff_fc_density_energy = vec![
ff_fc_density_energy.x,
ff_fc_density_energy.y,
ff_fc_density_energy.z,
];
let ff_fc_density_energy = HerculesImmBox::from(ff_fc_density_energy.as_slice());
let ff_fc_momentum_x = vec![ff_fc_momentum_x.x, ff_fc_momentum_x.y, ff_fc_momentum_x.z];
let ff_fc_momentum_x = HerculesImmBox::from(ff_fc_momentum_x.as_slice());
let ff_fc_momentum_y = vec![ff_fc_momentum_y.x, ff_fc_momentum_y.y, ff_fc_momentum_y.z];
let ff_fc_momentum_y = HerculesImmBox::from(ff_fc_momentum_y.as_slice());
let ff_fc_momentum_z = vec![ff_fc_momentum_z.x, ff_fc_momentum_z.y, ff_fc_momentum_z.z];
let ff_fc_momentum_z = HerculesImmBox::from(ff_fc_momentum_z.as_slice());
let mut runner = runner!(euler);
let normals_x = HerculesImmBox::from(normals.x.as_slice());
let normals_y = HerculesImmBox::from(normals.y.as_slice());
let normals_z = HerculesImmBox::from(normals.z.as_slice());
HerculesMutBox::from(async_std::task::block_on(async {
let mut runner = runner!(euler);
let (density, momentum_x, momentum_y, momentum_z, energy) = async_std::task::block_on(async {
runner
.run(
nelr as u64,
iterations as u64,
variables.to(),
v_density.to(),
v_momentum_x.to(),
v_momentum_y.to(),
v_momentum_z.to(),
v_energy.to(),
areas.to(),
elements_surrounding_elements.to(),
normals.to(),
ff_variable.to(),
ff_fc_density_energy.to(),
ff_fc_momentum_x.to(),
ff_fc_momentum_y.to(),
ff_fc_momentum_z.to(),
normals_x.to(),
normals_y.to(),
normals_z.to(),
ff_variable.density,
ff_variable.momentum.x,
ff_variable.momentum.y,
ff_variable.momentum.z,
ff_variable.energy,
ff_fc_density_energy.x,
ff_fc_density_energy.y,
ff_fc_density_energy.z,
ff_fc_momentum_x.x,
ff_fc_momentum_x.y,
ff_fc_momentum_x.z,
ff_fc_momentum_y.x,
ff_fc_momentum_y.y,
ff_fc_momentum_y.z,
ff_fc_momentum_z.x,
ff_fc_momentum_z.y,
ff_fc_momentum_z.z,
)
.await
}))
.as_slice()
.to_vec()
});
Variables {
density: AlignedSlice::from_slice(HerculesMutBox::from(density).as_slice()),
momentum: Momentum {
x: AlignedSlice::from_slice(HerculesMutBox::from(momentum_x).as_slice()),
y: AlignedSlice::from_slice(HerculesMutBox::from(momentum_y).as_slice()),
z: AlignedSlice::from_slice(HerculesMutBox::from(momentum_z).as_slice()),
},
energy: AlignedSlice::from_slice(HerculesMutBox::from(energy).as_slice()),
}
}
fn run_pre_euler(
nelr: usize,
iterations: usize,
mut variables: AlignedSlice<f32>,
mut variables: Variables,
areas: &[f32],
elements_surrounding_elements: &[i32],
normals: &[f32],
ff_variable: &[f32],
normals: &Normals,
ff_variable: &Variable,
ff_fc_density_energy: &Float3,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
) -> Vec<f32> {
let mut variables = HerculesMutBox::from(variables.as_mut_slice());
) -> Variables {
let mut v_density = HerculesMutBox::from(variables.density.as_mut_slice());
let mut v_momentum_x = HerculesMutBox::from(variables.momentum.x.as_mut_slice());
let mut v_momentum_y = HerculesMutBox::from(variables.momentum.y.as_mut_slice());
let mut v_momentum_z = HerculesMutBox::from(variables.momentum.z.as_mut_slice());
let mut v_energy = HerculesMutBox::from(variables.energy.as_mut_slice());
let areas = HerculesImmBox::from(areas);
let elements_surrounding_elements = HerculesImmBox::from(elements_surrounding_elements);
let normals = HerculesImmBox::from(normals);
let ff_variable = HerculesImmBox::from(ff_variable);
// TODO: Make hercules box handle structs, for now we'll copy into a vec
let ff_fc_density_energy = vec![
ff_fc_density_energy.x,
ff_fc_density_energy.y,
ff_fc_density_energy.z,
];
let ff_fc_density_energy = HerculesImmBox::from(ff_fc_density_energy.as_slice());
let ff_fc_momentum_x = vec![ff_fc_momentum_x.x, ff_fc_momentum_x.y, ff_fc_momentum_x.z];
let ff_fc_momentum_x = HerculesImmBox::from(ff_fc_momentum_x.as_slice());
let ff_fc_momentum_y = vec![ff_fc_momentum_y.x, ff_fc_momentum_y.y, ff_fc_momentum_y.z];
let ff_fc_momentum_y = HerculesImmBox::from(ff_fc_momentum_y.as_slice());
let ff_fc_momentum_z = vec![ff_fc_momentum_z.x, ff_fc_momentum_z.y, ff_fc_momentum_z.z];
let ff_fc_momentum_z = HerculesImmBox::from(ff_fc_momentum_z.as_slice());
let mut runner = runner!(pre_euler);
let variables = variables.to();
let normals_x = HerculesImmBox::from(normals.x.as_slice());
let normals_y = HerculesImmBox::from(normals.y.as_slice());
let normals_z = HerculesImmBox::from(normals.z.as_slice());
HerculesMutBox::from(async_std::task::block_on(async {
let mut runner = runner!(pre_euler);
let (density, momentum_x, momentum_y, momentum_z, energy) = async_std::task::block_on(async {
runner
.run(
nelr as u64,
iterations as u64,
variables,
v_density.to(),
v_momentum_x.to(),
v_momentum_y.to(),
v_momentum_z.to(),
v_energy.to(),
areas.to(),
elements_surrounding_elements.to(),
normals.to(),
ff_variable.to(),
ff_fc_density_energy.to(),
ff_fc_momentum_x.to(),
ff_fc_momentum_y.to(),
ff_fc_momentum_z.to(),
normals_x.to(),
normals_y.to(),
normals_z.to(),
ff_variable.density,
ff_variable.momentum.x,
ff_variable.momentum.y,
ff_variable.momentum.z,
ff_variable.energy,
ff_fc_density_energy.x,
ff_fc_density_energy.y,
ff_fc_density_energy.z,
ff_fc_momentum_x.x,
ff_fc_momentum_x.y,
ff_fc_momentum_x.z,
ff_fc_momentum_y.x,
ff_fc_momentum_y.y,
ff_fc_momentum_y.z,
ff_fc_momentum_z.x,
ff_fc_momentum_z.y,
ff_fc_momentum_z.z,
)
.await
}))
.as_slice()
.to_vec()
});
Variables {
density: AlignedSlice::from_slice(HerculesMutBox::from(density).as_slice()),
momentum: Momentum {
x: AlignedSlice::from_slice(HerculesMutBox::from(momentum_x).as_slice()),
y: AlignedSlice::from_slice(HerculesMutBox::from(momentum_y).as_slice()),
z: AlignedSlice::from_slice(HerculesMutBox::from(momentum_z).as_slice()),
},
energy: AlignedSlice::from_slice(HerculesMutBox::from(energy).as_slice()),
}
}
fn compare_float(x: f32, y: f32) -> bool {
(x - y).abs() < 1e-5
}
fn compare_floats(xs: &[f32], ys: &[f32]) -> bool {
xs.len() == ys.len() && xs.iter().zip(ys.iter()).all(|(x, y)| compare_float(*x, *y))
fn compare_floats(xs: &Variables, ys: &Variables) -> bool {
let xs_density = xs.density.as_slice();
let xs_momentum_x = xs.momentum.x.as_slice();
let xs_momentum_y = xs.momentum.y.as_slice();
let xs_momentum_z = xs.momentum.z.as_slice();
let xs_energy = xs.energy.as_slice();
let ys_density = ys.density.as_slice();
let ys_momentum_x = ys.momentum.x.as_slice();
let ys_momentum_y = ys.momentum.y.as_slice();
let ys_momentum_z = ys.momentum.z.as_slice();
let ys_energy = ys.energy.as_slice();
xs_density.len() == ys_density.len()
&& xs_density
.iter()
.zip(ys_density.iter())
.all(|(x, y)| compare_float(*x, *y))
&& xs_momentum_x.len() == ys_momentum_x.len()
&& xs_momentum_x
.iter()
.zip(ys_momentum_x.iter())
.all(|(x, y)| compare_float(*x, *y))
&& xs_momentum_y.len() == ys_momentum_y.len()
&& xs_momentum_y
.iter()
.zip(ys_momentum_y.iter())
.all(|(x, y)| compare_float(*x, *y))
&& xs_momentum_z.len() == ys_momentum_z.len()
&& xs_momentum_z
.iter()
.zip(ys_momentum_z.iter())
.all(|(x, y)| compare_float(*x, *y))
&& xs_energy.len() == ys_energy.len()
&& xs_energy
.iter()
.zip(ys_energy.iter())
.all(|(x, y)| compare_float(*x, *y))
}
pub fn cfd_harness(args: CFDInputs) {
......@@ -151,8 +221,6 @@ pub fn cfd_harness(args: CFDInputs) {
pre_euler,
} = args;
assert!(block_size % 16 == 0, "Hercules expects all arrays to be 64-byte aligned, cfd uses structs of arrays that are annoying to deal with if the block_size is not a multiple of 16");
let FarFieldConditions {
ff_variable,
ff_fc_momentum_x,
......@@ -168,7 +236,8 @@ pub fn cfd_harness(args: CFDInputs) {
normals,
} = read_domain_geometry(data_file, block_size);
let variables = initialize_variables(nelr, ff_variable.as_slice());
let variables = initialize_variables(nelr, &ff_variable);
println!("Running CFD with nelr = {}.", nelr);
let res_juno = if pre_euler {
run_pre_euler(
......@@ -177,8 +246,8 @@ pub fn cfd_harness(args: CFDInputs) {
variables.clone(),
areas.as_slice(),
elements_surrounding_elements.as_slice(),
normals.as_slice(),
ff_variable.as_slice(),
&normals,
&ff_variable,
&ff_fc_density_energy,
&ff_fc_momentum_x,
&ff_fc_momentum_y,
......@@ -191,8 +260,8 @@ pub fn cfd_harness(args: CFDInputs) {
variables.clone(),
areas.as_slice(),
elements_surrounding_elements.as_slice(),
normals.as_slice(),
ff_variable.as_slice(),
&normals,
&ff_variable,
&ff_fc_density_energy,
&ff_fc_momentum_x,
&ff_fc_momentum_y,
......@@ -206,8 +275,8 @@ pub fn cfd_harness(args: CFDInputs) {
variables,
areas.as_slice(),
elements_surrounding_elements.as_slice(),
normals.as_slice(),
ff_variable.as_slice(),
&normals,
&ff_variable,
&ff_fc_density_energy,
&ff_fc_momentum_x,
&ff_fc_momentum_y,
......@@ -220,8 +289,8 @@ pub fn cfd_harness(args: CFDInputs) {
variables,
areas.as_slice(),
elements_surrounding_elements.as_slice(),
normals.as_slice(),
ff_variable.as_slice(),
&normals,
&ff_variable,
&ff_fc_density_energy,
&ff_fc_momentum_x,
&ff_fc_momentum_y,
......@@ -229,8 +298,7 @@ pub fn cfd_harness(args: CFDInputs) {
)
};
if !compare_floats(&res_juno, res_rust.as_slice()) {
assert_eq!(res_juno.len(), res_rust.as_slice().len());
if !compare_floats(&res_juno, &res_rust) {
panic!("Mismatch in results");
}
}
juno_samples/rodinia/cfd/src/pre_euler.jn
View file @ 0717de36
......@@ -58,7 +58,7 @@ fn compute_speed_of_sound(density: f32, pressure: f32) -> f32 {
}
fn compute_step_factor<nelr: usize>(variables: Variables::<nelr>, areas: f32[nelr]) -> f32[nelr] {
let step_factors : f32[nelr];
@res let step_factors : f32[nelr];
for i in 0..nelr {
let density = variables.density[i];
......@@ -109,10 +109,10 @@ fn compute_flux_contribution(
fn compute_flux_contributions<nelr: usize>(
variables: Variables::<nelr>,
) -> (Momentum::<nelr>, Momentum::<nelr>, Momentum::<nelr>, Momentum::<nelr>) {
let fc_momentum_x: Momentum::<nelr>;
let fc_momentum_y: Momentum::<nelr>;
let fc_momentum_z: Momentum::<nelr>;
let fc_density_energy: Momentum::<nelr>;
@res let fc_momentum_x: Momentum::<nelr>;
@res let fc_momentum_y: Momentum::<nelr>;
@res let fc_momentum_z: Momentum::<nelr>;
@res let fc_density_energy: Momentum::<nelr>;
for i in 0..nelr {
let density_i = variables.density[i];
......@@ -167,9 +167,9 @@ fn compute_flux<nelr: usize>(
ff_fc_momentum_z: float3,
) -> Variables::<nelr> {
const smoothing_coefficient : f32 = 0.2;
let fluxes: Variables::<nelr>;
@res let fluxes: Variables::<nelr>;
for i in 0..nelr {
@outer_loop for i in 0..nelr {
let density_i = variables.density[i];
let momentum_i = float3 { x: variables.momentum.x[i],
......@@ -201,7 +201,7 @@ fn compute_flux<nelr: usize>(
let flux_i_momentum = float3 { x: 0.0, y: 0.0, z: 0.0 };
let flux_i_density_energy : f32 = 0.0;
for j in 0..NNB {
@inner_loop for j in 0..NNB {
let nb = elements_surrounding_elements[j, i];
let normal = float3 {
x: normals.x[j, i],
......@@ -328,7 +328,7 @@ fn time_step<nelr: usize>(
}
fn copy_vars<nelr: usize>(variables: Variables::<nelr>) -> Variables::<nelr> {
let result : Variables::<nelr>;
@res let result : Variables::<nelr>;
for i in 0..nelr {
result.density[i] = variables.density[i];
......
juno_samples/rodinia/cfd/src/rust_cfd.rs
View file @ 0717de36
......@@ -58,19 +58,19 @@ fn compute_speed_of_sound(density: f32, pressure: f32) -> f32 {
(GAMMA * pressure / density).sqrt()
}
fn compute_step_factor(nelr: usize, variables: &[f32], areas: &[f32]) -> Vec<f32> {
fn compute_step_factor(nelr: usize, variables: &Variables, areas: &[f32]) -> Vec<f32> {
let mut step_factors = vec![0.0; nelr];
for i in 0..nelr {
let density = variables[i + VAR_DENSITY * nelr];
let density = variables.density[i];
let momentum = Float3 {
x: variables[i + (VAR_MOMENTUM + 0) * nelr],
y: variables[i + (VAR_MOMENTUM + 1) * nelr],
z: variables[i + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[i],
y: variables.momentum.y[i],
z: variables.momentum.z[i],
};
let density_energy = variables[i + VAR_DENSITY_ENERGY * nelr];
let density_energy = variables.energy[i];
let velocity = compute_velocity(density, &momentum);
let speed_sqd = compute_speed_sqd(&velocity);
......@@ -85,28 +85,36 @@ fn compute_step_factor(nelr: usize, variables: &[f32], areas: &[f32]) -> Vec<f32
fn compute_flux_euler(
nelr: usize,
variables: &[f32],
variables: &Variables,
elements_surrounding_elements: &[i32],
normals: &[f32],
ff_variable: &[f32],
normals: &Normals,
ff_variable: &Variable,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
ff_fc_density_energy: &Float3,
) -> Vec<f32> {
) -> Variables {
let smoothing_coefficient: f32 = 0.2;
let mut fluxes = vec![0.0; nelr * NVAR];
let mut fluxes = Variables {
density: AlignedSlice::of_len(nelr),
momentum: Momentum {
x: AlignedSlice::of_len(nelr),
y: AlignedSlice::of_len(nelr),
z: AlignedSlice::of_len(nelr),
},
energy: AlignedSlice::of_len(nelr),
};
for i in 0..nelr {
let density_i = variables[i + VAR_DENSITY * nelr];
let density_i = variables.density[i];
let momentum_i = Float3 {
x: variables[i + (VAR_MOMENTUM + 0) * nelr],
y: variables[i + (VAR_MOMENTUM + 1) * nelr],
z: variables[i + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[i],
y: variables.momentum.y[i],
z: variables.momentum.z[i],
};
let density_energy_i = variables[i + VAR_DENSITY_ENERGY * nelr];
let density_energy_i = variables.energy[i];
let velocity_i = compute_velocity(density_i, &momentum_i);
let speed_sqd_i = compute_speed_sqd(&velocity_i);
......@@ -134,9 +142,9 @@ fn compute_flux_euler(
for j in 0..NNB {
let nb = elements_surrounding_elements[i + j * nelr];
let normal = Float3 {
x: normals[i + (j + 0 * NNB) * nelr],
y: normals[i + (j + 1 * NNB) * nelr],
z: normals[i + (j + 2 * NNB) * nelr],
x: normals.x[i + j * nelr],
y: normals.y[i + j * nelr],
z: normals.z[i + j * nelr],
};
let normal_len =
(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z).sqrt();
......@@ -144,13 +152,13 @@ fn compute_flux_euler(
if nb >= 0 {
// legitimate neighbor
let nb = nb as usize;
let density_nb = variables[nb + VAR_DENSITY * nelr];
let density_nb = variables.density[nb];
let momentum_nb = Float3 {
x: variables[nb + (VAR_MOMENTUM + 0) * nelr],
y: variables[nb + (VAR_MOMENTUM + 1) * nelr],
z: variables[nb + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[nb],
y: variables.momentum.y[nb],
z: variables.momentum.z[nb],
};
let density_energy_nb = variables[nb + VAR_DENSITY_ENERGY * nelr];
let density_energy_nb = variables.energy[nb];
let velocity_nb = compute_velocity(density_nb, &momentum_nb);
let speed_sqd_nb = compute_speed_sqd(&velocity_nb);
let pressure_nb = compute_pressure(density_nb, density_energy_nb, speed_sqd_nb);
......@@ -205,21 +213,21 @@ fn compute_flux_euler(
} else if nb == -2 {
// a far field boundary
let factor = 0.5 * normal.x;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 0] + momentum_i.x);
flux_i_density += factor * (ff_variable.momentum.x + momentum_i.x);
flux_i_density_energy += factor * (ff_fc_density_energy.x + fc_i_density_energy.x);
flux_i_momentum.x += factor * (ff_fc_momentum_x.x + fc_i_momentum_x.x);
flux_i_momentum.y += factor * (ff_fc_momentum_y.x + fc_i_momentum_y.x);
flux_i_momentum.z += factor * (ff_fc_momentum_z.x + fc_i_momentum_z.x);
let factor = 0.5 * normal.y;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 1] + momentum_i.y);
flux_i_density += factor * (ff_variable.momentum.y + momentum_i.y);
flux_i_density_energy += factor * (ff_fc_density_energy.y + fc_i_density_energy.y);
flux_i_momentum.x += factor * (ff_fc_momentum_x.y + fc_i_momentum_x.y);
flux_i_momentum.y += factor * (ff_fc_momentum_y.y + fc_i_momentum_y.y);
flux_i_momentum.z += factor * (ff_fc_momentum_z.y + fc_i_momentum_z.y);
let factor = 0.5 * normal.z;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 2] + momentum_i.z);
flux_i_density += factor * (ff_variable.momentum.z + momentum_i.z);
flux_i_density_energy += factor * (ff_fc_density_energy.z + fc_i_density_energy.z);
flux_i_momentum.x += factor * (ff_fc_momentum_x.z + fc_i_momentum_x.z);
flux_i_momentum.y += factor * (ff_fc_momentum_y.z + fc_i_momentum_y.z);
......@@ -227,11 +235,11 @@ fn compute_flux_euler(
}
}
fluxes[i + VAR_DENSITY * nelr] = flux_i_density;
fluxes[i + (VAR_MOMENTUM + 0) * nelr] = flux_i_momentum.x;
fluxes[i + (VAR_MOMENTUM + 1) * nelr] = flux_i_momentum.y;
fluxes[i + (VAR_MOMENTUM + 2) * nelr] = flux_i_momentum.z;
fluxes[i + VAR_DENSITY_ENERGY * nelr] = flux_i_density_energy;
fluxes.density[i] = flux_i_density;
fluxes.momentum.x[i] = flux_i_momentum.x;
fluxes.momentum.y[i] = flux_i_momentum.y;
fluxes.momentum.z[i] = flux_i_momentum.z;
fluxes.energy[i] = flux_i_density_energy;
}
fluxes
......@@ -239,7 +247,7 @@ fn compute_flux_euler(
fn compute_flux_contributions(
nelr: usize,
variables: &[f32],
variables: &Variables,
) -> (Vec<f32>, Vec<f32>, Vec<f32>, Vec<f32>) {
let mut fc_momentum_x = vec![0.0; nelr * NDIM];
let mut fc_momentum_y = vec![0.0; nelr * NDIM];
......@@ -247,14 +255,14 @@ fn compute_flux_contributions(
let mut fc_density_energy = vec![0.0; nelr * NDIM];
for i in 0..nelr {
let density_i = variables[i + VAR_DENSITY * nelr];
let density_i = variables.density[i];
let momentum_i = Float3 {
x: variables[i + (VAR_MOMENTUM + 0) * nelr],
y: variables[i + (VAR_MOMENTUM + 1) * nelr],
z: variables[i + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[i],
y: variables.momentum.y[i],
z: variables.momentum.z[i],
};
let density_energy_i = variables[i + VAR_DENSITY_ENERGY * nelr];
let density_energy_i = variables.energy[i];
let velocity_i = compute_velocity(density_i, &momentum_i);
let speed_sqd_i = compute_speed_sqd(&velocity_i);
......@@ -298,32 +306,40 @@ fn compute_flux_contributions(
fn compute_flux_pre_euler(
nelr: usize,
variables: &[f32],
variables: &Variables,
elements_surrounding_elements: &[i32],
normals: &[f32],
normals: &Normals,
fc_momentum_x: &[f32],
fc_momentum_y: &[f32],
fc_momentum_z: &[f32],
fc_density_energy: &[f32],
ff_variable: &[f32],
ff_variable: &Variable,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
ff_fc_density_energy: &Float3,
) -> Vec<f32> {
) -> Variables {
let smoothing_coefficient: f32 = 0.2;
let mut fluxes = vec![0.0; nelr * NVAR];
let mut fluxes = Variables {
density: AlignedSlice::of_len(nelr),
momentum: Momentum {
x: AlignedSlice::of_len(nelr),
y: AlignedSlice::of_len(nelr),
z: AlignedSlice::of_len(nelr),
},
energy: AlignedSlice::of_len(nelr),
};
for i in 0..nelr {
let density_i = variables[i + VAR_DENSITY * nelr];
let density_i = variables.density[i];
let momentum_i = Float3 {
x: variables[i + (VAR_MOMENTUM + 0) * nelr],
y: variables[i + (VAR_MOMENTUM + 1) * nelr],
z: variables[i + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[i],
y: variables.momentum.y[i],
z: variables.momentum.z[i],
};
let density_energy_i = variables[i + VAR_DENSITY_ENERGY * nelr];
let density_energy_i = variables.energy[i];
let velocity_i = compute_velocity(density_i, &momentum_i);
let speed_sqd_i = compute_speed_sqd(&velocity_i);
......@@ -363,22 +379,22 @@ fn compute_flux_pre_euler(
for j in 0..NNB {
let nb = elements_surrounding_elements[i + j * nelr];
let normal = Float3 {
x: normals[i + (j + 0 * NNB) * nelr],
y: normals[i + (j + 1 * NNB) * nelr],
z: normals[i + (j + 2 * NNB) * nelr],
x: normals.x[i + j * nelr],
y: normals.y[i + j * nelr],
z: normals.z[i + j * nelr],
};
let normal_len =
(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z).sqrt();
if nb >= 0 {
let nb = nb as usize;
let density_nb = variables[nb + VAR_DENSITY * nelr];
let density_nb = variables.density[nb];
let momentum_nb = Float3 {
x: variables[nb + (VAR_MOMENTUM + 0) * nelr],
y: variables[nb + (VAR_MOMENTUM + 1) * nelr],
z: variables[nb + (VAR_MOMENTUM + 2) * nelr],
x: variables.momentum.x[nb],
y: variables.momentum.y[nb],
z: variables.momentum.z[nb],
};
let density_energy_nb = variables[nb + VAR_DENSITY_ENERGY * nelr];
let density_energy_nb = variables.energy[nb];
let velocity_nb = compute_velocity(density_nb, &momentum_nb);
let speed_sqd_nb = compute_speed_sqd(&velocity_nb);
let pressure_nb = compute_pressure(density_nb, density_energy_nb, speed_sqd_nb);
......@@ -443,21 +459,21 @@ fn compute_flux_pre_euler(
flux_i_momentum.z += normal.z * pressure_i;
} else if nb == -2 {
let factor = 0.5 * normal.x;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 0] + momentum_i.x);
flux_i_density += factor * (ff_variable.momentum.x + momentum_i.x);
flux_i_density_energy += factor * (ff_fc_density_energy.x + fc_i_density_energy.x);
flux_i_momentum.x += factor * (ff_fc_momentum_x.x + fc_i_momentum_x.x);
flux_i_momentum.y += factor * (ff_fc_momentum_y.x + fc_i_momentum_y.x);
flux_i_momentum.z += factor * (ff_fc_momentum_z.x + fc_i_momentum_z.x);
let factor = 0.5 * normal.y;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 1] + momentum_i.y);
flux_i_density += factor * (ff_variable.momentum.y + momentum_i.y);
flux_i_density_energy += factor * (ff_fc_density_energy.y + fc_i_density_energy.y);
flux_i_momentum.x += factor * (ff_fc_momentum_x.y + fc_i_momentum_x.y);
flux_i_momentum.y += factor * (ff_fc_momentum_y.y + fc_i_momentum_y.y);
flux_i_momentum.z += factor * (ff_fc_momentum_z.y + fc_i_momentum_z.y);
let factor = 0.5 * normal.z;
flux_i_density += factor * (ff_variable[VAR_MOMENTUM + 2] + momentum_i.z);
flux_i_density += factor * (ff_variable.momentum.z + momentum_i.z);
flux_i_density_energy += factor * (ff_fc_density_energy.z + fc_i_density_energy.z);
flux_i_momentum.x += factor * (ff_fc_momentum_x.z + fc_i_momentum_x.z);
flux_i_momentum.y += factor * (ff_fc_momentum_y.z + fc_i_momentum_y.z);
......@@ -465,11 +481,11 @@ fn compute_flux_pre_euler(
}
}
fluxes[i + VAR_DENSITY * nelr] = flux_i_density;
fluxes[i + (VAR_MOMENTUM + 0) * nelr] = flux_i_momentum.x;
fluxes[i + (VAR_MOMENTUM + 1) * nelr] = flux_i_momentum.y;
fluxes[i + (VAR_MOMENTUM + 2) * nelr] = flux_i_momentum.z;
fluxes[i + VAR_DENSITY_ENERGY * nelr] = flux_i_density_energy;
fluxes.density[i] = flux_i_density;
fluxes.momentum.x[i] = flux_i_momentum.x;
fluxes.momentum.y[i] = flux_i_momentum.y;
fluxes.momentum.z[i] = flux_i_momentum.z;
fluxes.energy[i] = flux_i_density_energy;
}
fluxes
......@@ -478,47 +494,42 @@ fn compute_flux_pre_euler(
fn time_step(
j: usize,
nelr: usize,
old_variables: &[f32],
variables: &mut AlignedSlice<f32>,
old_variables: &Variables,
variables: &mut Variables,
step_factors: &[f32],
fluxes: &[f32],
fluxes: &Variables,
) {
for i in 0..nelr {
let factor = step_factors[i] / (RK + 1 - j) as f32;
variables[i + VAR_DENSITY * nelr] =
old_variables[i + VAR_DENSITY * nelr] + factor * fluxes[i + VAR_DENSITY * nelr];
variables[i + (VAR_MOMENTUM + 0) * nelr] = old_variables[i + (VAR_MOMENTUM + 0) * nelr]
+ factor * fluxes[i + (VAR_MOMENTUM + 0) * nelr];
variables[i + (VAR_MOMENTUM + 1) * nelr] = old_variables[i + (VAR_MOMENTUM + 1) * nelr]
+ factor * fluxes[i + (VAR_MOMENTUM + 1) * nelr];
variables[i + (VAR_MOMENTUM + 2) * nelr] = old_variables[i + (VAR_MOMENTUM + 2) * nelr]
+ factor * fluxes[i + (VAR_MOMENTUM + 2) * nelr];
variables[i + VAR_DENSITY_ENERGY * nelr] = old_variables[i + VAR_DENSITY_ENERGY * nelr]
+ factor * fluxes[i + VAR_DENSITY_ENERGY * nelr];
variables.density[i] = old_variables.density[i] + factor * fluxes.density[i];
variables.momentum.x[i] = old_variables.momentum.x[i] + factor * fluxes.momentum.x[i];
variables.momentum.y[i] = old_variables.momentum.y[i] + factor * fluxes.momentum.y[i];
variables.momentum.z[i] = old_variables.momentum.z[i] + factor * fluxes.momentum.z[i];
variables.energy[i] = old_variables.energy[i] + factor * fluxes.energy[i];
}
}
pub fn euler(
nelr: usize,
iterations: usize,
mut variables: AlignedSlice<f32>,
mut variables: Variables,
areas: &[f32],
elements_surrounding_elements: &[i32],
normals: &[f32],
ff_variable: &[f32],
normals: &Normals,
ff_variable: &Variable,
ff_fc_density_energy: &Float3,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
) -> AlignedSlice<f32> {
) -> Variables {
for i in 0..iterations {
let old_variables = variables.clone();
let step_factors = compute_step_factor(nelr, variables.as_slice(), areas);
let step_factors = compute_step_factor(nelr, &variables, areas);
for j in 0..RK {
let fluxes = compute_flux_euler(
nelr,
variables.as_slice(),
&variables,
elements_surrounding_elements,
normals,
ff_variable,
......@@ -530,7 +541,7 @@ pub fn euler(
time_step(
j,
nelr,
old_variables.as_slice(),
&old_variables,
&mut variables,
&step_factors,
&fluxes,
......@@ -544,26 +555,26 @@ pub fn euler(
pub fn pre_euler(
nelr: usize,
iterations: usize,
mut variables: AlignedSlice<f32>,
mut variables: Variables,
areas: &[f32],
elements_surrounding_elements: &[i32],
normals: &[f32],
ff_variable: &[f32],
normals: &Normals,
ff_variable: &Variable,
ff_fc_density_energy: &Float3,
ff_fc_momentum_x: &Float3,
ff_fc_momentum_y: &Float3,
ff_fc_momentum_z: &Float3,
) -> AlignedSlice<f32> {
) -> Variables {
for i in 0..iterations {
let old_variables = variables.clone();
let step_factors = compute_step_factor(nelr, variables.as_slice(), areas);
let step_factors = compute_step_factor(nelr, &variables, areas);
for j in 0..RK {
let (fc_momentum_x, fc_momentum_y, fc_momentum_z, fc_density_energy) =
compute_flux_contributions(nelr, variables.as_slice());
compute_flux_contributions(nelr, &variables);
let fluxes = compute_flux_pre_euler(
nelr,
variables.as_slice(),
&variables,
elements_surrounding_elements,
normals,
&fc_momentum_x,
......@@ -579,7 +590,7 @@ pub fn pre_euler(
time_step(
j,
nelr,
old_variables.as_slice(),
&old_variables,
&mut variables,
&step_factors,
&fluxes,
......
juno_samples/rodinia/cfd/src/setup.rs
View file @ 0717de36
use std::fmt::{Debug, Error, Formatter};
use std::fs::File;
use std::io::Read;
use std::ops::{Index, IndexMut};
use std::path::Path;
use std::str::FromStr;
use std::ops::{Index, IndexMut};
use nom::Parser;
use crate::rust_cfd;
......@@ -14,10 +14,6 @@ pub const ff_mach: f32 = 1.2;
pub const NDIM: usize = 3;
pub const NNB: usize = 4;
pub const RK: usize = 3;
pub const VAR_DENSITY: usize = 0;
pub const VAR_MOMENTUM: usize = 1;
pub const VAR_DENSITY_ENERGY: usize = VAR_MOMENTUM + NDIM;
pub const NVAR: usize = VAR_DENSITY_ENERGY + 1;
pub const deg_angle_of_attack: f32 = 0.0;
#[repr(align(64))]
......@@ -31,6 +27,15 @@ pub struct AlignedSlice<T> {
length: usize,
}
impl<T> Debug for AlignedSlice<T>
where
T: Debug
{
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
write!(f, "{:?}", self.as_slice())
}
}
impl<T> AlignedSlice<T>
where
T: Default,
......@@ -53,6 +58,17 @@ where
}
}
impl<T> AlignedSlice<T>
where
T: Clone + Default,
{
pub fn from_slice(slice: &[T]) -> Self {
let mut res = Self::of_len(slice.len());
res.as_mut_slice().clone_from_slice(slice);
res
}
}
impl<T> AlignedSlice<T> {
pub fn as_slice(&self) -> &[T] {
&self.slice[self.offset..self.offset + self.length]
......@@ -90,15 +106,20 @@ where
}
}
#[repr(C)]
pub struct Float3 {
pub x: f32,
pub y: f32,
pub z: f32,
}
pub struct Variable {
pub density: f32,
pub momentum: Float3,
pub energy: f32,
}
pub struct FarFieldConditions {
pub ff_variable: AlignedSlice<f32>,
pub ff_variable: Variable,
pub ff_fc_momentum_x: Float3,
pub ff_fc_momentum_y: Float3,
pub ff_fc_momentum_z: Float3,
......@@ -106,14 +127,14 @@ pub struct FarFieldConditions {
}
pub fn set_far_field_conditions() -> FarFieldConditions {
let mut ff_variable: AlignedSlice<f32> = AlignedSlice::of_len(NVAR);
let mut ff_variable = Variable { density: 0.0, momentum: Float3 { x: 0.0, y: 0.0, z: 0.0 }, energy: 0.0 };
let angle_of_attack = std::f32::consts::PI / 180.0 * deg_angle_of_attack;
ff_variable[VAR_DENSITY] = 1.4;
ff_variable.density = 1.4;
let ff_pressure = 1.0;
let ff_speed_of_sound = (GAMMA * ff_pressure / ff_variable[VAR_DENSITY]).sqrt();
let ff_speed_of_sound = (GAMMA * ff_pressure / ff_variable.density).sqrt();
let ff_speed = ff_mach * ff_speed_of_sound;
let ff_velocity = Float3 {
......@@ -122,23 +143,23 @@ pub fn set_far_field_conditions() -> FarFieldConditions {
z: 0.0,
};
ff_variable[VAR_MOMENTUM + 0] = ff_variable[VAR_DENSITY] * ff_velocity.x;
ff_variable[VAR_MOMENTUM + 1] = ff_variable[VAR_DENSITY] * ff_velocity.y;
ff_variable[VAR_MOMENTUM + 2] = ff_variable[VAR_DENSITY] * ff_velocity.z;
ff_variable.momentum.x = ff_variable.density * ff_velocity.x;
ff_variable.momentum.y = ff_variable.density * ff_velocity.y;
ff_variable.momentum.z = ff_variable.density * ff_velocity.z;
ff_variable[VAR_DENSITY_ENERGY] =
ff_variable[VAR_DENSITY] * (0.5 * (ff_speed * ff_speed)) + (ff_pressure / (GAMMA - 1.0));
ff_variable.energy =
ff_variable.density * (0.5 * (ff_speed * ff_speed)) + (ff_pressure / (GAMMA - 1.0));
let ff_momentum = Float3 {
x: ff_variable[VAR_MOMENTUM + 0],
y: ff_variable[VAR_MOMENTUM + 1],
z: ff_variable[VAR_MOMENTUM + 2],
x: ff_variable.momentum.x,
y: ff_variable.momentum.y,
z: ff_variable.momentum.z,
};
let (ff_fc_momentum_x, ff_fc_momentum_y, ff_fc_momentum_z, ff_fc_density_energy) =
rust_cfd::compute_flux_contribution(
ff_variable[VAR_DENSITY],
ff_variable.density,
&ff_momentum,
ff_variable[VAR_DENSITY_ENERGY],
ff_variable.energy,
ff_pressure,
&ff_velocity,
);
......@@ -152,11 +173,17 @@ pub fn set_far_field_conditions() -> FarFieldConditions {
}
}
pub struct Normals {
pub x: AlignedSlice<f32>,
pub y: AlignedSlice<f32>,
pub z: AlignedSlice<f32>,
}
pub struct GeometryData {
pub nelr: usize,
pub areas: AlignedSlice<f32>,
pub elements_surrounding_elements: AlignedSlice<i32>,
pub normals: AlignedSlice<f32>,
pub normals: Normals,
}
pub fn read_domain_geometry<P>(path: P, block_size: usize) -> GeometryData
......@@ -183,7 +210,11 @@ fn cfd_parser<'a>(block_size: usize, text: &'a str) -> nom::IResult<&'a str, Geo
let mut areas: AlignedSlice<f32> = AlignedSlice::of_len(nelr);
let mut elements_surrounding_elements: AlignedSlice<i32> = AlignedSlice::of_len(nelr * NNB);
let mut normals: AlignedSlice<f32> = AlignedSlice::of_len(NDIM * NNB * nelr);
let mut normals = Normals {
x: AlignedSlice::of_len(NNB * nelr),
y: AlignedSlice::of_len(NNB * nelr),
z: AlignedSlice::of_len(NNB * nelr),
};
// read in data
let mut text = text;
......@@ -209,14 +240,21 @@ fn cfd_parser<'a>(block_size: usize, text: &'a str) -> nom::IResult<&'a str, Geo
let val = i32::from_str(val).unwrap();
let val = if neg { -val } else { val };
elements_surrounding_elements[i + j * nelr] = if val < 0 { -1 } else { val } - 1; // it's coming in with Fortran numbering
for k in 0..NDIM {
let t = nom::character::complete::multispace0(text)?.0;
let (t, val) = nom::number::complete::float(t)?;
text = t;
normals[i + (j + k * NNB) * nelr] = -val;
}
let t = nom::character::complete::multispace0(text)?.0;
let (t, val) = nom::number::complete::float(t)?;
text = t;
normals.x[i + j * nelr] = -val;
let t = nom::character::complete::multispace0(text)?.0;
let (t, val) = nom::number::complete::float(t)?;
text = t;
normals.y[i + j * nelr] = -val;
let t = nom::character::complete::multispace0(text)?.0;
let (t, val) = nom::number::complete::float(t)?;
text = t;
normals.z[i + j * nelr] = -val;
}
}
......@@ -227,9 +265,9 @@ fn cfd_parser<'a>(block_size: usize, text: &'a str) -> nom::IResult<&'a str, Geo
for j in 0..NNB {
elements_surrounding_elements[i + j * nelr] =
elements_surrounding_elements[last + j * nelr];
for k in 0..NDIM {
normals[i + (j + k * NNB) * nelr] = normals[last + (j + k * NNB) * nelr];
}
normals.x[i + j * nelr] = normals.x[last + j * nelr];
normals.y[i + j * nelr] = normals.y[last + j * nelr];
normals.z[i + j * nelr] = normals.z[last + j * nelr];
}
}
......@@ -245,13 +283,37 @@ fn cfd_parser<'a>(block_size: usize, text: &'a str) -> nom::IResult<&'a str, Geo
))
}
pub fn initialize_variables(nelr: usize, ff_variable: &[f32]) -> AlignedSlice<f32> {
let mut variables = AlignedSlice::of_len(nelr * NVAR);
#[derive(Clone)]
pub struct Momentum {
pub x: AlignedSlice<f32>,
pub y: AlignedSlice<f32>,
pub z: AlignedSlice<f32>,
}
#[derive(Clone)]
pub struct Variables {
pub density: AlignedSlice<f32>,
pub momentum: Momentum,
pub energy: AlignedSlice<f32>,
}
pub fn initialize_variables(nelr: usize, ff_variable: &Variable) -> Variables {
let mut variables = Variables {
density: AlignedSlice::of_len(nelr),
momentum: Momentum {
x: AlignedSlice::of_len(nelr),
y: AlignedSlice::of_len(nelr),
z: AlignedSlice::of_len(nelr),
},
energy: AlignedSlice::of_len(nelr),
};
for i in 0..nelr {
for j in 0..NVAR {
variables[i + j * nelr] = ff_variable[j];
}
variables.density[i] = ff_variable.density;
variables.momentum.x[i] = ff_variable.momentum.x;
variables.momentum.y[i] = ff_variable.momentum.y;
variables.momentum.z[i] = ff_variable.momentum.z;
variables.energy[i] = ff_variable.energy;
}
variables
......
juno_samples/rodinia/srad/src/gpu.sch
View file @ 0717de36
......@@ -54,4 +54,10 @@ ip-sroa(*);
sroa(*);
simpl!(*);
fork-dim-merge(main_loops);
fork-tile[32, 0, false, true](main_loops);
dce(main_loops);
fork-split(main_loops);
simpl!(main_loops);
gcm(*);
juno_scheduler/src/compile.rs
View file @ 0717de36
......@@ -22,6 +22,7 @@ pub enum ScheduleCompilerError {
actual: usize,
loc: Location,
},
SemanticError(String, Location),
}
impl fmt::Display for ScheduleCompilerError {
......@@ -46,6 +47,11 @@ impl fmt::Display for ScheduleCompilerError {
"({}, {}) -- ({}, {}): Expected {} arguments, found {}",
loc.0 .0, loc.0 .1, loc.1 .0, loc.1 .1, expected, actual
),
ScheduleCompilerError::SemanticError(msg, loc) => write!(
f,
"({}, {}) -- ({}, {}): {}",
loc.0 .0, loc.0 .1, loc.1 .0, loc.1 .1, msg,
),
}
}
}
......@@ -76,6 +82,8 @@ enum Appliable {
// DeleteUncalled requires special handling because it changes FunctionIDs, so it is not
// treated like a pass
DeleteUncalled,
// Test whether a feature is enabled
Feature,
Schedule(Schedule),
Device(Device),
}
......@@ -85,6 +93,8 @@ impl Appliable {
fn is_valid_num_args(&self, num: usize) -> bool {
match self {
Appliable::Pass(pass) => pass.is_valid_num_args(num),
// Testing whether a feature is enabled takes the feature instead of a selection, so it
// has 0 arguments
// Delete uncalled, Schedules, and devices do not take arguments
_ => num == 0,
}
......@@ -158,6 +168,8 @@ impl FromStr for Appliable {
"serialize" => Ok(Appliable::Pass(ir::Pass::Serialize)),
"write-predication" => Ok(Appliable::Pass(ir::Pass::WritePredication)),
"feature" => Ok(Appliable::Feature),
"print" => Ok(Appliable::Pass(ir::Pass::Print)),
"cpu" | "llvm" => Ok(Appliable::Device(Device::LLVM)),
......@@ -275,6 +287,35 @@ fn compile_stmt(
limit,
}])
}
parser::Stmt::IfThenElse {
span: _,
cond,
thn,
els,
} => {
let cond = compile_exp_as_expr(cond, lexer, macrostab, macros)?;
macros.open_scope();
let thn = ir::ScheduleStmt::Block {
body: compile_ops_as_block(*thn, lexer, macrostab, macros)?,
};
macros.close_scope();
macros.open_scope();
let els = match els {
Some(els) => ir::ScheduleStmt::Block {
body: compile_ops_as_block(*els, lexer, macrostab, macros)?,
},
None => ir::ScheduleStmt::Block { body: vec![] },
};
macros.close_scope();
Ok(vec![ir::ScheduleStmt::IfThenElse {
cond,
thn: Box::new(thn),
els: Box::new(els),
}])
}
parser::Stmt::MacroDecl { span: _, def } => {
let parser::MacroDecl {
name,
......@@ -380,6 +421,17 @@ fn compile_expr(
on: selection,
}))
}
Appliable::Feature => match selection {
ir::Selector::Selection(mut args) if args.len() == 1 => {
Ok(ExprResult::Expr(ir::ScheduleExp::Feature {
feature: Box::new(args.pop().unwrap()),
}))
}
_ => Err(ScheduleCompilerError::SemanticError(
"feature requires exactly one argument as its selection".to_string(),
lexer.line_col(span),
)),
},
Appliable::Schedule(sched) => Ok(ExprResult::Stmt(ir::ScheduleStmt::AddSchedule {
sched,
on: selection,
......
juno_scheduler/src/ir.rs
View file @ 0717de36
......@@ -121,6 +121,9 @@ pub enum ScheduleExp {
DeleteUncalled {
on: Selector,
},
Feature {
feature: Box<ScheduleExp>,
},
Record {
fields: Vec<(String, ScheduleExp)>,
},
......@@ -180,4 +183,9 @@ pub enum ScheduleStmt {
device: Device,
on: Selector,
},
IfThenElse {
cond: ScheduleExp,
thn: Box<ScheduleStmt>,
els: Box<ScheduleStmt>,
},
}
juno_scheduler/src/lang.l
View file @ 0717de36
......@@ -20,12 +20,15 @@
\. "."
apply "apply"
else "else"
fixpoint "fixpoint"
if "if"
let "let"
macro "macro_keyword"
on "on"
set "set"
target "target"
then "then"
true "true"
false "false"
......
juno_scheduler/src/lang.y
View file @ 0717de36
......@@ -27,6 +27,10 @@ Stmt -> Stmt
{ Stmt::ExprStmt { span: $span, exp: $1 } }
| 'fixpoint' FixpointLimit '{' Schedule '}'
{ Stmt::Fixpoint { span: $span, limit: $2, body: Box::new($4) } }
| 'if' Expr '{' Schedule '}'
{ Stmt::IfThenElse { span: $span, cond: $2, thn: Box::new($4), els: None } }
| 'if' Expr '{' Schedule '}' 'else' '{' Schedule '}'
{ Stmt::IfThenElse { span: $span, cond: $2, thn: Box::new($4), els: Some(Box::new($8)) } }
| MacroDecl
{ Stmt::MacroDecl { span: $span, def: $1 } }
;
......@@ -163,6 +167,7 @@ pub enum Stmt {
AssignStmt { span: Span, var: Span, rhs: Expr },
ExprStmt { span: Span, exp: Expr },
Fixpoint { span: Span, limit: FixpointLimit, body: Box<OperationList> },
IfThenElse { span: Span, cond: Expr, thn: Box<OperationList>, els: Option<Box<OperationList>> },
MacroDecl { span: Span, def: MacroDecl },
}
......
juno_scheduler/src/pm.rs
View file @ 0717de36
......@@ -16,6 +16,7 @@ use juno_utils::stringtab::StringTable;
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::env;
use std::fmt;
use std::fs::File;
use std::io::Write;
......@@ -1090,7 +1091,9 @@ impl PassManager {
let mut nvcc_process = Command::new("nvcc")
.arg("-c")
.arg("-Xptxas")
.arg("-O3")
.arg("-use_fast_math")
.arg("-diag-suppress")
.arg("177")
.arg("-o")
......@@ -1197,6 +1200,23 @@ fn schedule_interpret(
// were made
Ok(i > 1)
}
ScheduleStmt::IfThenElse { cond, thn, els } => {
let (cond, modified) = interp_expr(pm, cond, stringtab, env, functions)?;
let Value::Boolean { val: cond } = cond else {
return Err(SchedulerError::SemanticError(
"Condition must be a boolean value".to_string(),
));
};
let changed = schedule_interpret(
pm,
if cond { &*thn } else { &*els },
stringtab,
env,
functions,
)?;
Ok(modified || changed)
}
ScheduleStmt::Block { body } => {
let mut modified = false;
env.open_scope();
......@@ -1441,6 +1461,23 @@ fn interp_expr(
changed,
))
}
ScheduleExp::Feature { feature } => {
let (feature, modified) = interp_expr(pm, &*feature, stringtab, env, functions)?;
let Value::String { val } = feature else {
return Err(SchedulerError::SemanticError(
"Feature expects a single string argument (instead of a selection)".to_string(),
));
};
// To test for features, the scheduler needs to be invoked from a build script so that
// Cargo provides the enabled features via environment variables
let key = "CARGO_FEATURE_".to_string() + &val.to_uppercase().replace("-", "_");
Ok((
Value::Boolean {
val: env::var(key).is_ok(),
},
modified,
))
}
ScheduleExp::Record { fields } => {
let mut result = HashMap::new();
let mut changed = false;
......