intrinsic-test: uses PASSES consistently

`PASSES` is a constant accessible to all of the `common` module but is
sometimes used directly and sometimes threaded through functions as an
argument - this commit eliminates the inconsistency and just uses the
constant everywhere.

Author: davidtwco

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

@@ -3,8 +3,8 @@ use itertools::Itertools;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::values::{test_values_array, test_values_array_length, test_values_array_name};
 
+use super::PASSES;
 use super::constraint::Constraint;
-use super::gen_rust::PASSES;
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
 /// An argument for the intrinsic.
@@ -165,18 +165,14 @@ where
     ///     0x80, 0x3b, 0xff,
     /// ];
     /// ```
-    pub fn gen_arg_rust(
-        arg: &Argument<T>,
-        w: &mut impl std::io::Write,
-        loads: u32,
-    ) -> std::io::Result<()> {
+    pub fn gen_arg_rust(arg: &Argument<T>, w: &mut impl std::io::Write) -> std::io::Result<()> {
         writeln!(
             w,
             "static {name}: [{ty}; {load_size}] = {values};\n",
-            name = test_values_array_name(&arg.ty, loads),
+            name = test_values_array_name(&arg.ty),
             ty = arg.ty.rust_scalar_type(),
-            load_size = test_values_array_length(&arg.ty, loads),
-            values = test_values_array(&arg.ty, loads)
+            load_size = test_values_array_length(&arg.ty),
+            values = test_values_array(&arg.ty)
         )
     }
 
@@ -197,7 +193,7 @@ where
     ///
     /// Each subsequent argument's first window is started one element further into the array
     /// then the previous.
-    pub fn load_values_rust(&self, loads: u32) -> String {
+    pub fn load_values_rust(&self) -> String {
         self.iter()
             .filter(|&arg| !arg.has_constraint())
             .enumerate()
@@ -206,14 +202,14 @@ where
                     format!(
                         "let {name} = {load}({vals_name}.as_ptr().add((i+{idx}) % {PASSES}) as _);\n",
                         name = arg.generate_name(),
-                        vals_name = test_values_array_name(&arg.ty, loads),
+                        vals_name = test_values_array_name(&arg.ty),
                         load = arg.ty.get_load_function(),
                     )
                 } else {
                     format!(
                         "let {name} = {vals_name}[(i+{idx}) % {PASSES}];\n",
                         name = arg.generate_name(),
-                        vals_name = test_values_array_name(&arg.ty, loads),
+                        vals_name = test_values_array_name(&arg.ty),
                     )
                 }
             })

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

@@ -3,16 +3,13 @@ use std::process::Command;
 use itertools::Itertools;
 
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
+use crate::common::PASSES;
 use crate::common::argument::ArgumentList;
 use crate::common::cli::{CcArgStyle, ProcessedCli};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::values::test_values_array_name;
 
-// The number of times each intrinsic will be called - influences the generation of the
-// test arrays to minimise repeated testing of the same test values.
-pub(crate) const PASSES: u32 = 20;
-
 /// Rust definitions that are included verbatim in the generated source. In particular, defines
 /// a wrapper around float types that defines `NaN`s to be equal reflexively to enable
 /// comparison of results that use floats types.
@@ -136,10 +133,10 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
     for intrinsic in intrinsics {
         for arg in &intrinsic.arguments.args {
             if !arg.has_constraint() {
-                let name = test_values_array_name(&arg.ty, PASSES);
+                let name = test_values_array_name(&arg.ty);
 
                 if seen.insert(name) {
-                    ArgumentList::gen_arg_rust(arg, w, PASSES)?;
+                    ArgumentList::gen_arg_rust(arg, w)?;
                 }
             }
         }
@@ -164,7 +161,6 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
 fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     intrinsic: &Intrinsic<T>,
-    passes: u32,
 ) -> std::io::Result<()> {
     let intrinsic_name = &intrinsic.name;
 
@@ -245,10 +241,10 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
             "        }}",
             "    }}",
         ),
