Cleanup checked_sub a bit

Author: domenukk

crates/libafl/src/events/mod.rs

@@ -482,7 +482,7 @@ where
     };
     let cur = current_time();
     // default to 0 here to avoid crashes on clock skew
-    if cur.checked_sub(*last_report_time).unwrap_or_default() > monitor_timeout {
+    if cur.saturating_sub(*last_report_time) > monitor_timeout {
         // report_progress sets a new `last_report_time` internally.
         reporter.report_progress(state)?;
     }

crates/libafl/src/executors/hooks/inprocess.rs

@@ -154,9 +154,7 @@ impl<I, S> HasTimeout for InProcessHooks<I, S> {
                         null_mut(),
                     );
                 }
-                let elapsed = cur_time
-                    .checked_sub(self.timer().tmout_start_time)
-                    .unwrap_or_default();
+                let elapsed = cur_time.saturating_sub(self.timer().tmout_start_time);
                 // set timer the next exec
                 if self.timer().executions > 0 {
                     self.timer_mut().avg_exec_time = elapsed / self.timer().executions;
@@ -167,9 +165,7 @@ impl<I, S> HasTimeout for InProcessHooks<I, S> {
                 return true;
             }
 
-            let elapsed_run = cur_time
-                .checked_sub(self.timer_mut().start_time)
-                .unwrap_or_default();
+            let elapsed_run = cur_time.saturating_sub(self.timer_mut().start_time);
             if elapsed_run < self.timer_mut().exec_tmout {
                 // fp, reset timeout
                 unsafe {
@@ -181,9 +177,7 @@ impl<I, S> HasTimeout for InProcessHooks<I, S> {
                     );
                 }
                 if self.timer().executions > 0 {
-                    let elapsed = cur_time
-                        .checked_sub(self.timer_mut().tmout_start_time)
-                        .unwrap_or_default();
+                    let elapsed = cur_time.saturating_sub(self.timer_mut().tmout_start_time);
                     self.timer_mut().avg_exec_time = elapsed / self.timer().executions;
                     self.timer_mut().executions = 0; // It will be 1 when the exec finish
                 }

crates/libafl/src/monitors/disk.rs

@@ -127,9 +127,7 @@ impl OnDiskTomlMonitor {
     {
         Self {
             filename: filename.into(),
-            last_update: current_time()
-                .checked_sub(update_interval)
-                .unwrap_or_default(),
+            last_update: current_time().saturating_sub(update_interval),
             update_interval,
         }
     }

crates/libafl/src/monitors/disk_aggregate.rs

@@ -93,9 +93,7 @@ impl OnDiskJsonAggregateMonitor {
     {
         Self {
             json_path: json_path.into(),
-            last_update: current_time()
-                .checked_sub(update_interval)
-                .unwrap_or_default(),
+            last_update: current_time().saturating_sub(update_interval),
             update_interval,
         }
     }

crates/libafl/src/monitors/prometheus.rs

@@ -253,8 +253,7 @@ where
             .set(cur_client_clone.execs_per_sec(current_time()));
 
         let client_run_time = current_time()
-            .checked_sub(cur_client_clone.start_time())
-            .unwrap_or_default()
+            .saturating_sub(cur_client_clone.start_time())
             .as_secs();
         self.prometheus_client_stats
             .runtime

crates/libafl/src/monitors/stats/manager.rs

@@ -170,7 +170,7 @@ impl ClientStatsManager {
 
         // Time-related data are always re-computed, since it is related with current time.
         let cur_time = current_time();
-        global_stats.run_time = cur_time.checked_sub(self.start_time).unwrap_or_default();
+        global_stats.run_time = cur_time.saturating_sub(self.start_time);
         global_stats.run_time_pretty = format_duration(&global_stats.run_time);
         global_stats.execs_per_sec = self
             .client_stats
@@ -199,14 +199,11 @@ impl ClientStatsManager {
                 new_objectives_time = stat.last_objective_time().max(new_objectives_time);
             }
             if new_path_time > self.start_time() {
-                total_process_timing.last_new_entry = current_time()
-                    .checked_sub(new_path_time)
-                    .unwrap_or_default();
+                total_process_timing.last_new_entry = current_time().saturating_sub(new_path_time);
             }
             if new_objectives_time > self.start_time() {
-                total_process_timing.last_saved_solution = current_time()
-                    .checked_sub(new_objectives_time)
-                    .unwrap_or_default();
+                total_process_timing.last_saved_solution =
+                    current_time().saturating_sub(new_objectives_time);
             }
         }
         total_process_timing

crates/libafl/src/monitors/stats/mod.rs

@@ -203,9 +203,7 @@ impl ClientStats {
     /// We got new information about executions for this client, insert them.
     #[cfg(feature = "afl_exec_sec")]
     pub fn update_executions(&mut self, executions: u64, cur_time: Duration) {
-        let diff = cur_time
-            .checked_sub(self.last_window_time)
-            .map_or(0, |d| d.as_secs());
+        let diff = cur_time.saturating_sub(self.last_window_time).as_secs();
         if diff > CLIENT_STATS_TIME_WINDOW_SECS {
             let _: f64 = self.execs_per_sec(cur_time);
             self.last_window_time = cur_time;
@@ -254,9 +252,7 @@ impl ClientStats {
             return 0.0;
         }
 
-        let elapsed = cur_time
-            .checked_sub(self.last_window_time)
-            .map_or(0.0, |d| d.as_secs_f64());
+        let elapsed = cur_time.saturating_sub(self.last_window_time).as_secs_f64();
         if elapsed as u64 == 0 {
             return self.last_execs_per_sec;
         }
@@ -286,9 +282,7 @@ impl ClientStats {
             return 0.0;
         }
 
-        let elapsed = cur_time
-            .checked_sub(self.last_window_time)
-            .map_or(0.0, |d| d.as_secs_f64());
+        let elapsed = cur_time.saturating_sub(self.last_window_time).as_secs_f64();
         if elapsed as u64 == 0 {
             return 0.0;
         }
@@ -330,17 +324,13 @@ impl ClientStats {
     pub fn process_timing(&mut self) -> ProcessTiming {
         let client_start_time = self.start_time();
         let last_new_entry = if self.last_corpus_time() > self.start_time() {
-            current_time()
-                .checked_sub(self.last_corpus_time())
-                .unwrap_or_default()
+            current_time().saturating_sub(self.last_corpus_time())
         } else {
             Duration::default()
         };
 
         let last_saved_solution = if self.last_objective_time() > self.start_time() {
-            current_time()
-                .checked_sub(self.last_objective_time())
-                .unwrap_or_default()
+            current_time().saturating_sub(self.last_objective_time())
         } else {
             Duration::default()
         };

crates/libafl/src/monitors/tui/mod.rs

@@ -137,8 +137,8 @@ impl TimedStats {
                 .back()
                 .unwrap_or(&default_stat)
                 .time
-                .checked_sub(self.series.front().unwrap_or(&default_stat).time)
-                .unwrap()
+                .saturating_sub(self.series.front().unwrap_or(&default_stat).time)
+                .unwrap_or(window)
                 >= window
         {
             self.series.pop_front();
@@ -562,9 +562,7 @@ fn run_tui_thread<W: Write + Send + Sync + 'static>(
             }
             terminal.draw(|f| ui.draw(f, &context))?;
 
-            let timeout = tick_rate
-                .checked_sub(last_tick.elapsed())
-                .unwrap_or_else(|| Duration::from_secs(0));
+            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
             if event::poll(timeout)?
                 && let Event::Key(key) = event::read()?
             {

crates/libafl/src/monitors/tui/ui.rs

@@ -319,7 +319,7 @@ impl TuiUi {
         let start = stats.series.front().unwrap().time;
         let end = stats.series.back().unwrap().time;
         let min_lbl_x = format_duration(&start);
-        let med_lbl_x = format_duration(&(end.checked_sub(start).unwrap_or_default() / 2));
+        let med_lbl_x = format_duration(&(end.saturating_sub(start) / 2));
         let max_lbl_x = format_duration(&end);
 
         let x_labels = vec![
@@ -329,7 +329,7 @@ impl TuiUi {
         ];
 
         let max_x = u64::from(area.width);
-        let window = end.checked_sub(start).unwrap_or_default();
+        let window = end.saturating_sub(start);
         let time_unit = if max_x > window.as_secs() {
             0 // millis / 10
         } else if max_x > window.as_secs() * 60 {
@@ -539,7 +539,7 @@ impl TuiUi {
             Row::new(vec![
                 Cell::from(Span::raw("run time")),
                 Cell::from(Span::raw(format_duration(
-                    &current_time().checked_sub(tup.0).unwrap_or_default(),
+                    &current_time().saturating_sub(tup.0),
                 ))),
             ]),
             Row::new(vec![

crates/libafl/src/mutators/mutations.rs

@@ -1971,8 +1971,7 @@ mod tests {
         assert!(counts.into_iter().all(|count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }));
         Ok(())
@@ -2021,8 +2020,7 @@ mod tests {
         assert!(counts.into_iter().all(|count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }));
         Ok(())
@@ -2067,16 +2065,14 @@ mod tests {
         assert!(counts.into_iter().all(|count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }));
         let average = insertions.iter().copied().sum::<usize>() / insertions.len();
         assert!(insertions.into_iter().all(|count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }));
         Ok(())
@@ -2124,16 +2120,14 @@ mod tests {
         assert!(counts.iter().all(|&count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }),);
         let average = insertions.iter().copied().sum::<usize>() / insertions.len();
         assert!(insertions.into_iter().all(|count| {
             count
                 .checked_sub(average)
-                .or_else(|| average.checked_sub(count))
-                .unwrap()
+                .unwrap_or_else(|| average.saturating_sub(count))
                 < 500
         }));
         Ok(())