introduced generic types and code refactor

Author: madhav-madhusoodanan

Diff for: crates/intrinsic-test/src/arm/constraint.rs

@@ -0,0 +1,61 @@
+use super::json_parser::ArgPrep;
+
+use crate::common::argument::MetadataDefinition;
+use serde::Deserialize;
+use serde_json::Value;
+use std::ops::Range;
+
+
+#[derive(Debug, PartialEq, Clone, Deserialize)]
+pub enum Constraint {
+    Equal(i64),
+    Range(Range<i64>),
+}
+
+impl Constraint {
+    pub fn to_range(&self) -> Range<i64> {
+        match self {
+            Constraint::Equal(eq) => *eq..*eq + 1,
+            Constraint::Range(range) => range.clone(),
+        }
+    }
+}
+
+impl MetadataDefinition for Constraint {
+    fn from_metadata(metadata: Option<Value>) -> Vec<Box<Self>> {
+        let arg_prep: Option<ArgPrep> = metadata.and_then(|a| {
+            if let Value::Object(_) = a {
+                a.try_into().ok()
+            } else {
+                None
+            }
+        });
+        let constraint: Option<Constraint> = arg_prep.and_then(|a| a.try_into().ok());
+        vec![constraint]
+            .into_iter()
+            .filter_map(|a| a)
+            .map(|a| Box::new(a))
+            .collect()
+    }
+}
+
+/// ARM-specific
+impl TryFrom<ArgPrep> for Constraint {
+    type Error = ();
+
+    fn try_from(prep: ArgPrep) -> Result<Self, Self::Error> {
+        let parsed_ints = match prep {
+            ArgPrep::Immediate { min, max } => Ok((min, max)),
+            _ => Err(()),
+        };
+        if let Ok((min, max)) = parsed_ints {
+            if min == max {
+                Ok(Constraint::Equal(min))
+            } else {
+                Ok(Constraint::Range(min..max + 1))
+            }
+        } else {
+            Err(())
+        }
+    }
+}

Diff for: crates/intrinsic-test/src/arm/functions.rs

@@ -1,9 +1,12 @@
-use super::argument::Argument;
 use super::config::{AARCH_CONFIGURATIONS, POLY128_OSTREAM_DEF, build_notices};
-use super::format::Indentation;
-use super::intrinsic::Intrinsic;
+use super::intrinsic::ArmIntrinsicType;
+use crate::arm::constraint::Constraint;
+use crate::common::argument::Argument;
+use crate::common::format::Indentation;
 use crate::common::gen_c::{compile_c, create_c_filenames, generate_c_program};
 use crate::common::gen_rust::{compile_rust, create_rust_filenames, generate_rust_program};
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_types::IntrinsicTypeDefinition;
 use crate::common::write_file;
 use itertools::Itertools;
 use rayon::prelude::*;
