Struct ConcurrentWrapper 

pub struct ConcurrentWrapper<P: ProgressLog = ProgressLogger> { /* private fields */ }

A ConcurrentProgressLog implementation that wraps a ProgressLog in an Arc/Mutex.

The methods update and update_with_count buffer the increment and add it to the underlying logger only when the buffer reaches a threshold; this prevents locking the underlying logger too often. The threshold is set at creation using the methods with_threshold and wrap_with_threshold, or by calling the method threshold; it is always clamped to MAX_THRESHOLD.

The method light_update, as in the case of ProgressLogger, further delays updates using an even faster check.

Examples

In this example, we manually spawn processes:

let mut cpl = concurrent_progress_logger![item_name = "pumpkin"];
cpl.start("Smashing pumpkins (using many threads)...");

std::thread::scope(|s| {
    for i in 0..100 {
        let mut pl = cpl.clone();
        s.spawn(move || {
            for _ in 0..100000 {
                // do something on each pumpkin
                pl.update();
            }
        });
    }
});

cpl.done();

You can obtain the same behavior with rayon using methods such as for_each_with and map_with:

let mut cpl = concurrent_progress_logger![item_name = "pumpkin"];
cpl.start("Smashing pumpkins (using many threads)...");

(0..1000000).into_par_iter().
    with_min_len(1000). // optional, might reduce the amount of cloning
    for_each_with(cpl.clone(), |pl, i| {
        // do something on each pumpkin
        pl.update();
    }
);

cpl.done();

Note that you have to pass cpl.clone() to avoid a move that would make the call to done impossible. Also, since for_each_with might perform excessive cloning if jobs are too short, you can use with_min_len to reduce the amount of cloning.

Implementations

impl ConcurrentWrapper

pub fn new() -> Self

Creates a new ConcurrentWrapper based on a default ProgressLogger, using the default threshold.

pub fn with_threshold(threshold: u32) -> Self

Creates a new ConcurrentWrapper wrapping a default ProgressLogger, using the given threshold.

The threshold is clamped to MAX_THRESHOLD.

impl<P: ProgressLog> ConcurrentWrapper<P>

pub const DEFAULT_THRESHOLD: u32

The default threshold for updating the underlying logger.

pub const LIGHT_UPDATE_MASK: u32

Calls to light_update will cause a call to update_with_count only if the current local count is a multiple of this mask plus one and at least equal to the threshold.

Note that this constant is significantly smaller than the one used in ProgressLogger, as updates will be further delayed by the threshold mechanism.

pub const MAX_THRESHOLD: u32

The maximum possible threshold for updating the underlying logger.

Thresholds passed to with_threshold, wrap_with_threshold, and threshold are clamped to this value, which guarantees that the internal counter used by light_update cannot overflow.

pub fn threshold(&mut self, threshold: u32) -> &mut Self

Sets the threshold for updating the underlying logger.

The threshold is clamped to MAX_THRESHOLD.

Note that concurrent loggers with the same underlying logger have independent thresholds.

pub fn wrap(inner: P) -> Self

Wraps a given ProgressLog in a ConcurrentWrapper using the default threshold.

pub fn wrap_with_threshold(inner: P, threshold: u32) -> Self

Wraps a given ProgressLog in a ConcurrentWrapper using a given threshold.

The threshold is clamped to MAX_THRESHOLD.

pub fn flush(&mut self)

Forces an update of the underlying logger with the current local count, if nonzero.

If the local count is zero, this method has no effect; in particular, dropping a wrapper after stop or done will not log spuriously. If the mutex guarding the underlying logger has been poisoned by a panic in another thread, the local count is discarded.

impl<P: ProgressLog + Clone> ConcurrentWrapper<P>

pub fn dup(&self) -> Self

Duplicates the concurrent wrapper, obtaining a new one with the same threshold, with a local count of zero, and with an inner ProgressLog that is a clone of the original one.

Trait Implementations

impl<P: ProgressLog + Clone> Clone for ConcurrentWrapper<P>

fn clone(&self) -> Self

Clones the concurrent wrapper, obtaining a new one with the same threshold, with a local count of zero, and with the same inner ProgressLog.

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

