diff --git a/benches/dataflow.rs b/benches/dataflow.rs index 24f5a16ee..db099c6b2 100644 --- a/benches/dataflow.rs +++ b/benches/dataflow.rs @@ -167,5 +167,46 @@ fn dataflow(criterion: &mut Criterion) { }); } -criterion_group!(benches, dataflow); +/// Emulates a data flow problem of the form: +/// ```py +/// self.x0 = self.x1 + self.x2 + self.x3 + self.x4 +/// self.x1 = self.x0 + self.x2 + self.x3 + self.x4 +/// self.x2 = self.x0 + self.x1 + self.x3 + self.x4 +/// self.x3 = self.x0 + self.x1 + self.x2 + self.x4 +/// self.x4 = 0 +/// ``` +fn nested(criterion: &mut Criterion) { + criterion.bench_function("converge_diverge_nested", |b| { + b.iter_batched_ref( + || { + let mut db = salsa::DatabaseImpl::new(); + + let def_x0 = Definition::new(&db, None, 0); + let def_x1 = Definition::new(&db, None, 0); + let def_x2 = Definition::new(&db, None, 0); + let def_x3 = Definition::new(&db, None, 0); + let def_x4 = Definition::new(&db, None, 0); + + let use_x0 = Use::new(&db, vec![def_x1, def_x2, def_x3, def_x4]); + let use_x1 = Use::new(&db, vec![def_x0, def_x2, def_x3, def_x4]); + let use_x2 = Use::new(&db, vec![def_x0, def_x1, def_x3, def_x4]); + let use_x3 = Use::new(&db, vec![def_x0, def_x1, def_x3, def_x4]); + + def_x0.set_base(&mut db).to(Some(use_x0)); + def_x1.set_base(&mut db).to(Some(use_x1)); + def_x2.set_base(&mut db).to(Some(use_x2)); + def_x3.set_base(&mut db).to(Some(use_x3)); + + (db, def_x0) + }, + |(db, def_x0)| { + // All symbols converge on 0. + assert_eq!(infer_definition(db, *def_x0), Type::Values(Box::from([0]))); + }, + BatchSize::LargeInput, + ); + }); +} + +criterion_group!(benches, dataflow, nested); criterion_main!(benches); diff --git a/components/salsa-macro-rules/src/unexpected_cycle_recovery.rs b/components/salsa-macro-rules/src/unexpected_cycle_recovery.rs index a1cd1e73f..8d56d54f3 100644 --- a/components/salsa-macro-rules/src/unexpected_cycle_recovery.rs +++ b/components/salsa-macro-rules/src/unexpected_cycle_recovery.rs @@ -5,7 +5,7 @@ macro_rules! unexpected_cycle_recovery { ($db:ident, $value:ident, $count:ident, $($other_inputs:ident),*) => {{ std::mem::drop($db); - std::mem::drop(($($other_inputs),*)); + std::mem::drop(($($other_inputs,)*)); panic!("cannot recover from cycle") }}; } @@ -14,7 +14,7 @@ macro_rules! unexpected_cycle_recovery { macro_rules! unexpected_cycle_initial { ($db:ident, $($other_inputs:ident),*) => {{ std::mem::drop($db); - std::mem::drop(($($other_inputs),*)); + std::mem::drop(($($other_inputs,)*)); panic!("no cycle initial value") }}; }