Refactor libm-test; add tests specifics for each type of API

Author: gnzlbg

crates/libm-analyze/src/lib.rs

@@ -5,6 +5,7 @@
 extern crate proc_macro;
 use self::proc_macro::TokenStream;
 use quote::quote;
+use std::collections::HashSet;
 use syn::parse_macro_input;
 
 /// `input` contains a single identifier, corresponding to a user-defined macro.
@@ -13,22 +14,26 @@ use syn::parse_macro_input;
 /// See tests/analyze or below for the API.
 #[proc_macro]
 pub fn for_each_api(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as Input);
     let files = get_libm_files();
-    let functions = get_functions(&files);
-    let input = parse_macro_input!(input as syn::Ident);
+    let functions = get_functions(&files, &input.ignored);
     let mut tokens = proc_macro2::TokenStream::new();
+    let input_macro = input.macro_id;
     for function in functions {
         let id = function.ident;
+        let api_kind = function.api_kind;
         let ret_ty = function.ret_ty;
         let arg_tys = function.arg_tys;
         let arg_ids = get_arg_ids(arg_tys.len());
         let t = quote! {
-            #input! {
+            #input_macro! {
                 id: #id;
+                api_kind: #api_kind;
                 arg_tys: #(#arg_tys),*;
                 arg_ids: #(#arg_ids),*;
                 ret_ty: #ret_ty;
             }
+
         };
         tokens.extend(t);
     }