Performs copy-assignment from source.

impl<P: ProgressLog + Clone + Send> ConcurrentProgressLog for ConcurrentWrapper<P>

type Duplicated = ConcurrentWrapper<P>

The type returned by dup.

fn dup(&self) -> Self

Duplicates the concurrent progress logger, obtaining a new one.

impl Default for ConcurrentWrapper

fn default() -> Self

Creates a new ConcurrentWrapper based on a default ProgressLogger, with a threshold of DEFAULT_THRESHOLD.

impl<P: ProgressLog + Display> Display for ConcurrentWrapper<P>

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

Formats the value using the given formatter.

impl<P: ProgressLog> Drop for ConcurrentWrapper<P>

This implementation just calls flush, to guarantee that all updates are correctly passed to the underlying logger.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<P: ProgressLog + Clone + Send> ProgressLog for ConcurrentWrapper<P>

type Concurrent = ConcurrentWrapper<P>

The type returned by concurrent.

fn log(&mut self, now: Instant)

Forces a log of self assuming now is the current time.

fn log_if(&mut self, now: Instant)

Logs self if it is time to log.

fn add_to_count(&mut self, count: usize)

Adds a value to the counter.

fn display_memory(&mut self, display_memory: bool) -> &mut Self

Sets the display of memory information.

fn item_name(&mut self, item_name: impl AsRef<str>) -> &mut Self

Sets the name of an item.

fn log_interval(&mut self, log_interval: Duration) -> &mut Self

Sets the log interval.

fn expected_updates( &mut self, expected_updates: impl Into<Option<usize>>, ) -> &mut Self

Sets the expected number of updates.

fn time_unit(&mut self, time_unit: impl Into<Option<TimeUnit>>) -> &mut Self

Sets the time unit to use for speed.

fn local_speed(&mut self, local_speed: bool) -> &mut Self

Sets whether to display additionally the speed achieved during the last log interval.

fn log_target(&mut self, target: impl AsRef<str>) -> &mut Self

Sets the log target.

fn push_log_target(&mut self, suffix: impl AsRef<str>) -> &mut Self

Pushes a suffix to the log target.

fn pop_log_target(&mut self) -> &mut Self

Pops the last suffix pushed with push_log_target.

fn log_level(&mut self, log_level: Level) -> &mut Self

Sets the log level used for progress messages.

fn start(&mut self, msg: impl AsRef<str>)

Starts the logger, displaying the given message.

fn update(&mut self)

Increases the count and checks whether it is time to log.

fn update_with_count_and_time(&mut self, count: usize, now: Instant)

Sets the count and checks whether it is time to log, given the current time.

fn update_with_count(&mut self, count: usize)

Sets the count and checks whether it is time to log.

fn light_update(&mut self)

Increases the count but checks whether it is time to log only after an implementation-defined number of calls.

fn update_and_display(&mut self)

Increases the count and forces a log.

fn stop(&mut self)

Stops the logger, fixing the final time.

fn done(&mut self)

Stops the logger, prints Completed., and displays the final stats. The number of expected updates will be cleared.

fn done_with_count(&mut self, count: usize)

Stops the logger, sets the count, prints Completed., and displays the final stats. The number of expected updates will be cleared.

fn elapsed(&self) -> Option<Duration>

Returns the elapsed time since the logger was started, or None if the logger has not been started.

fn count(&self) -> usize

Returns the last count the logger has been set to.

fn refresh(&mut self)

Refreshes memory information, if previously requested with display_memory. There is no need to call this method unless the logger is displayed manually.

fn trace(&self, args: Arguments<'_>)

Outputs the given message at the trace level.

fn debug(&self, args: Arguments<'_>)

Outputs the given message at the debug level.

fn info(&self, args: Arguments<'_>)

Outputs the given message at the info level.

fn warn(&self, args: Arguments<'_>)

Outputs the given message at the warn level.

fn error(&self, args: Arguments<'_>)

Outputs the given message at the error level.

fn concurrent(&self) -> Self::Concurrent

Returns a concurrent copy of the logger.