Replace random tests

tgross35 · tgross35 · commit 858a56c3b97c · 2024-12-30T02:26:42.000Z
diff --git a/crates/libm-test/benches/random.rs b/crates/libm-test/benches/random.rs
@@ -2,8 +2,9 @@ use std::hint::black_box;
 use std::time::Duration;
 
 use criterion::{Criterion, criterion_main};
-use libm_test::gen::{CachedInput, random};
-use libm_test::{CheckBasis, CheckCtx, GenerateInput, MathOp, TupleCall};
+use libm_test::gen::random;
+use libm_test::gen::random::RandomInput;
+use libm_test::{CheckBasis, CheckCtx, MathOp, TupleCall};
 
 /// Benchmark with this many items to get a variety
 const BENCH_ITER_ITEMS: usize = if cfg!(feature = "short-benchmarks") { 50 } else { 500 };
@@ -45,7 +46,7 @@ macro_rules! musl_rand_benches {
 fn bench_one<Op>(c: &mut Criterion, musl_extra: MuslExtra<Op::CFn>)
 where
     Op: MathOp,
-    CachedInput: GenerateInput<Op::RustArgs>,
+    <Op as MathOp>::RustArgs: RandomInput,
 {
     let name = Op::NAME;
 
diff --git a/crates/libm-test/src/gen.rs b/crates/libm-test/src/gen.rs
@@ -1,74 +1,5 @@
 //! Different generators that can create random or systematic bit patterns.
 
-use crate::GenerateInput;
 pub mod domain_logspace;
 pub mod edge_cases;
 pub mod random;
-
-/// Helper type to turn any reusable input into a generator.
-#[derive(Clone, Debug, Default)]
-pub struct CachedInput {
-    pub inputs_f32: Vec<(f32, f32, f32)>,
-    pub inputs_f64: Vec<(f64, f64, f64)>,
-    pub inputs_i32: Vec<(i32, i32, i32)>,
-}
-
-impl GenerateInput<(f32,)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f32,)> {
-        self.inputs_f32.iter().map(|f| (f.0,))
-    }
-}
-
-impl GenerateInput<(f32, f32)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f32, f32)> {
-        self.inputs_f32.iter().map(|f| (f.0, f.1))
-    }
-}
-
-impl GenerateInput<(i32, f32)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (i32, f32)> {
-        self.inputs_i32.iter().zip(self.inputs_f32.iter()).map(|(i, f)| (i.0, f.0))
-    }
-}
-
-impl GenerateInput<(f32, i32)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f32, i32)> {
-        GenerateInput::<(i32, f32)>::get_cases(self).map(|(i, f)| (f, i))
-    }
-}
-
-impl GenerateInput<(f32, f32, f32)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f32, f32, f32)> {
-        self.inputs_f32.iter().copied()
-    }
-}
-
-impl GenerateInput<(f64,)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f64,)> {
-        self.inputs_f64.iter().map(|f| (f.0,))
-    }
-}
-
-impl GenerateInput<(f64, f64)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f64, f64)> {
-        self.inputs_f64.iter().map(|f| (f.0, f.1))
-    }
-}
-
-impl GenerateInput<(i32, f64)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (i32, f64)> {
-        self.inputs_i32.iter().zip(self.inputs_f64.iter()).map(|(i, f)| (i.0, f.0))
-    }
-}
-
-impl GenerateInput<(f64, i32)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f64, i32)> {
-        GenerateInput::<(i32, f64)>::get_cases(self).map(|(i, f)| (f, i))
-    }
-}
-
-impl GenerateInput<(f64, f64, f64)> for CachedInput {
-    fn get_cases(&self) -> impl Iterator<Item = (f64, f64, f64)> {
-        self.inputs_f64.iter().copied()
-    }
-}
diff --git a/crates/libm-test/src/gen/random.rs b/crates/libm-test/src/gen/random.rs
@@ -1,116 +1,96 @@
-//! A simple generator that produces deterministic random input, caching to use the same
-//! inputs for all functions.
-
-use std::sync::LazyLock;
+use std::ops::RangeInclusive;
 