@@ -78,6 +83,7 @@ fn get_libm_files() -> Vec<syn::File> {
 /// Function signature that will be expanded for the user macro.
 struct FnSig {
     ident: syn::Ident,
+    api_kind: syn::Ident,
     c_abi: bool,
     ret_ty: Option<syn::Type>,
     arg_tys: Vec<syn::Type>,
@@ -101,7 +107,7 @@ macro_rules! syn_to_str {
 
 /// Extracts all public functions from the libm files while
 /// doing some sanity checks on the function signatures.
-fn get_functions(files: &[syn::File]) -> Vec<FnSig> {
+fn get_functions(files: &[syn::File], ignored: &Option<HashSet<String>>) -> Vec<FnSig> {
     let mut error = false;
     let mut functions = Vec::new();
     // Traverse all files matching function items
@@ -122,10 +128,17 @@ fn get_functions(files: &[syn::File]) -> Vec<FnSig> {
             // Build a function signature while doing some sanity checks
             let mut fn_sig = FnSig {
                 ident: ident.clone(),
+                api_kind: to_api_kind(ident.clone()),
                 c_abi: false,
                 arg_tys: Vec::new(),
                 ret_ty: None,
             };
+            // Skip ignored functions:
+            if let Some(ignored) = ignored {
+                if ignored.contains(&fn_sig.name()) {
+                    continue;
+                }
+            }
             macro_rules! err {
                 ($msg:expr) => {{
                     #[cfg(feature = "analyze")]
@@ -300,3 +313,48 @@ fn get_arg_ids(len: usize) -> Vec<syn::Ident> {
     }
     ids
 }
+
+/// Returns the ApiKind enum variant for this function
+fn to_api_kind(id: syn::Ident) -> syn::Ident {
+    let name = syn_to_str!(id);
+    let first = name.chars().nth(0).unwrap();
+    let first_upper = first.to_uppercase().nth(0).unwrap();
+    let name = name.replacen(first, &first_upper.to_string(), 1);
+    syn::Ident::new(&name, proc_macro2::Span::call_site())
+}
+
+#[derive(Debug)]
+struct Input {
+    macro_id: syn::Ident,
+    ignored: Option<HashSet<String>>,
+}
+
+impl syn::parse::Parse for Input {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let content;
+        let macro_id: syn::Ident = input.parse()?;
+        let lookahead = input.lookahead1();
+        if lookahead.peek(syn::token::Paren) {
+            let _paren_token = syn::parenthesized!(content in input);
+            let ignored: syn::Lit = content.parse::<syn::Lit>()?;
+            if let syn::Lit::Str(c) = ignored {
+                let s = c.value();
+                let mut hash_set = HashSet::<String>::new();
+                for i in s.split(",") {
+                    hash_set.insert(i.to_string());
+                }
+                Ok(Input {
+                    macro_id: macro_id,
+                    ignored: Some(hash_set),
+                })
+            } else {
+                Err(lookahead.error())
+            }
+        } else {
+            Ok(Input {
+                macro_id: macro_id,
+                ignored: None,
+            })
+        }
+    }
+}

crates/libm-analyze/tests/analyze.rs

@@ -4,6 +4,7 @@
 macro_rules! nop {
     (
         id: $id:ident;
+        api_kind: $api_kind:ident;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
         ret_ty: $ret_ty:ty;

crates/libm-analyze/tests/analyze_opt.rs

@@ -0,0 +1,14 @@
+//! Tests that the proc-macro accepts macros with
+//! the following pattern:
+
+macro_rules! nop {
+    (
+        id: $id:ident;
+        api_kind: $api_kind:ident;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) => {};
+}
+
+libm_analyze::for_each_api!(nop("j1f,jn"));

crates/libm-bench/benches/bench.rs

@@ -1,20 +1,14 @@
 #![feature(test)]
 extern crate test;
 
-use libm_test::{get_api_kind, ApiKind, Call};
+use libm_test::{ApiKind, CallFn};
 use rand::Rng;
 use test::Bencher;
 
 macro_rules! bench_fn {
-    // FIXME: jnf benches never terminate
-    (
-        id: jnf;
-        arg_tys: $($arg_tys:ty),*;
-        arg_ids: $($arg_ids:ident),*;
-        ret_ty: $ret_ty:ty;
-    ) => {};
     (
         id: $id:ident;
+        api_kind: $api_kind:ident;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
         ret_ty: $ret_ty:ty;
@@ -29,7 +23,7 @@ macro_rules! bench_fn {
             let mut rng = rand::thread_rng();
             let mut x: ( $($arg_tys,)+ ) = ( $(rng.gen::<$arg_tys>(),)+ );
 
-            if let ApiKind::Jx = get_api_kind!(fn: $id) {
+            if let ApiKind::Jn = ApiKind::$api_kind {
                 let ptr = &mut x as *mut _ as *mut i32;
                 unsafe { ptr.write(ptr.read() & 0xffff) };
             }
@@ -39,4 +33,4 @@ macro_rules! bench_fn {
     };
 }
 
-libm_analyze::for_each_api!(bench_fn);
+libm_analyze::for_each_api!(bench_fn(/*ignore:*/ "jnf"));

crates/libm-test/src/api_kind.rs

@@ -0,0 +1,120 @@
+//! An enum with one variant per API
+
+// FIXME: this should be auto-generated
+
+/// Kind of libm API - used to handle generating tests
+/// for some functions slightly differently.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ApiKind {
+    Acos,
+    Acosf,
+    Acosh,
+    Acoshf,
+    Asin,
+    Asinf,
+    Asinh,
+    Asinhf,
+    Atan,
+    Atan2,
+    Atan2f,
+    Atanf,
+    Atanh,
+    Atanhf,
+    Cbrt,
+    Cbrtf,
+    Ceil,
+    Ceilf,
+    Copysign,
+    Copysignf,
+    Cos,
+    Cosf,
+    Cosh,
+    Coshf,
+    Erf,
+    Erfc,
+    Erfcf,
+    Erff,
+    Exp,
+    Exp10,
+    Exp10f,
+    Exp2,
+    Exp2f,
+    Expf,
+    Expm1,
+    Expm1f,
+    Fabs,
+    Fabsf,
+    Fdim,
+    Fdimf,
+    Floor,
+    Floorf,
+    Fma,
+    Fmaf,
+    Fmax,
+    Fmaxf,
+    Fmin,
+    Fminf,
+    Fmod,
+    Fmodf,
+    Hypot,
+    Hypotf,
+    Ilogb,
+    Ilogbf,
+    J0,
+    J0f,
+    J1,
+    J1f,
+    Jn,
+    Ldexp,
+    Ldexpf,
+    Lgamma,
+    Lgammaf,
+    Log,
+    Log10,
+    Log10f,
+    Log1p,
+    Log1pf,
+    Log2,
+    Log2f,
+    Logf,
+    Modf,
+    Modff,
+    Nextafter,
+    Nextafterf,
+    Nexttoward,
+    Nexttowardf,
+    Pow,
+    Powf,
+    Remainder,
+    Remainderf,
+    Rint,
+    Rintf,
+    Round,
+    Roundf,
+    Scalbn,
+    Scalbnf,
+    Sin,
+    SinCos,
+    SinCosPi,
+    SinCosPif,
+    SinCosf,
+    Sinf,
+    Sinh,
+    Sinhf,
+    Sqrt,
+    Sqrtf,
+    Tan,
+    Tanf,
+    Tanh,
+    Tanhf,
+    Tgamma,
+    Tgammaf,
+    Trunc,
+    Truncf,
+    Y0,
+    Y0f,
+    Y1,
+    Y1f,
+    Yn,
+    Ynf,
+}

crates/libm-test/src/call_fn.rs

@@ -0,0 +1,38 @@
+//! Trait to do function dispatch based on tuples:
+
+/// This implements function dispatch for tuples of arguments used in the tests
+/// above, so that we can: (f32, 32).call(fn(f32, f32) -> f32) generically.
+///
+/// We need the input parameter F to support dispatching, e.g., (f32,f32) with
+/// functions that return both f32 or i32. Those are two different types, so we
+/// need to be parametric over them.
+pub trait CallFn<F> {
+    type Ret;
+    fn call(self, f: F) -> Self::Ret;
+}
+
+macro_rules! impl_call {
+    (($($arg_tys:ty),*) -> $ret_ty:ty: $self_:ident: $($xs:expr),*)  => {
+        impl CallFn<unsafe extern"C" fn($($arg_tys),*) -> $ret_ty> for ($($arg_tys,)+) {
+            type Ret = $ret_ty;
+            fn call(self, f: unsafe extern "C" fn($($arg_tys),*) -> $ret_ty) -> Self::Ret {
+                let $self_ = self;
+                unsafe { f($($xs),*) }
+            }
+        }
+    };
+}
+
+impl_call!((f32) -> f32: x: x.0);
+impl_call!((f64) -> f64: x: x.0);
+impl_call!((f64) -> i32: x: x.0);
+impl_call!((f32) -> i32: x: x.0);
+impl_call!((f32, f32) -> f32: x: x.0, x.1);
+impl_call!((f32, f64) -> f32: x: x.0, x.1);
+impl_call!((f64, f64) -> f64: x: x.0, x.1);
+impl_call!((f64, i32) -> f64: x: x.0, x.1);
+impl_call!((f32, i32) -> f32: x: x.0, x.1);
+impl_call!((i32, f64) -> f64: x: x.0, x.1);
+impl_call!((i32, f32) -> f32: x: x.0, x.1);
+impl_call!((f32, f32, f32) -> f32: x: x.0, x.1, x.2);
+impl_call!((f64, f64, f64) -> f64: x: x.0, x.1, x.2);

crates/libm-test/src/float_rng.rs

@@ -0,0 +1,49 @@
+//! Traits for generating ranges of floating-point values
+
+pub trait Toward: Sized {
+    /// Generates `len` minimal incremental steps from self to other.
+    ///
+    /// Other is often never reached.
+    fn toward(self, other: Self, len: usize) -> Vec<Self>;
+}
+
+pub trait Distribute: Sized {
+    /// Distributes `len` values in range `[self, other]`.
+    fn distribute(self, other: Self, len: usize) -> Vec<Self>;
+}
+
+macro_rules! impl_f {
+    ($float_ty:ident, $toward_fn:path) => {
+        impl Toward for $float_ty {
+            fn toward(self, other: Self, len: usize) -> Vec<Self> {
+                let mut vec = Vec::with_capacity(len);
+                let mut current = self;
+                vec.push(self);
+                for _ in 0..=len {
+                    current = $toward_fn(current, other as _);
+                    vec.push(self);
+                    if current.to_bits() == other.to_bits() {
+                        break;
+                    }
+                }
+                vec
+            }
+        }
+        impl Distribute for $float_ty {
+            fn distribute(self, other: Self, mut len: usize) -> Vec<Self> {
+                let mut vec = Vec::with_capacity(len + 1);
+                vec.push(self);
+                // Bresenham's alg:
+                let mut x = self;
+                while len > 0 {
+                    x += (other - self) / (len as Self);
+                    len -= 1;
+                    vec.push(x);
+                }
+                vec
+            }
+        }
+    };
+}
+impl_f!(f32, libm::nextafterf);
+impl_f!(f64, libm::nextafter);