Remove allow_nan because it isn't useful; adjust logic for number of fuzz tests

Author: tgross35

src/etc/test-float-parse/src/gen/fuzz.rs

@@ -1,18 +1,22 @@
+use std::any::{type_name, TypeId};
+use std::collections::BTreeMap;
 use std::fmt::Write;
 use std::marker::PhantomData;
 use std::ops::Range;
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
 
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 use rand_chacha::rand_core::SeedableRng;
 use rand_chacha::ChaCha8Rng;
 
-use crate::{Float, Generator, SEED};
+use crate::{Float, Generator, Int, SEED};
 
-/// How many iterations to fuzz for; can be updated before launching. We use a static since
-/// `Generator::new` doesn't take any input.
-pub static FUZZ_COUNT: AtomicU64 = AtomicU64::new(crate::DEFAULT_FUZZ_COUNT);
+/// Mapping of float types to the number of iterations that should be run.
+///
+/// We could probably make `Generator::new` take an argument instead of the global state,
+/// but we only load this once so it works.
+static FUZZ_COUNTS: Mutex<BTreeMap<TypeId, u64>> = Mutex::new(BTreeMap::new());
 
 /// Generic fuzzer; just tests deterministic random bit patterns N times.
 pub struct Fuzz<F> {
@@ -22,24 +26,46 @@ pub struct Fuzz<F> {
     marker: PhantomData<F>,
 }
 
+impl<F: Float> Fuzz<F> {
+    /// Register how many iterations the fuzzer should run for a type. Uses some logic by
+    /// default, but if `from_cfg` is `Some`, that will be used instead.
+    pub fn set_iterations(from_cfg: Option<u64>) {
+        let count = if let Some(cfg_count) = from_cfg {
+            cfg_count
+        } else if F::BITS <= crate::MAX_BITS_FOR_EXHAUUSTIVE {
+            // If we run exhaustively, still fuzz but only do half as many bits. The only goal here is
+            // to catch failures from e.g. high bit patterns before exhaustive tests would get to them.
+            (F::Int::MAX >> (F::BITS / 2)).try_into().unwrap()
+        } else {
+            // Eveything bigger gets a fuzz test with as many iterations as `f32` exhaustive.
+            u32::MAX.into()
+        };
+
+        let _ = FUZZ_COUNTS.lock().unwrap().insert(TypeId::of::<F>(), count);
+    }
+}
+
 impl<F: Float> Generator<F> for Fuzz<F>
 where
     Standard: Distribution<<F as Float>::Int>,
 {
     const NAME: &'static str = "fuzz";
     const SHORT_NAME: &'static str = "fuzz";
-    const PATTERNS_CONTAIN_NAN: bool = true;
 
     type WriteCtx = F;
 
     fn total_tests() -> u64 {
-        FUZZ_COUNT.load(Ordering::Relaxed)
+        *FUZZ_COUNTS
+            .lock()
+            .unwrap()
+            .get(&TypeId::of::<F>())
+            .unwrap_or_else(|| panic!("missing fuzz count for {}", type_name::<F>()))
     }
 
     fn new() -> Self {
         let rng = ChaCha8Rng::from_seed(SEED);
 
-        Self { iter: 0..FUZZ_COUNT.load(Ordering::Relaxed), rng, marker: PhantomData }
+        Self { iter: 0..Self::total_tests(), rng, marker: PhantomData }
     }
 
     fn write_string(s: &mut String, ctx: Self::WriteCtx) {

src/etc/test-float-parse/src/gen/sparse.rs

@@ -75,7 +75,6 @@ where
 {
     const NAME: &'static str = "few ones float";
     const SHORT_NAME: &'static str = "few ones float";
-    const PATTERNS_CONTAIN_NAN: bool = true;
 
     type WriteCtx = F;
 

src/etc/test-float-parse/src/gen/spot_checks.rs

@@ -19,8 +19,6 @@ impl<F: Float> Generator<F> for Special {
 
     const SHORT_NAME: &'static str = "special";
 
-    const PATTERNS_CONTAIN_NAN: bool = true;
-
     type WriteCtx = &'static str;
 
     fn total_tests() -> u64 {

src/etc/test-float-parse/src/lib.rs

@@ -29,9 +29,11 @@ mod gen {
     pub mod subnorm;
 }
 
-/// Fuzz iterations to run if not specified by CLI arg. By default, test as many conditions
-/// as the `f32` exhaustive test.
-pub const DEFAULT_FUZZ_COUNT: u64 = u32::MAX as u64;
+/// How many failures to exit after if unspecified.
+const DEFAULT_MAX_FAILURES: u64 = 20;
+
+/// Register exhaustive tests only for <= 32 bits. No more because it would take years.
+const MAX_BITS_FOR_EXHAUUSTIVE: u32 = 32;
 
 /// If there are more tests than this threashold, the test will be defered until after all
 /// others run (so as to avoid thread pool starvation). They also can be excluded with
@@ -46,21 +48,34 @@ const SEED: [u8; 32] = *b"3.141592653589793238462643383279";
 pub struct Config {
     pub timeout: Duration,
     /// Failures per test
-    pub max_failures: Option<u64>,
+    pub max_failures: u64,
+    pub disable_max_failures: bool,
+    /// If `None`, the default will be used
     pub fuzz_count: Option<u64>,
     pub skip_huge: bool,
 }
 
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(60 * 60 * 3),
+            max_failures: DEFAULT_MAX_FAILURES,
+            disable_max_failures: false,
+            fuzz_count: None,
+            skip_huge: false,
+        }
+    }
+}
+
 /// Collect, filter, and launch all tests.
 pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode {
-    gen::fuzz::FUZZ_COUNT.store(cfg.fuzz_count.unwrap_or(u64::MAX), Ordering::Relaxed);
-
     // With default parallelism, the CPU doesn't saturate. We don't need to be nice to
     // other processes, so do 1.5x to make sure we use all available resources.
     let threads = std::thread::available_parallelism().map(Into::into).unwrap_or(0) * 3 / 2;
     rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
 
-    let mut tests = register_tests();
+    let mut tests = register_tests(&cfg);
+    println!("registered");
     let initial_tests: Vec<_> = tests.iter().map(|t| t.name.clone()).collect();
 
     let unmatched: Vec<_> = include
@@ -89,20 +104,18 @@ pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode {
         println!("Skipping test '{exc}'");
     }
 
+    println!("launching");
     let elapsed = launch_tests(&mut tests, &cfg);
     ui::finish(&tests, elapsed, &cfg)
 }
 
 /// Enumerate tests to run but don't actaully run them.
-pub fn register_tests() -> Vec<TestInfo> {
+pub fn register_tests(cfg: &Config) -> Vec<TestInfo> {
     let mut tests = Vec::new();
 
     // Register normal generators for all floats.
-    register_float::<f32>(&mut tests);
-    register_float::<f64>(&mut tests);
-
-    // Register exhaustive tests for <= 32 bits. No more because it would take years.
-    TestInfo::register::<f32, gen::exhaustive::Exhaustive<f32>>(&mut tests);
+    register_float::<f32>(&mut tests, cfg);
+    register_float::<f64>(&mut tests, cfg);
 
     tests.sort_unstable_by_key(|t| (t.float_name, t.gen_name));
     for i in 0..(tests.len() - 1) {
@@ -115,12 +128,19 @@ pub fn register_tests() -> Vec<TestInfo> {
 }
 
 /// Register all generators for a single float.
-fn register_float<F: Float>(tests: &mut Vec<TestInfo>)
+fn register_float<F: Float>(tests: &mut Vec<TestInfo>, cfg: &Config)
 where
     RangeInclusive<F::Int>: Iterator<Item = F::Int>,
     <F::Int as TryFrom<u128>>::Error: std::fmt::Debug,
     Standard: Distribution<<F as traits::Float>::Int>,
 {
+    if F::BITS <= MAX_BITS_FOR_EXHAUUSTIVE {
+        // Only run exhaustive tests if there is a chance of completion.
+        TestInfo::register::<F, gen::exhaustive::Exhaustive<F>>(tests);
+    }
+
+    gen::fuzz::Fuzz::<F>::set_iterations(cfg.fuzz_count);
+
     TestInfo::register::<F, gen::exponents::LargeExponents<F>>(tests);
     TestInfo::register::<F, gen::exponents::SmallExponents<F>>(tests);
     TestInfo::register::<F, gen::fuzz::Fuzz<F>>(tests);
@@ -451,13 +471,13 @@ fn test_runner<F: Float, G: Generator<F>>(tx: &mpsc::Sender<Msg>, _info: &TestIn
         buf.clear();
         G::write_string(buf, ctx);
 
-        match validate::validate::<F>(buf, G::PATTERNS_CONTAIN_NAN) {
+        match validate::validate::<F>(buf) {
             Ok(()) => (),
             Err(e) => {
                 tx.send(Msg::new::<F, G>(e)).unwrap();
                 let f = failures.fetch_add(1, Ordering::Relaxed);
                 // End early if the limit is exceeded.
-                if cfg.max_failures.map_or(false, |mf| f >= mf) {
+                if f >= cfg.max_failures {
                     return Err(EarlyExit::MaxFailures);
                 }
             }

src/etc/test-float-parse/src/main.rs

@@ -53,7 +53,7 @@ fn main() -> ExitCode {
     }
 
     if args.iter().any(|arg| arg == "--list") {
-        let tests = tfp::register_tests();
+        let tests = tfp::register_tests(&tfp::Config::default());
         println!("Available tests:");
         for t in tests {
             println!("{}", t.name);
@@ -69,12 +69,7 @@ fn main() -> ExitCode {
 
 /// Simple command argument parser
 fn parse_args(args: Vec<String>) -> (tfp::Config, Vec<String>, Vec<String>) {
-    let mut cfg = tfp::Config {
-        timeout: Duration::from_secs(60 * 60 * 3),
-        max_failures: Some(20),
-        fuzz_count: Some(tfp::DEFAULT_FUZZ_COUNT),
-        skip_huge: false,
-    };
+    let mut cfg = tfp::Config::default();
 
     let mut mode = ArgMode::Any;
     let mut include = Vec::new();
@@ -109,15 +104,15 @@ fn parse_args(args: Vec<String>) -> (tfp::Config, Vec<String>, Vec<String>) {
             }
             ArgMode::MaxFailures => {
                 if arg == "none" {
-                    cfg.max_failures = None;
+                    cfg.disable_max_failures = true;
                 } else {
-                    cfg.max_failures = Some(arg.parse().unwrap());
+                    cfg.max_failures = arg.parse().unwrap();
                 }
                 ArgMode::Any
             }
             ArgMode::FuzzCount => {
                 if arg == "none" {
-                    cfg.fuzz_count = None;
+                    cfg.fuzz_count = Some(u64::MAX);
                 } else {
                     cfg.fuzz_count = Some(arg.parse().unwrap());
                 }

src/etc/test-float-parse/src/traits.rs

@@ -182,10 +182,6 @@ pub trait Generator<F: Float>: Iterator<Item = Self::WriteCtx> + Send + 'static
     /// Name for display with the progress bar
     const SHORT_NAME: &'static str;
 
-    /// If false (default), validation will assert on NaN. Set `true` for random patterns like
-    /// fuzzers or exhaustive.
-    const PATTERNS_CONTAIN_NAN: bool = false;
-
     /// The context needed to create a test string.
     type WriteCtx: Send;
 

src/etc/test-float-parse/src/ui.rs

@@ -52,7 +52,7 @@ pub fn finalize_pb(pb: &ProgressBar, short_name_padded: &str, c: &Completed) {
     };
 
     let pb_style = ProgressStyle::with_template(
-        &PB_TEMPLATE_FINAL.replace("NAME", &short_name_padded).replace("COLOR", color),
+        &PB_TEMPLATE_FINAL.replace("NAME", short_name_padded).replace("COLOR", color),
     )
     .unwrap();
 

src/etc/test-float-parse/src/validate.rs

@@ -89,13 +89,13 @@ impl Constants {
 }
 
 /// Validate that a string parses correctly
-pub fn validate<F: Float>(input: &str, allow_nan: bool) -> Result<(), Update> {
+pub fn validate<F: Float>(input: &str) -> Result<(), Update> {
     let parsed: F = input
         .parse()
         .unwrap_or_else(|e| panic!("parsing failed for {}: {e}. Input: {input}", type_name::<F>()));
 
     // Parsed float, decoded into significand and exponent
-    let decoded = decode(parsed, allow_nan);
+    let decoded = decode(parsed);
 
     // Float parsed separately into a rational
     let rational = Rational::parse(input);
@@ -249,7 +249,7 @@ impl<F: Float> FloatRes<F> {
 /// Decompose a float into its integral components. This includes the implicit bit.
 ///
 /// If `allow_nan` is `false`, panic if `NaN` values are reached.
-fn decode<F: Float>(f: F, allow_nan: bool) -> FloatRes<F> {
+fn decode<F: Float>(f: F) -> FloatRes<F> {
     let ione = F::SInt::ONE;
     let izero = F::SInt::ZERO;
 
@@ -263,9 +263,7 @@ fn decode<F: Float>(f: F, allow_nan: bool) -> FloatRes<F> {
 
         exponent_biased += 1;
     } else if exponent_biased == F::EXP_SAT {
-        if !allow_nan {
-            assert_eq!(mantissa, izero, "Unexpected NaN for {}", f.to_bits().hex());
-        } else if mantissa != izero {
+        if mantissa != izero {
             return FloatRes::Nan;
         }
 

src/etc/test-float-parse/src/validate/tests.rs

@@ -35,34 +35,31 @@ fn test_parse_rational() {
 
 #[test]
 fn test_decode() {
-    assert_eq!(decode(0f32, false), FloatRes::Zero);
-    assert_eq!(decode(f32::INFINITY, false), FloatRes::Inf);
-    assert_eq!(decode(f32::NEG_INFINITY, false), FloatRes::NegInf);
-    assert_eq!(decode(1.0f32, false).normalize(), FloatRes::Real { sig: 1, exp: 0 });
-    assert_eq!(decode(-1.0f32, false).normalize(), FloatRes::Real { sig: -1, exp: 0 });
-    assert_eq!(decode(100.0f32, false).normalize(), FloatRes::Real { sig: 100, exp: 0 });
-    assert_eq!(decode(100.5f32, false).normalize(), FloatRes::Real { sig: 201, exp: -1 });
-    assert_eq!(decode(-4.004f32, false).normalize(), FloatRes::Real { sig: -8396997, exp: -21 });
-    assert_eq!(decode(0.0004f32, false).normalize(), FloatRes::Real { sig: 13743895, exp: -35 });
-    assert_eq!(
-        decode(f32::from_bits(0x1), false).normalize(),
-        FloatRes::Real { sig: 1, exp: -149 }
-    );
+    assert_eq!(decode(0f32), FloatRes::Zero);
+    assert_eq!(decode(f32::INFINITY), FloatRes::Inf);
+    assert_eq!(decode(f32::NEG_INFINITY), FloatRes::NegInf);
+    assert_eq!(decode(1.0f32).normalize(), FloatRes::Real { sig: 1, exp: 0 });
+    assert_eq!(decode(-1.0f32).normalize(), FloatRes::Real { sig: -1, exp: 0 });
+    assert_eq!(decode(100.0f32).normalize(), FloatRes::Real { sig: 100, exp: 0 });
+    assert_eq!(decode(100.5f32).normalize(), FloatRes::Real { sig: 201, exp: -1 });
+    assert_eq!(decode(-4.004f32).normalize(), FloatRes::Real { sig: -8396997, exp: -21 });
+    assert_eq!(decode(0.0004f32).normalize(), FloatRes::Real { sig: 13743895, exp: -35 });
+    assert_eq!(decode(f32::from_bits(0x1)).normalize(), FloatRes::Real { sig: 1, exp: -149 });
 }
 
 #[test]
 fn test_validate() {
-    validate::<f32>("0", false).unwrap();
-    validate::<f32>("-0", false).unwrap();
-    validate::<f32>("1", false).unwrap();
-    validate::<f32>("-1", false).unwrap();
-    validate::<f32>("1.1", false).unwrap();
-    validate::<f32>("-1.1", false).unwrap();
-    validate::<f32>("1e10", false).unwrap();
-    validate::<f32>("1e1000", false).unwrap();
-    validate::<f32>("-1e1000", false).unwrap();
-    validate::<f32>("1e-1000", false).unwrap();
-    validate::<f32>("-1e-1000", false).unwrap();
+    validate::<f32>("0").unwrap();
+    validate::<f32>("-0").unwrap();
+    validate::<f32>("1").unwrap();
+    validate::<f32>("-1").unwrap();
+    validate::<f32>("1.1").unwrap();
+    validate::<f32>("-1.1").unwrap();
+    validate::<f32>("1e10").unwrap();
+    validate::<f32>("1e1000").unwrap();
+    validate::<f32>("-1e1000").unwrap();
+    validate::<f32>("1e-1000").unwrap();
+    validate::<f32>("-1e-1000").unwrap();
 }
 
 #[test]