Make floats static, as rounding is not a real concern here anymore

Author: sayantn

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

@@ -51,28 +51,15 @@ where
         self.constraint.is_some()
     }
 
-    /// The binding keyword (e.g. "const" or "let") for the array of possible test inputs.
-    fn rust_vals_array_binding(&self) -> impl std::fmt::Display {
-        if self.ty.is_rust_vals_array_const() {
-            "const"
-        } else {
-            "let"
-        }
-    }
-
     /// The name (e.g. "A_VALS" or "a_vals") for the array of possible test inputs.
     pub(crate) fn rust_vals_array_name(&self) -> impl std::fmt::Display {
-        if self.ty.is_rust_vals_array_const() {
-            let loads = crate::common::gen_rust::PASSES;
-            format!(
-                "{}_{ty}_{load_size}",
-                self.name.to_uppercase(),
-                ty = self.ty.rust_scalar_type(),
-                load_size = self.ty.num_lanes() * self.ty.num_vectors() + loads - 1,
-            )
-        } else {
-            format!("{}_vals", self.name.to_lowercase())
-        }
+        let loads = crate::common::gen_rust::PASSES;
+        format!(
+            "{}_{ty}_{load_size}",
+            self.name.to_uppercase(),
+            ty = self.ty.rust_scalar_type(),
+            load_size = self.ty.num_lanes() * self.ty.num_vectors() + loads - 1,
+        )
     }
 }
 
@@ -137,26 +124,6 @@ where
             .join("")
     }
 
-    /// Creates a line for each argument that initializes an array for Rust from which `loads` argument
-    /// values can be loaded as a sliding window, e.g `const A_VALS: [u32; 20]  = [...];`
-    pub fn gen_arglists_rust(
-        &self,
-        w: &mut impl std::io::Write,
-        indentation: Indentation,
-        loads: u32,
-    ) -> std::io::Result<()> {
-        for arg in self.iter().filter(|&arg| !arg.has_constraint()) {
-            // Constants are defined globally.
-            if arg.ty.is_rust_vals_array_const() {
-                continue;
-            }
-
-            Self::gen_arg_rust(arg, w, indentation, loads)?;
-        }
-
-        Ok(())
-    }
-
     pub fn gen_arg_rust(
         arg: &Argument<T>,
         w: &mut impl std::io::Write,
@@ -165,8 +132,7 @@ where
     ) -> std::io::Result<()> {
         writeln!(
             w,
-            "{indentation}{bind} {name}: [{ty}; {load_size}] = {values};\n",
-            bind = arg.rust_vals_array_binding(),
+            "{indentation}static {name}: [{ty}; {load_size}] = {values};\n",
             name = arg.rust_vals_array_name(),
             ty = arg.ty.rust_scalar_type(),
             load_size = arg.ty.num_lanes() * arg.ty.num_vectors() + loads - 1,

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

@@ -101,7 +101,7 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
 
     for intrinsic in intrinsics {
         for arg in &intrinsic.arguments.args {
-            if !arg.has_constraint() && arg.ty.is_rust_vals_array_const() {
+            if !arg.has_constraint() {
                 let name = arg.rust_vals_array_name().to_string();
 
                 if seen.insert(name) {
@@ -227,10 +227,6 @@ fn create_rust_test<T: IntrinsicTypeDefinition>(
         intrinsic_name = intrinsic.name,
     )?;
 
-    // Define the arrays of arguments.
-    let arguments = &intrinsic.arguments;
-    arguments.gen_arglists_rust(w, Indentation::default().nested(), PASSES)?;
-
     generate_rust_test_loop(w, intrinsic, PASSES)?;
 
     writeln!(w, "}}")?;

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

@@ -231,21 +231,6 @@ impl IntrinsicType {
             _ => unimplemented!("populate random: {self:#?}"),
         }
     }
-
-    pub fn is_rust_vals_array_const(&self) -> bool {
-        match self {
-            // Floats have to be loaded at runtime for stable NaN conversion.
-            IntrinsicType {
-                kind: TypeKind::Float,
-                ..
-            } => false,
-            IntrinsicType {
-                kind: TypeKind::Int(_) | TypeKind::Poly,
-                ..
-            } => true,
-            _ => true,
-        }
-    }
 }
 
 pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {