1 | use std::borrow::Cow; |
---|---|
2 | use std::io; |
3 | use std::sync::Arc; |
4 | use std::time::Duration; |
5 | #[cfg(not(target_arch = "wasm32"))] |
6 | use std::time::Instant; |
7 | |
8 | use portable_atomic::{AtomicU64, AtomicU8, Ordering}; |
9 | #[cfg(target_arch = "wasm32")] |
10 | use web_time::Instant; |
11 | |
12 | use crate::draw_target::ProgressDrawTarget; |
13 | use crate::style::ProgressStyle; |
14 | |
15 | pub(crate) struct BarState { |
16 | pub(crate) draw_target: ProgressDrawTarget, |
17 | pub(crate) on_finish: ProgressFinish, |
18 | pub(crate) style: ProgressStyle, |
19 | pub(crate) state: ProgressState, |
20 | pub(crate) tab_width: usize, |
21 | } |
22 | |
23 | impl BarState { |
24 | pub(crate) fn new( |
25 | len: Option<u64>, |
26 | draw_target: ProgressDrawTarget, |
27 | pos: Arc<AtomicPosition>, |
28 | ) -> Self { |
29 | Self { |
30 | draw_target, |
31 | on_finish: ProgressFinish::default(), |
32 | style: ProgressStyle::default_bar(), |
33 | state: ProgressState::new(len, pos), |
34 | tab_width: DEFAULT_TAB_WIDTH, |
35 | } |
36 | } |
37 | |
38 | /// Finishes the progress bar using the [`ProgressFinish`] behavior stored |
39 | /// in the [`ProgressStyle`]. |
40 | pub(crate) fn finish_using_style(&mut self, now: Instant, finish: ProgressFinish) { |
41 | self.state.status = Status::DoneVisible; |
42 | match finish { |
43 | ProgressFinish::AndLeave => { |
44 | if let Some(len) = self.state.len { |
45 | self.state.pos.set(len); |
46 | } |
47 | } |
48 | ProgressFinish::WithMessage(msg) => { |
49 | if let Some(len) = self.state.len { |
50 | self.state.pos.set(len); |
51 | } |
52 | self.state.message = TabExpandedString::new(msg, self.tab_width); |
53 | } |
54 | ProgressFinish::AndClear => { |
55 | if let Some(len) = self.state.len { |
56 | self.state.pos.set(len); |
57 | } |
58 | self.state.status = Status::DoneHidden; |
59 | } |
60 | ProgressFinish::Abandon => {} |
61 | ProgressFinish::AbandonWithMessage(msg) => { |
62 | self.state.message = TabExpandedString::new(msg, self.tab_width); |
63 | } |
64 | } |
65 | |
66 | // There's no need to update the estimate here; once the `status` is no longer |
67 | // `InProgress`, we will use the length and elapsed time to estimate. |
68 | let _ = self.draw(true, now); |
69 | } |
70 | |
71 | pub(crate) fn reset(&mut self, now: Instant, mode: Reset) { |
72 | // Always reset the estimator; this is the only reset that will occur if mode is |
73 | // `Reset::Eta`. |
74 | self.state.est.reset(now); |
75 | |
76 | if let Reset::Elapsed | Reset::All = mode { |
77 | self.state.started = now; |
78 | } |
79 | |
80 | if let Reset::All = mode { |
81 | self.state.pos.reset(now); |
82 | self.state.status = Status::InProgress; |
83 | |
84 | for tracker in self.style.format_map.values_mut() { |
85 | tracker.reset(&self.state, now); |
86 | } |
87 | |
88 | let _ = self.draw(false, now); |
89 | } |
90 | } |
91 | |
92 | pub(crate) fn update(&mut self, now: Instant, f: impl FnOnce(&mut ProgressState), tick: bool) { |
93 | f(&mut self.state); |
94 | if tick { |
95 | self.tick(now); |
96 | } |
97 | } |
98 | |
99 | pub(crate) fn unset_length(&mut self, now: Instant) { |
100 | self.state.len = None; |
101 | self.update_estimate_and_draw(now); |
102 | } |
103 | |
104 | pub(crate) fn set_length(&mut self, now: Instant, len: u64) { |
105 | self.state.len = Some(len); |
106 | self.update_estimate_and_draw(now); |
107 | } |
108 | |
109 | pub(crate) fn inc_length(&mut self, now: Instant, delta: u64) { |
110 | if let Some(len) = self.state.len { |
111 | self.state.len = Some(len.saturating_add(delta)); |
112 | } |
113 | self.update_estimate_and_draw(now); |
114 | } |
115 | |
116 | pub(crate) fn set_tab_width(&mut self, tab_width: usize) { |
117 | self.tab_width = tab_width; |
118 | self.state.message.set_tab_width(tab_width); |
119 | self.state.prefix.set_tab_width(tab_width); |
120 | self.style.set_tab_width(tab_width); |
121 | } |
122 | |
123 | pub(crate) fn set_style(&mut self, style: ProgressStyle) { |
124 | self.style = style; |
125 | self.style.set_tab_width(self.tab_width); |
126 | } |
127 | |
128 | pub(crate) fn tick(&mut self, now: Instant) { |
129 | self.state.tick = self.state.tick.saturating_add(1); |
130 | self.update_estimate_and_draw(now); |
131 | } |
132 | |
133 | pub(crate) fn update_estimate_and_draw(&mut self, now: Instant) { |
134 | let pos = self.state.pos.pos.load(Ordering::Relaxed); |
135 | self.state.est.record(pos, now); |
136 | |
137 | for tracker in self.style.format_map.values_mut() { |
138 | tracker.tick(&self.state, now); |
139 | } |
140 | |
141 | let _ = self.draw(false, now); |
142 | } |
143 | |
144 | pub(crate) fn println(&mut self, now: Instant, msg: &str) { |
145 | let width = self.draw_target.width(); |
146 | let mut drawable = match self.draw_target.drawable(true, now) { |
147 | Some(drawable) => drawable, |
148 | None => return, |
149 | }; |
150 | |
151 | let mut draw_state = drawable.state(); |
152 | let lines: Vec<String> = msg.lines().map(Into::into).collect(); |
153 | // Empty msg should trigger newline as we are in println |
154 | if lines.is_empty() { |
155 | draw_state.lines.push(String::new()); |
156 | } else { |
157 | draw_state.lines.extend(lines); |
158 | } |
159 | |
160 | draw_state.orphan_lines_count = draw_state.lines.len(); |
161 | if let Some(width) = width { |
162 | if !matches!(self.state.status, Status::DoneHidden) { |
163 | self.style |
164 | .format_state(&self.state, &mut draw_state.lines, width); |
165 | } |
166 | } |
167 | |
168 | drop(draw_state); |
169 | let _ = drawable.draw(); |
170 | } |
171 | |
172 | pub(crate) fn suspend<F: FnOnce() -> R, R>(&mut self, now: Instant, f: F) -> R { |
173 | if let Some((state, _)) = self.draw_target.remote() { |
174 | return state.write().unwrap().suspend(f, now); |
175 | } |
176 | |
177 | if let Some(drawable) = self.draw_target.drawable(true, now) { |
178 | let _ = drawable.clear(); |
179 | } |
180 | |
181 | let ret = f(); |
182 | let _ = self.draw(true, Instant::now()); |
183 | ret |
184 | } |
185 | |
186 | pub(crate) fn draw(&mut self, mut force_draw: bool, now: Instant) -> io::Result<()> { |
187 | let width = self.draw_target.width(); |
188 | |
189 | // `|= self.is_finished()` should not be needed here, but we used to always draw for |
190 | // finished progress bars, so it's kept as to not cause compatibility issues in weird cases. |
191 | force_draw |= self.state.is_finished(); |
192 | let mut drawable = match self.draw_target.drawable(force_draw, now) { |
193 | Some(drawable) => drawable, |
194 | None => return Ok(()), |
195 | }; |
196 | |
197 | let mut draw_state = drawable.state(); |
198 | |
199 | if let Some(width) = width { |
200 | if !matches!(self.state.status, Status::DoneHidden) { |
201 | self.style |
202 | .format_state(&self.state, &mut draw_state.lines, width); |
203 | } |
204 | } |
205 | |
206 | drop(draw_state); |
207 | drawable.draw() |
208 | } |
209 | } |
210 | |
211 | impl Drop for BarState { |
212 | fn drop(&mut self) { |
213 | // Progress bar is already finished. Do not need to do anything other than notify |
214 | // the `MultiProgress` that we're now a zombie. |
215 | if self.state.is_finished() { |
216 | self.draw_target.mark_zombie(); |
217 | return; |
218 | } |
219 | |
220 | self.finish_using_style(Instant::now(), self.on_finish.clone()); |
221 | |
222 | // Notify the `MultiProgress` that we're now a zombie. |
223 | self.draw_target.mark_zombie(); |
224 | } |
225 | } |
226 | |
227 | pub(crate) enum Reset { |
228 | Eta, |
229 | Elapsed, |
230 | All, |
231 | } |
232 | |
233 | /// The state of a progress bar at a moment in time. |
234 | #[non_exhaustive] |
235 | pub struct ProgressState { |
236 | pos: Arc<AtomicPosition>, |
237 | len: Option<u64>, |
238 | pub(crate) tick: u64, |
239 | pub(crate) started: Instant, |
240 | status: Status, |
241 | est: Estimator, |
242 | pub(crate) message: TabExpandedString, |
243 | pub(crate) prefix: TabExpandedString, |
244 | } |
245 | |
246 | impl ProgressState { |
247 | pub(crate) fn new(len: Option<u64>, pos: Arc<AtomicPosition>) -> Self { |
248 | let now = Instant::now(); |
249 | Self { |
250 | pos, |
251 | len, |
252 | tick: 0, |
253 | status: Status::InProgress, |
254 | started: now, |
255 | est: Estimator::new(now), |
256 | message: TabExpandedString::NoTabs("".into()), |
257 | prefix: TabExpandedString::NoTabs("".into()), |
258 | } |
259 | } |
260 | |
261 | /// Indicates that the progress bar finished. |
262 | pub fn is_finished(&self) -> bool { |
263 | match self.status { |
264 | Status::InProgress => false, |
265 | Status::DoneVisible => true, |
266 | Status::DoneHidden => true, |
267 | } |
268 | } |
269 | |
270 | /// Returns the completion as a floating-point number between 0 and 1 |
271 | pub fn fraction(&self) -> f32 { |
272 | let pos = self.pos.pos.load(Ordering::Relaxed); |
273 | let pct = match (pos, self.len) { |
274 | (_, None) => 0.0, |
275 | (_, Some(0)) => 1.0, |
276 | (0, _) => 0.0, |
277 | (pos, Some(len)) => pos as f32 / len as f32, |
278 | }; |
279 | pct.clamp(0.0, 1.0) |
280 | } |
281 | |
282 | /// The expected ETA |
283 | pub fn eta(&self) -> Duration { |
284 | if self.is_finished() { |
285 | return Duration::new(0, 0); |
286 | } |
287 | |
288 | let len = match self.len { |
289 | Some(len) => len, |
290 | None => return Duration::new(0, 0), |
291 | }; |
292 | |
293 | let pos = self.pos.pos.load(Ordering::Relaxed); |
294 | |
295 | let sps = self.est.steps_per_second(Instant::now()); |
296 | |
297 | // Infinite duration should only ever happen at the beginning, so in this case it's okay to |
298 | // just show an ETA of 0 until progress starts to occur. |
299 | if sps == 0.0 { |
300 | return Duration::new(0, 0); |
301 | } |
302 | |
303 | secs_to_duration(len.saturating_sub(pos) as f64 / sps) |
304 | } |
305 | |
306 | /// The expected total duration (that is, elapsed time + expected ETA) |
307 | pub fn duration(&self) -> Duration { |
308 | if self.len.is_none() || self.is_finished() { |
309 | return Duration::new(0, 0); |
310 | } |
311 | self.started.elapsed().saturating_add(self.eta()) |
312 | } |
313 | |
314 | /// The number of steps per second |
315 | pub fn per_sec(&self) -> f64 { |
316 | if let Status::InProgress = self.status { |
317 | self.est.steps_per_second(Instant::now()) |
318 | } else { |
319 | self.pos() as f64 / self.started.elapsed().as_secs_f64() |
320 | } |
321 | } |
322 | |
323 | pub fn elapsed(&self) -> Duration { |
324 | self.started.elapsed() |
325 | } |
326 | |
327 | pub fn pos(&self) -> u64 { |
328 | self.pos.pos.load(Ordering::Relaxed) |
329 | } |
330 | |
331 | pub fn set_pos(&mut self, pos: u64) { |
332 | self.pos.set(pos); |
333 | } |
334 | |
335 | #[allow(clippy::len_without_is_empty)] |
336 | pub fn len(&self) -> Option<u64> { |
337 | self.len |
338 | } |
339 | |
340 | pub fn set_len(&mut self, len: u64) { |
341 | self.len = Some(len); |
342 | } |
343 | } |
344 | |
345 | #[derive(Debug, PartialEq, Eq, Clone)] |
346 | pub(crate) enum TabExpandedString { |
347 | NoTabs(Cow<'static, str>), |
348 | WithTabs { |
349 | original: Cow<'static, str>, |
350 | expanded: String, |
351 | tab_width: usize, |
352 | }, |
353 | } |
354 | |
355 | impl TabExpandedString { |
356 | pub(crate) fn new(s: Cow<'static, str>, tab_width: usize) -> Self { |
357 | let expanded = s.replace('\t ', & " ".repeat(tab_width)); |
358 | if s == expanded { |
359 | Self::NoTabs(s) |
360 | } else { |
361 | Self::WithTabs { |
362 | original: s, |
363 | expanded, |
364 | tab_width, |
365 | } |
366 | } |
367 | } |
368 | |
369 | pub(crate) fn expanded(&self) -> &str { |
370 | match &self { |
371 | Self::NoTabs(s) => { |
372 | debug_assert!(!s.contains('\t ')); |
373 | s |
374 | } |
375 | Self::WithTabs { expanded, .. } => expanded, |
376 | } |
377 | } |
378 | |
379 | pub(crate) fn set_tab_width(&mut self, new_tab_width: usize) { |
380 | if let Self::WithTabs { |
381 | original, |
382 | expanded, |
383 | tab_width, |
384 | } = self |
385 | { |
386 | if *tab_width != new_tab_width { |
387 | *tab_width = new_tab_width; |
388 | *expanded = original.replace('\t ', & " ".repeat(new_tab_width)); |
389 | } |
390 | } |
391 | } |
392 | } |
393 | |
394 | /// Double-smoothed exponentially weighted estimator |
395 | /// |
396 | /// This uses an exponentially weighted *time-based* estimator, meaning that it exponentially |
397 | /// downweights old data based on its age. The rate at which this occurs is currently a constant |
398 | /// value of 15 seconds for 90% weighting. This means that all data older than 15 seconds has a |
399 | /// collective weight of 0.1 in the estimate, and all data older than 30 seconds has a collective |
400 | /// weight of 0.01, and so on. |
401 | /// |
402 | /// The primary value exposed by `Estimator` is `steps_per_second`. This value is doubly-smoothed, |
403 | /// meaning that is the result of using an exponentially weighted estimator (as described above) to |
404 | /// estimate the value of another exponentially weighted estimator, which estimates the value of |
405 | /// the raw data. |
406 | /// |
407 | /// The purpose of this extra smoothing step is to reduce instantaneous fluctations in the estimate |
408 | /// when large updates are received. Without this, estimates might have a large spike followed by a |
409 | /// slow asymptotic approach to zero (until the next spike). |
410 | #[derive(Debug)] |
411 | pub(crate) struct Estimator { |
412 | smoothed_steps_per_sec: f64, |
413 | double_smoothed_steps_per_sec: f64, |
414 | prev_steps: u64, |
415 | prev_time: Instant, |
416 | start_time: Instant, |
417 | } |
418 | |
419 | impl Estimator { |
420 | fn new(now: Instant) -> Self { |
421 | Self { |
422 | smoothed_steps_per_sec: 0.0, |
423 | double_smoothed_steps_per_sec: 0.0, |
424 | prev_steps: 0, |
425 | prev_time: now, |
426 | start_time: now, |
427 | } |
428 | } |
429 | |
430 | fn record(&mut self, new_steps: u64, now: Instant) { |
431 | // sanity check: don't record data if time or steps have not advanced |
432 | if new_steps <= self.prev_steps || now <= self.prev_time { |
433 | // Reset on backwards seek to prevent breakage from seeking to the end for length determination |
434 | // See https://github.com/console-rs/indicatif/issues/480 |
435 | if new_steps < self.prev_steps { |
436 | self.prev_steps = new_steps; |
437 | self.reset(now); |
438 | } |
439 | return; |
440 | } |
441 | |
442 | let delta_steps = new_steps - self.prev_steps; |
443 | let delta_t = duration_to_secs(now - self.prev_time); |
444 | |
445 | // the rate of steps we saw in this update |
446 | let new_steps_per_second = delta_steps as f64 / delta_t; |
447 | |
448 | // update the estimate: a weighted average of the old estimate and new data |
449 | let weight = estimator_weight(delta_t); |
450 | self.smoothed_steps_per_sec = |
451 | self.smoothed_steps_per_sec * weight + new_steps_per_second * (1.0 - weight); |
452 | |
453 | // An iterative estimate like `smoothed_steps_per_sec` is supposed to be an exponentially |
454 | // weighted average from t=0 back to t=-inf; Since we initialize it to 0, we neglect the |
455 | // (non-existent) samples in the weighted average prior to the first one, so the resulting |
456 | // average must be normalized. We normalize the single estimate here in order to use it as |
457 | // a source for the double smoothed estimate. See comment on normalization in |
458 | // `steps_per_second` for details. |
459 | let delta_t_start = duration_to_secs(now - self.start_time); |
460 | let total_weight = 1.0 - estimator_weight(delta_t_start); |
461 | let normalized_smoothed_steps_per_sec = self.smoothed_steps_per_sec / total_weight; |
462 | |
463 | // determine the double smoothed value (EWA smoothing of the single EWA) |
464 | self.double_smoothed_steps_per_sec = self.double_smoothed_steps_per_sec * weight |
465 | + normalized_smoothed_steps_per_sec * (1.0 - weight); |
466 | |
467 | self.prev_steps = new_steps; |
468 | self.prev_time = now; |
469 | } |
470 | |
471 | /// Reset the state of the estimator. Once reset, estimates will not depend on any data prior |
472 | /// to `now`. This does not reset the stored position of the progress bar. |
473 | pub(crate) fn reset(&mut self, now: Instant) { |
474 | self.smoothed_steps_per_sec = 0.0; |
475 | self.double_smoothed_steps_per_sec = 0.0; |
476 | |
477 | // only reset prev_time, not prev_steps |
478 | self.prev_time = now; |
479 | self.start_time = now; |
480 | } |
481 | |
482 | /// Average time per step in seconds, using double exponential smoothing |
483 | fn steps_per_second(&self, now: Instant) -> f64 { |
484 | // Because the value stored in the Estimator is only updated when the Estimator receives an |
485 | // update, this value will become stuck if progress stalls. To return an accurate estimate, |
486 | // we determine how much time has passed since the last update, and treat this as a |
487 | // pseudo-update with 0 steps. |
488 | let delta_t = duration_to_secs(now - self.prev_time); |
489 | let reweight = estimator_weight(delta_t); |
490 | |
491 | // Normalization of estimates: |
492 | // |
493 | // The raw estimate is a single value (smoothed_steps_per_second) that is iteratively |
494 | // updated. At each update, the previous value of the estimate is downweighted according to |
495 | // its age, receiving the iterative weight W(t) = 0.1 ^ (t/15). |
496 | // |
497 | // Since W(Sum(t_n)) = Prod(W(t_n)), the total weight of a sample after a series of |
498 | // iterative steps is simply W(t_e) - W(t_b), where t_e is the time since the end of the |
499 | // sample, and t_b is the time since the beginning. The resulting estimate is therefore a |
500 | // weighted average with sample weights W(t_e) - W(t_b). |
501 | // |
502 | // Notice that the weighting function generates sample weights that sum to 1 only when the |
503 | // sample times span from t=0 to t=inf; but this is not the case. We have a first sample |
504 | // with finite, positive t_b = t_f. In the raw estimate, we handle times prior to t_f by |
505 | // setting an initial value of 0, meaning that these (non-existent) samples have no weight. |
506 | // |
507 | // Therefore, the raw estimate must be normalized by dividing it by the sum of the weights |
508 | // in the weighted average. This sum is just W(0) - W(t_f), where t_f is the time since the |
509 | // first sample, and W(0) = 1. |
510 | let delta_t_start = duration_to_secs(now - self.start_time); |
511 | let total_weight = 1.0 - estimator_weight(delta_t_start); |
512 | |
513 | // Generate updated values for `smoothed_steps_per_sec` and `double_smoothed_steps_per_sec` |
514 | // (sps and dsps) without storing them. Note that we normalize sps when using it as a |
515 | // source to update dsps, and then normalize dsps itself before returning it. |
516 | let sps = self.smoothed_steps_per_sec * reweight / total_weight; |
517 | let dsps = self.double_smoothed_steps_per_sec * reweight + sps * (1.0 - reweight); |
518 | dsps / total_weight |
519 | } |
520 | } |
521 | |
522 | pub(crate) struct AtomicPosition { |
523 | pub(crate) pos: AtomicU64, |
524 | capacity: AtomicU8, |
525 | prev: AtomicU64, |
526 | start: Instant, |
527 | } |
528 | |
529 | impl AtomicPosition { |
530 | pub(crate) fn new() -> Self { |
531 | Self { |
532 | pos: AtomicU64::new(0), |
533 | capacity: AtomicU8::new(MAX_BURST), |
534 | prev: AtomicU64::new(0), |
535 | start: Instant::now(), |
536 | } |
537 | } |
538 | |
539 | pub(crate) fn allow(&self, now: Instant) -> bool { |
540 | if now < self.start { |
541 | return false; |
542 | } |
543 | |
544 | let mut capacity = self.capacity.load(Ordering::Acquire); |
545 | // `prev` is the number of ns after `self.started` we last returned `true` |
546 | let prev = self.prev.load(Ordering::Acquire); |
547 | // `elapsed` is the number of ns since `self.started` |
548 | let elapsed = (now - self.start).as_nanos() as u64; |
549 | // `diff` is the number of ns since we last returned `true` |
550 | let diff = elapsed.saturating_sub(prev); |
551 | |
552 | // If `capacity` is 0 and not enough time (1ms) has passed since `prev` |
553 | // to add new capacity, return `false`. The goal of this method is to |
554 | // make this decision as efficient as possible. |
555 | if capacity == 0 && diff < INTERVAL { |
556 | return false; |
557 | } |
558 | |
559 | // We now calculate `new`, the number of INTERVALs since we last returned `true`, |
560 | // and `remainder`, which represents a number of ns less than INTERVAL which we cannot |
561 | // convert into capacity now, so we're saving it for later. We do this by |
562 | // subtracting this from `elapsed` before storing it into `self.prev`. |
563 | let (new, remainder) = ((diff / INTERVAL), (diff % INTERVAL)); |
564 | // We add `new` to `capacity`, subtract one for returning `true` from here, |
565 | // then make sure it does not exceed a maximum of `MAX_BURST`. |
566 | capacity = Ord::min(MAX_BURST as u128, (capacity as u128) + (new as u128) - 1) as u8; |
567 | |
568 | // Then, we just store `capacity` and `prev` atomically for the next iteration |
569 | self.capacity.store(capacity, Ordering::Release); |
570 | self.prev.store(elapsed - remainder, Ordering::Release); |
571 | true |
572 | } |
573 | |
574 | fn reset(&self, now: Instant) { |
575 | self.set(0); |
576 | let elapsed = (now.saturating_duration_since(self.start)).as_nanos() as u64; |
577 | self.prev.store(elapsed, Ordering::Release); |
578 | } |
579 | |
580 | pub(crate) fn inc(&self, delta: u64) { |
581 | self.pos.fetch_add(delta, Ordering::SeqCst); |
582 | } |
583 | |
584 | pub(crate) fn set(&self, pos: u64) { |
585 | self.pos.store(pos, Ordering::Release); |
586 | } |
587 | } |
588 | |
589 | const INTERVAL: u64 = 1_000_000; |
590 | const MAX_BURST: u8 = 10; |
591 | |
592 | /// Behavior of a progress bar when it is finished |
593 | /// |
594 | /// This is invoked when a [`ProgressBar`] or [`ProgressBarIter`] completes and |
595 | /// [`ProgressBar::is_finished`] is false. |
596 | /// |
597 | /// [`ProgressBar`]: crate::ProgressBar |
598 | /// [`ProgressBarIter`]: crate::ProgressBarIter |
599 | /// [`ProgressBar::is_finished`]: crate::ProgressBar::is_finished |
600 | #[derive(Clone, Debug)] |
601 | pub enum ProgressFinish { |
602 | /// Finishes the progress bar and leaves the current message |
603 | /// |
604 | /// Same behavior as calling [`ProgressBar::finish()`](crate::ProgressBar::finish). |
605 | AndLeave, |
606 | /// Finishes the progress bar and sets a message |
607 | /// |
608 | /// Same behavior as calling [`ProgressBar::finish_with_message()`](crate::ProgressBar::finish_with_message). |
609 | WithMessage(Cow<'static, str>), |
610 | /// Finishes the progress bar and completely clears it (this is the default) |
611 | /// |
612 | /// Same behavior as calling [`ProgressBar::finish_and_clear()`](crate::ProgressBar::finish_and_clear). |
613 | AndClear, |
614 | /// Finishes the progress bar and leaves the current message and progress |
615 | /// |
616 | /// Same behavior as calling [`ProgressBar::abandon()`](crate::ProgressBar::abandon). |
617 | Abandon, |
618 | /// Finishes the progress bar and sets a message, and leaves the current progress |
619 | /// |
620 | /// Same behavior as calling [`ProgressBar::abandon_with_message()`](crate::ProgressBar::abandon_with_message). |
621 | AbandonWithMessage(Cow<'static, str>), |
622 | } |
623 | |
624 | impl Default for ProgressFinish { |
625 | fn default() -> Self { |
626 | Self::AndClear |
627 | } |
628 | } |
629 | |
630 | /// Get the appropriate dilution weight for Estimator data given the data's age (in seconds) |
631 | /// |
632 | /// Whenever an update occurs, we will create a new estimate using a weight `w_i` like so: |
633 | /// |
634 | /// ```math |
635 | /// <new estimate> = <previous estimate> * w_i + <new data> * (1 - w_i) |
636 | /// ``` |
637 | /// |
638 | /// In other words, the new estimate is a weighted average of the previous estimate and the new |
639 | /// data. We want to choose weights such that for any set of samples where `t_0, t_1, ...` are |
640 | /// the durations of the samples: |
641 | /// |
642 | /// ```math |
643 | /// Sum(t_i) = ews ==> Prod(w_i) = 0.1 |
644 | /// ``` |
645 | /// |
646 | /// With this constraint it is easy to show that |
647 | /// |
648 | /// ```math |
649 | /// w_i = 0.1 ^ (t_i / ews) |
650 | /// ``` |
651 | /// |
652 | /// Notice that the constraint implies that estimates are independent of the durations of the |
653 | /// samples, a very useful feature. |
654 | fn estimator_weight(age: f64) -> f64 { |
655 | const EXPONENTIAL_WEIGHTING_SECONDS: f64 = 15.0; |
656 | 0.1_f64.powf(age / EXPONENTIAL_WEIGHTING_SECONDS) |
657 | } |
658 | |
659 | fn duration_to_secs(d: Duration) -> f64 { |
660 | d.as_secs() as f64 + f64::from(d.subsec_nanos()) / 1_000_000_000f64 |
661 | } |
662 | |
663 | fn secs_to_duration(s: f64) -> Duration { |
664 | let secs: u64 = s.trunc() as u64; |
665 | let nanos: u32 = (s.fract() * 1_000_000_000f64) as u32; |
666 | Duration::new(secs, nanos) |
667 | } |
668 | |
669 | #[derive(Debug)] |
670 | pub(crate) enum Status { |
671 | InProgress, |
672 | DoneVisible, |
673 | DoneHidden, |
674 | } |
675 | |
676 | pub(crate) const DEFAULT_TAB_WIDTH: usize = 8; |
677 | |
678 | #[cfg(test)] |
679 | mod tests { |
680 | use super::*; |
681 | use crate::ProgressBar; |
682 | |
683 | // https://github.com/rust-lang/rust-clippy/issues/10281 |
684 | #[allow(clippy::uninlined_format_args)] |
685 | #[test] |
686 | fn test_steps_per_second() { |
687 | let test_rate = |items_per_second| { |
688 | let mut now = Instant::now(); |
689 | let mut est = Estimator::new(now); |
690 | let mut pos = 0; |
691 | |
692 | for _ in 0..20 { |
693 | pos += items_per_second; |
694 | now += Duration::from_secs(1); |
695 | est.record(pos, now); |
696 | } |
697 | let avg_steps_per_second = est.steps_per_second(now); |
698 | |
699 | assert!(avg_steps_per_second > 0.0); |
700 | assert!(avg_steps_per_second.is_finite()); |
701 | |
702 | let absolute_error = (avg_steps_per_second - items_per_second as f64).abs(); |
703 | let relative_error = absolute_error / items_per_second as f64; |
704 | assert!( |
705 | relative_error < 1.0 / 1e9, |
706 | "Expected rate: {}, actual: {}, relative error: {}", |
707 | items_per_second, |
708 | avg_steps_per_second, |
709 | relative_error |
710 | ); |
711 | }; |
712 | |
713 | test_rate(1); |
714 | test_rate(1_000); |
715 | test_rate(1_000_000); |
716 | test_rate(1_000_000_000); |
717 | test_rate(1_000_000_001); |
718 | test_rate(100_000_000_000); |
719 | test_rate(1_000_000_000_000); |
720 | test_rate(100_000_000_000_000); |
721 | test_rate(1_000_000_000_000_000); |
722 | } |
723 | |
724 | #[test] |
725 | fn test_double_exponential_ave() { |
726 | let mut now = Instant::now(); |
727 | let mut est = Estimator::new(now); |
728 | let mut pos = 0; |
729 | |
730 | // note: this is the default weight set in the Estimator |
731 | let weight = 15; |
732 | |
733 | for _ in 0..weight { |
734 | pos += 1; |
735 | now += Duration::from_secs(1); |
736 | est.record(pos, now); |
737 | } |
738 | now += Duration::from_secs(weight); |
739 | |
740 | // The first level EWA: |
741 | // -> 90% weight @ 0 eps, 9% weight @ 1 eps, 1% weight @ 0 eps |
742 | // -> then normalized by deweighting the 1% weight (before -30 seconds) |
743 | let single_target = 0.09 / 0.99; |
744 | |
745 | // The second level EWA: |
746 | // -> same logic as above, but using the first level EWA as the source |
747 | let double_target = (0.9 * single_target + 0.09) / 0.99; |
748 | assert_eq!(est.steps_per_second(now), double_target); |
749 | } |
750 | |
751 | #[test] |
752 | fn test_estimator_rewind_position() { |
753 | let mut now = Instant::now(); |
754 | let mut est = Estimator::new(now); |
755 | |
756 | now += Duration::from_secs(1); |
757 | est.record(1, now); |
758 | |
759 | // should not panic |
760 | now += Duration::from_secs(1); |
761 | est.record(0, now); |
762 | |
763 | // check that reset occurred (estimator at 1 event per sec) |
764 | now += Duration::from_secs(1); |
765 | est.record(1, now); |
766 | assert_eq!(est.steps_per_second(now), 1.0); |
767 | |
768 | // check that progress bar handles manual seeking |
769 | let pb = ProgressBar::hidden(); |
770 | pb.set_length(10); |
771 | pb.set_position(1); |
772 | pb.tick(); |
773 | // Should not panic. |
774 | pb.set_position(0); |
775 | } |
776 | |
777 | #[test] |
778 | fn test_reset_eta() { |
779 | let mut now = Instant::now(); |
780 | let mut est = Estimator::new(now); |
781 | |
782 | // two per second, then reset |
783 | now += Duration::from_secs(1); |
784 | est.record(2, now); |
785 | est.reset(now); |
786 | |
787 | // now one per second, and verify |
788 | now += Duration::from_secs(1); |
789 | est.record(3, now); |
790 | assert_eq!(est.steps_per_second(now), 1.0); |
791 | } |
792 | |
793 | #[test] |
794 | fn test_duration_stuff() { |
795 | let duration = Duration::new(42, 100_000_000); |
796 | let secs = duration_to_secs(duration); |
797 | assert_eq!(secs_to_duration(secs), duration); |
798 | } |
799 | |
800 | #[test] |
801 | fn test_atomic_position_large_time_difference() { |
802 | let atomic_position = AtomicPosition::new(); |
803 | let later = atomic_position.start + Duration::from_nanos(INTERVAL * u64::from(u8::MAX)); |
804 | // Should not panic. |
805 | atomic_position.allow(later); |
806 | } |
807 | |
808 | #[test] |
809 | fn test_atomic_position_reset() { |
810 | const ELAPSE_TIME: Duration = Duration::from_millis(20); |
811 | let mut pos = AtomicPosition::new(); |
812 | pos.reset(pos.start + ELAPSE_TIME); |
813 | |
814 | // prev should be exactly ELAPSE_TIME after reset |
815 | assert_eq!(*pos.pos.get_mut(), 0); |
816 | assert_eq!(*pos.prev.get_mut(), ELAPSE_TIME.as_nanos() as u64); |
817 | } |
818 | } |
819 |
Definitions
- BarState
- draw_target
- on_finish
- style
- state
- tab_width
- new
- finish_using_style
- reset
- update
- unset_length
- set_length
- inc_length
- set_tab_width
- set_style
- tick
- update_estimate_and_draw
- println
- suspend
- draw
- drop
- Reset
- Eta
- Elapsed
- All
- ProgressState
- pos
- len
- tick
- started
- status
- est
- message
- prefix
- new
- is_finished
- fraction
- eta
- duration
- per_sec
- elapsed
- pos
- set_pos
- len
- set_len
- TabExpandedString
- NoTabs
- WithTabs
- original
- expanded
- tab_width
- new
- expanded
- expanded
- set_tab_width
- original
- expanded
- tab_width
- Estimator
- smoothed_steps_per_sec
- double_smoothed_steps_per_sec
- prev_steps
- prev_time
- start_time
- new
- record
- reset
- steps_per_second
- AtomicPosition
- pos
- capacity
- prev
- start
- new
- allow
- reset
- inc
- set
- ProgressFinish
- AndLeave
- WithMessage
- AndClear
- Abandon
- AbandonWithMessage
- default
- estimator_weight
- duration_to_secs
- secs_to_duration
- Status
- InProgress
- DoneVisible
Learn Rust with the experts
Find out more