use std::env;
use constellation::*;
fn main() {
init(Resources::default());
let processes = env::args()
.nth(1)
.and_then(|arg| arg.parse::<usize>().ok())
.unwrap_or(10);
let pids: Vec<Pid> = (0..processes)
.map(|process_index| {
spawn(
Resources {
mem: 20 * 1024 * 1024,
..Resources::default()
},
serde_closure::FnOnce!([process_index] move |parent| {
let receiver = Receiver::<Vec<Pid>>::new(parent);
let pids = receiver.recv().block().unwrap();
assert_eq!(pids[process_index], pid());
let mut senders: Vec<Option<Sender<usize>>> = Vec::with_capacity(pids.len());
let mut receivers: Vec<Option<Receiver<usize>>> = Vec::with_capacity(pids.len());
for i in 0..pids.len() {
for j in 0..pids.len() {
if i == process_index {
senders.push(if i != j {
Some(Sender::new(pids[j]))
} else {
None
});
}
if j == process_index {
receivers.push(if i != j {
Some(Receiver::new(pids[i]))
} else {
None
});
}
}
}
for (i,receiver) in receivers.iter().enumerate() {
for (j,sender) in senders.iter().enumerate() {
if i == j {
continue;
}
if i == process_index {
sender.as_ref().unwrap().send(i * j).block();
}
if j == process_index {
let x = receiver.as_ref().unwrap().recv().block().unwrap();
assert_eq!(x, i * j);
}
}
}
println!("done");
}),
)
.block()
.expect("spawn() failed to allocate process")
})
.collect();
let senders: Vec<Sender<std::vec::Vec<Pid>>> =
pids.iter().map(|&pid| Sender::new(pid)).collect();
for sender in senders {
sender.send(pids.clone()).block();
}
}