10000 Make extensive a field rather than enum variant · rust-lang/compiler-builtins@e0434f8 · GitHub
[go: up one dir, main page]
Skip to content

Commit e0434f8

Browse files
tgross35tgross35
committed
Make extensive a field rather than enum variant
Add more extensive tests
1 parent 11cf244 commit e0434f8

File tree

6 files changed

+86
-40
lines changed

6 files changed

+86
-40
lines changed

‎libm-test/benches/random.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ where
5757
let name = Op::NAME;
5858

5959
let ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Musl, GeneratorKind::Random);
60-
let benchvec: Vec<_> = random::get_test_cases::<Op::RustArgs>(&ctx)
60+
let benchvec: Vec<_> = random::get_test_cases::<Op>(ctx.clone())
6161
.0
6262
.take(BENCH_ITER_ITEMS)
6363
.collect();

‎libm-test/examples/plot_domains.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -61,15 +61,15 @@ where
6161
&ctx,
6262
"logspace",
6363
config,
64-
spaced::get_test_cases::<Op>(&ctx).0,
64+
spaced::get_test_cases::<Op>(ctx.clone()).0,
6565
);
6666
ctx.gen_kind = GeneratorKind::EdgeCases;
6767
plot_one_generator(
6868
out_dir,
6969
&ctx,
7070
"edge_cases",
7171
config,
72-
edge_cases::get_test_cases::<Op>(&ctx).0,
72+
edge_cases::get_test_cases::<Op>(ctx.clone()).0,
7373
);
7474
}
7575

‎libm-test/src/run_cfg.rs

