Trait Destination

pub trait Destination: AsCommunicator {
    // Required method
    fn destination_rank(&self) -> Rank;

    // Provided methods
    fn send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)
       where Buf: Buffer + ?Sized { ... }
    fn send<Buf>(&self, buf: &Buf)
       where Buf: Buffer + ?Sized { ... }
    fn buffered_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)
       where Buf: Buffer + ?Sized { ... }
    fn buffered_send<Buf>(&self, buf: &Buf)
       where Buf: Buffer + ?Sized { ... }
    fn synchronous_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)
       where Buf: Buffer + ?Sized { ... }
    fn synchronous_send<Buf>(&self, buf: &Buf)
       where Buf: Buffer + ?Sized { ... }
    fn ready_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)
       where Buf: Buffer + ?Sized { ... }
    fn ready_send<Buf>(&self, buf: &Buf)
       where Buf: Buffer + ?Sized { ... }
    fn immediate_send_with_tag<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
        tag: Tag,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_send<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_buffered_send_with_tag<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
        tag: Tag,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_buffered_send<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_synchronous_send_with_tag<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
        tag: Tag,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_synchronous_send<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_ready_send_with_tag<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
        tag: Tag,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_ready_send<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
}

Something that can be used as the destination in a point to point send operation

Examples

• Using a Process as the destination will send data to that specific process.

Standard section(s)

3.2.3

Required Methods

fn destination_rank(&self) -> Rank

Rank that identifies the destination

Provided Methods

fn send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)

where Buf: Buffer + ?Sized,

Blocking standard mode send operation

Send the contents of a Buffer to the Destination &self and tag it.

Standard section(s)

3.2.1

fn send<Buf>(&self, buf: &Buf)

where Buf: Buffer + ?Sized,

Blocking standard mode send operation

Send the contents of a Buffer to the Destination &self.

Examples

extern crate mpi_fork_fnsp as mpi;
use mpi::traits::*;

let universe = mpi::initialize().unwrap();
let world = universe.world();

let v = vec![ 1.0f64, 2.0, 3.0 ];
world.process_at_rank(1).send(&v[..]);

See also examples/send_receive.rs

Standard section(s)

3.2.1

Examples found in repository

examples/barrier.rs (line 25)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let receiver_rank = 0;

    if world.rank() == receiver_rank {
        let n = (world.size() - 1) as usize;
        let mut buf = vec![0u64; 2 * n];
        for x in buf[0..n].iter_mut() {
            world.any_process().receive_into(x);
        }
        world.barrier();
        for x in buf[n..2 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        println!("{:?}", buf);
        assert!(buf[0..n].iter().all(|&x| x == 1));
        assert!(buf[n..2 * n].iter().all(|&x| x == 2));
    } else {
        world.process_at_rank(0).send(&1u64);
        world.barrier();
        world.process_at_rank(0).send(&2u64);
    }
}

examples/send_receive.rs (line 29)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    let next_rank = if rank + 1 < size { rank + 1 } else { 0 };
    let next_process = world.process_at_rank(next_rank);
    let previous_rank = if rank > 0 { rank - 1 } else { size - 1 };
    let previous_process = world.process_at_rank(previous_rank);

    let (msg, status): (Rank, _) = p2p::send_receive(&rank, &previous_process, &next_process);
    println!(
        "Process {} got message {}.\nStatus is: {:?}",
        rank, msg, status
    );
    world.barrier();
    assert_eq!(msg, next_rank);

    if rank > 0 {
        let msg = vec![rank, rank + 1, rank - 1];
        world.process_at_rank(0).send(&msg[..]);
    } else {
        for _ in 1..size {
            let (msg, status) = world.any_process().receive_vec::<Rank>();
            println!(
                "Process {} got long message {:?}.\nStatus is: {:?}",
                rank, msg, status
            );

            let x = status.source_rank();
            let v = vec![x, x + 1, x - 1];
            assert_eq!(v, msg);
        }
    }
    world.barrier();

    let mut x = rank;
    p2p::send_receive_replace_into(&mut x, &next_process, &previous_process);
    assert_eq!(x, previous_rank);
}

