Migrate libm-bench to libm-analyze

gnzlbg · gnzlbg · commit 82a5c69eb902 · 2019-07-05T02:24:32.000+02:00
diff --git a/crates/libm-analyze/README.md b/crates/libm-analyze/README.md
@@ -8,7 +8,7 @@ macro_rules! nop {
         id: $id:ident;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ty:ty;
+        ret_ty: $ty:ty;
     ) => {};
 }
 
diff --git a/crates/libm-analyze/src/lib.rs b/crates/libm-analyze/src/lib.rs
@@ -27,7 +27,7 @@ pub fn for_each_api(input: TokenStream) -> TokenStream {
                 id: #id;
                 arg_tys: #(#arg_tys),*;
                 arg_ids: #(#arg_ids),*;
-                ret: #ret_ty;
+                ret_ty: #ret_ty;
             }
         };
         tokens.extend(t);
diff --git a/crates/libm-analyze/tests/analyze.rs b/crates/libm-analyze/tests/analyze.rs
@@ -6,7 +6,7 @@ macro_rules! nop {
         id: $id:ident;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ty:ty;
+        ret_ty: $ret_ty:ty;
     ) => {};
 }
 
diff --git a/crates/libm-bench/Cargo.toml b/crates/libm-bench/Cargo.toml
@@ -7,8 +7,9 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 libm = { path = "../libm", default-features = false }
+libm-analyze = { path = "../libm-analyze", default-features = false }
+libm-test = { path = "../libm-test", default-features = false }
 rand = "0.6.5"
-paste = "0.1.5"
 
 [features]
 default = []
diff --git a/crates/libm-bench/benches/bench.rs b/crates/libm-bench/benches/bench.rs
@@ -1,115 +1,44 @@
 #![feature(test)]
 extern crate test;
 
+use libm_test::{adjust_input, Call};
 use rand::Rng;
 use test::Bencher;
 
-macro_rules! unary {
-  ($($func:ident),*) => ($(
-      paste::item! {
-        #[bench]
-        pub fn [<$func>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f64>();
-            bh.iter(|| test::black_box(libm::[<$func>](x)))
-        }
-        #[bench]
-        pub fn [<$func f>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f32>();
-            bh.iter(|| test::black_box(libm::[<$func f>](x)))
-        }
-    }
-  )*);
-}
-macro_rules! binary {
-  ($($func:ident),*) => ($(
-      paste::item! {
-        #[bench]
-        pub fn [<$func>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f64>();
-            let y = rng.gen::<f64>();
-            bh.iter(|| test::black_box(libm::[<$func>](x, y)))
-        }
-        #[bench]
-        pub fn [<$func f>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f32>();
-            let y = rng.gen::<f32>();
-            bh.iter(|| test::black_box(libm::[<$func f>](x, y)))
-        }
-    }
-  )*);
-  ($($func:ident);*) => ($(
-      paste::item! {
-        #[bench]
-        pub fn [<$func>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f64>();
-            let n = rng.gen::<i32>();
-            bh.iter(|| test::black_box(libm::[<$func>](x, n)))
-        }
-        #[bench]
-        pub fn [<$func f>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f32>();
-            let n = rng.gen::<i32>();
-            bh.iter(|| test::black_box(libm::[<$func f>](x, n)))
-        }
-    }
-  )*);
-}
-macro_rules! trinary {
-  ($($func:ident),*) => ($(
-      paste::item! {
-        #[bench]
-        pub fn [<$func>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f64>();
-            let y = rng.gen::<f64>();
-            let z = rng.gen::<f64>();
-            bh.iter(|| test::black_box(libm::[<$func>](x, y, z)))
-        }
-        #[bench]
-        pub fn [<$func f>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen::<f32>();
-            let y = rng.gen::<f32>();
-            let z = rng.gen::<f32>();
-            bh.iter(|| test::black_box(libm::[<$func f>](x, y, z)))
-        }
-    }
-  )*);
-}
-macro_rules! bessel {
-  ($($func:ident),*) => ($(
-      paste::item! {
-        #[bench]
-        pub fn [<$func>](bh: &mut Bencher) {
-            let mut rng = rand::thread_rng();
-            let mut n = rng.gen::<i32>();
-            n &= 0xffff;
-            let x = rng.gen::<f64>();
-            bh.iter(|| test::black_box(libm::[<$func>](n, x)))
-        }
-        #[bench]
-        pub fn [<$func f>](bh: &mut 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;
+        arg_tys: $($arg_tys:ty),*;
+        arg_ids: $($arg_ids:ident),*;
+        ret_ty: $ret_ty:ty;
+    ) => {
+        #[bench]
+        #[allow(unused_mut)]
+        pub fn $id(bh: &mut Bencher) {
+            // Type of the system libm fn:
+            type FnTy = unsafe extern "C" fn ($($arg_ids: $arg_tys),*) -> $ret_ty;
+
+            // FIXME: extern "C" wrapper
+            extern "C" fn libm_fn($($arg_ids: $arg_tys),*) -> $ret_ty {
+                libm::$id($($arg_ids),*)
+            }
+
+            // Generate a tuple of arguments containing random values:
             let mut rng = rand::thread_rng();
-            let mut n = rng.gen::<i32>();
-            n &= 0xffff;
-            let x = rng.gen::<f32>();
-            bh.iter(|| test::black_box(libm::[<$func f>](n, x)))
+            let mut x: ( $($arg_tys,)+ ) = ( $(rng.gen::<$arg_tys>(),)+ );
+
+            adjust_input!(fn: $id, input: x);
+
+            bh.iter(|| test::black_box(x).call(libm_fn as FnTy))
         }
-    }
-  )*);
+    };
 }
 
