sva-engine 0.7.9

Renders a resolved graph into per-node buffers a query can be asked of
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
72
73
74
75

// Concern: hands out each staged value's samples a window held, before release drops them | Non-concern: where they go, which values are staged | IO: (Table, window) -> samples per key

use sva_formula::Hash;
use sva_samples::Buffer;

use super::segments::Segments;
use super::{Need, Table};
use crate::cache::Stored;

struct Staging {
    at: usize,
    key: Hash,
    taken: Segments,
    meta: Option<Stored>,
}

pub(crate) struct Spill {
    staged: Vec<Staging>,
    pub(crate) samples: Vec<(Hash, Buffer)>,
}

impl Spill {
    pub(crate) fn over(staged: Vec<(usize, Hash, Stored)>) -> Spill {
        Spill {
            staged: staged
                .into_iter()
                .map(|(at, key, meta)| Staging {
                    at,
                    key,
                    taken: Segments::default(),
                    meta: Some(meta),
                })
                .collect(),
            samples: Vec::new(),
        }
    }

    pub(crate) fn take(&mut self, table: &Table, asked: &[Need]) {
        let own = self.staged.iter_mut();
        for staging in own.filter(|s| !s.meta.as_ref().is_some_and(Stored::refers)) {
            let fresh = asked[staging.at].hold.minus(&staging.taken);
            for e in fresh.iter() {
                self.samples
                    .push((staging.key, table.samples(staging.at, e)));
            }
            staging.taken.union(&fresh);
        }
    }

    /// Each meta whose value is now handed out over its whole support.
    pub(crate) fn whole(&mut self, table: &Table) -> Vec<(Hash, Stored)> {
        let mut out = Vec::new();
        for staging in &mut self.staged {
            let support = table.values[staging.at].support;
            if support.is_bounded() && staging.taken.covers(&Segments::of(support)) {
                out.extend(handed(staging, table));
            }
        }
        out
    }

    pub(crate) fn rest(&mut self, table: &Table) -> Vec<(Hash, Stored)> {
        self.staged
            .iter_mut()
            .filter_map(|staging| handed(staging, table))
            .collect()
    }
}

/// A label settles once the value is computed, so it is read as the meta leaves.
fn handed(staging: &mut Staging, table: &Table) -> Option<(Hash, Stored)> {
    let mut meta = staging.meta.take()?;
    meta.label = table.label(staging.at);
    Some((staging.key, meta))
}