[RFC] fixpoint iteration support

Cargo.toml

@@ -45,7 +45,6 @@ trybuild = "1.0"
 name = "compare"
 harness = false
 
-
 [[bench]]
 name = "incremental"
 harness = false
@@ -54,5 +53,9 @@ harness = false
 name = "accumulator"
 harness = false
 
+[[bench]]
+name = "dataflow"
+harness = false
+
 [workspace]
 members = ["components/salsa-macro-rules", "components/salsa-macros"]

benches/dataflow.rs

@@ -0,0 +1,170 @@
+//! Benchmark for fixpoint iteration cycle resolution.
+//!
+//! This benchmark simulates a (very simplified) version of a real dataflow analysis using fixpoint
+//! iteration.
+use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Criterion};
+use salsa::{CycleRecoveryAction, Database as Db, Setter};
+use std::collections::BTreeSet;
+use std::iter::IntoIterator;
+
+/// A Use of a symbol.
+#[salsa::input]
+struct Use {
+    reaching_definitions: Vec<Definition>,
+}
+
+/// A Definition of a symbol, either of the form `base + increment` or `0 + increment`.
+#[salsa::input]
+struct Definition {
+    base: Option<Use>,
+    increment: usize,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, salsa::Update)]
+enum Type {
+    Bottom,
+    Values(Box<[usize]>),
+    Top,
+}
+
+impl Type {
+    fn join(tys: impl IntoIterator<Item = Type>) -> Type {
+        let mut result = Type::Bottom;
+        for ty in tys.into_iter() {
+            result = match (result, ty) {
+                (result, Type::Bottom) => result,
+                (_, Type::Top) => Type::Top,
+                (Type::Top, _) => Type::Top,
+                (Type::Bottom, ty) => ty,
+                (Type::Values(a_ints), Type::Values(b_ints)) => {
+                    let mut set = BTreeSet::new();
+                    set.extend(a_ints);
+                    set.extend(b_ints);
+                    Type::Values(set.into_iter().collect())
+                }
+            }
+        }
+        result
+    }
+}
+
+#[salsa::tracked(cycle_fn=use_cycle_recover, cycle_initial=use_cycle_initial)]
+fn infer_use<'db>(db: &'db dyn Db, u: Use) -> Type {
+    let defs = u.reaching_definitions(db);
+    match defs[..] {
+        [] => Type::Bottom,
+        [def] => infer_definition(db, def),
+        _ => Type::join(defs.iter().map(|&def| infer_definition(db, def))),
+    }
+}
+
+#[salsa::tracked(cycle_fn=def_cycle_recover, cycle_initial=def_cycle_initial)]
+fn infer_definition<'db>(db: &'db dyn Db, def: Definition) -> Type {
+    let increment_ty = Type::Values(Box::from([def.increment(db)]));
+    if let Some(base) = def.base(db) {
+        let base_ty = infer_use(db, base);
+        add(&base_ty, &increment_ty)
+    } else {
+        increment_ty
+    }
+}
+
+fn def_cycle_initial(_db: &dyn Db, _def: Definition) -> Type {
+    Type::Bottom
+}
+
+fn def_cycle_recover(
+    _db: &dyn Db,
+    value: &Type,
+    count: u32,
+    _def: Definition,
+) -> CycleRecoveryAction<Type> {
+    cycle_recover(value, count)
+}
+
+fn use_cycle_initial(_db: &dyn Db, _use: Use) -> Type {
+    Type::Bottom
+}
+
+fn use_cycle_recover(
+    _db: &dyn Db,
+    value: &Type,
+    count: u32,
+    _use: Use,
+) -> CycleRecoveryAction<Type> {
+    cycle_recover(value, count)
+}
+
+fn cycle_recover(value: &Type, count: u32) -> CycleRecoveryAction<Type> {
+    match value {
+        Type::Bottom => CycleRecoveryAction::Iterate,
+        Type::Values(_) => {
+            if count > 4 {
+                CycleRecoveryAction::Fallback(Type::Top)
+            } else {
+                CycleRecoveryAction::Iterate
+            }
+        }
+        Type::Top => CycleRecoveryAction::Iterate,
+    }
+}
+
+fn add(a: &Type, b: &Type) -> Type {
+    match (a, b) {
+        (Type::Bottom, _) | (_, Type::Bottom) => Type::Bottom,
+        (Type::Top, _) | (_, Type::Top) => Type::Top,
+        (Type::Values(a_ints), Type::Values(b_ints)) => {
+            let mut set = BTreeSet::new();
+            set.extend(
+                a_ints
+                    .into_iter()
+                    .flat_map(|a| b_ints.into_iter().map(move |b| a + b)),
+            );
+            Type::Values(set.into_iter().collect())
+        }
+    }
+}
+
+fn dataflow(criterion: &mut Criterion) {
+    criterion.bench_function("converge_diverge", |b| {
+        b.iter_batched_ref(
+            || {
+                let mut db = salsa::DatabaseImpl::new();
+
+                let defx0 = Definition::new(&db, None, 0);
+                let defy0 = Definition::new(&db, None, 0);
+                let defx1 = Definition::new(&db, None, 0);
+                let defy1 = Definition::new(&db, None, 0);
+                let use_x = Use::new(&db, vec![defx0, defx1]);
+                let use_y = Use::new(&db, vec![defy0, defy1]);
+                defx1.set_base(&mut db).to(Some(use_y));
+                defy1.set_base(&mut db).to(Some(use_x));
+
+                // prewarm cache
+                let _ = infer_use(&db, use_x);
+                let _ = infer_use(&db, use_y);
+
+                (db, defx1, use_x, use_y)
+            },
+            |(db, defx1, use_x, use_y)| {
+                // Set the increment on x to 0.
+                defx1.set_increment(db).to(0);
+
+                // Both symbols converge on 0.
+                assert_eq!(infer_use(db, *use_x), Type::Values(Box::from([0])));
+                assert_eq!(infer_use(db, *use_y), Type::Values(Box::from([0])));
+
+                // Set the increment on x to 1.
+                defx1.set_increment(db).to(1);
+
+                // Now the loop diverges and we fall back to Top.
+                assert_eq!(infer_use(db, *use_x), Type::Top);
+                assert_eq!(infer_use(db, *use_y), Type::Top);
+            },
+            BatchSize::LargeInput,
+        );
+    });
+}
+
+criterion_group!(benches, dataflow);
+criterion_main!(benches);