-unary!(
-    acos, acosh, asin, atan, cbrt, ceil, cos, cosh, erf, exp, exp2, exp10, expm1, fabs, floor, j0,
-    j1, lgamma, log, log1p, log2, log10, round, sin, sinh, sqrt, tan, tanh, tgamma, trunc, y0, y1
-);
-binary!(atan2, copysign, fdim, fmax, fmin, fmod, hypot, pow);
-trinary!(fma);
-bessel!(jn, yn);
-binary!(ldexp; scalbn);
+libm_analyze::for_each_api!(bench_fn);
diff --git a/crates/libm-test/src/lib.rs b/crates/libm-test/src/lib.rs
@@ -5,9 +5,6 @@ pub trait WithinUlps {
     fn within_ulps(self, other: Self, ulp_tol: usize) -> bool;
 }
 
-// TODO: this should be moved to the libm-test/src/lib.rs library. And we
-// should make ulps configurable.
-
 // Stamp the impls for floats:
 macro_rules! impl_within_ulps_f {
     ($f_ty:ty, $i_ty:ty) => {
@@ -65,7 +62,6 @@ pub trait Call<F> {
 
 macro_rules! impl_call {
     (($($arg_tys:ty),*) -> $ret_ty:ty: $self_:ident: $($xs:expr),*)  => {
-        // We only care about unsafe extern "C" functions here, safe functions coerce to them:
         impl Call<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 {
@@ -88,3 +84,23 @@ 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);
+
+// Adjust the input of a function.
+#[macro_export]
+macro_rules! adjust_input {
+    (fn: j1, input: $arg:ident) => {
+        adjust_input!(adjust: $arg)
+    };
+    (fn: jn, input: $arg:ident) => {
+        adjust_input!(adjust: $arg)
+    };
+    (fn: $id:ident, input: $args:ident) => {};
+    (adjust: $arg:ident) => {
+        // First argument to these functions are a number of
+        // iterations and passing large random numbers takes forever
+        // to execute, so check if their higher bits are set and
+        // zero them:
+        let p = &mut $arg as *mut _ as *mut i32;
+        unsafe { p.write(p.read() & 0xff_ffff) }
+    };
+}
diff --git a/crates/libm-test/tests/system_libm.rs b/crates/libm-test/tests/system_libm.rs
@@ -1,8 +1,8 @@
 //! Compare the results of the `libm` implementation against the system's libm.
 #![cfg(test)]
-#![cfg(feature = "system_libm")]
+//#![cfg(feature = "system_libm")]
 
-use libm_test::{Call, WithinUlps};
+use libm_test::{adjust_input, Call, WithinUlps};
 
 // Number of tests to generate for each function
 const NTESTS: usize = 500;
@@ -18,57 +18,57 @@ macro_rules! system_libm {
         id: j0f;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: j1f;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: jnf;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: y0f;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: y1f;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: ynf;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: exp10;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
     (
         id: exp10f;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) =>  {};
 
     // Generate random tests for all others:
     (
         id: $id:ident;
         arg_tys: $($arg_tys:ty),*;
         arg_ids: $($arg_ids:ident),*;
-        ret: $ret_ty:ty;
+        ret_ty: $ret_ty:ty;
     ) => {
         #[test]
         #[allow(unused)]
@@ -91,15 +91,9 @@ macro_rules! system_libm {
                 // Generate a tuple of arguments containing random values:
                 let mut args: ( $($arg_tys,)+ ) = ( $(<$arg_tys as Rand>::gen(&mut rng),)+ );
 
-                // HACK
-                if let "j1" | "jn" = stringify!($id) {
-                    // First argument to these functions are a number of
-                    // iterations and passing large random numbers takes forever
-                    // to execute, so check if their higher bits are set and
-                    // zero them:
-                    let p = &mut args as *mut _ as *mut i32;
-                    unsafe { p.write(p.read() & 0xffff) }
-                }
+                // Some APIs need their inputs to be "adjusted" (see macro):
+                // correct_input!(fn: $id, input: args);
+                adjust_input!(fn: $id, input: args);
 
                 let result = args.call(libm_fn as FnTy);
                 let expected = args.call($id as FnTy);

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ macro_rules! nop {`
`8`	`8`	`id: $id:ident;`
`9`	`9`	`arg_tys: $($arg_tys:ty),*;`
`10`	`10`	`arg_ids: $($arg_ids:ident),*;`
`11`		`- ret: $ty:ty;`
	`11`	`+ ret_ty: $ty:ty;`
`12`	`12`	`) => {};`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ pub fn for_each_api(input: TokenStream) -> TokenStream {`
`27`	`27`	`id: #id;`
`28`	`28`	`arg_tys: #(#arg_tys),*;`
`29`	`29`	`arg_ids: #(#arg_ids),*;`
`30`		`- ret: #ret_ty;`
	`30`	`+ ret_ty: #ret_ty;`
`31`	`31`	`}`
`32`	`32`	`};`
`33`	`33`	`tokens.extend(t);`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ macro_rules! nop {`
`6`	`6`	`id: $id:ident;`
`7`	`7`	`arg_tys: $($arg_tys:ty),*;`
`8`	`8`	`arg_ids: $($arg_ids:ident),*;`
`9`		`- ret: $ty:ty;`
	`9`	`+ ret_ty: $ret_ty:ty;`
`10`	`10`	`) => {};`
`11`	`11`	`}`
`12`	`12`