-        loaded_args = intrinsic.arguments.load_values_rust(passes),
+        loaded_args = intrinsic.arguments.load_values_rust(),
         rust_args = intrinsic.arguments.as_call_param_rust(),
         c_args = intrinsic.arguments.as_c_call_param_rust(),
-        passes = passes,
+        passes = PASSES,
         cast_prefix = cast_prefix,
         cast_suffix = cast_suffix,
     )
@@ -268,7 +264,7 @@ fn create_rust_test<T: IntrinsicTypeDefinition>(
         intrinsic_name = intrinsic.name,
     )?;
 
-    generate_rust_test_loop(w, intrinsic, PASSES)?;
+    generate_rust_test_loop(w, intrinsic)?;
 
     writeln!(w, "}}")?;
 

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

@@ -23,6 +23,10 @@ mod gen_c;
 mod gen_rust;
 mod values;
 
+// The number of times each intrinsic will be called - influences the generation of the
+// test arrays to minimise repeated testing of the same test values.
+pub(crate) const PASSES: u32 = 20;
+
 /// Architectures must support this trait
 /// to be successfully tested.
 pub trait SupportedArchitectureTest {

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

@@ -1,19 +1,20 @@
 use itertools::Itertools as _;
 
-use crate::common::intrinsic_helpers::{
-    IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind,
+use crate::common::{
+    PASSES,
+    intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind},
 };
 
 /// Maximum size of a SVE vector
 pub const MAX_SVE_BITS: u32 = 2048;
 
 /// Returns a string with the name of the static variable containing test values for intrinsic
 /// arguments of this type.
-pub fn test_values_array_name<T: IntrinsicTypeDefinition>(ty: &T, num_loads: u32) -> String {
+pub fn test_values_array_name<T: IntrinsicTypeDefinition>(ty: &T) -> String {
     format!(
         "{ty}_{load_size}",
         ty = ty.rust_scalar_type().to_uppercase(),
-        load_size = test_values_array_length(&ty, num_loads),
+        load_size = test_values_array_length(&ty),
     )
 }
 
@@ -25,7 +26,7 @@ pub fn test_values_array_name<T: IntrinsicTypeDefinition>(ty: &T, num_loads: u32
 /// which is then printed as a hex value in the generated code (and if identified as a negative
 /// value, with the appropriate minus and corrected hex pattern). Calls to `fN::from_bits` are
 /// generated for floats.
-pub fn test_values_array(ty: &IntrinsicType, num_loads: u32) -> String {
+pub fn test_values_array(ty: &IntrinsicType) -> String {
     let (bit_len, kind) = match ty {
         IntrinsicType {
             kind: TypeKind::Float,
@@ -46,7 +47,7 @@ pub fn test_values_array(ty: &IntrinsicType, num_loads: u32) -> String {
 
     format!(
         "[{}]",
-        (0..test_values_array_length(ty, num_loads)).format_with(",", |i, fmt| {
+        (0..test_values_array_length(ty)).format_with(",", |i, fmt| {
             let src = bit_pattern_for_test_values_array(bit_len, i);
             assert!(src == 0 || src.ilog2() < bit_len);
             match kind {
@@ -80,7 +81,7 @@ pub fn test_values_array(ty: &IntrinsicType, num_loads: u32) -> String {
 ///
 /// For scalable vectors (only SVE is currently supported), assume that the length of the vector is
 /// the maximum supported by the architecture.
-pub fn test_values_array_length(ty: &IntrinsicType, num_loads: u32) -> u32 {
+pub fn test_values_array_length(ty: &IntrinsicType) -> u32 {
     let IntrinsicType {
         simd_len, vec_len, ..
     } = ty;
@@ -94,7 +95,7 @@ pub fn test_values_array_length(ty: &IntrinsicType, num_loads: u32) -> u32 {
     });
     let vec_len = vec_len.unwrap_or(1);
 
-    (simd_len * vec_len) + num_loads - 1
+    (simd_len * vec_len) + PASSES - 1
 }
 
 /// Returns a bit pattern for a value being output into a array of test values. Bit patterns come