timely 0.29.0

A low-latency data-parallel dataflow system in Rust
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

use timely::dataflow::channels::pact::Pipeline;
use timely::dataflow::operators::{Exchange, Input, Operator, Probe};
use timely::dataflow::InputHandle;
use timely::Config;

#[test]
fn gh_523() {
    timely::execute(Config::thread(), |worker| {
        let mut input = InputHandle::new();
        let probe = worker.dataflow::<u64, _, _>(|scope| {
            scope
                .input_from(&mut input)
                .container::<Vec<_>>()
                .unary(Pipeline, "Test", move |_, _| {
                    move |input, output| {
                        input.for_each_time(|cap, data| {
                            let mut session = output.session(&cap);
                            for data in data {
                                session.give_container(&mut Vec::new());
                                session.give_container(data);
                            }
                        });
                    }
                })
                .exchange(|x| *x)
                .probe()
                .0
        });

        for round in 0..2 {
            input.send(round);
            input.advance_to(round + 1);
        }
        input.close();

        while !probe.done() {
            worker.step();
        }

        println!("worker {} complete", worker.index());
    })
    .unwrap();
}