salsa 0.26.1

A generic framework for on-demand, incrementalized computation (experimental)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::active_query::CompletedQuery;
use crate::function::memo::Memo;
use crate::function::{Configuration, IngredientImpl};
use crate::hash::FxIndexSet;
use crate::zalsa::Zalsa;
use crate::zalsa_local::{QueryOriginRef, QueryRevisions, output_edges};
use crate::{DatabaseKeyIndex, Event, EventKind};

impl<C> IngredientImpl<C>
where
    C: Configuration,
{
    /// Compute the old and new outputs and invoke `remove_stale_output` for each output that
    /// was generated before but is not generated now.
    pub(super) fn diff_outputs(
        &self,
        zalsa: &Zalsa,
        key: DatabaseKeyIndex,
        old_memo: &Memo<'_, C>,
        completed_query: &CompletedQuery,
    ) {
        diff_outputs_on_revision(zalsa, key, &old_memo.revisions, completed_query);
    }
}

fn diff_outputs_on_revision(
    zalsa: &Zalsa,
    key: DatabaseKeyIndex,
    old_revisions: &QueryRevisions,
    completed_query: &CompletedQuery,
) {
    let (QueryOriginRef::Derived(edges) | QueryOriginRef::DerivedUntracked(edges)) =
        old_revisions.origin.as_ref()
    else {
        return;
    };

    // Note that tracked structs are not stored as direct query outputs, but they are still outputs
    // that need to be reported as stale.
    for (identity, id) in &completed_query.stale_tracked_structs {
        let output = DatabaseKeyIndex::new(identity.ingredient_index(), *id);
        report_stale_output(zalsa, key, output);
    }

    let mut stale_outputs = output_edges(edges).collect::<FxIndexSet<_>>();

    if stale_outputs.is_empty() {
        return;
    }

    // Preserve any outputs that were recreated in the current revision.
    for new_output in completed_query.revisions.origin.as_ref().outputs() {
        stale_outputs.swap_remove(&new_output);
    }

    // Any outputs that were created in a previous revision but not the current one are stale.
    for output in stale_outputs {
        report_stale_output(zalsa, key, output);
    }
}

fn report_stale_output(zalsa: &Zalsa, key: DatabaseKeyIndex, output: DatabaseKeyIndex) {
    zalsa.event(&|| {
        Event::new(EventKind::WillDiscardStaleOutput {
            execute_key: key,
            output_key: output,
        })
    });

    output.remove_stale_output(zalsa, key);
}