Atomic

examples/fastbar.rs

@@ -1,26 +1,17 @@
-use std::time::Instant;
-
-use indicatif::{HumanDuration, ProgressBar};
+use indicatif::ProgressBar;
 
 fn many_units_of_easy_work(n: u64, label: &str) {
     let pb = ProgressBar::new(n);
 
     let mut sum = 0;
-    let started = Instant::now();
     for i in 0..n {
         // Any quick computation, followed by an update to the progress bar.
         sum += 2 * i + 3;
         pb.inc(1);
     }
     pb.finish();
-    let finished = started.elapsed();
 
-    println!(
-        "[{}] Sum ({}) calculated in {}",
-        label,
-        sum,
-        HumanDuration(finished)
-    );
+    println!("[{}] Sum ({}) calculated in {:?}", label, sum, pb.elapsed());
 }
 
 fn main() {

src/progress_bar.rs

@@ -6,7 +6,7 @@ use std::sync::{Arc, Mutex, Weak};
 use std::time::{Duration, Instant};
 
 use crate::draw_target::ProgressDrawTarget;
-use crate::state::{BarState, ProgressFinish, Reset, Ticker};
+use crate::state::{AtomicPosition, BarState, ProgressFinish, Reset, Ticker};
 use crate::style::ProgressStyle;
 use crate::ProgressState;
 use crate::{ProgressBarIter, ProgressIterator};
@@ -18,6 +18,7 @@ use crate::{ProgressBarIter, ProgressIterator};
 #[derive(Clone)]
 pub struct ProgressBar {
     state: Arc<Mutex<BarState>>,
+    pos: Arc<AtomicPosition>,
 }
 
 impl fmt::Debug for ProgressBar {
@@ -46,14 +47,16 @@ impl ProgressBar {
 
     /// Creates a new progress bar with a given length and draw target
     pub fn with_draw_target(len: u64, draw_target: ProgressDrawTarget) -> ProgressBar {
+        let pos = Arc::new(AtomicPosition::default());
         ProgressBar {
-            state: Arc::new(Mutex::new(BarState::new(len, draw_target))),
+            state: Arc::new(Mutex::new(BarState::new(len, draw_target, pos.clone()))),
+            pos,
         }
     }
 
     /// A convenience builder-like function for a progress bar with a given style
     pub fn with_style(self, style: ProgressStyle) -> ProgressBar {
-        self.state.lock().unwrap().style = style;
+        self.state().style = style;
         self
     }
 
@@ -71,13 +74,13 @@ impl ProgressBar {
 
     /// A convenience builder-like function for a progress bar with a given position
     pub fn with_position(self, pos: u64) -> ProgressBar {
-        self.state.lock().unwrap().state.set_pos(pos);
+        self.state().state.set_pos(pos);
         self
     }
 
     /// A convenience builder-like function for a progress bar with a given elapsed time
     pub fn with_elapsed(self, elapsed: Duration) -> ProgressBar {
-        self.state.lock().unwrap().state.started = Instant::now() - elapsed;
+        self.state().state.started = Instant::now() - elapsed;
         self
     }
 
@@ -110,7 +113,7 @@ impl ProgressBar {
     ///
     /// This does not redraw the bar. Call [`ProgressBar::tick()`] to force it.
     pub fn set_style(&self, style: ProgressStyle) {
-        self.state.lock().unwrap().style = style;
+        self.state().style = style;
     }
 
     /// Spawns a background thread to tick the progress bar
@@ -138,17 +141,21 @@ impl ProgressBar {
 
     /// Advances the position of the progress bar by `delta`
     pub fn inc(&self, delta: u64) {
-        self.state().inc(Instant::now(), delta)
+        self.pos.inc(delta);
+        let now = Instant::now();
+        if self.pos.allow(now) {
+            self.state().tick(now);
+        }
     }
 
     /// A quick convenience check if the progress bar is hidden
     pub fn is_hidden(&self) -> bool {
-        self.state.lock().unwrap().draw_target.is_hidden()
+        self.state().draw_target.is_hidden()
     }
 
     /// Indicates that the progress bar finished
     pub fn is_finished(&self) -> bool {
-        self.state.lock().unwrap().state.is_finished()
+        self.state().state.is_finished()
     }
 
     /// Print a log line above the progress bar
@@ -173,7 +180,11 @@ impl ProgressBar {
 
     /// Sets the position of the progress bar
     pub fn set_position(&self, pos: u64) {
-        self.state().set_position(Instant::now(), pos)
+        self.pos.set(pos);
+        let now = Instant::now();
+        if self.pos.allow(now) {
+            self.state().tick(now);
+        }
     }
 
     /// Sets the length of the progress bar
@@ -206,6 +217,7 @@ impl ProgressBar {
     pub fn downgrade(&self) -> WeakProgressBar {
         WeakProgressBar {
             state: Arc::downgrade(&self.state),
+            pos: Arc::downgrade(&self.pos),
         }
     }
 
@@ -292,7 +304,7 @@ impl ProgressBar {
     /// [`MultiProgress::add`]: crate::MultiProgress::add
     /// [`MultiProgress::set_draw_target`]: crate::MultiProgress::set_draw_target
     pub fn set_draw_target(&self, target: ProgressDrawTarget) {
-        let mut state = self.state.lock().unwrap();
+        let mut state = self.state();
         state.draw_target.disconnect(Instant::now());
         state.draw_target = target;
     }
@@ -420,27 +432,27 @@ impl ProgressBar {
 
     /// Returns the current position
     pub fn position(&self) -> u64 {
-        self.state.lock().unwrap().state.pos()
+        self.state().state.pos()
     }
 
     /// Returns the current length
     pub fn length(&self) -> u64 {
-        self.state.lock().unwrap().state.len()
+        self.state().state.len()
     }
 
     /// Returns the current ETA
     pub fn eta(&self) -> Duration {
-        self.state.lock().unwrap().state.eta()
+        self.state().state.eta()
     }
 
     /// Returns the current rate of progress
     pub fn per_sec(&self) -> f64 {
-        self.state.lock().unwrap().state.per_sec()
+        self.state().state.per_sec()
     }
 
     /// Returns the current expected duration
     pub fn duration(&self) -> Duration {
-        self.state.lock().unwrap().state.duration()
+        self.state().state.duration()
     }
 
     /// Returns the current elapsed time
@@ -453,6 +465,7 @@ impl ProgressBar {
         self.state().draw_target.remote().map(|(_, idx)| idx)
     }
 
+    #[inline]
     pub(crate) fn state(&self) -> MutexGuard<'_, BarState> {
         self.state.lock().unwrap()
     }
@@ -464,6 +477,7 @@ impl ProgressBar {
 #[derive(Clone, Default)]
 pub struct WeakProgressBar {
     state: Weak<Mutex<BarState>>,
+    pos: Weak<AtomicPosition>,
 }
 
 impl WeakProgressBar {
@@ -479,7 +493,9 @@ impl WeakProgressBar {
     ///
     /// [`ProgressBar`]: struct.ProgressBar.html
     pub fn upgrade(&self) -> Option<ProgressBar> {
-        self.state.upgrade().map(|state| ProgressBar { state })
+        let state = self.state.upgrade()?;
+        let pos = self.pos.upgrade()?;
+        Some(ProgressBar { state, pos })
     }
 }
 
@@ -491,14 +507,14 @@ mod tests {
     #[test]
     fn test_pbar_zero() {
         let pb = ProgressBar::new(0);
-        assert_eq!(pb.state.lock().unwrap().state.fraction(), 1.0);
+        assert_eq!(pb.state().state.fraction(), 1.0);
     }
 
     #[allow(clippy::float_cmp)]
     #[test]
     fn test_pbar_maxu64() {
         let pb = ProgressBar::new(!0);
-        assert_eq!(pb.state.lock().unwrap().state.fraction(), 0.0);
+        assert_eq!(pb.state().state.fraction(), 0.0);
     }
 
     #[test]