Function timely_communication::initialize::initialize

pub fn initialize<T: Send + 'static, F: Fn(Generic) -> T + Send + Sync + 'static>(
    config: Configuration, 
    log_sender: Arc<Fn(CommsSetup) -> CommsLogger + Send + Sync>, 
    func: F
) -> Result<WorkerGuards<T>, String>

Initializes communication and executes a distributed computation.

This method allocates an allocator::Generic for each thread, spawns local worker threads, and invokes the supplied function with the allocator. The method returns a WorkerGuards<T> which can be joined to retrieve the return values (or errors) of the workers.

#Examples

// configure for two threads, just one process.
let config = timely_communication::Configuration::Process(2);

// create a source of inactive loggers.
let logger = ::std::sync::Arc::new(|_| timely_communication::logging::BufferingLogger::new_inactive());

// initializes communication, spawns workers
let guards = timely_communication::initialize(config, logger, |mut allocator| {
    println!("worker {} started", allocator.index());

    // allocates pair of senders list and one receiver.
    let (mut senders, mut receiver, _) = allocator.allocate();

    // send typed data along each channel
    senders[0].send(format!("hello, {}", 0));
    senders[1].send(format!("hello, {}", 1));

    // no support for termination notification,
    // we have to count down ourselves.
    let mut expecting = 2;
    while expecting > 0 {
        if let Some(message) = receiver.recv() {
            println!("worker {}: received: <{}>", allocator.index(), message);
            expecting -= 1;
        }
    }

    // optionally, return something
    allocator.index()
});

// computation runs until guards are joined or dropped.
if let Ok(guards) = guards {
    for guard in guards.join() {
        println!("result: {:?}", guard);
    }
}
else { println!("error in computation"); }

The should produce output like:

worker 0 started
worker 1 started
worker 0: received: <hello, 0>
worker 1: received: <hello, 1>
worker 0: received: <hello, 0>
worker 1: received: <hello, 1>
result: Ok(0)
result: Ok(1)