use std::io;
use std::sync::atomic::Ordering;
use std::time::{Duration, Instant};
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Cell, Gauge, Paragraph, Row, Sparkline, Table, Tabs};
use ratatui::{DefaultTerminal, Frame};
use super::layout::{bar, fmt_ms, fmt_tick, fmt_us, grouped, short_duration};
use super::metrics::{Buckets, Ledger, Placement, RateRing, MAX_BUCKET_ROWS, MIN_RATE_SAMPLES};
use super::{BenchConfig, Shared};
#[derive(Clone, Copy, PartialEq, Eq)]
enum Pane {
Placement,
Workers,
Failures,
}
impl Pane {
const ALL: [Pane; 3] = [Pane::Placement, Pane::Workers, Pane::Failures];
fn title(&self) -> &'static str {
match self {
Pane::Placement => "placement",
Pane::Workers => "workers",
Pane::Failures => "failures",
}
}
fn next(self) -> Pane {
match self {
Pane::Placement => Pane::Workers,
Pane::Workers => Pane::Failures,
Pane::Failures => Pane::Placement,
}
}
}
pub(crate) enum Exit {
Finished,
Quit,
}
struct App<'a> {
config: &'a BenchConfig,
shared: &'a Shared,
start: Instant,
total: u64,
workers: u64,
pane: Pane,
paused: bool,
scroll: usize,
frozen: Option<Snapshot>,
}
struct Snapshot {
done: u64,
ok: u64,
failed: u64,
elapsed: Duration,
samples: Vec<u64>,
ledger: Ledger,
rates: RateRing,
failures: Vec<(String, u64)>,
}
impl App<'_> {
fn read(&self) -> Snapshot {
Snapshot {
done: self.shared.completed.load(Ordering::Relaxed),
ok: self.shared.successful.load(Ordering::Relaxed),
failed: self.shared.failed.load(Ordering::Relaxed),
elapsed: self.start.elapsed(),
samples: self
.shared
.latencies
.lock()
.map(|l| l.clone())
.unwrap_or_default(),
ledger: self
.shared
.ledger
.lock()
.map(|l| l.clone())
.unwrap_or_default(),
rates: self
.shared
.rates
.lock()
.map(|r| r.clone())
.unwrap_or_default(),
failures: {
let mut v: Vec<(String, u64)> = self
.shared
.failure_reasons
.lock()
.map(|f| f.iter().map(|(r, c)| (r.clone(), *c)).collect())
.unwrap_or_default();
v.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
v
},
}
}
}
const MAX_WIDTH: u16 = 180;
const SPARK_ROWS: u16 = 6;
const MAX_DIST_HEIGHT: u16 = 18;
const MAX_PANEL_HEIGHT: u16 = 18;
const GREY: Color = Color::Indexed(245);
const FREE: Color = Color::Indexed(41);
const BILLED: Color = Color::Indexed(178);
const ACCENT: Color = Color::Indexed(80);
fn label<T: Into<String>>(s: T) -> Span<'static> {
Span::styled(s.into(), Style::default().fg(GREY))
}
pub(crate) fn run(
config: &BenchConfig,
shared: &Shared,
start: Instant,
total: u64,
workers: u64,
) -> io::Result<Exit> {
let mut terminal = ratatui::init();
let mut app = App {
config,
shared,
start,
total,
workers,
pane: Pane::Placement,
paused: false,
scroll: 0,
frozen: None,
};
let outcome = event_loop(&mut terminal, &mut app);
ratatui::restore();
outcome
}
fn event_loop(terminal: &mut DefaultTerminal, app: &mut App) -> io::Result<Exit> {
loop {
let done = app.shared.completed.load(Ordering::Relaxed);
if done >= app.total || app.shared.stop.load(Ordering::Relaxed) {
let snap = app.read();
if let Ok(mut r) = app.shared.rates.lock() {
r.sample(snap.done, snap.elapsed);
}
terminal.draw(|f| draw(f, app, &snap))?;
return Ok(Exit::Finished);
}
let snap = match (&app.frozen, app.paused) {
(Some(s), true) => Snapshot {
done: s.done,
ok: s.ok,
failed: s.failed,
elapsed: s.elapsed,
samples: s.samples.clone(),
ledger: s.ledger.clone(),
rates: s.rates.clone(),
failures: s.failures.clone(),
},
_ => {
let s = app.read();
if let Ok(mut r) = app.shared.rates.lock() {
r.sample(s.done, s.elapsed);
}
s
}
};
terminal.draw(|f| draw(f, app, &snap))?;
if event::poll(Duration::from_millis(100))? {
if let Event::Key(key) = event::read()? {
if key.kind != KeyEventKind::Release && handle_key(app, key) {
return Ok(Exit::Quit);
}
}
}
}
}
fn handle_key(app: &mut App, key: KeyEvent) -> bool {
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
match key.code {
KeyCode::Char('q') | KeyCode::Esc => return true,
KeyCode::Char('c') if ctrl => return true,
KeyCode::Char('p') | KeyCode::Char(' ') => {
app.paused = !app.paused;
app.frozen = match app.paused {
true => Some(app.read()),
false => None,
};
}
KeyCode::Tab | KeyCode::Right => {
app.pane = app.pane.next();
app.scroll = 0;
}
KeyCode::BackTab | KeyCode::Left => {
app.pane = app.pane.next().next();
app.scroll = 0;
}
KeyCode::Char('1') => app.pane = Pane::Placement,
KeyCode::Char('2') => app.pane = Pane::Workers,
KeyCode::Char('3') => app.pane = Pane::Failures,
KeyCode::Down | KeyCode::Char('j') => app.scroll = app.scroll.saturating_add(1),
KeyCode::Up | KeyCode::Char('k') => app.scroll = app.scroll.saturating_sub(1),
_ => {}
}
false
}
fn draw(f: &mut Frame, app: &App, snap: &Snapshot) {
const HEADER: u16 = 3;
const PROGRESS: u16 = 4;
const KEYS: u16 = 1;
const DIST_MIN: u16 = 9;
let area = Rect {
width: f.area().width.min(MAX_WIDTH),
..f.area()
};
let lat_rows = Buckets::of(&snap.samples, MAX_BUCKET_ROWS)
.interesting()
.count() as u16;
let thr_rows = match snap.rates.per_second().len() < MIN_RATE_SAMPLES {
true => 0,
false => Buckets::linear(snap.rates.per_second(), 6)
.interesting()
.count() as u16,
};
let dist_h = (2 + lat_rows.max(SPARK_ROWS + thr_rows)).clamp(DIST_MIN, MAX_DIST_HEIGHT);
let panel_rows = match app.pane {
Pane::Placement => snap.ledger.rows().len() as u16 + 4,
Pane::Workers => snap.ledger.worker_names().len() as u16 + 2,
Pane::Failures => snap.failures.len().max(1) as u16 + 2,
};
let panel_h = (2 + panel_rows).clamp(6, MAX_PANEL_HEIGHT);
let height = area.height;
let tall = height >= HEADER + PROGRESS + DIST_MIN + 6 + KEYS;
let areas = match tall {
true => Layout::vertical([
Constraint::Length(HEADER),
Constraint::Length(PROGRESS),
Constraint::Length(dist_h),
Constraint::Length(panel_h),
Constraint::Min(0),
Constraint::Length(KEYS),
])
.split(area),
false => Layout::vertical([
Constraint::Length(HEADER),
Constraint::Length(PROGRESS),
Constraint::Length(0),
Constraint::Min(3),
Constraint::Length(0),
Constraint::Length(KEYS),
])
.split(area),
};
header(f, app, areas[0]);
progress(f, app, snap, areas[1]);
if tall {
let halves = Layout::horizontal([Constraint::Percentage(52), Constraint::Percentage(48)])
.split(areas[2]);
latency(f, snap, halves[0]);
throughput(f, snap, halves[1]);
}
match app.pane {
Pane::Placement => placement(f, app, snap, areas[3]),
Pane::Workers => workers(f, app, snap, areas[3]),
Pane::Failures => failures(f, app, snap, areas[3]),
}
footer(f, app, areas[5]);
}
fn header(f: &mut Frame, app: &App, area: Rect) {
let broker = app
.config
.broker_url
.trim_start_matches("http://")
.trim_start_matches("https://")
.trim_end_matches('/');
let line = Line::from(vec![
Span::styled(
app.config.workload.name(),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(" ยท "),
Span::styled(
app.config.strategy.as_str(),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(" ยท "),
Span::raw(format!("{} concurrent", app.config.concurrency)),
label(" ยท "),
Span::raw(grouped(app.total)),
label(" requests"),
label(" broker "),
Span::styled(broker, Style::default().fg(ACCENT)),
label(" "),
Span::raw(format!("{} workers", app.workers)),
]);
f.render_widget(
Paragraph::new(line).block(
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
" zc bench ",
Style::default().add_modifier(Modifier::BOLD),
)),
),
area,
);
}
fn progress(f: &mut Frame, app: &App, snap: &Snapshot, area: Rect) {
let rows = Layout::vertical([Constraint::Length(1), Constraint::Length(1)])
.margin(1)
.split(area);
let ratio = (snap.done as f64 / app.total.max(1) as f64).clamp(0.0, 1.0);
let eta = super::layout::eta(snap.done, app.total, snap.elapsed)
.map(|d| format!(" ยท eta {}", short_duration(d)))
.unwrap_or_default();
f.render_widget(
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Line::from(vec![
label(" "),
Span::raw(format!("{} / {}", grouped(snap.done), grouped(app.total))),
label(format!(" {}{} ", short_duration(snap.elapsed), eta)),
])),
area,
);
f.render_widget(
Gauge::default()
.gauge_style(Style::default().fg(ACCENT))
.ratio(ratio)
.label(format!("{:.1}%", ratio * 100.0)),
rows[0],
);
let now = snap.rates.now(5, snap.done, snap.elapsed);
let mean = snap.done as f64 / snap.elapsed.as_secs_f64().max(0.001);
let (p50, p99) = super::metrics::percentiles_us(&snap.samples);
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(grouped(snap.ok), Style::default().fg(FREE)),
label(" ok ยท "),
Span::styled(
grouped(snap.failed),
Style::default().fg(match snap.failed {
0 => GREY,
_ => Color::Indexed(203),
}),
),
label(" failed "),
Span::styled(
format!("{now:.1}"),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(" req/s now ยท "),
Span::raw(format!("{mean:.1}")),
label(" avg ยท "),
Span::raw(snap.rates.peak().to_string()),
label(" peak "),
Span::raw(fmt_us(p50)),
label(" p50 ยท "),
Span::raw(fmt_us(p99)),
label(" p99"),
])),
rows[1],
);
}
fn latency(f: &mut Frame, snap: &Snapshot, area: Rect) {
let b = Buckets::of(
&snap.samples,
MAX_BUCKET_ROWS.min(area.height.saturating_sub(2) as usize),
);
let rows: Vec<usize> = b.interesting().collect();
let peak = b.peak();
let total = b.total().max(1);
let label_w = rows
.iter()
.map(|i| b.label(*i, &fmt_tick).chars().count())
.max()
.unwrap_or(7);
let bar_w = (area.width as usize).saturating_sub(label_w + 16).min(56);
let lines: Vec<Line> = rows
.iter()
.map(|i| {
let n = b.counts[*i];
Line::from(vec![
label(format!("{:>w$} ", b.label(*i, &fmt_tick), w = label_w)),
Span::styled(bar(n, peak, bar_w), Style::default().fg(ACCENT)),
Span::raw(format!("{:>8}", grouped(n))),
label(format!(
"{:>5}",
format!("{:.0}%", n as f64 / total as f64 * 100.0)
)),
])
})
.collect();
f.render_widget(
Paragraph::new(lines).block(
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
" latency ",
Style::default().add_modifier(Modifier::BOLD),
)),
),
area,
);
}
fn throughput(f: &mut Frame, snap: &Snapshot, area: Rect) {
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
" throughput req/s ",
Style::default().add_modifier(Modifier::BOLD),
));
let inner = block.inner(area);
f.render_widget(block, area);
let per_second = snap.rates.per_second();
if per_second.is_empty() {
f.render_widget(Paragraph::new(label("measuringโฆ")), inner);
return;
}
let split = Layout::vertical([Constraint::Length(SPARK_ROWS), Constraint::Min(1)]).split(inner);
let width = split[0].width as usize;
let data: Vec<u64> = per_second.iter().rev().take(width).rev().copied().collect();
f.render_widget(
Sparkline::default()
.data(&data)
.style(Style::default().fg(FREE)),
split[0],
);
let b = Buckets::linear(per_second, 6);
let rows: Vec<usize> = match per_second.len() < MIN_RATE_SAMPLES {
true => Vec::new(),
false => b.interesting().collect(),
};
let peak = b.peak();
let total = b.total().max(1);
let lines: Vec<Line> = match rows.is_empty() {
true => vec![Line::from(label(
"a distribution needs a few seconds of samples",
))],
false => rows
.iter()
.map(|i| {
let n = b.counts[*i];
Line::from(vec![
label(format!("{:>10} ", b.label(*i, &|v| format!("{v} req/s")))),
Span::styled(
bar(
n,
peak,
(split[1].width as usize).saturating_sub(22).min(20),
),
Style::default().fg(FREE),
),
Span::raw(format!("{n:>5}")),
label(
format!("{:>5}", format!("{:.0}%", n as f64 / total as f64 * 100.0)).leak(),
),
])
})
.collect(),
};
f.render_widget(Paragraph::new(lines), split[1]);
}
fn panel() -> Block<'static> {
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
}
fn tabs(app: &App) -> Tabs<'static> {
Tabs::new(Pane::ALL.iter().map(|p| p.title()).collect::<Vec<_>>())
.select(Pane::ALL.iter().position(|p| *p == app.pane).unwrap_or(0))
.style(Style::default().fg(GREY))
.highlight_style(Style::default().fg(ACCENT).add_modifier(Modifier::BOLD))
.divider(" ")
}
fn placement(f: &mut Frame, app: &App, snap: &Snapshot, area: Rect) {
let block = panel();
let inner = block.inner(area);
f.render_widget(block, area);
let split = Layout::vertical([
Constraint::Length(1),
Constraint::Length(2),
Constraint::Min(1),
])
.split(inner);
f.render_widget(tabs(app), split[0]);
let (free_n, _) = snap.ledger.totals(Placement::Free);
let (billed_n, billed) = snap.ledger.totals(Placement::Billed);
let placed = snap.ledger.placed().max(1);
let bar_w = (split[1].width as usize).saturating_sub(48).clamp(8, 40);
let (free_run, billed_run) = super::layout::split_bar(free_n, billed_n, bar_w);
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(free_run, Style::default().fg(FREE)),
Span::styled(billed_run, Style::default().fg(BILLED)),
label(" free "),
Span::styled(
format!("{:.0}%", free_n as f64 / placed as f64 * 100.0),
Style::default().fg(FREE).add_modifier(Modifier::BOLD),
),
label(" of the work ยท billed "),
Span::styled(
format!("{:.0}%", billed_n as f64 / placed as f64 * 100.0),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(" "),
Span::styled(format!("ยฅ{billed:.4}"), Style::default().fg(BILLED)),
])),
split[1],
);
let rows: Vec<Row> = snap
.ledger
.rows()
.into_iter()
.skip(app.scroll)
.map(|(class, node, stat)| {
let tint = match class {
Placement::Free => FREE,
Placement::Billed => BILLED,
};
let expected = match stat.expectation.avg_expected_ms() {
Some(ms) => match stat.expectation.is_miscalibrated() {
true => format!("{} โ ", fmt_ms(ms)),
false => fmt_ms(ms),
},
None => "โ".to_string(),
};
Row::new(vec![
Cell::from(class.as_str()).style(Style::default().fg(tint)),
Cell::from(node).style(Style::default().fg(ACCENT)),
Cell::from(stat.price()).style(Style::default().fg(
match stat.priced_but_unbilled() {
true => BILLED,
false => GREY,
},
)),
Cell::from(stat.via()).style(Style::default().fg(GREY)),
Cell::from(grouped(stat.requests)),
Cell::from(format!(
"{:.1}%",
stat.requests as f64 / placed as f64 * 100.0
))
.style(Style::default().fg(GREY)),
Cell::from(fmt_us(stat.p50_us())),
Cell::from(expected).style(Style::default().fg(GREY)),
Cell::from(match class {
Placement::Free => "free".to_string(),
Placement::Billed => format!("ยฅ{:.4}", stat.charged),
})
.style(Style::default().fg(tint)),
Cell::from(""),
])
})
.collect();
let widths = [
Constraint::Length(8),
Constraint::Length(24),
Constraint::Length(11),
Constraint::Length(7),
Constraint::Length(9),
Constraint::Length(8),
Constraint::Length(10),
Constraint::Length(13),
Constraint::Length(13),
Constraint::Fill(1),
];
let table = Table::new(rows, widths).header(
Row::new(vec![
"",
"node",
"via",
"req",
"share",
"p50",
"router said",
"spend",
])
.style(Style::default().fg(GREY)),
);
f.render_widget(table, split[2]);
}
fn workers(f: &mut Frame, app: &App, snap: &Snapshot, area: Rect) {
let block = panel();
let inner = block.inner(area);
f.render_widget(block, area);
let split = Layout::vertical([Constraint::Length(1), Constraint::Min(1)]).split(inner);
f.render_widget(tabs(app), split[0]);
let mut all: Vec<(String, String, u64)> = Vec::new();
for (_, node, stat) in snap.ledger.rows() {
for (w, n) in &stat.workers {
all.push((node.clone(), super::layout::worker_leaf(w), *n));
}
}
all.sort_by(|a, b| b.2.cmp(&a.2).then_with(|| a.0.cmp(&b.0)));
let busiest = all.first().map(|w| w.2).unwrap_or(0);
let rows: Vec<Row> = all
.into_iter()
.skip(app.scroll)
.map(|(node, leaf, n)| {
Row::new(vec![
Cell::from(node).style(Style::default().fg(ACCENT)),
Cell::from(leaf).style(Style::default().fg(GREY)),
Cell::from(bar(n, busiest, 32)).style(Style::default().fg(ACCENT)),
Cell::from(grouped(n)),
Cell::from(""),
])
})
.collect();
f.render_widget(
Table::new(
rows,
[
Constraint::Length(24),
Constraint::Length(10),
Constraint::Length(34),
Constraint::Length(9),
Constraint::Fill(1),
],
)
.header(Row::new(vec!["node", "worker", "", "req", ""]).style(Style::default().fg(GREY))),
split[1],
);
}
fn failures(f: &mut Frame, app: &App, snap: &Snapshot, area: Rect) {
let block = panel();
let inner = block.inner(area);
f.render_widget(block, area);
let split = Layout::vertical([Constraint::Length(1), Constraint::Min(1)]).split(inner);
f.render_widget(tabs(app), split[0]);
let lines: Vec<Line> = match snap.failures.is_empty() {
true => vec![Line::from(Span::styled(
"nothing has failed",
Style::default().fg(FREE),
))],
false => snap
.failures
.iter()
.skip(app.scroll)
.map(|(reason, n)| {
Line::from(vec![
Span::styled(
format!("{:>7}ร ", grouped(*n)),
Style::default().fg(Color::Indexed(203)),
),
label(reason.as_str()),
])
})
.collect(),
};
f.render_widget(Paragraph::new(lines), split[1]);
}
fn footer(f: &mut Frame, app: &App, area: Rect) {
let paused = match app.paused {
true => Span::styled(
" PAUSED (run continues) ",
Style::default()
.fg(Color::Black)
.bg(BILLED)
.add_modifier(Modifier::BOLD),
),
false => Span::raw(""),
};
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(" q", Style::default().add_modifier(Modifier::BOLD)),
label(" stop & report "),
Span::styled("p", Style::default().add_modifier(Modifier::BOLD)),
label(" pause "),
Span::styled("tab", Style::default().add_modifier(Modifier::BOLD)),
label(" pane "),
Span::styled("โโ", Style::default().add_modifier(Modifier::BOLD)),
label(" scroll "),
paused,
])),
area,
);
}
pub(crate) fn wanted(config: &BenchConfig) -> bool {
use std::io::IsTerminal;
if config.no_tui || config.json || config.no_progress || config.silent {
return false;
}
std::io::stdout().is_terminal() && std::io::stdin().is_terminal()
}
pub(crate) fn run_compare(
base: &BenchConfig,
progress: &std::sync::Arc<super::compare::Progress>,
) -> io::Result<()> {
let mut terminal = ratatui::init();
let outcome = compare_loop(&mut terminal, base, progress);
ratatui::restore();
outcome
}
fn compare_loop(
terminal: &mut DefaultTerminal,
base: &BenchConfig,
progress: &std::sync::Arc<super::compare::Progress>,
) -> io::Result<()> {
loop {
terminal.draw(|f| draw_compare(f, base, progress))?;
if progress.is_over() {
terminal.draw(|f| draw_compare(f, base, progress))?;
return Ok(());
}
if event::poll(Duration::from_millis(100))? {
if let Event::Key(key) = event::read()? {
if key.kind == KeyEventKind::Release {
continue;
}
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
match key.code {
KeyCode::Char('q') | KeyCode::Esc => progress.ask_to_stop(),
KeyCode::Char('x') | KeyCode::Char('Q') => progress.abandon(),
KeyCode::Char('c') if ctrl => progress.abandon(),
_ => {}
}
}
}
}
}
fn draw_compare(
f: &mut Frame,
base: &BenchConfig,
progress: &std::sync::Arc<super::compare::Progress>,
) {
use super::compare::{free_share, verdicts, STRATEGIES};
let area = Rect {
width: f.area().width.min(MAX_WIDTH),
..f.area()
};
let areas = Layout::vertical([
Constraint::Length(3),
Constraint::Length(4),
Constraint::Length(STRATEGIES.len() as u16 + 4),
Constraint::Length(3),
Constraint::Min(0),
Constraint::Length(1),
])
.split(area);
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(
base.workload.name(),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(format!(" ยท {} concurrent ยท ", base.concurrency)),
Span::raw(grouped(base.requests)),
label(" requests each broker "),
Span::styled(
base.broker_url
.trim_start_matches("http://")
.trim_start_matches("https://")
.trim_end_matches('/')
.to_string(),
Style::default().fg(ACCENT),
),
]))
.block(
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
" zc bench --compare ",
Style::default().add_modifier(Modifier::BOLD),
)),
),
areas[0],
);
let running = progress.running();
let nth = progress.started().max(1).min(STRATEGIES.len());
let title = match &running {
Some((s, _, _)) => format!(" {} of {} ยท {} ", nth, STRATEGIES.len(), s.as_str()),
None => match progress.is_over() {
true => " done ".to_string(),
false => format!(" {} of {} ยท starting ", nth, STRATEGIES.len()),
},
};
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
title,
Style::default().add_modifier(Modifier::BOLD),
));
let inner = block.inner(areas[1]);
f.render_widget(block, areas[1]);
let rows = Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).split(inner);
if let Some((_, shared, started)) = &running {
let done = shared.completed.load(Ordering::Relaxed);
let ok = shared.successful.load(Ordering::Relaxed);
let failed = shared.failed.load(Ordering::Relaxed);
let elapsed = started.elapsed();
let ratio = (done as f64 / base.requests.max(1) as f64).clamp(0.0, 1.0);
f.render_widget(
Gauge::default()
.gauge_style(Style::default().fg(ACCENT))
.ratio(ratio)
.label(format!("{} / {}", grouped(done), grouped(base.requests))),
rows[0],
);
let samples = shared
.latencies
.lock()
.map(|l| l.clone())
.unwrap_or_default();
let (p50, _) = super::metrics::percentiles_us(&samples);
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(grouped(ok), Style::default().fg(FREE)),
label(" ok ยท "),
Span::styled(
grouped(failed),
Style::default().fg(match failed {
0 => GREY,
_ => Color::Indexed(203),
}),
),
label(" failed "),
Span::styled(
format!("{:.1}", done as f64 / elapsed.as_secs_f64().max(0.001)),
Style::default().fg(BILLED).add_modifier(Modifier::BOLD),
),
label(" req/s "),
Span::raw(fmt_us(p50)),
label(" p50"),
])),
rows[1],
);
} else {
f.render_widget(
Paragraph::new(label(match progress.is_over() {
true => "every strategy measured",
false => "startingโฆ",
})),
rows[0],
);
}
let done = progress.finished();
let v = verdicts(&done);
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY))
.title(Span::styled(
" strategies ",
Style::default().add_modifier(Modifier::BOLD),
));
let inner = block.inner(areas[2]);
f.render_widget(block, areas[2]);
let running_name = running.as_ref().map(|(s, _, _)| s.as_str());
let rows: Vec<Row> = STRATEGIES
.iter()
.map(|s| {
let finished = done.iter().position(|(d, _)| d == s);
match finished {
Some(i) => {
let r = &done[i].1;
let share = free_share(r);
let (free_run, billed_run) = super::layout::split_bar(
(share * 100.0).round() as u64,
((1.0 - share) * 100.0).round() as u64,
14,
);
let mark = match (Some(i) == v.fastest, Some(i) == v.cheapest) {
(true, true) => "fastest, cheapest",
(true, false) => "fastest",
(false, true) => "cheapest",
_ => "",
};
Row::new(vec![
Cell::from("โ").style(Style::default().fg(FREE)),
Cell::from(s.as_str()),
Cell::from(format!("{:.1}", r.rps)),
Cell::from(fmt_us(super::metrics::percentile_us(&r.latencies_us, 50.0))),
Cell::from(fmt_us(super::metrics::percentile_us(&r.latencies_us, 99.0))),
Cell::from(Line::from(vec![
Span::styled(free_run, Style::default().fg(FREE)),
Span::styled(billed_run, Style::default().fg(BILLED)),
Span::raw(format!(" {:.0}%", share * 100.0)),
])),
Cell::from(format!("{:.4}", r.total_charged)),
Cell::from(mark).style(Style::default().fg(BILLED)),
])
}
None if running_name == Some(s.as_str()) => Row::new(vec![
Cell::from("โถ").style(Style::default().fg(ACCENT)),
Cell::from(s.as_str()).style(Style::default().add_modifier(Modifier::BOLD)),
Cell::from("running").style(Style::default().fg(GREY)),
]),
None => Row::new(vec![
Cell::from("ยท").style(Style::default().fg(GREY)),
Cell::from(s.as_str()).style(Style::default().fg(GREY)),
Cell::from(match progress.asked_to_stop() {
true => "skipped",
false => "queued",
})
.style(Style::default().fg(GREY)),
]),
}
})
.collect();
f.render_widget(
Table::new(
rows,
[
Constraint::Length(2),
Constraint::Length(20),
Constraint::Length(9),
Constraint::Length(10),
Constraint::Length(10),
Constraint::Length(20),
Constraint::Length(9),
Constraint::Length(18),
Constraint::Fill(1),
],
)
.header(
Row::new(vec![
"",
"strategy",
"req/s",
"p50",
"p99",
"free / billed",
"spend",
"",
])
.style(Style::default().fg(GREY)),
),
inner,
);
let mut parts: Vec<Span> = Vec::new();
for (name, idx, extra) in [
("fastest", v.fastest, None),
("cheapest", v.cheapest, None),
(
"most free",
v.freest,
v.freest
.map(|i| format!(" ({:.0}% of the work)", free_share(&done[i].1) * 100.0)),
),
] {
let Some(i) = idx else { continue };
if !parts.is_empty() {
parts.push(label(" "));
}
parts.push(label(format!("{name} ")));
parts.push(Span::styled(
done[i].0.as_str(),
Style::default().fg(ACCENT),
));
if let Some(e) = extra {
parts.push(label(e));
}
}
let verdict = match (parts.is_empty(), done.len()) {
(false, _) => Line::from(parts),
(true, 0) => Line::from(label("nothing measured yet")),
(true, n) => Line::from(label(format!(
"no clear winner โ all {n} within {:.1}% of each other on speed",
v.rps_spread * 100.0
))),
};
f.render_widget(
Paragraph::new(verdict).block(
Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(GREY)),
),
areas[3],
);
f.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(" q", Style::default().add_modifier(Modifier::BOLD)),
label(" stop after this strategy "),
Span::styled("x", Style::default().add_modifier(Modifier::BOLD)),
label(" abandon it and report"),
])),
areas[5],
);
}