chore: update rustfmt & rust-toolchain

Signed-off-by: Wenxuan Zhang <[email protected]>

Author: wfxr

.rustfmt.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+components = ["rustfmt", "clippy", "rust-analyzer"]

rust-toolchain.toml

@@ -0,0 +1,13 @@
+edition = "2021"
+max_width = 120
+reorder_imports = true
+struct_lit_width = 60
+struct_variant_width = 60
+
+# struct_field_align_threshold = 40
+# comment_width = 120
+# fn_single_line = false
+# imports_layout = "HorizontalVertical"
+# match_arm_blocks = false
+# overflow_delimited_expr = true
+# imports_granularity = "Crate"

rustfmt.toml

@@ -14,8 +14,8 @@ use crate::{
 
 pub struct SilentCollector {
     bench_opts: BenchOpts,
-    res_rx:     UnboundedReceiver<Result<IterReport>>,
-    cancel:     CancellationToken,
+    res_rx: UnboundedReceiver<Result<IterReport>>,
+    cancel: CancellationToken,
 }
 
 impl SilentCollector {

src/collector/silent.rs

@@ -3,8 +3,7 @@ use async_trait::async_trait;
 use crossterm::{
     cursor,
     event::{Event, KeyCode, KeyEvent, KeyModifiers},
-    terminal,
-    ExecutableCommand,
+    terminal, ExecutableCommand,
 };
 use itertools::Itertools;
 use ratatui::{
@@ -13,8 +12,7 @@ use ratatui::{
     style::{Color, Style, Stylize},
     text::Line,
     widgets::{block::Title, BarChart, Block, Borders, Clear, Gauge, Padding, Paragraph},
-    CompletedFrame,
-    Frame,
+    CompletedFrame, Frame,
 };
 use std::{collections::HashMap, fmt, io, time::Duration};
 use tokio::{
@@ -35,10 +33,10 @@ use crate::{
 
 pub struct TuiCollector {
     pub bench_opts: BenchOpts,
-    pub fps:        u8,
-    pub res_rx:     mpsc::UnboundedReceiver<Result<IterReport>>,
-    pub pause:      watch::Sender<bool>,
-    pub cancel:     CancellationToken,
+    pub fps: u8,
+    pub res_rx: mpsc::UnboundedReceiver<Result<IterReport>>,
+    pub pause: watch::Sender<bool>,
+    pub cancel: CancellationToken,
 }
 
 impl TuiCollector {
@@ -274,10 +272,13 @@ fn render_stats_rate(counter: &Counter, elapsed: Duration) -> Paragraph<'static>
     let lines = vec![
         Line::from(format!("{:.2} iters/s", counter.iters as f64 / secs)),
         Line::from(format!("{:.2} items/s", counter.items as f64 / secs)),
-        Line::from(format!("{}/s", match (counter.bytes as f64 / secs).to_bytes() {
-            Ok(bps) => format!("{:.2}", bps),
-            Err(_) => "NaN B".to_string(),
-        })),
+        Line::from(format!(
+            "{}/s",
+            match (counter.bytes as f64 / secs).to_bytes() {
+                Ok(bps) => format!("{:.2}", bps),
+                Err(_) => "NaN B".to_string(),
+            }
+        )),
     ];
     Paragraph::new(lines).block(Block::new().borders(Borders::NONE))
 }
@@ -450,9 +451,9 @@ fn render_latency_hist(frame: &mut Frame, area: Rect, hist: &LatencyHistogram, h
         return;
     }
     let area = Rect {
-        x:      area.x + area.width - width as u16,
-        y:      area.y,
-        width:  width as u16,
+        x: area.x + area.width - width as u16,
+        y: area.y,
+        width: width as u16,
         height: content.len() as u16,
     };
     let content = content.into_iter().map(Line::from).collect_vec();

src/collector/tui.rs

@@ -11,18 +11,18 @@ use crate::{
 #[derive(Debug, Clone)]
 pub struct IterReport {
     pub duration: Duration,
-    pub status:   Status,
-    pub bytes:    u64,
-    pub items:    u64,
+    pub status: Status,
+    pub bytes: u64,
+    pub items: u64,
 }
 
 pub struct BenchReport {
     pub concurrency: u32,
-    pub hist:        LatencyHistogram,
-    pub stats:       IterStats,
+    pub hist: LatencyHistogram,
+    pub stats: IterStats,
     pub status_dist: HashMap<Status, u64>,
-    pub error_dist:  HashMap<String, u64>,
-    pub elapsed:     Duration,
+    pub error_dist: HashMap<String, u64>,
+    pub elapsed: Duration,
 }
 
 impl BenchReport {

src/report.rs

@@ -13,18 +13,18 @@ impl BenchReporter for JsonReporter {
         let counter = &report.stats.counter;
         let summary = Summary {
             success_ratio: report.success_ratio(),
-            total_time:    elapsed,
-            concurrency:   report.concurrency,
+            total_time: elapsed,
+            concurrency: report.concurrency,
 
             iters: ItersSummary {
-                total:          counter.iters,
-                rate:           counter.iters as f64 / elapsed,
+                total: counter.iters,
+                rate: counter.iters as f64 / elapsed,
                 bytes_per_iter: counter.bytes.checked_div(counter.iters),
             },
 
             items: ItemsSummary {
-                total:          counter.items,
-                rate:           counter.items as f64 / elapsed,
+                total: counter.items,
+                rate: counter.items as f64 / elapsed,
                 items_per_iter: counter.items as f64 / counter.iters as f64,
                 bytes_per_item: counter.bytes.checked_div(counter.items),
             },
@@ -36,19 +36,19 @@ impl BenchReporter for JsonReporter {
             None
         } else {
             Latency {
-                stats:       LatencyStats {
-                    min:    report.hist.min().as_secs_f64(),
-                    max:    report.hist.max().as_secs_f64(),
-                    mean:   report.hist.mean().as_secs_f64(),
+                stats: LatencyStats {
+                    min: report.hist.min().as_secs_f64(),
+                    max: report.hist.max().as_secs_f64(),
+                    mean: report.hist.mean().as_secs_f64(),
                     median: report.hist.median().as_secs_f64(),
-                    stdev:  report.hist.stdev().as_secs_f64(),
+                    stdev: report.hist.stdev().as_secs_f64(),
                 },
                 percentiles: report
                     .hist
                     .percentiles(PERCENTAGES)
                     .map(|(p, v)| (format!("p{p}"), v.as_secs_f64()))
                     .collect(),
-                histogram:   report
+                histogram: report
                     .hist
                     .quantiles()
                     .map(|(k, v)| (k.as_secs_f64().to_string(), v))
@@ -57,12 +57,15 @@ impl BenchReporter for JsonReporter {
             .into()
         };
 
-        serde_json::to_writer_pretty(&mut *w, &Report {
-            summary,
-            latency,
-            status: report.status_dist.iter().map(|(k, &v)| (k.to_string(), v)).collect(),
-            errors: report.error_dist.iter().map(|(k, &v)| (k.clone(), v)).collect(),
-        })?;
+        serde_json::to_writer_pretty(
+            &mut *w,
+            &Report {
+                summary,
+                latency,
+                status: report.status_dist.iter().map(|(k, &v)| (k.to_string(), v)).collect(),
+                errors: report.error_dist.iter().map(|(k, &v)| (k.clone(), v)).collect(),
+            },
+        )?;
 
         writeln!(w)?;
         Ok(())
@@ -72,8 +75,8 @@ impl BenchReporter for JsonReporter {
 #[derive(Serialize)]
 struct Summary {
     success_ratio: f64,
-    total_time:    f64,
-    concurrency:   u32,
+    total_time: f64,
+    concurrency: u32,
 
     iters: ItersSummary,
     items: ItemsSummary,
@@ -82,16 +85,16 @@ struct Summary {
 
 #[derive(Serialize)]
 struct ItersSummary {
-    total:          u64,
-    rate:           f64,
+    total: u64,
+    rate: f64,
     #[serde(skip_serializing_if = "Option::is_none")]
     bytes_per_iter: Option<u64>,
 }
 
 #[derive(Serialize)]
 struct ItemsSummary {
-    total:          u64,
-    rate:           f64,
+    total: u64,
+    rate: f64,
     #[serde(skip_serializing_if = "not_normal_f64")]
     items_per_iter: f64,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -101,32 +104,32 @@ struct ItemsSummary {
 #[derive(Serialize)]
 struct BytesSummary {
     total: u64,
-    rate:  f64,
+    rate: f64,
 }
 
 #[derive(Serialize)]
 pub struct LatencyStats {
-    min:    f64,
-    max:    f64,
-    mean:   f64,
+    min: f64,
+    max: f64,
+    mean: f64,
     median: f64,
-    stdev:  f64,
+    stdev: f64,
 }
 
 #[derive(Serialize)]
 pub struct Latency {
-    stats:       LatencyStats,
+    stats: LatencyStats,
     percentiles: BTreeMap<String, f64>,
-    histogram:   BTreeMap<String, u64>,
+    histogram: BTreeMap<String, u64>,
 }
 
 #[derive(Serialize)]
 struct Report {
     summary: Summary,
     #[serde(skip_serializing_if = "Option::is_none")]
     latency: Option<Latency>,
-    status:  BTreeMap<String, u64>,
-    errors:  BTreeMap<String, u64>,
+    status: BTreeMap<String, u64>,
+    errors: BTreeMap<String, u64>,
 }
 
 fn not_normal_f64(v: &f64) -> bool {

src/reporter/json.rs

@@ -20,11 +20,11 @@ use crate::report::IterReport;
 
 #[derive(Copy, Clone, Debug)]
 pub struct BenchOpts {
-    pub start:       Instant,
+    pub start: Instant,
     pub concurrency: u32,
-    pub iterations:  Option<u64>,
-    pub duration:    Option<Duration>,
-    pub rate:        Option<u32>, // iterations per second
+    pub iterations: Option<u64>,
+    pub duration: Option<Duration>,
+    pub rate: Option<u32>, // iterations per second
 }
 
 impl BenchOpts {
@@ -50,17 +50,17 @@ pub struct Runner<BS>
 where
     BS: BenchSuite,
 {
-    suite:   BS,
-    opts:    BenchOpts,
-    res_tx:  mpsc::UnboundedSender<Result<IterReport>>,
-    pause:   watch::Receiver<bool>,
-    cancel:  CancellationToken,
+    suite: BS,
+    opts: BenchOpts,
+    res_tx: mpsc::UnboundedSender<Result<IterReport>>,
+    pause: watch::Receiver<bool>,
+    cancel: CancellationToken,
     counter: Arc<AtomicU64>,
 }
 
 pub struct WorkerState {
-    rng:        StdRng,
-    worker_id:  u32,
+    rng: StdRng,
+    worker_id: u32,
     worker_seq: u64,
     global_seq: u64,
 }

src/runner.rs

@@ -4,9 +4,9 @@ use crate::report::IterReport;
 
 #[derive(Default, Clone, Copy, Debug)]
 pub struct Counter {
-    pub iters:    u64,
-    pub items:    u64,
-    pub bytes:    u64,
+    pub iters: u64,
+    pub items: u64,
+    pub bytes: u64,
     pub duration: Duration,
 }
 

src/stats/counter.rs

@@ -11,7 +11,7 @@ use super::IterStats;
 
 pub struct RotateWindow {
     buckets: VecDeque<IterStats>,
-    size:    usize,
+    size: usize,
 }
 
 impl RotateWindow {
@@ -58,10 +58,10 @@ impl RotateWindow {
 }
 
 pub struct RotateWindowGroup {
-    frame:              Instant,
-    pub stats_by_sec:   RotateWindow,
+    frame: Instant,
+    pub stats_by_sec: RotateWindow,
     pub stats_by_10sec: RotateWindow,
-    pub stats_by_min:   RotateWindow,
+    pub stats_by_min: RotateWindow,
     pub stats_by_10min: RotateWindow,
 }
 
@@ -102,11 +102,11 @@ impl RotateWindowGroup {
 }
 
 pub struct RotateDiffWindowGroup {
-    frame:            Instant,
-    interval:         Duration,
-    stats_last_sec:   RotateWindow,
+    frame: Instant,
+    interval: Duration,
+    stats_last_sec: RotateWindow,
     stats_last_10sec: RotateWindow,
-    stats_last_min:   RotateWindow,
+    stats_last_min: RotateWindow,
     stats_last_10min: RotateWindow,
 }