chore: adding comments about memory alignment of variables and bash scripts that will be used in CI

Author: madhav-madhusoodanan

ci/run.sh

@@ -186,8 +186,11 @@ case "${TARGET}" in
         ;;
 
     x86_64-unknown-linux-gnu*)
+        # `CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER` is not necessary for `intrinsic-test`
+        # because the binary needs to run directly on the host.
+        # Since the same cannot be assigned an empty string, `"eval"` is used instead.
         CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=warn \
-            CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="true" \
+            CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="eval" \
             cargo run "${INTRINSIC_TEST}" "${PROFILE}"  \
             --bin intrinsic-test -- intrinsics_data/x86-intel.xml \
             --runner "${TEST_RUNNER}" \

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

@@ -36,8 +36,6 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         "cstring",
         "iomanip",
         "sstream",
-        "cstddef",
-        "cstdint",
         "arm_neon.h",
         "arm_acle.h",
         "arm_fp16.h",

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

@@ -106,6 +106,8 @@ where
         loads: u32,
     ) -> std::io::Result<()> {
         for arg in self.iter().filter(|&arg| !arg.has_constraint()) {
+            // Setting the variables on an aligned boundary to make it easier to pick
+            // functions (of a specific architecture) that would help load the values.
             writeln!(
                 w,
                 "{indentation}alignas(64) const {ty} {name}_vals[] = {values};",

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

@@ -190,7 +190,7 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     intrinsic: &Intrinsic<T>,
     indentation: Indentation,
-    specializations: &[Vec<i64>],
+    specializations: &[Vec<i32>],
     passes: u32,
 ) -> std::io::Result<()> {
     let intrinsic_name = &intrinsic.name;
@@ -255,15 +255,15 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
 /// Generate the specializations (unique sequences of const-generic arguments) for this intrinsic.
 fn generate_rust_specializations<'a>(
     constraints: &mut impl Iterator<Item = impl Iterator<Item = i64>>,
-) -> Vec<Vec<i64>> {
+) -> Vec<Vec<i32>> {
     let mut specializations = vec![vec![]];
 
     for constraint in constraints {
         specializations = constraint
             .flat_map(|right| {
                 specializations.iter().map(move |left| {
                     let mut left = left.clone();
-                    left.push(i64::try_from(right).unwrap());
+                    left.push(i32::try_from(right).unwrap());
                     left
                 })
             })

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

@@ -1,5 +1,4 @@
 use std::fs::File;
-use std::io::{self, Write};
 
 use rayon::prelude::*;
 
@@ -77,14 +76,6 @@ pub trait SupportedArchitectureTest {
                 if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
                     let output = cpp_compiler
                         .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
-                    if !output.status.success() {
-                        io::stdout()
-                            .write_all(&output.stdout)
-                            .expect("Failed to write to stdout!");
-                        io::stderr()
-                            .write_all(&output.stderr)
-                            .expect("Failed to write to stderr!");
-                    }
                     assert!(output.status.success(), "{output:?}");
                 }