+ build + + } + label={`Seconds to build rustls on rind, ring, and aws-lc-rs, averaged over ${data.hosts.length} CPUs, as a race.`} + table={{ + head: ["CPU", "Build", "Time", "CPU time", "Binary", "Tools"], + rows: data.hosts.flatMap((x) => + x.builds.map((b) => [ + x.name, + label(b.name), + `${b.seconds.toFixed(1)} s`, + `${b.cpu_seconds.toFixed(1)} s`, + `${(b.bytes / 1024 / 1024).toFixed(2)} MiB`, + needs(b.tools), + ]), + ), + }} + source={ + <> + rind's admin/build-cost: the median of cold builds with an empty target directory and a warm download cache.{" "} + {data.hosts.map((x, i) => ( + <> + {i ? "; " : ""} + {x.name}: {cpu(x.source.cpu)}, {x.source.jobs} jobs, {x.source.runs} runs, {day(x.source.date)}, at{" "} + {commit(x.source.rind)} + + ))} + . A tool counts when the build fails without it. + + } + > +
+
+
+
+
+ {clock().toFixed(1)} srace clock, {SPEED}× speed
+
+
+
+ + The geometric mean over CPUs. {data.hosts.map((x) => `${x.name}: ${ratio(x).toFixed(1)}×`).join(", ")}. +
+ +
+
+
+ { }
+ >
+
+ );
+}
+
+export const reduced = () => matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+// Runs `fn` once `el` reaches the middle half of the viewport, so an animation starts where it's seen.
+export function midscreen(el: Element, fn: () => void) {
+ const observer = new IntersectionObserver(
+ (entries) => {
+ if (!entries[0].isIntersecting) return;
+ observer.disconnect();
+ fn();
+ },
+ { rootMargin: "-25% 0px -25% 0px" },
+ );
+ observer.observe(el);
+ onCleanup(() => observer.disconnect());
+}
+
+// Calls `fn` with the seconds since start on every frame until it returns false; returns a cancel.
+export function frames(fn: (seconds: number) => boolean) {
+ let id = 0;
+ let start: number | undefined;
+ const step = (now: number) => {
+ start ??= now;
+ if (fn((now - start) / 1000)) id = requestAnimationFrame(step);
+ };
+ id = requestAnimationFrame(step);
+ return () => cancelAnimationFrame(id);
+}
+
+// A CPU model as people say it: "Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz" is "Core i7-8700".
+export const cpu = (model: string) =>
+ model
+ .replace(/\((R|TM)\)/g, "")
+ .replace(/^(Intel|AMD)\s+/, "")
+ .replace(/\s+(CPU @.*|\d+-Core Processor)$/, "")
+ .trim();
+
+export const geomean = (xs: number[]) => Math.exp(xs.reduce((a, x) => a + Math.log(x), 0) / xs.length);
+
+export function time(ns: number) {
+ if (ns < 1_000) return `${ns.toPrecision(3)} ns`;
+ if (ns < 1_000_000) return `${(ns / 1_000).toPrecision(3)} µs`;
+ return `${(ns / 1_000_000).toPrecision(3)} ms`;
+}
+
+export const times = (x: number) => `${x.toFixed(2)}×`;
+
+// admin/bench-report's speed bands, by time over the fastest's; a heatmap colors each as .s{props.kicker}
+ {props.headline}
}
+
+
+ {props.children}
+
+ {/* A fraction's slash dips below the digits into the headline, so it gets its own span */}
+ {props.number?.split("/").flatMap((p, i) => (i ? [/, p] : [p]))}
+
+ {props.headline}
+
+
+ Data
+
+
+
+
+
+ | {h} | }
|---|
| {typeof cell === "number" ? cell : Array.isArray(cell) ? cell.map(part) : part(cell)} | + )} +
{props.source}
+
+
+ {(label, i) => (
+
+
+
+
+ {label}
+
+ )}
+
+
+ );
+}
+
+export const day = (iso: string) => iso.slice(0, 10);
+// The days a set of hosts ran, since each host's report can come from a different run.
+export const days = (hosts: { source: { date: string } }[]) =>
+ [...new Set(hosts.map((h) => day(h.source.date)))].sort().join(" and ");
+
+export const commit = (sha: string) => {sha.slice(0, 8)};
+
+// rind's report names for libraries, as the post spells them.
+export const NAMES: Record+ their crypto + + } + label="Which primitives each Rust crypto library proves, end to end or only at its core, on each CPU." + table={{ + head: ["Primitive", ...data.libraries.map(name)], + rows: data.rows.map((row) => [ + row, + ...data.libraries.map((lib) => { + const s = statuses(row, lib); + if (s.every((x) => x === null)) return ""; + const text = data.hosts.map((h, i) => `${h.name}: ${s[i] ? WORDS[s[i]] : "none"}`).join(", "); + return [ + text, + ...arches.flatMap((arch) => { + const partial = data.partial[arch][lib]?.[row]; + return partial ? [" · ", { text: `${arch}: ${partial.proof}`, href: partial.link }] : []; + }), + ]; + }), + ]), + }} + source={ + <> + End to end: rind's benchmarks/verified.toml at {commit(data.source.rind)}, whose ✓ needs a machine-checked + proof of all the code, glue included. Proven core: a proven routine does the whole cipher, block function, + scalar multiplication, or NTT for at least some of the row's operations; field arithmetic alone doesn't count. + Checked against each library's source for each CPU's architecture, at the versions rind's report locks, run{" "} + {days(data.hosts)}. + + } + > +
+
+
+
+ {(lib) =>
+
+ {(row) => (
+ <>
+
+ {(lib) => (
+
+
+ )}
+
+
+ {name(lib)}
}{row}
+
+
+ {(s) => }
+
+
+ )}
+
+
+
+
+
+ proven end to end
+
+
+
+
+
+ proven core, unproven glue
+
+
+
+
+
+ unproven
+
+
+ Squares: {data.hosts.map((h) => h.name).join(", ")}. Blank: not offered.
++ packets per core + + } + label={`Packets sealed per second by each library, averaged over ${data.hosts.length} CPUs, drawn as balls bouncing once per packet.`} + table={table} + source={source} + > +
+
+ {([lib, ns], i) => (
+
+
+
+
+ )}
+
+ {name(lib)}
+ {time(ns)}
+
+ + AES-128-GCM, the geometric mean over CPUs.{" "} + {data.hosts.map((h) => `${h.name}: ${times(ratio(h, "1350B"))}`).join(", ")}. aws-lc is Amazon's BoringSSL fork. + On ARM, rind holds DIT (constant-time mode) across each batch. +
++ stock Bun + + } + label={`Geomean time per call over ${OPS.length} asymmetric crypto operations in ${RUNS.map(label).join(", ")}.`} + table={TABLE} + source={SOURCE} + > + +
Shorter is faster. Same Bun commit, with rind swapped in.
++ or within 10% + + } + label={`Time per call for ${ALL.length} asymmetric crypto operations in ${RUNS.map(label).join(", ")}, colored by time over the fastest runtime's.`} + table={TABLE} + source={SOURCE} + > +
+
+
+
+ {(r) =>
+
+ {(s) => (
+ <>
+
+ {(op) => (
+ <>
+
+ {(r) => (
+
+
+ )}
+
+
+ )}
+
+
+ {label(r)}
}{s.section}
+ {op.split("/")[2]}
+
+
+ {us(r.us[op])}
+
+
+ )}
+ Blank: the runtime refuses it. P-256 runs BoringSSL in both Buns.
+
+
+
+
+
+ {([item, cost]) => (
+
+
+
+ {([item, value]) => (
+
+
+
+
+
+
+
+ {data.calendar_span.count} DAYS · TERMINAL /goal +
+ RIND
+ {date(data.calendar_span.first).toUpperCase()} → {date(data.calendar_span.last).toUpperCase()}{" "}
+ {data.calendar_span.last.slice(0, 4)}
+ + {data.calendar_span.count} DAYS · TERMINAL /goal +
+
+ {item.toUpperCase()}
+ {cost}
+
+ )}
+ +
+ {item.toUpperCase()}
+ {value}
+
+ )}
+ +
+ LIST PRICE
+ {usd(list, true)}
+
+
+ SUBSIDIES
+ −{usd(list - paid, true)}
+
+ +
+ PAID
+ {usd(paid, true)}
+
+
+ {data.calendar_span.count} DAYS OF {usd(PLAN)}/MO · YOU SAVED {Math.floor((1 - paid / list) * 100)}%
+
+ +
THANK YOU FOR VIBING
+
+ + or within 10% + + } + label="Every operation rind's benchmark report times, for every library, colored by its time over the fastest library's on each CPU." + table={{ + head: ["Operation", ...LIBRARIES.map(name)], + rows: operations.map((o) => [ + o.label, + ...LIBRARIES.map((lib) => + data.hosts + .map((h) => h.times[o.id][lib]) + .map((t) => (t === undefined ? "-" : time(t))) + .join(" / "), + ), + ]), + }} + source={ + <> + Criterion's estimates from rind's benchmark report at {commit(data.source.rind)}, run {days(data.hosts)}, as{" "} + {data.hosts.map((h) => h.name).join(" / ")}. Every library runs its native path on each CPU. Where the CPU has + DIT, rind holds it across the timed loop, as a caller batching calls does. + + } + > +
+
+
+
+ {(lib) =>
+
+ {(section) => (
+ <>
+
+ {(o) => (
+ <>
+
+ {(lib) => (
+
+
+ )}
+
+
+ )}
+
+
+ {name(lib)}
}{section.name}
+ {o.label}
+
+
+
+ {(h) => {
+ const r = ratio(o.id, lib, h);
+ return r === undefined ? (
+
+ ) : (
+
+ );
+ }}
+
+
+
+ )}
+ + Squares: {data.hosts.map((h) => h.name).join(", ")}. Blank: not offered. On ARM, rind holds DIT (constant-time + mode) across each batch. +
+
+
+It started as fork of [Graviola](https://github.com/ctz/graviola) and quickly morphed into a monsterish combination of [ring](https://github.com/briansmith/ring) and [aws-lc-rs](https://github.com/aws/aws-lc-rs) and [libcrux](https://github.com/celabshq/libcrux).
+
+