Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 7 additions & 1 deletion differential-dataflow/src/operators/cursor/reduce.rs
Original file line number Diff line number Diff line change
Expand Up @@ -412,7 +412,13 @@ mod history_replay {
// We have no particular guarantee that known times will not be in advance of `upper_limit`.
// We may have the guarantee that synthetic times will not be, as we test against the limit
// before we add the time to `synth_times`.
if !upper_limit.less_equal(&next_time) {
//
// An uninteresting time in advance of `upper_limit` still needs its synthetic times. With
// partially ordered times, advancing history by `meet` can move a time from before the
// interval to beyond it. Its joins with batch times and `times_current` are interesting,
// and no later interval finds them, as it seeds only from its own batch and pending times.
// The joins are also in advance of `upper_limit`, so the determination below defers them.
if !interesting || !upper_limit.less_equal(&next_time) {

// DETERMINATION (times only). Determine synthetic interesting times.
//
Expand Down
16 changes: 10 additions & 6 deletions differential-dataflow/src/operators/int_proxy/reduce.rs
Original file line number Diff line number Diff line change
Expand Up @@ -599,14 +599,18 @@ impl<T: Timestamp + Lattice, RIn: Semigroup + Clone, ROut: Semigroup + Clone, VI
fn tick(&mut self, upper: &Antichain<T>, pended: &mut Vec<T>) -> Tick<T> {
let Some(at) = self.frontier() else { return Tick::Done };
let reached = self.absorb(&at);
if upper.less_equal(&at) {
// Out of the interval: nothing can be emitted here, so there is nothing to close
// against either — a join with `at` is at or beyond `at`, hence also out of interval,
// and will be rediscovered from `at` in the round that admits it.
if reached && upper.less_equal(&at) {
// Out of the interval: nothing can be emitted here. A join with `at` is at or beyond
// `at`, hence also out of interval, and will be rediscovered from `at` in the round
// that admits it.
self.settle();
if reached { pended.push(at); return Tick::Pended; }
return Tick::Passed;
pended.push(at);
return Tick::Pended;
}
// An unreached time is closed against the reached times even out of the interval. With
// partially ordered times, advancing the prior times by the meet can move one from before
// the interval to beyond it, and no later round rediscovers its joins with this round's
// seeds: there both are prior. The joins are at or beyond `at`, so `close` pends them.
self.close(&at, reached, upper, pended);
if reached { return Tick::Crossing(at); }
self.settle();
Expand Down
40 changes: 40 additions & 0 deletions differential-dataflow/tests/int_proxy.rs
Original file line number Diff line number Diff line change
Expand Up @@ -609,6 +609,46 @@ fn reduce_prior_advanced_past_novel() {
assert!(pending.is_empty());
}

/// Advancing a prior record by the meet of the seeds can move it past `upper` while its join with
/// a seed is still owed. Prior `(0,1,0)` advances by the meet `(0,0,1)` of seeds `(0,0,2)` and
/// `(1,0,1)` to `(0,1,1)`, which is past `upper`. Its join with `(0,0,2)`, at `(0,1,2)`, must be
/// pended, as the value is present twice there. Two dimensions cannot produce this case.
#[test]
fn reduce_unreached_time_past_upper_pends_joins() {
type T = Product<u64, Product<u64, u64>>;
let time = |a, b, c| -> T { Product::new(a, Product::new(b, c)) };
let updates = vec![((7u64, 3u64), time(0, 1, 0), 1i64), ((7, 3), time(0, 0, 2), 1), ((7, 3), time(1, 0, 1), 1)];
let prior = hbatch(updates[.. 1].to_vec(), time(0, 0, 0), time(0, 0, 1));
let novel = hbatch(updates[1 ..].to_vec(), time(0, 0, 1), time(0, 1, 1));
let frontier = Antichain::from_elem;
let mut tactic = ProxyReduceTactic::new(VecReduceBackend::new(max_logic));
let (first, pending) = tactic.retire(
vec![], vec![], vec![prior.clone()],
&frontier(time(0, 0, 0)), &frontier(time(0, 0, 1)), &frontier(time(0, 0, 0)),
);
assert!(pending.is_empty());
let mut outputs: Vec<_> = first.into_iter().filter_map(|s| s.inner).collect();
let (second, pending) = tactic.retire(
vec![prior.clone()], outputs.clone(), vec![novel.clone()],
&frontier(time(0, 0, 1)), &frontier(time(0, 1, 1)), &frontier(time(0, 0, 1)),
);
outputs.extend(second.into_iter().filter_map(|s| s.inner));
// No new records: the rest of the work is the pending times.
let (third, pending) = tactic.retire(
vec![prior, novel], outputs.clone(), vec![],
&frontier(time(0, 1, 1)), &frontier(time(3, 3, 3)), &pending,
);
assert!(pending.is_empty());
outputs.extend(third.into_iter().filter_map(|s| s.inner));
let outputs = hread(&outputs);
for (a, b, c) in (0 .. 3).flat_map(|a| (0 .. 3).flat_map(move |b| (0 .. 3).map(move |c| (a, b, c)))) {
let at = time(a, b, c);
let count: i64 = updates.iter().filter(|(_, t, _)| timely::PartialOrder::less_equal(t, &at)).map(|(_, _, d)| d).sum();
let output: i64 = outputs.iter().filter(|(_, t, _)| timely::PartialOrder::less_equal(t, &at)).map(|(_, _, d)| d).sum();
assert_eq!(output, if count > 0 { 1 } else { 0 }, "at {at:?}");
}
}

// ===== Reading as of a time =====
//
// A trace's accumulations are correct only at or beyond its compaction frontier: compaction can
Expand Down
109 changes: 109 additions & 0 deletions differential-dataflow/tests/reduce.rs
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
use timely::dataflow::operators::{ToStream, Capture, vec::Map};
use timely::dataflow::operators::capture::Extract;
use differential_dataflow::AsCollection;
use differential_dataflow::operators::Iterate;
use differential_dataflow::input::InputSession;
use differential_dataflow::trace::implementations::{ValBuilder, ValSpine};

Expand Down Expand Up @@ -84,3 +85,111 @@ fn reduce_frontier_ahead_of_trace() {
let updates: Vec<_> = recv.extract().into_iter().flat_map(|(_, data)| data).collect();
assert_eq!(updates, vec![((0, 1), 7, 1)]);
}

/// A time in a three-dimensional product order. The case below needs three dimensions.
type Time3 = timely::order::Product<u64, timely::order::Product<u64, u64>>;
fn time3(a: u64, b: u64, c: u64) -> Time3 { timely::order::Product::new(a, timely::order::Product::new(b, c)) }

/// Feeds `rounds` to `logic` through an unordered input whose frontier starts at `initial`. Each
/// round gives its updates, advances the input frontier to the round's frontier, and runs the
/// dataflow until the output frontier catches up. Returns every output update.
fn run_rounds<D, F>(initial: Vec<Time3>, rounds: Vec<(Vec<(D, Time3, isize)>, Vec<Time3>)>, logic: F) -> Vec<(D, Time3, isize)>
where
D: differential_dataflow::Data + Send + Sync,
F: for<'scope> FnOnce(differential_dataflow::VecCollection<'scope, Time3, D, isize>) -> differential_dataflow::VecCollection<'scope, Time3, D, isize> + Send + Sync + 'static,
{
use timely::PartialOrder;
use timely::dataflow::operators::vec::unordered_input::UnorderedInput;

let (send, recv) = std::sync::mpsc::channel();
timely::execute_directly(move |worker| {
let (mut input, root, probe) = worker.dataflow::<u64, _, _>(|outer| {
outer.scoped::<Time3, _, _>("Product", |scope| {
let ((input, root), stream) = scope.new_unordered_input::<(D, Time3, isize)>();
// `inspect` rather than `capture`: the output can carry multi-capability stamps.
let (probe, _) = logic(stream.as_collection()).inspect(move |update| send.send(update.clone()).unwrap()).probe();
(input, root, probe)
})
});
let mut caps: Vec<_> = initial.iter().map(|t| root.delayed(t)).collect();
drop(root);
for (updates, frontier) in rounds {
for (data, time, diff) in updates {
let cap = caps.iter().find(|c| c.time().less_equal(&time)).expect("update behind the frontier");
input.activate().session(cap).give((data, time, diff));
}
caps = frontier.iter().map(|t| caps.iter().find(|c| c.time().less_equal(t)).expect("frontier regresses").delayed(t)).collect();
worker.step_while(|| probe.with_frontier(|f| f.iter().any(|p| !caps.iter().any(|c| c.time().less_equal(p)))));
}
});
recv.try_iter().collect()
}

/// The accumulation of `updates` at `time`, without zeros.
fn accumulate<D: Ord + Clone>(updates: &[(D, Time3, isize)], time: &Time3) -> std::collections::BTreeMap<D, isize> {
use timely::PartialOrder;
let mut acc = std::collections::BTreeMap::new();
for (data, t, diff) in updates {
if t.less_equal(time) { *acc.entry(data.clone()).or_insert(0) += diff; }
}
acc.retain(|_, diff| *diff != 0);
acc
}

/// Every time in `[0, bound)^3`.
fn grid(bound: u64) -> impl Iterator<Item = Time3> {
(0 .. bound).flat_map(move |a| (0 .. bound).flat_map(move |b| (0 .. bound).map(move |c| time3(a, b, c))))
}

/// A history time can need re-evaluation at its join with a new time even though both lie outside
/// the interval the reduce retires. Here `(0,1,0)` arrives first; `(0,0,2)` and `(1,0,1)` follow in
/// `[(0,0,1), (0,1,1))`. The reduce advances the history time by the meet of the new times, to
/// `(0,1,1)`, past the interval. Its join with `(0,0,2)`, at `(0,1,2)`, must still come back as a
/// pending time, where `distinct` retracts the second copy of the record.
#[test]
fn distinct_join_with_history_past_upper() {
let rounds = vec![
(vec![(0u64, time3(0, 1, 0), 1)], vec![time3(0, 0, 1)]),
(vec![(0, time3(0, 0, 2), 1), (0, time3(1, 0, 1), 1)], vec![time3(0, 1, 1)]),
];
let input: Vec<_> = rounds.iter().flat_map(|(updates, _)| updates.clone()).collect();
let output = run_rounds(vec![time3(0, 0, 0)], rounds, |c| c.distinct());
for time in grid(4) {
let expected = accumulate(&input, &time).into_keys().map(|k| (k, 1)).collect();
assert_eq!(accumulate(&output, &time), expected, "at {time:?}");
}
}

/// The case above, as a randomized test found it (seed 219): a transitive closure by `iterate` and
/// `distinct`, over edges that arrive at incomparable times in two rounds. The edge `1 -> 6` is
/// derived at `(0,1,2)` (`1 -> 2 -> 6`) and at `(2,1,0)` (`1 -> 2 -> 5 -> 6`), and at their join
/// `(2,1,2)` the closure must still hold it once.
#[test]
fn iterate_distinct_join_with_history_past_upper() {
let rounds = vec![
(vec![((5u8, 6u8), time3(1, 0, 0), 1), ((1, 2), time3(0, 1, 0), 1), ((2, 5), time3(2, 0, 0), 1), ((1, 6), time3(3, 0, 0), 1)],
vec![time3(4, 0, 0), time3(0, 2, 0), time3(0, 0, 1)]),
(vec![((1, 1), time3(0, 0, 1), 1), ((2, 6), time3(0, 0, 2), 1)],
vec![time3(4, 0, 0), time3(0, 2, 0), time3(0, 0, 3)]),
];
let input: Vec<_> = rounds.iter().flat_map(|(updates, _)| updates.clone()).collect();
let initial = vec![time3(1, 0, 0), time3(0, 1, 0), time3(0, 0, 1)];
let output = run_rounds(initial, rounds, |edges| {
let links = edges.clone();
edges.iterate(move |inner, reach| {
let links = links.enter(inner);
reach.map(|(a, b)| (b, a)).join_map(links.clone(), |_b, a, c| (*a, *c)).concat(links).distinct()
})
});
for time in grid(4) {
let mut expected = accumulate(&input, &time);
loop {
let paths: Vec<_> = expected.keys().flat_map(|&(a, b)| expected.keys().filter(move |&&(c, _)| c == b).map(move |&(_, d)| (a, d))).collect();
let size = expected.len();
expected.extend(paths.into_iter().map(|path| (path, 1)));
if expected.len() == size { break; }
}
let expected = expected.into_keys().map(|path| (path, 1)).collect();
assert_eq!(accumulate(&output, &time), expected, "at {time:?}");
}
}