examples/immediate_barrier.rs (line 44)

fn main() {
    use mpi::traits::*;
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let receiver_rank = 0;

    if world.rank() == receiver_rank {
        // receiver process
        let n = (size - 1) as usize;
        let mut buf = vec![0u64; 3 * n];
        // receive first 2 * n messages
        for x in buf[0..2 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        // signal the waiting senders that 2 * n messages have been received
        let breq = world.immediate_barrier();
        // receive remaining n messages
        for x in buf[2 * n..3 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        println!("{:?}", buf);
        // messages "1" and "2" may be interleaved, but all have to be contained within the first
        // 2 * n slots of the buffer
        assert_eq!(buf[0..2 * n].iter().filter(|&&x| x == 1).count(), n);
        assert_eq!(buf[0..2 * n].iter().filter(|&&x| x == 2).count(), n);
        // the last n slots in the buffer may only contain message "3"
        assert!(buf[2 * n..3 * n].iter().all(|&x| x == 3));
        // clean up the barrier request
        breq.wait();
    } else {
        // sender processes
        // send message "1"
        world.process_at_rank(0).send(&1u64);
        // join barrier, but do not block
        let breq = world.immediate_barrier();
        // send message "2"
        world.process_at_rank(0).send(&2u64);
        // wait for receiver process to receive the first 2 * n messages
        breq.wait();
        // send message "3"
        world.process_at_rank(0).send(&3u64);
    }
}

examples/immediate.rs (line 56)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn buffered_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)

where Buf: Buffer + ?Sized,

Blocking buffered mode send operation

Send the contents of a Buffer to the Destination &self and tag it.

Standard section(s)

3.4

fn buffered_send<Buf>(&self, buf: &Buf)

where Buf: Buffer + ?Sized,

Blocking buffered mode send operation

Send the contents of a Buffer to the Destination &self.

Standard section(s)

3.4

Examples found in repository

examples/buffered.rs (line 30)

fn main() {
    let mut universe = mpi::initialize().unwrap();
    // Try to attach a buffer.
    universe.set_buffer_size(BUFFER_SIZE);
    // Check buffer size matches.
    assert_eq!(universe.buffer_size(), BUFFER_SIZE);
    // Try to detach the buffer.
    universe.detach_buffer();
    // Attach another buffer.
    universe.set_buffer_size(BUFFER_SIZE);

    let world = universe.world();

    let x = vec![std::f32::consts::PI; 1024];
    let mut y = vec![0.0; 1024];
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(
            world
                .any_process()
                .immediate_receive_into(scope, &mut y[..]),
        );
        world.this_process().buffered_send(&x[..]);
    });
    assert_eq!(x, y);
}

fn synchronous_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)

where Buf: Buffer + ?Sized,

Blocking synchronous mode send operation

Send the contents of a Buffer to the Destination &self and tag it.

Completes only once the matching receive operation has started.

Standard section(s)

3.4

fn synchronous_send<Buf>(&self, buf: &Buf)

where Buf: Buffer + ?Sized,

Blocking synchronous mode send operation

Send the contents of a Buffer to the Destination &self.

Completes only once the matching receive operation has started.

Standard section(s)

3.4

fn ready_send_with_tag<Buf>(&self, buf: &Buf, tag: Tag)

where Buf: Buffer + ?Sized,

Blocking ready mode send operation

Send the contents of a Buffer to the Destination &self and tag it.

Fails if the matching receive operation has not been posted.

Standard section(s)

3.4

fn ready_send<Buf>(&self, buf: &Buf)

where Buf: Buffer + ?Sized,

Blocking ready mode send operation

Send the contents of a Buffer to the Destination &self.

Fails if the matching receive operation has not been posted.

Standard section(s)

3.4

Examples found in repository

