[−][src]Function timely::execute::execute_from_args
pub fn execute_from_args<I, T, F>(
iter: I,
func: F
) -> Result<WorkerGuards<T>, String> where
I: Iterator<Item = String>,
T: Send + 'static,
F: Fn(&mut Worker<Allocator>) -> T + Send + Sync + 'static,
Executes a timely dataflow from supplied arguments and per-communicator logic.
The execute
method takes arguments (typically std::env::args()
) and spins up some number of
workers threads, each of which execute the supplied closure to construct and run a timely
dataflow computation.
The closure may return a T: Send+'static
, and execute
returns a result
containing a WorkerGuards<T>
(or error information), which can be joined
to recover the result T
values from the local workers.
The arguments execute
currently understands are:
-w, --workers
: number of per-process worker threads.
-n, --processes
: number of processes involved in the computation.
-p, --process
: identity of this process; from 0 to n-1.
-h, --hostfile
: a text file whose lines are "hostname:port" in order of process identity.
If not specified, localhost
will be used, with port numbers increasing from 2101 (chosen
arbitrarily).
Examples
use timely::dataflow::operators::{ToStream, Inspect}; // execute a timely dataflow using command line parameters timely::execute_from_args(std::env::args(), |worker| { worker.dataflow::<(),_,_>(|scope| { (0..10).to_stream(scope) .inspect(|x| println!("seen: {:?}", x)); }) }).unwrap();
host0% cargo run -- -w 2 -n 4 -h hosts.txt -p 0 host1% cargo run -- -w 2 -n 4 -h hosts.txt -p 1 host2% cargo run -- -w 2 -n 4 -h hosts.txt -p 2 host3% cargo run -- -w 2 -n 4 -h hosts.txt -p 3
% cat hosts.txt host0:port host1:port host2:port host3:port