Struct Balancer 

pub struct Balancer<O> {
    pub workers: usize,
    pub rank: usize,
    pub size: usize,
    /* private fields */
}

This struct helps manage compute on a given node and across nodes

Fields

workers: usize

rank: usize

size: usize

Implementations

impl<O> Balancer<O>

where O: Send + Equivalence,

pub fn new(universe: Arc<Universe>, verbose: bool) -> Self

Constructs a new Balancer from an mpi::SystemCommunicator a.k.a. world.

Examples found in repository

examples/simple.rs (line 24)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    balancer.work_subset(&data, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

examples/distribute.rs (line 30)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    let ours = balancer.distribute(Some(data.clone())).unwrap();
    balancer.work(&ours, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

fn helper(universe: Arc<Universe>) {
    // Initialize balancer
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);

    // Get relevant portion of data on this node
    // rank !=0 passes in none
    let data: Vec<f64> = balancer.distribute(None).unwrap();

    // Define task
    let work = |x: &f64| x * x;

    balancer.work(&data, work);
    balancer.collect();
}

pub fn work_subset<'b, I, F>(&self, items: &'b [I], work: F)

where I: Send + Sync, F: Fn(&'b I) -> O + Send + Sync, O: Send,

Calculates local set of items on which to work on.

Examples found in repository

examples/simple.rs (line 25)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    balancer.work_subset(&data, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

pub fn work<'b, I, F>(&self, items: &'b [I], work: F)

where I: Send + Sync, F: Fn(&'b I) -> O + Send + Sync, O: Send,

Works on the entire set provided

Examples found in repository

examples/distribute.rs (line 32)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    let ours = balancer.distribute(Some(data.clone())).unwrap();
    balancer.work(&ours, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

fn helper(universe: Arc<Universe>) {
    // Initialize balancer
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);

    // Get relevant portion of data on this node
    // rank !=0 passes in none
    let data: Vec<f64> = balancer.distribute(None).unwrap();

    // Define task
    let work = |x: &f64| x * x;

    balancer.work(&data, work);
    balancer.collect();
}

pub fn distribute<'b, I>(&self, items: Option<Vec<I>>) -> Option<Vec<I>>

where I: Send + Sync + Equivalence,

Distributes items for work

Examples found in repository

examples/distribute.rs (line 31)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    let ours = balancer.distribute(Some(data.clone())).unwrap();
    balancer.work(&ours, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

fn helper(universe: Arc<Universe>) {
    // Initialize balancer
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);

    // Get relevant portion of data on this node
    // rank !=0 passes in none
    let data: Vec<f64> = balancer.distribute(None).unwrap();

    // Define task
    let work = |x: &f64| x * x;

    balancer.work(&data, work);
    balancer.collect();
}

pub fn collect(&self) -> Option<Vec<O>>

Examples found in repository

examples/simple.rs (line 26)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    balancer.work_subset(&data, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

examples/distribute.rs (line 33)

fn experiment(universe: Arc<Universe>) {
    // Get relevant portion of data on this node
    let data: Vec<f64> = (0..100_000).map(|x| x as f64 / 100_000.0).collect();

    // Define task
    let work = |x: &f64| x * x;

    // Initialize balancer, work and collect
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);
    let ours = balancer.distribute(Some(data.clone())).unwrap();
    balancer.work(&ours, work);
    let output = balancer.collect();

    // That's it!
    // Let's do some verification
    if balancer.rank == 0 {
        for (expected, actual) in data.iter().map(work).zip(output.as_ref().unwrap()) {
            assert_eq!(expected, *actual);
        }
    }
}

fn helper(universe: Arc<Universe>) {
    // Initialize balancer
    let verbose = false;
    let balancer = Balancer::new(universe, verbose);

    // Get relevant portion of data on this node
    // rank !=0 passes in none
    let data: Vec<f64> = balancer.distribute(None).unwrap();

    // Define task
    let work = |x: &f64| x * x;

    balancer.work(&data, work);
    balancer.collect();
}

pub fn barrier(&mut self)

Waits for all threads to finish across all ranks.