Struct tangram_progress_counter::ProgressCounter

pub struct ProgressCounter { /* fields omitted */ }

A ProgressCounter is used to efficiently track the progress of a task occurring across multiple threads.

Imagine you have the following code:

use rayon::prelude::*;

let mut v: Vec<usize> = (0..1_000).collect();
v.par_iter_mut().for_each(|v| { *v += 1; });

Now you want to track the progress of this loop. You can use Arc<Mutex<T>> like so:

use rayon::prelude::*;
use std::sync::{Arc, Mutex};

let mut v: Vec<usize> = (0..1_000).collect();
let progress_counter = Arc::new(Mutex::new(0));
v.par_iter_mut().for_each(|v| {
  *v += 1;
  *progress_counter.lock().unwrap() += 1;
});

However, because the work done in each loop iteration is small, a large portion of time will be spent waiting on the mutex. A better choice in this case is to use atomics. ProgressCounter is a convenient wrapper around atomics for use in tracking progress. This example will now run much faster:

use rayon::prelude::*;
use tangram_progress_counter::ProgressCounter;

let mut v: Vec<usize> = (0..1_000).collect();
let progress_counter = ProgressCounter::new(v.len() as u64);
v.par_iter_mut().for_each(|v| {
  *v += 1;
  progress_counter.inc(1);
});

Implementations

impl ProgressCounter

pub fn new(total: u64) -> ProgressCounter

Create a new ProgressCounter that will count from 0 up to the specified total.

pub fn total(&self) -> u64

Retrieve the total value this ProgressCounter counts up to.

pub fn get(&self) -> u64

Retrieve the current progress value.

pub fn set(&self, value: u64)

Set the current progress value.

pub fn inc(&self, amount: u64)

Increment the progress value by amount.

Trait Implementations

impl Clone for ProgressCounter

fn clone(&self) -> ProgressCounter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProgressCounter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.