components/salsa-macro-rules/src/setup_tracked_fn.rs

@@ -37,6 +37,9 @@ macro_rules! setup_tracked_fn {
         // Path to the cycle recovery function to use.
         cycle_recovery_fn: ($($cycle_recovery_fn:tt)*),
 
+        // Path to function to get the initial value to use for cycle recovery.
+        cycle_recovery_initial: ($($cycle_recovery_initial:tt)*),
+
         // Name of cycle recovery strategy variant to use.
         cycle_recovery_strategy: $cycle_recovery_strategy:ident,
 
@@ -158,15 +161,15 @@ macro_rules! setup_tracked_fn {
 
                 const CYCLE_STRATEGY: $zalsa::CycleRecoveryStrategy = $zalsa::CycleRecoveryStrategy::$cycle_recovery_strategy;
 
-                fn should_backdate_value(
+                fn values_equal(
                     old_value: &Self::Output<'_>,
                     new_value: &Self::Output<'_>,
                 ) -> bool {
                     $zalsa::macro_if! {
                         if $no_eq {
                             false
                         } else {
-                            $zalsa::should_backdate_value(old_value, new_value)
+                            $zalsa::values_equal(old_value, new_value)
                         }
                     }
                 }
@@ -177,12 +180,17 @@ macro_rules! setup_tracked_fn {
                     $inner($db, $($input_id),*)
                 }
 
+                fn cycle_initial<$db_lt>(db: &$db_lt dyn $Db, ($($input_id),*): ($($input_ty),*)) -> Self::Output<$db_lt> {
+                    $($cycle_recovery_initial)*(db, $($input_id),*)
+                }
+
                 fn recover_from_cycle<$db_lt>(
                     db: &$db_lt dyn $Db,
-                    cycle: &$zalsa::Cycle,
+                    value: &Self::Output<$db_lt>,
+                    count: u32,
                     ($($input_id),*): ($($input_ty),*)
-                ) -> Self::Output<$db_lt> {
-                    $($cycle_recovery_fn)*(db, cycle, $($input_id),*)
+                ) -> $zalsa::CycleRecoveryAction<Self::Output<$db_lt>> {
+                    $($cycle_recovery_fn)*(db, value, count, $($input_id),*)
                 }
 
                 fn id_to_input<$db_lt>(db: &$db_lt Self::DbView, key: salsa::Id) -> Self::Input<$db_lt> {

components/salsa-macro-rules/src/unexpected_cycle_recovery.rs

@@ -3,11 +3,18 @@
 // a macro because it can take a variadic number of arguments.
 #[macro_export]
 macro_rules! unexpected_cycle_recovery {
-    ($db:ident, $cycle:ident, $($other_inputs:ident),*) => {
-        {
-            std::mem::drop($db);
-            std::mem::drop(($($other_inputs),*));
-            panic!("cannot recover from cycle `{:?}`", $cycle)
-        }
-    }
+    ($db:ident, $value:ident, $count:ident, $($other_inputs:ident),*) => {{
+        std::mem::drop($db);
+        std::mem::drop(($($other_inputs),*));
+        panic!("cannot recover from cycle")
+    }};
+}
+
+#[macro_export]
+macro_rules! unexpected_cycle_initial {
+    ($db:ident, $($other_inputs:ident),*) => {{
+        std::mem::drop($db);
+        std::mem::drop(($($other_inputs),*));
+        panic!("no cycle initial value")
+    }};
 }

components/salsa-macros/src/accumulator.rs

@@ -40,7 +40,8 @@ impl AllowedOptions for Accumulator {
     const SINGLETON: bool = false;
     const DATA: bool = false;
     const DB: bool = false;
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+    const CYCLE_INITIAL: bool = false;
     const LRU: bool = false;
     const CONSTRUCTOR_NAME: bool = false;
     const ID: bool = false;

components/salsa-macros/src/input.rs

@@ -52,7 +52,9 @@ impl crate::options::AllowedOptions for InputStruct {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+
+    const CYCLE_INITIAL: bool = false;
 
     const LRU: bool = false;
 

components/salsa-macros/src/interned.rs

@@ -53,7 +53,9 @@ impl crate::options::AllowedOptions for InternedStruct {
 
     const DB: bool = false;
 
-    const RECOVERY_FN: bool = false;
+    const CYCLE_FN: bool = false;
+
+    const CYCLE_INITIAL: bool = false;
 
     const LRU: bool = false;
 

components/salsa-macros/src/options.rs

@@ -50,10 +50,15 @@ pub(crate) struct Options<A: AllowedOptions> {
     /// If this is `Some`, the value is the `<path>`.
     pub db_path: Option<syn::Path>,
 
-    /// The `recovery_fn = <path>` option is used to indicate the recovery function.
+    /// The `cycle_fn = <path>` option is used to indicate the cycle recovery function.
     ///
     /// If this is `Some`, the value is the `<path>`.
-    pub recovery_fn: Option<syn::Path>,
+    pub cycle_fn: Option<syn::Path>,
+
+    /// The `cycle_initial = <path>` option is the initial value for cycle iteration.
+    ///
+    /// If this is `Some`, the value is the `<path>`.
+    pub cycle_initial: Option<syn::Path>,
 
     /// The `data = <ident>` option is used to define the name of the data type for an interned
     /// struct.
@@ -92,7 +97,8 @@ impl<A: AllowedOptions> Default for Options<A> {
             no_lifetime: Default::default(),
             no_clone: Default::default(),
             db_path: Default::default(),
-            recovery_fn: Default::default(),
+            cycle_fn: Default::default(),
+            cycle_initial: Default::default(),
             data: Default::default(),
             constructor_name: Default::default(),
             phantom: Default::default(),
@@ -114,7 +120,8 @@ pub(crate) trait AllowedOptions {
     const SINGLETON: bool;
     const DATA: bool;
     const DB: bool;
-    const RECOVERY_FN: bool;
+    const CYCLE_FN: bool;
+    const CYCLE_INITIAL: bool;
     const LRU: bool;
     const CONSTRUCTOR_NAME: bool;
     const ID: bool;
@@ -237,20 +244,39 @@ impl<A: AllowedOptions> syn::parse::Parse for Options<A> {
                         "`db` option not allowed here",
                     ));
                 }
-            } else if ident == "recovery_fn" {
-                if A::RECOVERY_FN {
+            } else if ident == "cycle_fn" {
+                if A::CYCLE_FN {
+                    let _eq = Equals::parse(input)?;
+                    let path = syn::Path::parse(input)?;
+                    if let Some(old) = std::mem::replace(&mut options.cycle_fn, Some(path)) {
+                        return Err(syn::Error::new(
+                            old.span(),
+                            "option `cycle_fn` provided twice",
+                        ));
+                    }
+                } else {
+                    return Err(syn::Error::new(
+                        ident.span(),
+                        "`cycle_fn` option not allowed here",
+                    ));
+                }
+            } else if ident == "cycle_initial" {
+                if A::CYCLE_INITIAL {
+                    // TODO(carljm) should it be an error to give cycle_initial without cycle_fn,
+                    // or should we just allow this to fall into potentially infinite iteration, if
+                    // iteration never converges?
                     let _eq = Equals::parse(input)?;
                     let path = syn::Path::parse(input)?;
-                    if let Some(old) = std::mem::replace(&mut options.recovery_fn, Some(path)) {
+                    if let Some(old) = std::mem::replace(&mut options.cycle_initial, Some(path)) {
                         return Err(syn::Error::new(
                             old.span(),
-                            "option `recovery_fn` provided twice",
+                            "option `cycle_initial` provided twice",
                         ));
                     }
                 } else {
                     return Err(syn::Error::new(
                         ident.span(),
-                        "`recovery_fn` option not allowed here",
+                        "`cycle_initial` option not allowed here",
                     ));
                 }
             } else if ident == "data" {