@@ -14,14 +17,14 @@ const PASSES: u32 = 20;
 
 fn gen_code_c(
     indentation: Indentation,
-    intrinsic: &Intrinsic,
-    constraints: &[&Argument],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    constraints: &[&Argument<ArmIntrinsicType, Constraint>],
     name: String,
     target: &str,
 ) -> String {
     if let Some((current, constraints)) = constraints.split_last() {
         let range = current
-            .constraints
+            .metadata
             .iter()
             .map(|c| c.to_range())
             .flat_map(|r| r.into_iter());
@@ -52,11 +55,15 @@ fn gen_code_c(
     }
 }
 
-fn generate_c_program_arm(header_files: &[&str], intrinsic: &Intrinsic, target: &str) -> String {
+fn generate_c_program_arm(
+    header_files: &[&str],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    target: &str,
+) -> String {
     let constraints = intrinsic
         .arguments
         .iter()
-        .filter(|i| i.has_constraint())
+        .filter(|&i| i.has_constraint())
         .collect_vec();
 
     let indentation = Indentation::default();
@@ -82,13 +89,13 @@ fn generate_c_program_arm(header_files: &[&str], intrinsic: &Intrinsic, target:
 
 fn gen_code_rust(
     indentation: Indentation,
-    intrinsic: &Intrinsic,
-    constraints: &[&Argument],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    constraints: &[&Argument<ArmIntrinsicType, Constraint>],
     name: String,
 ) -> String {
     if let Some((current, constraints)) = constraints.split_last() {
         let range = current
-            .constraints
+            .metadata
             .iter()
             .map(|c| c.to_range())
             .flat_map(|r| r.into_iter());
@@ -118,7 +125,10 @@ fn gen_code_rust(
     }
 }
 
-fn generate_rust_program_arm(intrinsic: &Intrinsic, target: &str) -> String {
+fn generate_rust_program_arm(
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    target: &str,
+) -> String {
     let constraints = intrinsic
         .arguments
         .iter()
@@ -220,7 +230,7 @@ fn compile_c_arm(
 }
 
 pub fn build_c(
-    intrinsics: &Vec<Intrinsic>,
+    intrinsics: &Vec<Intrinsic<ArmIntrinsicType, Constraint>>,
     compiler: Option<&str>,
     target: &str,
     cxx_toolchain_dir: Option<&str>,
@@ -252,7 +262,7 @@ pub fn build_c(
 }
 
 pub fn build_rust(
-    intrinsics: &[Intrinsic],
+    intrinsics: &[Intrinsic<ArmIntrinsicType, Constraint>],
     toolchain: Option<&str>,
     target: &str,
     linker: Option<&str>,

Diff for: crates/intrinsic-test/src/arm/intrinsic.rs

@@ -1,40 +1,83 @@
-use super::argument::ArgumentList;
-use super::format::Indentation;
-use super::types::{IntrinsicType, TypeKind};
+use super::constraint::Constraint;
+use crate::common::argument::ArgumentList;
+use crate::common::format::Indentation;
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_types::{
+    BaseIntrinsicTypeDefinition, IntrinsicType, IntrinsicTypeDefinition, TypeKind
+};
+use crate::common::types::Language;
 
-/// An intrinsic
-#[derive(Debug, PartialEq, Clone)]
-pub struct Intrinsic {
-    /// The function name of this intrinsic.
-    pub name: String,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ArmIntrinsicType(pub IntrinsicType);
 
-    /// Any arguments for this intrinsic.
-    pub arguments: ArgumentList,
+impl BaseIntrinsicTypeDefinition for ArmIntrinsicType {
+    fn kind(&self) -> TypeKind {
+        self.0.kind()
+    }
+    fn inner_size(&self) -> u32 {
+        self.0.inner_size()
+    }
+    fn num_lanes(&self) -> u32 {
+        self.0.num_lanes()
+    }
+    fn num_vectors(&self) -> u32 {
+        self.0.num_vectors()
+    }
+    fn is_simd(&self) -> bool {
+        self.0.is_simd()
+    }
+    fn is_ptr(&self) -> bool {
+        self.0.is_ptr()
+    }
+    fn c_scalar_type(&self) -> String {
+        self.0.c_scalar_type()
+    }
+    fn rust_scalar_type(&self) -> String {
+        self.0.rust_scalar_type()
+    }
+    fn c_promotion(&self) -> &str {
+        self.0.c_promotion()
+    }
+    fn populate_random(&self, indentation: Indentation, loads: u32, language: &Language) -> String {
+        self.0.populate_random(indentation, loads, language)
+    }
+    fn is_rust_vals_array_const(&self) -> bool {
+        self.0.is_rust_vals_array_const()
+    }
+    fn as_call_param_c(&self, name: &String) -> String {
+        self.0.as_call_param_c(name)
+    }
+}
 
-    /// The return type of this intrinsic.
-    pub results: IntrinsicType,
+impl IntrinsicDefinition<ArmIntrinsicType, Constraint> for Intrinsic<ArmIntrinsicType, Constraint> {
+    fn arguments(&self) -> ArgumentList<ArmIntrinsicType, Constraint> {
+        self.arguments.clone()
+    }
 
-    /// Whether this intrinsic is only available on A64.
-    pub a64_only: bool,
-}
+    fn results(&self) -> ArmIntrinsicType {
+        self.results.clone()
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
 
-impl Intrinsic {
     /// Generates a std::cout for the intrinsics results that will match the
     /// rust debug output format for the return type. The generated line assumes
     /// there is an int i in scope which is the current pass number.
-    pub fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.results.num_vectors() > 1 {
-            (0..self.results.num_vectors())
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
+        let lanes = if self.results().num_vectors() > 1 {
+            (0..self.results().num_vectors())
                 .map(|vector| {
                     format!(
                         r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.results.c_single_vector_type(),
-                        lanes = (0..self.results.num_lanes())
+                        ty = self.results().c_single_vector_type(),
+                        lanes = (0..self.results().num_lanes())
                             .map(move |idx| -> std::string::String {
                                 format!(
                                     "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.results.c_promotion(),
-                                    lane_fn = self.results.get_lane_function(),
+                                    cast = self.results().c_promotion(),
+                                    lane_fn = self.results().get_lane_function(),
                                     lane = idx,
                                     vector = vector,
                                 )
@@ -45,13 +88,13 @@ impl Intrinsic {
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
-        } else if self.results.num_lanes() > 1 {
-            (0..self.results.num_lanes())
+        } else if self.results().num_lanes() > 1 {
+            (0..self.results().num_lanes())
                 .map(|idx| -> std::string::String {
                     format!(
                         "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.results.c_promotion(),
-                        lane_fn = self.results.get_lane_function(),
+                        cast = self.results().c_promotion(),
+                        lane_fn = self.results().get_lane_function(),
                         lane = idx
                     )
                 })
@@ -61,77 +104,26 @@ impl Intrinsic {
             format!(
                 "{promote}cast<{cast}>(__return_value)",
                 cast = match self.results.kind() {
-                    TypeKind::Float if self.results.inner_size() == 16 => "float16_t".to_string(),
-                    TypeKind::Float if self.results.inner_size() == 32 => "float".to_string(),
-                    TypeKind::Float if self.results.inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int => format!("int{}_t", self.results.inner_size()),
-                    TypeKind::UInt => format!("uint{}_t", self.results.inner_size()),
-                    TypeKind::Poly => format!("poly{}_t", self.results.inner_size()),
+                    TypeKind::Float if self.results().inner_size() == 16 => "float16_t".to_string(),
+                    TypeKind::Float if self.results().inner_size() == 32 => "float".to_string(),
+                    TypeKind::Float if self.results().inner_size() == 64 => "double".to_string(),
+                    TypeKind::Int => format!("int{}_t", self.results().inner_size()),
+                    TypeKind::UInt => format!("uint{}_t", self.results().inner_size()),
+                    TypeKind::Poly => format!("poly{}_t", self.results().inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },
-                promote = self.results.c_promotion(),
+                promote = self.results().c_promotion(),
             )
         };
 
         format!(
             r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.results.is_simd() {
-                format!("{}(", self.results.c_type())
+            ty = if self.results().is_simd() {
+                format!("{}(", self.results().c_type())
             } else {
                 String::from("")
             },
-            close = if self.results.is_simd() { ")" } else { "" },
-        )
-    }
-
-    pub fn generate_loop_c(
-        &self,
-        indentation: Indentation,
-        additional: &str,
-        passes: u32,
-        _target: &str,
-    ) -> String {
-        let body_indentation = indentation.nested();
-        format!(
-            "{indentation}for (int i=0; i<{passes}; i++) {{\n\
-                {loaded_args}\
-                {body_indentation}auto __return_value = {intrinsic_call}({args});\n\
-                {print_result}\n\
-            {indentation}}}",
-            loaded_args = self.arguments.load_values_c(body_indentation),
-            intrinsic_call = self.name,
-            args = self.arguments.as_call_param_c(),
-            print_result = self.print_result_c(body_indentation, additional)
-        )
-    }
-
-    pub fn generate_loop_rust(
-        &self,
-        indentation: Indentation,
-        additional: &str,
-        passes: u32,
-    ) -> String {
-        let constraints = self.arguments.as_constraint_parameters_rust();
-        let constraints = if !constraints.is_empty() {
-            format!("::<{constraints}>")
-        } else {
-            constraints
-        };
-
-        let indentation2 = indentation.nested();
-        let indentation3 = indentation2.nested();
-        format!(
-            "{indentation}for i in 0..{passes} {{\n\
-                {indentation2}unsafe {{\n\
-                    {loaded_args}\
-                    {indentation3}let __return_value = {intrinsic_call}{const}({args});\n\
-                    {indentation3}println!(\"Result {additional}-{{}}: {{:.150?}}\", i + 1, __return_value);\n\
-                {indentation2}}}\n\
-            {indentation}}}",
-            loaded_args = self.arguments.load_values_rust(indentation3),
-            intrinsic_call = self.name,
-            const = constraints,
-            args = self.arguments.as_call_param_rust(),
+            close = if self.results().is_simd() { ")" } else { "" },
         )
     }
 }