Lines changed: 26 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -24,9 +24,9 @@ static EXTENSIVE_ITER_OVERRIDE: LazyLock<Option<u64>> = LazyLock::new(|| {
2424
/// amount of time.
2525
///
2626
/// Contains the itentifier+generator combo to match on, plus the factor to reduce by.
27-
const EXTEMELY_SLOW_TESTS: &[(Identifier, GeneratorKind, u64)] = &[
28-
(Identifier::Fmodf128, GeneratorKind::QuickSpaced, 50),
29-
(Identifier::Fmodf128, GeneratorKind::Extensive, 50),
27+
const EXTEMELY_SLOW_TESTS: &[(Identifier, GeneratorKind, bool, u64)] = &[
28+
(Identifier::Fmodf128, GeneratorKind::QuickSpaced, false, 50),
29+
(Identifier::Fmodf128, GeneratorKind::Extensive, true, 50),
3030
];
3131

3232
/// Maximum number of iterations to run for a single routine.
@@ -54,6 +54,7 @@ pub struct CheckCtx {
5454
/// Source of truth for tests.
5555
pub basis: CheckBasis,
5656
pub gen_kind: GeneratorKind,
57+
pub extensive: bool,
5758
/// If specified, this value will override the value returned by [`iteration_count`].
5859
pub override_iterations: Option<u64>,
5960
}
@@ -69,12 +70,19 @@ impl CheckCtx {
6970
base_name_str: fn_ident.base_name().as_str(),
7071
basis,
7172
gen_kind,
73+
extensive: false,
7274
override_iterations: None,
7375
};
7476
ret.ulp = crate::default_ulp(&ret);
7577
ret
7678
}
7779

80+
/// Configure that this is an extensive test.
81+
pub fn extensive(mut self, extensive: bool) -> Self {
82+
self.extensive = extensive;
83+
self
84+
}
85+
7886
/// The number of input arguments for this function.
7987
pub fn input_count(&self) -> usize {
8088
self.fn_ident.math_op().rust_sig.args.len()
@@ -101,8 +109,7 @@ pub enum CheckBasis {
101109
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
102110
pub enum GeneratorKind {
103111
EdgeCases,
104-
Extensive,
105-
QuickSpaced,
112+
Spaced,
106113
Random,
107114
List,
108115
}
@@ -216,17 +223,17 @@ pub fn iteration_count(ctx: &CheckCtx, argnum: usize) -> u64 {
216223
let random_iter_count = domain_iter_count / 100;
217224

218225
let mut total_iterations = match ctx.gen_kind {
219-
GeneratorKind::QuickSpaced => domain_iter_count,
226+
GeneratorKind::Spaced if ctx.extensive => extensive_max_iterations(),
227+
GeneratorKind::Spaced => domain_iter_count,
220228
GeneratorKind::Random => random_iter_count,
221-
GeneratorKind::Extensive => extensive_max_iterations(),
222229
GeneratorKind::EdgeCases | GeneratorKind::List => {
223230
unimplemented!("shoudn't need `iteration_count` for {:?}", ctx.gen_kind)
224231
}
225232
};
226233

227234
// Larger float types get more iterations.
228-
if t_env.large_float_ty && ctx.gen_kind != GeneratorKind::Extensive {
229-
if ctx.gen_kind == GeneratorKind::Extensive {
235+
if t_env.large_float_ty {
236+
if ctx.extensive {
230237
// Extensive already has a pretty high test count.
231238
total_iterations *= 2;
232239
} else {
@@ -244,12 +251,15 @@ pub fn iteration_count(ctx: &CheckCtx, argnum: usize) -> u64 {
244251
}
245252

246253
// Some tests are significantly slower than others and need to be further reduced.
247-
if let Some((_id, _gen, scale)) = EXTEMELY_SLOW_TESTS
248-
.iter()
249-
.find(|(id, generator, _scale)| *id == ctx.fn_ident && *generator == ctx.gen_kind)
254+
if let Some((_id, _generator, _extensive, scale)) =
255+
EXTEMELY_SLOW_TESTS
256+
.iter()
257+
.find(|(id, generator, extensive, _scale)| {
258+
*id == ctx.fn_ident && *generator == ctx.gen_kind && *extensive == ctx.extensive
259+
})
250260
{
251261
// However, do not override if the extensive iteration count has been manually set.
252-
if !(ctx.gen_kind == GeneratorKind::Extensive && EXTENSIVE_ITER_OVERRIDE.is_some()) {
262+
if !(ctx.extensive && EXTENSIVE_ITER_OVERRIDE.is_some()) {
253263
total_iterations /= scale;
254264
}
255265
}
@@ -279,7 +289,7 @@ pub fn iteration_count(ctx: &CheckCtx, argnum: usize) -> u64 {
279289
let total = ntests.pow(t_env.input_count.try_into().unwrap());
280290

281291
let seed_msg = match ctx.gen_kind {
282-
GeneratorKind::QuickSpaced | GeneratorKind::Extensive => String::new(),
292+
GeneratorKind::Spaced => String::new(),
283293
GeneratorKind::Random => {
284294
format!(
285295
" using `{SEED_ENV}={}`",
@@ -327,8 +337,8 @@ pub fn int_range(ctx: &CheckCtx, argnum: usize) -> RangeInclusive<i32> {
327337
let extensive_range = (-0xfff)..=0xfffff;
328338

329339
match ctx.gen_kind {
330-
GeneratorKind::Extensive => exte 1C6A nsive_range,
331-
GeneratorKind::QuickSpaced | GeneratorKind::Random => non_extensive_range,
340+
_ if ctx.extensive => extensive_range,
341+
GeneratorKind::Spaced | GeneratorKind::Random => non_extensive_range,
332342
GeneratorKind::EdgeCases => extensive_range,
333343
GeneratorKind::List => unimplemented!("shoudn't need range for {:?}", ctx.gen_kind),
334344
}

‎libm-test/tests/compare_built_musl.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ macro_rules! musl_tests {
4848
fn [< musl_random_ $fn_name >]() {
4949
type Op = libm_test::op::$fn_name::Routine;
5050
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
51-
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
51+
let cases = random::get_test_cases::<Op>(ctx.clone()).0;
5252
musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
5353
}
5454

@@ -57,16 +57,16 @@ macro_rules! musl_tests {
5757
fn [< musl_edge_case_ $fn_name >]() {
5858
type Op = libm_test::op::$fn_name::Routine;
5959
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
60-
let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
60+
let cases = edge_cases::get_test_cases::<Op>(ctx.clone()).0;
6161
musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
6262
}
6363

6464
#[test]
6565
$(#[$attr])*
66-
fn [< musl_quickspace_ $fn_name >]() {
66+
fn [< musl_logspace_ $fn_name >]() {
6767
type Op = libm_test::op::$fn_name::Routine;
68-
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::QuickSpaced);
69-
let cases = spaced::get_test_cases::<Op>(&ctx).0;
68+
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Spaced);
69+
let cases = spaced::get_test_cases::<Op>(ctx.clone()).0;
7070
musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
7171
}
7272
}

‎libm-test/tests/multiprecision.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ macro_rules! mp_tests {
3838
fn [< mp_random_ $fn_name >]() {
3939
type Op = libm_test::op::$fn_name::Routine;
4040
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
41-
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
41+
let cases = random::get_test_cases::<Op>(ctx.clone()).0;
4242
mp_runner::<Op>(&ctx, cases);
4343
}
4444

@@ -47,16 +47,16 @@ macro_rules! mp_tests {
4747
fn [< mp_edge_case_ $fn_name >]() {
4848
type Op = libm_test::op::$fn_name::Routine;
4949
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
50-
let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
50+
let cases = edge_cases::get_test_cases::<Op>(ctx.clone()).0;
5151
mp_runner::<Op>(&ctx, cases);
5252
}
5353

5454
#[test]
5555
$(#[$attr])*
56-
fn [< mp_quickspace_ $fn_name >]() {
56+
fn [< mp_logspace_ $fn_name >]() {
5757
type Op = libm_test::op::$fn_name::Routine;
58-
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::QuickSpaced);
59-
let cases = spaced::get_test_cases::<Op>(&ctx).0;
58+
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Spaced);
59+
let cases = spaced::get_test_cases::<Op>(ctx.clone()).0;
6060
mp_runner::<Op>(&ctx, cases);
6161
}
6262
}

‎libm-test/tests/z_extensive/run.rs

Lines changed: 47 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,9 @@ use std::sync::atomic::{AtomicU64, Ordering};
66
use std::time::Duration;
77

88
use indicatif::{ProgressBar, ProgressStyle};
9-
use libm_test::generate::spaced;
9+
use libm_test::generate::edge_cases::EdgeCaseInput;
10+
use libm_test::generate::random::RandomInput;
11+
use libm_test::generate::{edge_cases, random, spaced};
1012
use libm_test::mpfloat::MpOp;
1113
use libm_test::{
1214
CheckBasis, CheckCtx, CheckOutput, GeneratorKind, MathOp, TestResult, TupleCall,
@@ -17,7 +19,6 @@ use rayon::prelude::*;
1719
use spaced::SpacedInput;
1820

1921
const BASIS: CheckBasis = CheckBasis::Mpfr;
20-
const GEN_KIND: GeneratorKind = GeneratorKind::Extensive;
2122

2223
/// Run the extensive test suite.
2324
pub fn run() {
@@ -48,7 +49,7 @@ macro_rules! mp_extensive_tests {
4849
extra: [$push_to:ident],
4950
) => {
5051
$(#[$attr])*
51-
register_single_test::<libm_test::op::$fn_name::Routine>(&mut $push_to);
52+
register_single_op::<libm_test::op::$fn_name::Routine>(&mut $push_to);
5253
};
5354
}
5455

@@ -71,21 +72,51 @@ fn register_all_tests() -> Vec<Trial> {
7172
}
7273

7374
/// Add a single test to the list.
74-
fn register_single_test<Op>(all: &mut Vec<Trial>)
75+
fn register_single_op<Op>(all: &mut Vec<Trial>)
7576
where
77+
Op: MathOp + MpOp + 'static,
78+
Op::RustArgs: SpacedInput<Op> + RandomInput + EdgeCaseInput<Op> + Send,
79+
{
80+
// All generators need to take `ctx` by value to avoid
81+
// https://github.com/rust-lang/rust/issues/42940
82+
83+
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases).extensive(true);
84+
let (cases, total) = edge_cases::get_test_cases::<Op>(ctx.clone());
85+
register_single_test::<Op>(all, ctx, cases, total);
86+
87+
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Spaced).extensive(true);
88+
let (cases, total) = spaced::get_test_cases::<Op>(ctx.clone());
89+
register_single_test::<Op>(all, ctx, cases, total);
90+
91+
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random).extensive(true);
92+
let (cases, total) = random::get_test_cases::<Op>(ctx.clone());
93+
register_single_test::<Op>(all, ctx, cases, total);
94+
}
95+
96+
fn register_single_test<Op>(
97+
all: &mut Vec<Trial>,
98+
ctx: CheckCtx,
99+
cases: impl Iterator<Item = Op::RustArgs> + Send + 'static,
100+
total: u64,
101+
) where
76102
Op: MathOp + MpOp,
77-
Op::RustArgs: SpacedInput<Op> + Send,
103+
Op::RustArgs: SpacedInput<Op> + RandomInput + EdgeCaseInput<Op> + Send,
78104
{
79-
let test_name = format!("mp_extensive_{}", Op::NAME);
80-
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GEN_KIND);
105+
let x = match ctx.gen_kind {
106+
GeneratorKind::EdgeCases => "edge_cases",
107+
GeneratorKind::Spaced => "logspace",
108+
GeneratorKind::Random => "random",
109+
};
110+
111+
let test_name = format!("mp_extensive_{x}_{}", Op::NAME);
81112
let skip = skip_extensive_test(&ctx);
82113

83114
let runner = move || {
84115
if !cfg!(optimizations_enabled) {
85116
panic!("extensive tests should be run with --release");
86117
}
87118

88-
let res = run_single_test::<Op>(&ctx);
119+
let res = run_single_test::<Op>(&ctx, cases, total);
89120
let e = match res {
90121
Ok(()) => return Ok(()),
91122
Err(e) => e,
@@ -103,7 +134,11 @@ where
103134
}
104135

105136
/// Test runner for a signle routine.
106-
fn run_single_test<Op>(ctx: &CheckCtx) -> TestResult
137+
fn run_single_test<Op>(
138+
ctx: &CheckCtx,
139+
mut cases: impl Iterator<Item = Op::RustArgs> + Send,
140+
total: u64,
141+
) -> TestResult
107142
where
108143
Op: MathOp + MpOp,
109144
Op::RustArgs: SpacedInput<Op> + Send,
@@ -113,7 +148,8 @@ where
113148
eprintln!();
114149

115150
let completed = AtomicU64::new(0);
116-
let (ref mut cases, total) = spaced::get_test_cases::<Op>(ctx);
151+
// let ref mut cases = cases;
152+
// let (ref mut cases, total) = spaced::get_test_cases::<Op>(ctx);
117153
let pb = Progress::new(Op::NAME, total);
118154

119155
let test_single_chunk = |mp_vals: &mut Op::MpTy, input_vec: Vec<Op::RustArgs>| -> TestResult {
@@ -136,7 +172,7 @@ where
136172
let chunk_size = 50_000;
137173
let chunks = std::iter::from_fn(move || {
138174
let mut v = Vec::with_capacity(chunk_size);
139-
v.extend(cases.take(chunk_size));
175+
v.extend((&mut cases).take(chunk_size));
140176
(!v.is_empty()).then_some(v)
141177
});
142178

0 commit comments

Comments
 (0)
0