+use libm::support::Float;
+use rand::distributions::Standard;
+use rand::prelude::Distribution;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 
-use super::CachedInput;
-use crate::{BaseName, CheckCtx, GenerateInput};
+use crate::run_cfg::{int_range, iteration_count};
+use crate::{CheckCtx, GeneratorKind};
 
 const SEED: [u8; 32] = *b"3.141592653589793238462643383279";
 
-/// Number of tests to run.
-// FIXME(ntests): clean this up when possible
-const NTESTS: usize = {
-    if cfg!(optimizations_enabled) {
-        if crate::emulated()
-            || !cfg!(target_pointer_width = "64")
-            || cfg!(all(target_arch = "x86_64", target_vendor = "apple"))
-        {
-            // Tests are pretty slow on non-64-bit targets, x86 MacOS, and targets that run
-            // in QEMU.
-            100_000
-        } else {
-            5_000_000
-        }
-    } else {
-        // Without optimizations just run a quick check
-        800
-    }
-};
-
-/// Tested inputs.
-static TEST_CASES: LazyLock<CachedInput> = LazyLock::new(|| make_test_cases(NTESTS));
-
-/// The first argument to `jn` and `jnf` is the number of iterations. Make this a reasonable
-/// value so tests don't run forever.
-static TEST_CASES_JN: LazyLock<CachedInput> = LazyLock::new(|| {
-    // Start with regular test cases
-    let mut cases = (*TEST_CASES).clone();
-
-    // These functions are extremely slow, limit them
-    let ntests_jn = (NTESTS / 1000).max(80);
-    cases.inputs_i32.truncate(ntests_jn);
-    cases.inputs_f32.truncate(ntests_jn);
-    cases.inputs_f64.truncate(ntests_jn);
-
-    // It is easy to overflow the stack with these in debug mode
-    let max_iterations = if cfg!(optimizations_enabled) && cfg!(target_pointer_width = "64") {
-        0xffff
-    } else if cfg!(windows) {
-        0x00ff
-    } else {
-        0x0fff
-    };
+pub trait RandomInput {
+    fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self>;
+}
 
+fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F>
+where
+    Standard: Distribution<F::Int>,
+{
     let mut rng = ChaCha8Rng::from_seed(SEED);
 
-    for case in cases.inputs_i32.iter_mut() {
-        case.0 = rng.gen_range(3..=max_iterations);
-    }
-
-    cases
-});
+    // Generate integers to get a full range of bitpatterns, then convert back to
+    // floats.
+    (0..count).map(move |_| F::from_bits(rng.gen::<F::Int>()))
+}
 