examples/ready_send.rs (line 16)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    if rank > 0 {
        let msg = rank as u8;
        world.barrier();
        world.process_at_rank(0).ready_send(&msg);
    } else {
        let mut v = vec![0u8; (size - 1) as usize];
        mpi::request::scope(|scope| {
            let reqs = v
                .iter_mut()
                .zip(1..)
                .map(|(x, i)| {
                    world
                        .process_at_rank(i as Rank)
                        .immediate_receive_into(scope, x)
                })
                .collect::<Vec<_>>();
            world.barrier();
            for req in reqs {
                req.wait();
            }
        });
        println!("Got message: {:?}", v);
        assert!(v.iter().zip(1..).all(|(x, i)| i == *x as usize));
    }
}

fn immediate_send_with_tag<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, tag: Tag, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) standard mode send operation.

Initiate sending the data in buf in standard mode and tag it.

Standard section(s)

3.7.2

fn immediate_send<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) standard mode send operation.

Initiate sending the data in buf in standard mode.

Examples

See examples/immediate.rs

Standard section(s)

3.7.2

Examples found in repository

examples/readme.rs (line 21)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    let next_rank = if rank + 1 < size { rank + 1 } else { 0 };
    let previous_rank = if rank > 0 { rank - 1 } else { size - 1 };

    let msg = vec![rank, 2 * rank, 4 * rank];
    mpi::request::scope(|scope| {
        let _sreq = WaitGuard::from(
            world
                .process_at_rank(next_rank)
                .immediate_send(scope, &msg[..]),
        );

        let (msg, status) = world.any_process().receive_vec();

        println!(
            "Process {} got message {:?}.\nStatus is: {:?}",
            rank, msg, status
        );
        let x = status.source_rank();
        assert_eq!(x, previous_rank);
        assert_eq!(vec![x, 2 * x, 4 * x], msg);

        let root_rank = 0;
        let root_process = world.process_at_rank(root_rank);

        let mut a;
        if world.rank() == root_rank {
            a = vec![2, 4, 8, 16];
            println!("Root broadcasting value: {:?}.", &a[..]);
        } else {
            a = vec![0; 4];
        }
        root_process.broadcast_into(&mut a[..]);
        println!("Rank {} received value: {:?}.", world.rank(), &a[..]);
        assert_eq!(&a[..], &[2, 4, 8, 16]);
    });
}

examples/immediate.rs (line 16)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn immediate_buffered_send_with_tag<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, tag: Tag, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) buffered mode send operation.

Initiate sending the data in buf in buffered mode and tag it.

Standard section(s)

3.7.2

fn immediate_buffered_send<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) buffered mode send operation.

Initiate sending the data in buf in buffered mode.

Standard section(s)

3.7.2

fn immediate_synchronous_send_with_tag<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, tag: Tag, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) synchronous mode send operation.

Initiate sending the data in buf in synchronous mode and tag it.

Standard section(s)

3.7.2

fn immediate_synchronous_send<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) synchronous mode send operation.

Initiate sending the data in buf in synchronous mode.

Standard section(s)

3.7.2

Examples found in repository

examples/wait_any.rs (line 22)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        if world.rank() == 0 {
            let mut requests = Vec::new();
            for i in 1..world.size() {
                requests.push(
                    world
                        .process_at_rank(i)
                        .immediate_synchronous_send(scope, &x),
                );
            }

            println!("World size {}", world.size());
            while let Some((index, _status)) = mpi::request::wait_any(&mut requests) {
                println!("Request with index {} completed", index);
            }
            println!("All requests completed");
        } else {
            let secs = time::Duration::from_secs(world.rank() as u64);

            thread::sleep(secs);

            let rreq = world.any_process().immediate_receive_into(scope, &mut y);
            rreq.wait();
            println!("Process {} received data", world.rank());
        }
    });
}

examples/immediate.rs (line 46)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn immediate_ready_send_with_tag<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, tag: Tag, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) ready mode send operation.

Initiate sending the data in buf in ready mode and tag it.

Standard section(s)

3.7.2

fn immediate_ready_send<'a, Sc, Buf>( &self, scope: Sc, buf: &'a Buf, ) -> Request<'a, Sc>

where Buf: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) ready mode send operation.

Initiate sending the data in buf in ready mode.

Examples

See examples/immediate.rs

Standard section(s)

3.7.2

Examples found in repository

examples/immediate.rs (line 35)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, C> Destination for Process<'a, C>

where C: 'a + Communicator,