# loadbearer reference baseline — v1
#
# CALIBRATED. Each value is the geometric mean of that metric across seven real
# machines benchmarked with `loadbearer run --duration thorough` from the
# released (default, non-native) build — see the list below.  A machine that
# matches the baseline on a metric scores ~1000 on it.
#
#   host              CPU                              cores  OS
#   SGS-D47TDY3        Intel Core i7-1370P (2023)         20  Windows 11
#   dell-ubuntu        Intel Core i7-10510U (2019)         8  Linux
#   ThinkPad-X280      Intel Core i5-8350U (2018)          8  Linux
#   DESKTOP-QRLKF2J    Intel N95 (2023)                    4  Windows 11
#   docker-nuc         Intel Core i5-5250U (2015)          4  Linux
#   LYNN-LAPTOP        Intel Core i5-6300U (2015)          4  Windows 10
#   openvms            Intel Celeron J4005 (2017)          2  Linux
#
# It is a SMALL, INTEL-ONLY sample skewed toward older low-power laptops, so
# the anchors sit on the low side: a current mainstream machine grades A/S, and
# five of the seven lack the SHA extensions so `sha256` anchors low. Treat the
# absolute score and letter as a rough position and lean on `loadbearer compare`
# — baseline-independent — for anything that has to be defensible. The baseline
# is calibration data, not part of the stability contract (see VERSIONING.md);
# it will be recalibrated as more machines are measured.
#
# HOW PRECISE IS THIS, REALLY? Less than four significant figures suggests.
# Recalibrating on 2026-09-09 moved `hash` +19 %, `float_single` +18 % and
# `int_single` +8 % — subtests whose kernels had not changed at all since the
# previous calibration. That is run-to-run variation, and it is not small:
# `int_single` alone was measured between 13330 and 16071 Mops/s across
# repeated runs on one machine, a 20 % spread. Read every anchor as carrying
# something like ±10-20 %, and don't attribute a machine scoring 1050 rather
# than 1000 to its hardware.
#
# `gpu` rests on THREE of the seven machines (the others have no OpenCL device,
# and the X280 contributes none since its integrated engine wedges under load —
# see src/benches/gpu/mod.rs). Its anchors moved a long way at this
# recalibration simply because the contributing set changed, so treat them as
# indicative. GPU is not folded into any grade.
#
# Recalibrated 2026-09-09 against 1.5.0, which cleared four anchors that had
# been knowingly stale: `aes_gcm` (+52 %, the VAES code paths that arrived with
# aes 0.9 and that the old figure predated), `int_multi` (+34 %) and
# `float_multi` (+38 %) — both now the *peak* of their timed runs rather than
# the median, because an all-core series decays from boost to the package power
# limit and a median over that is bimodal — and `memory.latency` (+4 %), which
# reads colder now the pointer-chase array is built once per subtest instead of
# being rebuilt, and left warm, before every iteration.
#
# STILL A KNOWN GAP: `memory.latency` is measured over the preset-scaled working
# set, so a `--duration short` run chases 128 MiB against thorough's 512 MiB and
# reads ~9 % faster. These anchors are thorough-calibrated, so a short run
# flatters itself on that subtest. See the notes in src/benches/memory.rs.
#
# Regenerate:  loadbearer baseline run1.json run2.json … --name reference-v1 \
#                --description "…" > baseline/reference-v1.toml && cargo build
#              (it takes explicit paths — it does not expand wildcards)

name = "reference-v1"
description = "geomean of 7 Intel machines (2015-2023), recalibrated 2026-09-09"

[components.cpu]
int_single   = 6945.0    # Mops/s
int_multi    = 23594.0   # Mops/s  (peak of the timed runs, not the median)
float_single = 6704.0    # MFLOP/s
float_multi  = 31692.0   # MFLOP/s (peak of the timed runs, not the median)
hash         = 2229.0    # MiB/s   (BLAKE3, SIMD)
compress     = 47.36     # MiB/s   (DEFLATE level 6)
aes_gcm      = 1153.0    # MiB/s   (AES-256-GCM, single thread; VAES where present)
sha256       = 415.9     # MiB/s   (SHA-256, single thread; mostly software in this sample)

[components.memory]
bw_read      = 11.45     # GiB/s
bw_write     = 7.162     # GiB/s
bw_copy      = 6.352     # GiB/s
bw_read_mt   = 18.34     # GiB/s   (all cores, rates summed)
latency      = 153.6     # ns      (random access, 512 MiB chase at `thorough`)

[components.disk]
seq_write    = 372.2     # MiB/s
seq_read     = 642.8     # MiB/s
rand_read    = 9049.0    # IOPS    (4 KiB, QD1)
rand_write   = 13054.0   # IOPS    (4 KiB, QD1)

[components.network]
tcp_stream   = 2.538     # GiB/s   (loopback, single stream)
tcp_parallel = 3.611     # GiB/s   (loopback, all cores)
tcp_rtt      = 30.63     # us      (loopback round trip)
udp_pps      = 136.1     # Kpps    (loopback send rate)

[components.gpu]
compute_fp32 = 177.4     # GFLOP/s (three machines only — see above)
bandwidth    = 22.68     # GiB/s   (three machines only — see above)