-fn make_test_cases(ntests: usize) -> CachedInput {
+fn random_ints(count: u64, range: RangeInclusive<i32>) -> impl Iterator<Item = i32> {
     let mut rng = ChaCha8Rng::from_seed(SEED);
+    (0..count).map(move |_| rng.gen_range::<i32, _>(range.clone()))
+}
 
-    // make sure we include some basic cases
-    let mut inputs_i32 = vec![(0, 0, 0), (1, 1, 1), (-1, -1, -1)];
-    let mut inputs_f32 = vec![
-        (0.0, 0.0, 0.0),
-        (f32::EPSILON, f32::EPSILON, f32::EPSILON),
-        (f32::INFINITY, f32::INFINITY, f32::INFINITY),
-        (f32::NEG_INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY),
-        (f32::MAX, f32::MAX, f32::MAX),
-        (f32::MIN, f32::MIN, f32::MIN),
-        (f32::MIN_POSITIVE, f32::MIN_POSITIVE, f32::MIN_POSITIVE),
-        (f32::NAN, f32::NAN, f32::NAN),
-    ];
-    let mut inputs_f64 = vec![
-        (0.0, 0.0, 0.0),
-        (f64::EPSILON, f64::EPSILON, f64::EPSILON),
-        (f64::INFINITY, f64::INFINITY, f64::INFINITY),
-        (f64::NEG_INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY),
-        (f64::MAX, f64::MAX, f64::MAX),
-        (f64::MIN, f64::MIN, f64::MIN),
-        (f64::MIN_POSITIVE, f64::MIN_POSITIVE, f64::MIN_POSITIVE),
-        (f64::NAN, f64::NAN, f64::NAN),
-    ];
+macro_rules! impl_random_input {
+    ($fty:ty) => {
+        impl RandomInput for ($fty,) {
+            fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self> {
+                let count = iteration_count(ctx, GeneratorKind::Random, 0);
+                random_floats(count).map(|f: $fty| (f,))
+            }
+        }
 
-    inputs_i32.extend((0..(ntests - inputs_i32.len())).map(|_| rng.gen::<(i32, i32, i32)>()));
+        impl RandomInput for ($fty, $fty) {
+            fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self> {
+                let count0 = iteration_count(ctx, GeneratorKind::Random, 0);
+                let count1 = iteration_count(ctx, GeneratorKind::Random, 1);
+                random_floats(count0)
+                    .flat_map(move |f1: $fty| random_floats(count1).map(move |f2: $fty| (f1, f2)))
+            }
+        }
 
-    // Generate integers to get a full range of bitpatterns, then convert back to
-    // floats.
-    inputs_f32.extend((0..(ntests - inputs_f32.len())).map(|_| {
-        let ints = rng.gen::<(u32, u32, u32)>();
-        (f32::from_bits(ints.0), f32::from_bits(ints.1), f32::from_bits(ints.2))
-    }));
-    inputs_f64.extend((0..(ntests - inputs_f64.len())).map(|_| {
-        let ints = rng.gen::<(u64, u64, u64)>();
-        (f64::from_bits(ints.0), f64::from_bits(ints.1), f64::from_bits(ints.2))
-    }));
+        impl RandomInput for ($fty, $fty, $fty) {
+            fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self> {
+                let count0 = iteration_count(ctx, GeneratorKind::Random, 0);
+                let count1 = iteration_count(ctx, GeneratorKind::Random, 1);
+                let count2 = iteration_count(ctx, GeneratorKind::Random, 2);
+                random_floats(count0).flat_map(move |f1: $fty| {
+                    random_floats(count1).flat_map(move |f2: $fty| {
+                        random_floats(count2).map(move |f3: $fty| (f1, f2, f3))
+                    })
+                })
+            }
+        }
 
-    CachedInput { inputs_f32, inputs_f64, inputs_i32 }
+        impl RandomInput for (i32, $fty) {
+            fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self> {
+                let count0 = iteration_count(ctx, GeneratorKind::Random, 0);
+                let count1 = iteration_count(ctx, GeneratorKind::Random, 1);
+                let range0 = int_range(ctx, 0);
+                random_ints(count0, range0)
+                    .flat_map(move |f1: i32| random_floats(count1).map(move |f2: $fty| (f1, f2)))
+            }
+        }
+
+        impl RandomInput for ($fty, i32) {
+            fn get_cases(ctx: &CheckCtx) -> impl Iterator<Item = Self> {
+                let count0 = iteration_count(ctx, GeneratorKind::Random, 0);
+                let count1 = iteration_count(ctx, GeneratorKind::Random, 1);
+                let range1 = int_range(ctx, 1);
+                random_floats(count0).flat_map(move |f1: $fty| {
+                    random_ints(count1, range1.clone()).map(move |f2: i32| (f1, f2))
+                })
+            }
+        }
+    };
 }
 
+impl_random_input!(f32);
+impl_random_input!(f64);
+
 /// Create a test case iterator.
-pub fn get_test_cases<RustArgs>(ctx: &CheckCtx) -> impl Iterator<Item = RustArgs>
-where
-    CachedInput: GenerateInput<RustArgs>,
-{
-    let inputs = if ctx.base_name == BaseName::Jn { &TEST_CASES_JN } else { &TEST_CASES };
-    inputs.get_cases()
+pub fn get_test_cases<RustArgs: RandomInput>(
+    ctx: &CheckCtx,
+) -> impl Iterator<Item = RustArgs> + use<'_, RustArgs> {
+    RustArgs::get_cases(ctx)
 }
diff --git a/crates/libm-test/src/lib.rs b/crates/libm-test/src/lib.rs
@@ -24,7 +24,7 @@ pub use num::{FloatExt, logspace};
 pub use op::{BaseName, FloatTy, Identifier, MathOp, OpCFn, OpFTy, OpRustFn, OpRustRet, Ty};
 pub use precision::{MaybeOverride, SpecialCase, default_ulp};
 pub use run_cfg::{CheckBasis, CheckCtx, EXTENSIVE_ENV, GeneratorKind, TestAction};
-pub use test_traits::{CheckOutput, GenerateInput, Hex, TupleCall};
+pub use test_traits::{CheckOutput, Hex, TupleCall};
 
 /// Result type for tests is usually from `anyhow`. Most times there is no success value to
 /// propagate.
diff --git a/crates/libm-test/src/test_traits.rs b/crates/libm-test/src/test_traits.rs
@@ -1,8 +1,7 @@
 //! Traits related to testing.
 //!
-//! There are three main traits in this module:
+//! There are two main traits in this module:
 //!
-//! - `GenerateInput`: implemented on any types that create test cases.
 //! - `TupleCall`: implemented on tuples to allow calling them as function arguments.
 //! - `CheckOutput`: implemented on anything that is an output type for validation against an
 //!   expected value.
@@ -13,11 +12,6 @@ use anyhow::{Context, bail, ensure};
 
 use crate::{CheckCtx, Float, Int, MaybeOverride, SpecialCase, TestResult};
 
-/// Implement this on types that can generate a sequence of tuples for test input.
-pub trait GenerateInput<TupleArgs> {
-    fn get_cases(&self) -> impl Iterator<Item = TupleArgs>;
-}
-
 /// Trait for calling a function with a tuple as arguments.
 ///
 /// Implemented on the tuple with the function signature as the generic (so we can use the same
diff --git a/crates/libm-test/tests/compare_built_musl.rs b/crates/libm-test/tests/compare_built_musl.rs
@@ -9,10 +9,11 @@
 // There are some targets we can't build musl for
 #![cfg(feature = "build-musl")]
 
-use libm_test::gen::{CachedInput, random};
-use libm_test::{CheckBasis, CheckCtx, CheckOutput, GenerateInput, MathOp, TupleCall};
+use libm_test::gen::random;
+use libm_test::gen::random::RandomInput;
+use libm_test::{CheckBasis, CheckCtx, CheckOutput, MathOp, TupleCall};
 
-macro_rules! musl_rand_tests {
+macro_rules! musl_rand_tests{
     (
         fn_name: $fn_name:ident,
         attrs: [$($meta:meta)*]
@@ -21,16 +22,16 @@ macro_rules! musl_rand_tests {
             #[test]
             $(#[$meta])*
             fn [< musl_random_ $fn_name >]() {
-                test_one::<libm_test::op::$fn_name::Routine>(musl_math_sys::$fn_name);
+                test_one_random::<libm_test::op::$fn_name::Routine>(musl_math_sys::$fn_name);
             }
         }
     };
 }
 
-fn test_one<Op>(musl_fn: Op::CFn)
+fn test_one_random<Op>(musl_fn: Op::CFn)
 where
     Op: MathOp,
-    CachedInput: GenerateInput<Op::RustArgs>,
+    <Op as MathOp>::RustArgs: RandomInput,
 {
     let ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Musl);
     let cases = random::get_test_cases::<Op::RustArgs>(&ctx);
diff --git a/crates/libm-test/tests/multiprecision.rs b/crates/libm-test/tests/multiprecision.rs
@@ -3,11 +3,10 @@
 #![cfg(feature = "test-multiprecision")]
 
 use libm_test::domain::HasDomain;
-use libm_test::gen::{CachedInput, domain_logspace, edge_cases, random};
+use libm_test::gen::random::RandomInput;
+use libm_test::gen::{domain_logspace, edge_cases, random};
 use libm_test::mpfloat::MpOp;
-use libm_test::{
-    CheckBasis, CheckCtx, CheckOutput, GenerateInput, MathOp, OpFTy, OpRustFn, OpRustRet, TupleCall,
-};
+use libm_test::{CheckBasis, CheckCtx, CheckOutput, MathOp, OpFTy, OpRustFn, OpRustRet, TupleCall};
 
 /// Test against MPFR with random inputs.
 macro_rules! mp_rand_tests {
@@ -29,7 +28,7 @@ macro_rules! mp_rand_tests {
 fn test_one_random<Op>()
 where
     Op: MathOp + MpOp,
-    CachedInput: GenerateInput<Op::RustArgs>,
+    <Op as MathOp>::RustArgs: RandomInput,
 {
     let mut mp_vals = Op::new_mp();
     let ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Mpfr);
