node: virtual graph endpoints and the Kahn-order BFS sweep (M0b core)

Per docs/zh/plans/render-pipeline-threads.md §3.8:

- oak-node/nodes/graphendpoints.rs: the GraphInput/GraphOutput
  virtual node pair — factory-registered but hidden from every create
  menu, duplicate refused, real value() semantics (the input forwards
  its feed_in row, the output publishes its tex_in as the frame).
  The input endpoint also declares a connectable feed_in port
  (documented deviation: footage/generator sources have no connectable
  inputs, so the walk needs a feeder anchor).
- graph.rs: ensure_endpoints/endpoints/is_endpoint — idempotent,
  identified by type id, default input->output edge only while the
  output's tex_in is free; remove_node refuses endpoints.
- project.rs + serializer.rs: every project graph carries the pair;
  a legacy file without endpoints migrates on load (roundtrip and
  legacy-migration tests, re-save is idempotent).
- traverser.rs: eval_graph_bfs — the endpoint-to-endpoint Kahn
  sweep. Live set = (input's forward cone U its feeder cone) INTERSECT
  (output's backward cone); multi-input nodes dequeue at zero
  in-degree over the live subgraph; deterministic ascending-id ready
  order (Graph::edges is a BTreeSet, so insertion order is
  unrecoverable — documented); time-shifted upstreams pull through
  the shared DFS memo (walk_dfs, factored out of evaluate);
  un-orderable remainder reports a named cycle; missing endpoints /
  unreachable output are errors. Eight BFS tests cover the plan's
  acceptance bullets.
- oak-render: bfs_endpoint_sweep_renders_footage_through_position —
  real clip through a real Position node via the sweep, shifted
  pixels asserted against a reference decode.
- Endpoint names localized in all eight i18n packs; storage/structure
  tests updated for the two extra nodes.
This commit is contained in:
2026-09-11 15:13:53 +08:00
parent 3a48dd4991
commit 29204d1f63
24 changed files with 1849 additions and 81 deletions
+743 -40
View File
@@ -37,7 +37,7 @@
//! (C++ `ProcessInputElement` → `GetValueAtTime`).
//! `// CPP-PARITY: src/node/src/traverser.cpp`.
use std::collections::{HashMap, HashSet};
use std::collections::{BTreeSet, HashMap, HashSet};
use oak_core::{Rational, TimeRange};
@@ -133,55 +133,126 @@ impl Traverser {
// Per-pass memo: (node, time) -> evaluated output table. A shared
// upstream evaluates once per requested time (C++ value_cache_).
let mut cache: HashMap<(NodeId, Rational), NodeValueTable> = HashMap::new();
let mut queued: HashSet<(NodeId, Rational)> = HashSet::new();
let mut stack: Vec<Frame> = vec![Frame::Enter(request.root, request.time)];
queued.insert((request.root, request.time));
walk_dfs(graph, &mut cache, request.root, request.time, hooks)?;
Ok(cache
.remove(&(request.root, request.time))
.unwrap_or_default())
}
while let Some(frame) = stack.pop() {
/// Evaluate the graph as one Kahn-order sweep of the *live set* and
/// return the [`GraphOutput`](crate::nodes::graphendpoints) value —
/// the frame (C++ has no counterpart; the C++ traversal starts at the
/// consumer and walks backwards, Oak starts at the graph's input
/// endpoint and converges on its output endpoint).
///
/// The live set is `(downstream of the input ∨ feeding the input) ∧
/// (upstream of the output)`: the input's forward cone plus the nodes
/// that reach the input (a sequence feeds the graph through
/// `GraphInput.feed_in`, which puts it in that feeder cone),
/// intersected with the output's backward cone. Isolated nodes and
/// branches that never reach the output are never queued. A
/// connection coming from *outside* the live set leaves `None` in the
/// consuming row (same as a missing cache entry in the DFS walk).
///
/// Each live node is dequeued once, in ascending [`NodeId`] order
/// among the ready nodes, with the DFS walk's per-node semantics
/// (`GenerateRowValue` → `value()` → [`RenderHooks::resolve`]), and
/// the resolved table is what its downstream consumers see. The
/// ascending-id order is the only deterministic order available:
/// `Graph::edges` is a `BTreeSet` keyed by `(from, to, input,
/// element)`, so the order in which connections were made is not
/// stored and cannot be recovered.
///
/// Time semantics are single-time: `time` is the frame being
/// rendered, and the consuming node's `input_time_adjustment` applies
/// as usual — an upstream at a different time is evaluated through
/// the DFS memo (exactly what [`Traverser::evaluate`] would do),
/// while same-time upstreams are the sweep's own job. Multi-time
/// memoization across a range is M1+ work.
///
/// Errors: `NotFound` when either endpoint is missing; `Failed` when
/// the live set cannot be ordered (the message names a cycle found
/// in it) or when the output is not reachable from the input; `State`
/// on cancellation.
pub fn eval_graph_bfs(
&mut self,
graph: &Graph,
time: Rational,
hooks: &mut dyn RenderHooks,
) -> crate::error::Result<NodeValue> {
use crate::error::Error;
let (input, output) = graph.endpoints().ok_or(Error::NotFound)?;
let live = live_nodes(graph, input, output);
// In-degree over the live-induced subgraph only: an edge whose
// source lies outside the live set must not keep its target from
// ever becoming ready.
let mut indegree: HashMap<NodeId, usize> = HashMap::new();
for node in &live {
let n = graph
.input_connections(*node)
.iter()
.filter(|(from, _, _)| live.contains(from))
.count();
indegree.insert(*node, n);
}
let mut ready: BTreeSet<NodeId> = indegree
.iter()
.filter(|(_, n)| **n == 0)
.map(|(node, _)| *node)
.collect();
let mut cache: HashMap<(NodeId, Rational), NodeValueTable> = HashMap::new();
let mut done = 0usize;
while let Some(node) = ready.iter().next().copied() {
ready.remove(&node);
if hooks.is_cancelled() {
return Err(Error::State);
}
match frame {
Frame::Enter(node, time) => {
if cache.contains_key(&(node, time)) {
continue;
}
let Some(entry) = graph.get(node) else {
continue;
};
stack.push(Frame::Exit(node, time));
// Queue every connected upstream at its adjusted time.
for (from, input, element) in graph.input_connections(node) {
let from = entry
.behavior
.connected_render_output(&entry.core, &input, element)
.unwrap_or(from);
let adjusted = adjusted_time(entry, &input, element, time);
let key = (from, adjusted);
if !cache.contains_key(&key) && queued.insert(key) {
stack.push(Frame::Enter(from, adjusted));
}
}
let Some(entry) = graph.get(node) else {
continue;
};
done += 1;
// Time-shifted upstreams are not part of this sweep; pull them
// through the DFS memo. A node may already own a table at
// `time` (a pull deeper down evaluated it out of order) — in
// that case it is not evaluated (and resolved) twice.
pull_adjusted_upstreams(graph, &mut cache, entry, node, time, hooks)?;
if !cache.contains_key(&(node, time)) {
let row = build_row(graph, &cache, entry, node, time);
let mut table = NodeValueTable::default();
entry.behavior.value(&entry.core, &row, time, &mut table);
hooks.resolve(node, &row, &mut table);
cache.insert((node, time), table);
}
for (to, _, _) in graph.output_connections(node) {
if !live.contains(&to) {
continue;
}
Frame::Exit(node, time) => {
if cache.contains_key(&(node, time)) {
continue;
if let Some(n) = indegree.get_mut(&to) {
*n -= 1;
if *n == 0 {
ready.insert(to);
}
let Some(entry) = graph.get(node) else {
continue;
};
let row = build_row(graph, &cache, entry, node, time);
let mut table = NodeValueTable::default();
entry.behavior.value(&entry.core, &row, time, &mut table);
hooks.resolve(node, &row, &mut table);
cache.insert((node, time), table);
}
}
}
Ok(cache
.remove(&(request.root, request.time))
.unwrap_or_default())
if done < live.len() {
let cycle = find_cycle(graph, &indegree);
return Err(Error::Failed(format!("graph contains a cycle: {cycle:?}")));
}
let Some(table) = cache.remove(&(output, time)) else {
return Err(Error::Failed(
"graph output is not reachable from the graph input".to_string(),
));
};
Ok(table
.get(ValueType::Texture)
.cloned()
.or_else(|| table.rows().last().map(|(_, value, _)| value.clone()))
.unwrap_or(NodeValue::None))
}
/// Invalidate walk: mark downstream caches dirty after an input
@@ -208,6 +279,171 @@ impl Default for Traverser {
}
}
/// Explicit-stack DFS from `root` at `time` (the C++ recursion, minus
/// the recursion), memoizing every evaluated `(node, time)` table into
/// `cache`. `Enter` queues the connected upstreams at their adjusted
/// times, `Exit` builds the row and runs `GenerateRowValue` →
/// `value()` → [`RenderHooks::resolve`]; a node is entered at most once
/// per time (`queued` is the DFS gray set, `cache` the black set).
///
/// Shared by [`Traverser::evaluate`] (whole walk) and
/// [`Traverser::eval_graph_bfs`] (time-shifted upstream pulls).
///
/// Errors: `State` on cancellation.
fn walk_dfs(
graph: &Graph,
cache: &mut HashMap<(NodeId, Rational), NodeValueTable>,
root: NodeId,
time: Rational,
hooks: &mut dyn RenderHooks,
) -> crate::error::Result<()> {
use crate::error::Error;
let mut queued: HashSet<(NodeId, Rational)> = HashSet::new();
let mut stack: Vec<Frame> = vec![Frame::Enter(root, time)];
queued.insert((root, time));
while let Some(frame) = stack.pop() {
if hooks.is_cancelled() {
return Err(Error::State);
}
match frame {
Frame::Enter(node, time) => {
if cache.contains_key(&(node, time)) {
continue;
}
let Some(entry) = graph.get(node) else {
continue;
};
stack.push(Frame::Exit(node, time));
// Queue every connected upstream at its adjusted time.
for (from, input, element) in graph.input_connections(node) {
let from = entry
.behavior
.connected_render_output(&entry.core, &input, element)
.unwrap_or(from);
let adjusted = adjusted_time(entry, &input, element, time);
let key = (from, adjusted);
if !cache.contains_key(&key) && queued.insert(key) {
stack.push(Frame::Enter(from, adjusted));
}
}
}
Frame::Exit(node, time) => {
if cache.contains_key(&(node, time)) {
continue;
}
let Some(entry) = graph.get(node) else {
continue;
};
let row = build_row(graph, cache, entry, node, time);
let mut table = NodeValueTable::default();
entry.behavior.value(&entry.core, &row, time, &mut table);
hooks.resolve(node, &row, &mut table);
cache.insert((node, time), table);
}
}
}
Ok(())
}
/// Pull the upstreams of `node` that the sweep will not visit itself:
/// connections whose `input_time_adjustment` maps `time` to a different
/// time are evaluated on the spot through the DFS memo (the very walk
/// [`Traverser::evaluate`] performs, so those values carry the same
/// semantics), and their tables land in `cache` for [`build_row`].
///
/// Errors: `State` on cancellation (propagated from the pull).
fn pull_adjusted_upstreams(
graph: &Graph,
cache: &mut HashMap<(NodeId, Rational), NodeValueTable>,
entry: &crate::graph::NodeEntry,
node: NodeId,
time: Rational,
hooks: &mut dyn RenderHooks,
) -> crate::error::Result<()> {
for (from, input, element) in graph.input_connections(node) {
let from = entry
.behavior
.connected_render_output(&entry.core, &input, element)
.unwrap_or(from);
let adjusted = adjusted_time(entry, &input, element, time);
if adjusted == time || !graph.is_valid(from) {
continue;
}
if !cache.contains_key(&(from, adjusted)) {
walk_dfs(graph, cache, from, adjusted, hooks)?;
}
}
Ok(())
}
/// Every node reachable from `root` (including `root`) walking
/// downstream, or — with `upstream` — every node that can reach `root`.
fn reachable(graph: &Graph, root: NodeId, upstream: bool) -> HashSet<NodeId> {
let mut seen: HashSet<NodeId> = HashSet::new();
let mut stack: Vec<NodeId> = vec![root];
while let Some(node) = stack.pop() {
if !seen.insert(node) {
continue;
}
if upstream {
stack.extend(graph.upstream(node));
} else {
stack.extend(graph.downstream(node));
}
}
seen
}
/// The live set of the endpoint-to-endpoint sweep: the input's forward
/// cone plus its feeder cone (nodes that reach the input — how a
/// sequence feeds `GraphInput.feed_in`), intersected with the output's
/// backward cone. See [`Traverser::eval_graph_bfs`].
fn live_nodes(graph: &Graph, input: NodeId, output: NodeId) -> HashSet<NodeId> {
let mut live = reachable(graph, input, false);
live.extend(reachable(graph, input, true));
let reaches_output = reachable(graph, output, true);
live.retain(|node| reaches_output.contains(node));
live
}
/// A cycle inside the nodes the sweep could not order: residual nodes
/// (positive in-degree left) walked upstream, always taking the
/// smallest-id residual feeder, until a node repeats — the repeated
/// suffix is the cycle. Deterministic; empty when there is no residual
/// node.
fn find_cycle(graph: &Graph, indegree: &HashMap<NodeId, usize>) -> Vec<NodeId> {
let residual: BTreeSet<NodeId> = indegree
.iter()
.filter(|(_, n)| **n > 0)
.map(|(node, _)| *node)
.collect();
let mut path: Vec<NodeId> = Vec::new();
let mut seen: HashMap<NodeId, usize> = HashMap::new();
let Some(start) = residual.iter().next().copied() else {
return path;
};
let mut node = start;
loop {
if let Some(&at) = seen.get(&node) {
return path.split_off(at);
}
seen.insert(node, path.len());
path.push(node);
// Every residual node has a residual feeder: in-degree was only
// counted over live edges, and an unprocessed feeder keeps its
// own positive in-degree.
match graph
.upstream(node)
.into_iter()
.find(|from| residual.contains(from))
{
Some(from) => node = from,
None => return path,
}
}
}
/// The consuming node's time adjustment for `input` (C++
/// `Node::InputTimeAdjustment` with `traverse = true`): clips map
/// sequence time to media time, tracks clamp to the covering block. The
@@ -323,3 +559,470 @@ pub struct ValueDatabase {
/// Rows keyed by node input id.
pub rows: Vec<(String, Vec<(ValueType, NodeValue)>)>,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::Error;
use crate::handle::CHandle;
use crate::input::Input;
use crate::node::{NodeBehavior, NodeCore};
use crate::nodes::graphendpoints::{GRAPH_INPUT_FEED_INPUT, GRAPH_OUTPUT_INPUT};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
/// What a [`TestNode`] pushes to its own output table.
enum Emit {
/// Nothing at all.
Nothing,
/// A constant float.
Float(f64),
/// The time the node was evaluated at.
Time,
/// A null texture handle.
Texture,
}
/// Counting stand-in for a real node: emits on demand so a test can
/// observe evaluation counts, dequeue order, and input rows.
struct TestNode {
emit: Emit,
calls: Arc<AtomicUsize>,
}
impl NodeBehavior for TestNode {
fn name(&self) -> &str {
"Test Node"
}
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.test-bfs-node"
}
fn value(
&self,
_core: &NodeCore,
_inputs: &NodeValueRow,
time: Rational,
table: &mut NodeValueTable,
) {
self.calls.fetch_add(1, Ordering::Relaxed);
match self.emit {
Emit::Nothing => {}
Emit::Float(value) => table.push(ValueType::Float, NodeValue::Float(value), None),
Emit::Time => table.push(ValueType::Float, NodeValue::Float(time.to_f64()), None),
Emit::Texture => {
table.push(ValueType::Texture, NodeValue::Texture(CHandle::null()), None)
}
}
}
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
None
}
}
/// Add a [`TestNode`] declaring `inputs`; returns its id and call counter.
fn add_node(
graph: &mut Graph,
inputs: &[(&str, ValueType)],
emit: Emit,
) -> (NodeId, Arc<AtomicUsize>) {
let calls = Arc::new(AtomicUsize::new(0));
let mut core = NodeCore::new();
for (id, value_type) in inputs {
core.add_input(Input::new(id, *value_type, NodeValue::None));
}
let id = graph.add_node(
core,
Box::new(TestNode {
emit,
calls: Arc::clone(&calls),
}),
);
(id, calls)
}
/// The endpoint pair with the default `input -> output` edge removed,
/// so a test can wire the convergence itself.
fn detached_endpoints(graph: &mut Graph) -> (NodeId, NodeId) {
let (input, output) = graph.ensure_endpoints();
graph.disconnect(input, output, GRAPH_OUTPUT_INPUT, -1);
(input, output)
}
/// A node that samples `val_in` one second late: observes that the
/// sweep pulls a time-shifted upstream through the DFS memo.
struct Delay {
rows: Arc<Mutex<Vec<NodeValueRow>>>,
}
impl NodeBehavior for Delay {
fn name(&self) -> &str {
"Delay"
}
fn type_id(&self) -> &str {
"org.olivevideoeditor.Olive.test-bfs-delay"
}
fn input_time_adjustment(
&self,
_core: &NodeCore,
input: &str,
_element: i32,
time: TimeRange,
_traverse: bool,
) -> TimeRange {
if input == "val_in" {
TimeRange::new(
time.in_() + Rational::new(1, 1),
time.out() + Rational::new(1, 1),
)
} else {
time
}
}
fn value(
&self,
_core: &NodeCore,
inputs: &NodeValueRow,
_time: Rational,
table: &mut NodeValueTable,
) {
self.rows.lock().expect("delay rows").push(inputs.clone());
if let Some(value @ NodeValue::Float(_)) = inputs.get("val_in") {
table.push(ValueType::Float, value.clone(), None);
}
}
fn duplicate(&self, _core: &NodeCore) -> Option<Box<dyn NodeBehavior>> {
None
}
}
/// Records resolve order/rows and can replace a node's resolved table.
struct Probe {
order: Vec<NodeId>,
rows: HashMap<NodeId, NodeValueRow>,
replace: Option<(NodeId, Vec<(ValueType, NodeValue)>)>,
}
impl Probe {
fn new() -> Probe {
Probe {
order: Vec::new(),
rows: HashMap::new(),
replace: None,
}
}
}
impl RenderHooks for Probe {
fn resolve(&mut self, node: NodeId, row: &NodeValueRow, table: &mut NodeValueTable) {
self.order.push(node);
self.rows.insert(node, row.clone());
if let Some((target, rows)) = &self.replace {
if *target == node {
table.clear();
for (ty, value) in rows {
table.push(*ty, value.clone(), None);
}
}
}
}
}
#[test]
fn bfs_starts_at_graph_input_and_skips_unreachable_nodes() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (dead, dead_calls) =
add_node(&mut graph, &[("x_in", ValueType::Texture)], Emit::Nothing);
let (_island, island_calls) = add_node(&mut graph, &[], Emit::Float(1.0));
graph
.connect(input, dead, "x_in", -1)
.expect("input -> dead");
graph
.connect(input, output, GRAPH_OUTPUT_INPUT, -1)
.expect("input -> output");
let mut probe = Probe::new();
let value = Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("the input -> output edge alone is a valid graph");
assert_eq!(probe.order, vec![input, output]);
assert_eq!(dead_calls.load(Ordering::Relaxed), 0, "dead branch skipped");
assert_eq!(
island_calls.load(Ordering::Relaxed),
0,
"island never queued"
);
assert_eq!(value, NodeValue::None);
}
#[test]
fn bfs_waits_for_every_input_of_a_converging_node() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (a, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(1.0));
let (b, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(2.0));
let (merge, _) = add_node(
&mut graph,
&[("a_in", ValueType::Float), ("b_in", ValueType::Float)],
Emit::Float(3.0),
);
graph.connect(input, a, "tex_in", -1).expect("input -> a");
graph.connect(input, b, "tex_in", -1).expect("input -> b");
graph.connect(a, merge, "a_in", -1).expect("a -> merge");
graph.connect(b, merge, "b_in", -1).expect("b -> merge");
graph
.connect(merge, output, GRAPH_OUTPUT_INPUT, -1)
.expect("merge -> output");
let mut probe = Probe::new();
Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("the converging graph is orderable");
assert_eq!(probe.order, vec![input, a, b, merge, output]);
let row = probe.rows.get(&merge).expect("merge resolved");
assert_eq!(row.get("a_in"), Some(&NodeValue::Float(1.0)));
assert_eq!(row.get("b_in"), Some(&NodeValue::Float(2.0)));
}
#[test]
fn bfs_evaluates_a_shared_source_once() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (source, source_calls) = add_node(
&mut graph,
&[("tex_in", ValueType::Texture)],
Emit::Float(7.0),
);
let (m, _) = add_node(&mut graph, &[("a_in", ValueType::Float)], Emit::Float(1.0));
let (n, _) = add_node(&mut graph, &[("a_in", ValueType::Float)], Emit::Float(2.0));
let (f, _) = add_node(
&mut graph,
&[("c_in", ValueType::Float), ("d_in", ValueType::Float)],
Emit::Float(3.0),
);
graph
.connect(input, source, "tex_in", -1)
.expect("input -> source");
graph.connect(source, m, "a_in", -1).expect("source -> m");
graph.connect(source, n, "a_in", -1).expect("source -> n");
graph.connect(m, f, "c_in", -1).expect("m -> f");
graph.connect(n, f, "d_in", -1).expect("n -> f");
graph
.connect(f, output, GRAPH_OUTPUT_INPUT, -1)
.expect("f -> output");
let mut probe = Probe::new();
Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("the fan-out graph is orderable");
assert_eq!(probe.order, vec![input, source, m, n, f, output]);
assert_eq!(
source_calls.load(Ordering::Relaxed),
1,
"the shared source runs once"
);
assert_eq!(
probe.rows.get(&m).and_then(|r| r.get("a_in")),
Some(&NodeValue::Float(7.0))
);
assert_eq!(
probe.rows.get(&n).and_then(|r| r.get("a_in")),
Some(&NodeValue::Float(7.0))
);
}
#[test]
fn bfs_dequeue_order_is_deterministic() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (a, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(1.0));
let (b, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(2.0));
let (c, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(3.0));
let (merge, _) = add_node(
&mut graph,
&[
("a_in", ValueType::Float),
("b_in", ValueType::Float),
("c_in", ValueType::Float),
],
Emit::Float(4.0),
);
for (from, to, input) in [
(input, a, "tex_in"),
(input, b, "tex_in"),
(input, c, "tex_in"),
(a, merge, "a_in"),
(b, merge, "b_in"),
(c, merge, "c_in"),
(merge, output, GRAPH_OUTPUT_INPUT),
] {
graph
.connect(from, to, input, -1)
.unwrap_or_else(|e| panic!("{from:?} -> {to:?}.{input}: {e:?}"));
}
let mut first = Probe::new();
Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut first)
.expect("the fan-in graph is orderable");
let mut second = Probe::new();
Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut second)
.expect("the fan-in graph is orderable");
assert_eq!(first.order, vec![input, a, b, c, merge, output]);
assert_eq!(first.order, second.order, "same graph -> same order");
}
#[test]
fn bfs_pulls_time_shifted_upstreams_through_the_dfs_memo() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (source, source_calls) = add_node(&mut graph, &[], Emit::Time);
let rows = Arc::new(Mutex::new(Vec::new()));
let mut core = NodeCore::new();
core.add_input(Input::new("tex_in", ValueType::Texture, NodeValue::None));
core.add_input(Input::new("val_in", ValueType::Float, NodeValue::None));
let delay = graph.add_node(
core,
Box::new(Delay {
rows: Arc::clone(&rows),
}),
);
graph
.connect(input, delay, "tex_in", -1)
.expect("input -> delay.tex_in");
graph
.connect(source, delay, "val_in", -1)
.expect("source -> delay.val_in");
graph
.connect(delay, output, GRAPH_OUTPUT_INPUT, -1)
.expect("delay -> output");
let mut probe = Probe::new();
let value = Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("an out-of-live-set feeder does not stall the sweep");
assert_eq!(
probe.order,
vec![input, source, delay, output],
"the far end is pulled during delay's turn, not queued"
);
assert_eq!(source_calls.load(Ordering::Relaxed), 1);
let rows = rows.lock().expect("delay rows");
assert_eq!(rows.len(), 1);
// One second late: the sweep pulled the source at time 1, not 0.
assert_eq!(rows[0].get("val_in"), Some(&NodeValue::Float(1.0)));
assert_eq!(value, NodeValue::None);
}
#[test]
fn bfs_hands_resolved_tables_to_downstream_nodes() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (a, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(1.0));
let (b, _) = add_node(&mut graph, &[("tex_in", ValueType::Texture)], Emit::Float(2.0));
let (merge, _) = add_node(
&mut graph,
&[("a_in", ValueType::Float), ("b_in", ValueType::Float)],
Emit::Float(3.0),
);
graph.connect(input, a, "tex_in", -1).expect("input -> a");
graph.connect(input, b, "tex_in", -1).expect("input -> b");
graph.connect(a, merge, "a_in", -1).expect("a -> merge");
graph.connect(b, merge, "b_in", -1).expect("b -> merge");
graph
.connect(merge, output, GRAPH_OUTPUT_INPUT, -1)
.expect("merge -> output");
let mut probe = Probe::new();
probe.replace = Some((
a,
vec![(ValueType::Float, NodeValue::Float(999.0))],
));
Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("the converging graph is orderable");
let row = probe.rows.get(&merge).expect("merge resolved");
assert_eq!(
row.get("a_in"),
Some(&NodeValue::Float(999.0)),
"the downstream row carries what resolve() left in a's table"
);
assert_eq!(row.get("b_in"), Some(&NodeValue::Float(2.0)));
}
#[test]
fn bfs_reports_a_cycle_and_names_its_nodes() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (a, a_calls) = add_node(&mut graph, &[("in", ValueType::Float)], Emit::Float(1.0));
let (b, b_calls) = add_node(&mut graph, &[("in", ValueType::Float)], Emit::Float(2.0));
graph.connect(input, a, "in", -1).expect("input -> a");
graph.connect(a, b, "in", -1).expect("a -> b");
graph
.connect(b, output, GRAPH_OUTPUT_INPUT, -1)
.expect("b -> output");
graph.force_connect(b, a, "in", -1);
let mut probe = Probe::new();
let error = Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect_err("a cycle must be reported, not ordered");
let message = match error {
Error::Failed(message) => message,
other => panic!("Failed expected, got {other:?}"),
};
assert!(message.contains("cycle"), "message names the failure: {message}");
assert!(
message.contains(&format!("{a:?}")),
"message names {a:?}: {message}"
);
assert!(
message.contains(&format!("{b:?}")),
"message names {b:?}: {message}"
);
assert_eq!(probe.order, vec![input], "nothing past the cycle resolves");
assert_eq!(a_calls.load(Ordering::Relaxed), 0);
assert_eq!(b_calls.load(Ordering::Relaxed), 0);
}
#[test]
fn bfs_returns_the_output_texture() {
let mut graph = Graph::new();
let (input, output) = detached_endpoints(&mut graph);
let (source, source_calls) = add_node(&mut graph, &[], Emit::Texture);
graph
.connect(source, input, GRAPH_INPUT_FEED_INPUT, -1)
.expect("source -> feed_in");
graph
.connect(input, output, GRAPH_OUTPUT_INPUT, -1)
.expect("input -> output");
let mut probe = Probe::new();
let value = Traverser::new()
.eval_graph_bfs(&graph, Rational::new(0, 1), &mut probe)
.expect("a fed input -> output graph is orderable");
match value {
NodeValue::Texture(handle) => assert!(handle.ctx.is_null()),
other => panic!("texture expected, got {other:?}"),
}
assert_eq!(probe.order, vec![source, input, output]);
assert_eq!(source_calls.load(Ordering::Relaxed), 1);
}
#[test]
fn bfs_requires_both_endpoints() {
let mut probe = Probe::new();
let error = Traverser::new()
.eval_graph_bfs(&Graph::new(), Rational::new(0, 1), &mut probe)
.expect_err("an endpointless graph cannot be swept");
assert_eq!(error, Error::NotFound);
}
}