use std::{fmt::Write as _, net::SocketAddr, path::Path, time::Instant};
use exec_viz::{
Backpressure, Tape, Viz,
api_types::{ActivationFrame, SeekReq, StepReq, StepUntilReq},
};
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
use trading_data_dag::{Fidelity, Fire, Glance, Observer as _, Plot};
const TICKS_PER_DAY: usize = 159_210;
const DAYS: usize = 2;
const GLANCE_BYTES_PER_TICK: usize = 106;
const CAPS: [usize; 5] = [2_048, 8_192, 20_000, 65_536, 262_144];
const SAMPLES: usize = 64;
const BAR: usize = 44;
const MIN: usize = TICKS_PER_DAY / 1440;
const NODES: [Node; 6] = [
Node {
name: "Book",
period: 1,
face: GLANCE_BYTES_PER_TICK,
dims: &[4],
},
Node {
name: "Screen",
period: 100,
face: 24,
dims: &[3],
},
Node {
name: "Bar:1m",
period: MIN,
face: 24,
dims: &[5],
},
Node {
name: "Bar:5m",
period: 5 * MIN,
face: 24,
dims: &[5],
},
Node {
name: "Bar:1h",
period: 60 * MIN,
face: 24,
dims: &[5],
},
Node {
name: "Cap",
period: TICKS_PER_DAY / 2,
face: 24,
dims: &[1],
},
];
const CARD: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
const BEGIN: &str = "<!-- capacity:begin -->";
const END: &str = "<!-- capacity:end -->";
fn main() {
unsafe { std::env::set_var("EXEC_VIZ_WEB_DIR", std::env::temp_dir()) };
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a current-thread runtime asks nothing of the system")
.block_on(sweep());
}
struct Node {
name: &'static str,
period: usize,
face: usize,
dims: &'static [usize],
}
struct Face(&'static str);
impl Glance for Face {
fn glance(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.0)
}
}
struct Row {
cap: usize,
retained: usize,
bytes: usize,
rec_ns: f64,
seek_us: f64,
reach: Vec<usize>,
}
async fn sweep() {
let ticks = TICKS_PER_DAY * DAYS;
let fires: Vec<usize> = NODES.iter().map(|n| ticks.div_ceil(n.period)).collect();
let mut rows = Vec::new();
let mut hop_us = 0.0;
for cap in CAPS {
let began = Instant::now();
let viz = record(cap, ticks);
let rec_ns = began.elapsed().as_secs_f64() * 1e9 / ticks as f64;
let bytes = viz.bytes();
let listener = Viz::bind(0).await;
let addr = listener.local_addr().expect("a bound listener has an address");
let row = tokio::select! {
() = viz.serve_on(listener) => unreachable!("axum::serve returns only on an error it panics on"),
(row, hop) = read(addr, cap, bytes, ticks, rec_ns) => { hop_us = hop; row }
};
eprintln!(
"capacity {cap}: {} retained, {:.1} MB, {:.0}ns/tick, {:.0}µs",
row.retained,
row.bytes as f64 / 1e6,
row.rec_ns,
row.seek_us
);
rows.push(row);
}
let out = render(&rows, &fires, ticks, hop_us);
print!("{out}");
let docs = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../docs"));
std::fs::write(docs.join("capacity.txt"), &out).expect("write capacity.txt");
splice(&docs.join(".readme_assets/other.md"), &out);
}
fn record(cap: usize, ticks: usize) -> Viz {
let (tape, mut rec) = Tape::new(None, cap, 60_000, Backpressure::Block);
let viz = tape.viz();
for i in 0..ticks {
let mut r = rec.at(i as i64 * 1_000_000_000);
for n in &NODES {
let vals = [1.0, 2.0, 3.0, 4.0, 5.0];
r.on(
n.name,
&[],
&[],
Fire {
glance: &Face(&CARD[..n.face]),
dims: n.dims,
plots: &[Plot::DEFAULT],
clock: None,
fidelity: Fidelity::Exact,
fires: 1,
ran: i % n.period == 0,
vals: (i % n.period == 0).then(|| &vals[..n.dims[0]]),
dep_dims: &[],
jac: None,
exact_block: None,
exact: false,
formula: None,
deriv: None,
trace: None,
},
);
}
}
rec.seal();
viz
}
async fn read(addr: SocketAddr, cap: usize, bytes: usize, ticks: usize, rec_ns: f64) -> (Row, f64) {
let mut api = Api::connect(addr).await;
let end = {
api.seek(0).await;
api.step(usize::MAX).await.tick
};
let (mut lo, mut hi) = (0usize, cap);
while lo < hi {
let mid = lo.midpoint(hi);
api.seek(0).await;
match api.step(mid).await.tick == end {
true => hi = mid,
false => lo = mid + 1,
}
}
let retained = lo + 1;
let mut hop = Vec::with_capacity(SAMPLES);
for _ in 0..SAMPLES {
let began = Instant::now();
api.topology().await;
hop.push(began.elapsed());
}
let mut seek = Vec::with_capacity(SAMPLES);
for i in 0..SAMPLES {
let began = Instant::now();
api.seek(ticks / 2 + i).await;
seek.push(began.elapsed());
}
let mut reach = Vec::new();
for n in &NODES {
let start = api.seek(0).await;
let mut hits = usize::from(start.activations.iter().any(|a| a.node == n.name && a.fired));
while api.step_until(n.name).await.found {
hits += 1;
}
reach.push(hits);
}
(
Row {
cap,
retained,
bytes,
rec_ns,
seek_us: median(seek),
reach,
},
median(hop),
)
}
fn median(mut took: Vec<std::time::Duration>) -> f64 {
took.sort_unstable();
took[took.len() / 2].as_secs_f64() * 1e6
}
fn render(rows: &[Row], fires: &[usize], ticks: usize, hop_us: f64) -> String {
let mut s = String::new();
let per_tick = NODES.iter().map(|n| n.face as f64 / n.period as f64).sum::<f64>();
let w = |s: &mut String, line: std::fmt::Arguments<'_>| s.write_fmt(line).expect("`String`'s `Write` is infallible");
w(
&mut s,
format_args!(
"{ticks} ticks ({DAYS} days at spl's {TICKS_PER_DAY}/day), {} nodes, {per_tick:.0} B/tick of card faces\n",
NODES.len()
),
);
w(&mut s, format_args!("fires over the run:"));
for (n, f) in NODES.iter().zip(fires) {
w(&mut s, format_args!(" {}={f}", n.name));
}
s.push_str("\n\n");
let mut chart = |title: std::fmt::Arguments<'_>, val: &dyn Fn(&Row) -> f64, note: &dyn Fn(&Row, f64) -> String| {
w(&mut s, title);
let max = rows.iter().map(val).fold(0.0f64, f64::max);
for r in rows {
let v = val(r);
let bar = ((v / max) * BAR as f64).round() as usize;
w(&mut s, format_args!(" {:>7} │{:▬<width$} {}\n", r.cap, "", note(r, v), width = bar.max(1)));
}
s.push('\n');
};
chart(format_args!("footprint — Viz::bytes over the retained ticks\n"), &|r| r.bytes as f64 / 1e6, &|r, v| {
format!("{v:.1} MB ({} B/tick)", r.bytes / r.retained)
});
chart(
format_args!("reactivity — one /api/seek mid-tape, median of {SAMPLES}; the bare loopback hop under it is {hop_us:.0}µs\n"),
&|r| r.seek_us,
&|_, v| format!("{v:.0}µs"),
);
chart(
format_args!("absorption — the whole recording's wall clock per tick, tape-thread bound under `Block`\n"),
&|r| r.rec_ns,
&|_, v| format!("{v:.0}ns"),
);
w(&mut s, format_args!("addressability — fires still reachable by `step_until`, against the run's own\n"));
w(&mut s, format_args!(" {:>7} {:>9}", "capacity", "retained"));
for n in &NODES {
w(&mut s, format_args!(" {:>13}", n.name));
}
s.push('\n');
for r in rows {
w(&mut s, format_args!(" {:>7} {:>9}", r.cap, r.retained));
for (hits, all) in r.reach.iter().zip(fires) {
w(&mut s, format_args!(" {:>13}", format!("{hits}/{all}")));
}
s.push('\n');
}
s
}
fn splice(at: &Path, out: &str) {
let md = std::fs::read_to_string(at).expect("other.md is this crate's, and checked in");
let (head, rest) = md.split_once(BEGIN).unwrap_or_else(|| panic!("{} has no {BEGIN} marker", at.display()));
let (_, tail) = rest.split_once(END).unwrap_or_else(|| panic!("{} has no {END} marker", at.display()));
std::fs::write(at, format!("{head}{BEGIN}\n```\n{out}```\n{END}{tail}")).expect("write other.md");
}
struct Api {
sock: tokio::net::TcpStream,
buf: Vec<u8>,
}
impl Api {
async fn connect(addr: SocketAddr) -> Self {
let sock = tokio::net::TcpStream::connect(addr).await.expect("the server bound the address being asked for");
sock.set_nodelay(true).expect("a connected TCP socket takes TCP_NODELAY");
Self { sock, buf: Vec::new() }
}
async fn seek(&mut self, tick: usize) -> ActivationFrame {
self.post("seek", &SeekReq { tick }).await
}
async fn step(&mut self, n: usize) -> ActivationFrame {
self.post("step", &StepReq { n }).await
}
async fn step_until(&mut self, node: &str) -> ActivationFrame {
self.post("step_until", &StepUntilReq { node: node.into() }).await
}
async fn topology(&mut self) {
self.send("GET /api/topology HTTP/1.1\r\nHost: t\r\n\r\n").await;
self.recv().await;
}
async fn post(&mut self, route: &str, body: &impl serde::Serialize) -> ActivationFrame {
let body = serde_json::to_string(body).expect("a request shape serializes");
let req = format!(
"POST /api/{route} HTTP/1.1\r\nHost: t\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}",
body.len()
);
self.send(&req).await;
let body = self.recv().await;
serde_json::from_slice(&body).unwrap_or_else(|e| panic!("/api/{route} answered {}: {e}", String::from_utf8_lossy(&body)))
}
async fn send(&mut self, req: &str) {
self.sock.write_all(req.as_bytes()).await.expect("the served tape outlives the sweep reading it");
}
async fn recv(&mut self) -> Vec<u8> {
let head = loop {
if let Some(i) = self.buf.windows(4).position(|w| w == b"\r\n\r\n") {
break i + 4;
}
self.fill().await;
};
let len: usize = std::str::from_utf8(&self.buf[..head])
.expect("HTTP headers are ASCII")
.to_ascii_lowercase()
.split_once("content-length: ")
.and_then(|(_, rest)| rest.split_once("\r\n"))
.expect("axum length-delimits every response this asks for")
.0
.parse()
.expect("a decimal length");
while self.buf.len() < head + len {
self.fill().await;
}
let body = self.buf[head..head + len].to_vec();
self.buf.drain(..head + len);
body
}
async fn fill(&mut self) {
let was = self.buf.len();
self.buf.resize(was + 16 * 1024, 0);
let n = self.sock.read(&mut self.buf[was..]).await.expect("read the response the server committed to");
assert!(n > 0, "the server closed the connection mid-sweep");
self.buf.truncate(was + n);
}
}