Compare commits

...
150 Commits
Author SHA1 Message Date
Niko1221 2ca1b6645f docs (AMD): images through the CPU encoder and the Monitor's AMD readings (0.1.32, #304 #301) 2026-10-01 18:45:09 +02:00
Niko1221 3f11e286b4 docs: #337's top-k dispatch is AMD-only 2026-10-01 18:45:00 +02:00
Niko1221 01ec3ac900 qsa_select (#337 follow-up): the top-k dispatch by active blocks on HIP only - CUDA keeps the capacity rule (the 64K prompts read 1-3% slower with it on an RTX 5070; #337 was measured on RDNA4) 2026-10-01 18:44:53 +02:00
Niko1221 5a826638b4 qsa_select (#337 follow-up): the gfx12 WMMA block scorer is opt-in (STRATA_SELECT_WMMA=1) - it selects slightly differently from the warp kernel; the top-k dispatch by active blocks (the same ids) stays on; docs 2026-10-01 17:58:46 +02:00
bsorensen110 dd670cac36 hip: gfx12 (RDNA4) QSA select - WMMA block scorer, and a top-k dispatch that follows the prompt, not the capacity
Two changes to the prompt path's QSA selection (qsa_select.cu), measured on a Radeon AI PRO R9700 (gfx1201) with
--max-context 262144:

1. qsa_block_topk picked its register kernel by max_blocks, a CAPACITY (--max-context / 4 + 2). With a 262144-cell
   capacity every prompt, even a 4K one, took the slow reference top-k (up to ~10x slower at 128K+). The prompt path
   now passes the batch's active block count (the argument qsa_block_scores already takes); decode passes none and
   keeps the capacity rule and the original register width, so it is unchanged. On HIP the register kernel is
   instantiated for 66 blocks per thread (contexts up to 270,336 cells, the 262144 --max-context) and, below
   ~28K cells, where it measured 0.2-0.9x of the reference on gfx1201, the reference is kept. Same ids as the reference
   (checked 256/256 at every size).

2. qsa_block_scores_tc on gfx1200/gfx1201: block_scores_wmma_kernel on v_wmma_f32_16x16x16_bf16 (wave32). Each operand
   is split into three bf16 slices (hi / mid / lo are exact 8-bit mantissa slices of the fp32, so no scaling is
   needed) and the six products of order <= 2 are summed; the hi*hi chain keeps its own accumulator and the five
   corrections another, added once at the end (a single shared accumulator rounded the corrections at the big
   accumulator's ulp: 8e-7 of the score scale, failing the harness's gate at short context; split: 1.6e-7, the warp
   kernel's own error is of the same order). The tail block n_bid is the warp kernel's arithmetic. Like the TF32
   kernel it is not bitwise with the warp kernel (a near-tie can select differently). Gated at compile time
   (__gfx1200__/__gfx1201__) and run time (gcnArchName); other HIP targets keep the warp kernel; CUDA is unchanged.

qsa_select_bench now builds on HIP, takes the engine's capacity as a 4th argument, checks the scorer against an FP64
reference (gate: no worse than 4x the warp kernel's error, floored at 1e-6 of the score scale), exits non-zero on a
failed gate, and is registered with ctest (32K context under a 262144-cell capacity).

R9700, synthetic bench, 256 queries, capacity 262144: scores 0.81 -> 0.18 ms at 32K, 3.5 -> 0.65 ms at 131K, 6.8 ->
1.5 ms at 262K; top-k 3.9 -> 0.51 ms at 131K, 12.9 -> 1.3 ms at 262K. End to end (Swift 1.5 IQ3_XXS, --kv int8,
prefill timing, same binary with STRATA_SELECT_OLD=1 STRATA_TOPK_OLD=1 as the old arm): 107.7K-token prompt 79.5 s ->
59.5 s (1.34x; qsa select 23.3 s -> 3.4 s); 30.9K 1.02x; below 10K about 1.01x. ctest 44/44.
2026-10-01 17:58:17 +02:00
Rafael Grossi 7d15ef727b AMD HIP: RDNA2 gfx1030 (tested), gfx(1031, 1032) untested.
dp4a through the plain signed v_dot4_i32_i8 (RDNA2 has no sudot4).
setup knows the card and the gfx103X-all TheRock index.
docs carry a community report (RX 6900 XT 16 GB: complete build, 28/28
ctest, 38-42 tok/s decode at 131,072 context, 330-339 tok/s prefill)
2026-10-01 17:58:17 +02:00
bsorensen110 a8d57b1f00 hip: address review of the gfx1201 table: current docs, smoke-test wording
docs/AMD_HIP.md: the RDNA4 validation note still said there was no gfx1201 table and none was shipped; it now says
that holds for hipBLASLt 1.4.1 and points to the 1.5.0 table and its measured gain. The "Tuning table" text no longer
says the parity test "exits non-zero when the table does not fit". It describes what the test checks (architecture and
version through the loader, two of the 32 rows against hipBLASEx) and what it does not: a solution id the library
rejects falls back to hipBLASEx and the test still passes, so it says to read STRATA_HIPBLASLT_VERBOSE's
"fallbacks=" summary and to recalibrate for another 1.5.0 build.

tests/hip/prefill_hipblaslt_gemm.cpp: the header comment, the SKIP and missing-row messages and the case comment now
say it is a smoke test over two rows, and it prints "smoke test: 4 cases on 2 of the table's N rows" at the end.
Test behaviour and exit codes are unchanged.
2026-10-01 17:57:41 +02:00
Soren-ldandCopilot Autofix powered by AI cfe6021eb2 Update AMD HIP documentation for hipBLASLt 1.5.0
Clarify usage of hip_prefill_hipblaslt_gemm and tuning process for different 1.5.0 builds.

Co-authored-by: Copilot Autofix powered by AI <[email protected]>
2026-10-01 17:57:24 +02:00
bsorensen110 025602c2be hip: encode the BF16 fixtures of the hipBLASLt tuner and parity test with bf16_from_f32()
Both helpers built their BF16 inputs with hip_bfloat16(x).data. Compiled as host C++ (no __HIPCC__) the SDK's
hip_bfloat16 is a struct holding a uint16_t, and the conversion from a float is not the engine's round-to-nearest-even
BF16 encoding (kernels/bf16_bits.hpp has that one).

Observed effect on gfx1201 with ROCm 10.2.0a, parity test with the 100500 table: the T=37 beta=1 BF16 case printed
relative_l2=0 max_abs=0 with the old encoding and relative_l2=3.6e-07 max_abs=2.6e-06 with this one; the T=4096 BF16
case prints 0 either way, and the f16 cases are unchanged. I did not inspect the old encoder's bit patterns directly,
so the exact fault is inferred from that difference, not shown.

Use strata::kernels::bf16_from_f32() in both, so the BF16 rows of gfx1201-hipblaslt-100500.txt were calibrated on
intended inputs and anyone regenerating a table gets the same. No change to the engine or to the f16 path.
2026-10-01 17:57:24 +02:00
bsorensen110 dd088d3324 hip: hipBLASLt tuning table for gfx1201 (Radeon AI PRO R9700) with ROCm 10.2.0a nightly (hipBLASLt 1.5.0)
tools/hip/gfx1201-hipblaslt-100500.txt: 16 dense GEMM geometries (bf16 and f16) at T=4096 and T=8192, 32 rows,
calibrated on an R9700 with tune_hipblaslt (16 candidates per row, relative L2 <= 1e-4, max abs <= 1e-2, no padding
writes) against rocm-nightly-gfx120x-all 10.2.0a20260914, hipBLASLt 1.5.0 (version number 100500).

The engine refuses a table of another hipBLASLt version, so the existing gfx1201 table in #262 (100401, hipBLASLt
1.4.1) is not used on this ROCm; setup picks tools/hip/<arch>-hipblaslt-<version>.txt by the installed version, so both
can be shipped side by side. Compared with #262's 24 rows this table has the same 24 shapes (with solution ids chosen
for hipBLASLt 1.5.0: 13 of the 24 ids are the same) and 8 more, all bf16 (N=1/K=2560 at T=8192, N=4/K=10240, N=512/K=2560
at T=4096, N=2560/K=2560 at T=4096, and N=10240 with K=2560 and K=320 at T=4096/8192).

docs/AMD_HIP.md lists the shipped tables and how to check one.
2026-10-01 17:57:24 +02:00
Niko1221 99b3bde00a Engine 0.1.32: split prompts faster with the same output (#340), AMD router +12% decode (bit-identical), RDNA4 matrix-core prompt attention (opt-in), Unsloth UD-Q4_K_XL in setup (experimental) with 2.8x faster prompts, fixes #326 #327 #342 #344 #331, the PR batch; setup requires it 2026-10-01 15:25:30 +02:00
Niko1221 97712287fe serve (merge #333 + #344): the engine stays not-alive from the start of __init__ until READY - #333's lazy start set ended=False before READY, so a request could again plan with context 0 (RestartWindow test) 2026-10-01 15:17:14 +02:00
Niko1221 b0abdeb446 Merge branch 'f-132-pr' into rel-0.1.32
# Conflicts:
#	CMakeLists.txt
#	serve/server.py
#	src/program/generate.cpp
2026-10-01 15:10:33 +02:00
Niko1221 aebfd69a2f Merge branch 'f-132-amd' into rel-0.1.32 2026-10-01 15:09:45 +02:00
Niko1221 d9fe3019e0 Merge branch 'f-132-q4' into rel-0.1.32
# Conflicts:
#	setup.py
2026-10-01 15:09:45 +02:00
Niko1221 3b7162131d #278 follow-up: an Anthropic request that doesn't ask for thinking renders without it only with "anthropic_thinking": "on_request" in the config - the default thinks as 0.1.31 did (a client that never asks would otherwise lose the thinking on every turn); docs 2026-10-01 14:42:53 +02:00
Niko1221 e12ecf6ac8 #280 follow-up: the rope kernels without the table are 0.1.31's code exactly (template <bool TAB>)
With STRATA_ROPE_TABLE unset the table was skipped at run time, yet the compiled default kernels changed their
results: the model-level parity run (Swift IQ2_XS, tools/conversation_cache_parity.py, STRATA_STATE_HASH) gave the
same tokens but other GDN / indexer / K/V state hashes than 0.1.31's (bisected to #280). native_rope's apply,
the indexer's append / append_first / append_blocks and the prompt path's rope_kernel are templates on TAB now;
the host launches <false> whenever no table applies, and that instantiation has no table read at all. Checked:
the same tokens and every state hash as round 1 with the whole branch.
2026-10-01 14:34:20 +02:00
Niko1221 dadc9e781a #340: a split's own prompt buffers are opt-in (STRATA_SPLIT_OWN=1, or auto for the 12% rule) - the owner's choice: the default borrows as 0.1.31 did, with the concurrent refill, the 96-blob split ring and own buffers only on a card with free VRAM, so the split's output stays 0.1.31's (2K +27%, 16K +5%, decode unchanged on the R9700 + 9070 XT); docs 2026-10-01 14:30:39 +02:00
Niko1221 e6a06be558 HIP (S6): STRATA_HIP_WMMA=1 also takes a 96-slot prompt expert ring (9070 XT 4K prompts 718 -> 1,211 tok/s with it); docs/AMD_HIP.md: the router and WMMA switches, with credit to PR #329's equal-speed kernel 2026-10-01 13:06:56 +02:00
Niko1221 c92c4540e3 #340: with the split's own prompt buffers (its rule, not --no-prefill-borrow) the boundary is searched as the borrowing configuration would; the reserve only shrinks the caches (STRATA_SPLIT_OWN_PLACE=reserve: the search sees it)
9070 XT + R9700: the reserve moved K 28 -> 32 and split decode 58.5 -> 54.8 tok/s; own buffers at K=28 decode 58.4.
2026-10-01 11:34:19 +02:00
Niko1221 bf7b181a2c prefill: the Q4_K / Q5_K / Q5_1 MMQ kernels are a build option (STRATA_MMQ_KQUANTS, off) - with every kernel loaded at start they took 1-3 expert slots from every model
The engine sets CUDA_MODULE_LOADING=EAGER (a kernel loaded mid-prompt found no VRAM), so the three extra mmq
instances (+24 MB of binary) were resident for every model: IQ3_S 2261 -> 2260 slots, Q2_0 3678 -> 3675 (S1's A/B,
IQ3_S story decode ~1.5% lower). Measured with the IQ3_S setup config against 0.1.31 (wt-131-r9 build-release):
- slots 2261 / free 5.25 GiB, the same as 0.1.31 again (2260 / 5.24 with the instances);
- engine threads the same (23 at READY, 25 after a request, 0.1.31 likewise): nothing new runs for a normal pack -
  the stager's 32 threads are only for a source with file-read blobs, the verify hook only with STRATA_LOGPOS;
- 5 alternating pairs, greedy story / code / third prompt: 0.1.31 39.5 / 44.7 / 32.0, this 40.3 / 45.2 / 33.3
  tok/s (story B >= A in 5 of 5).
The UD-Q4_K_XL prompt is SSD-bound with or without MMQ (29 s per 4K chunk either way), so the released engine keeps
FP16 products for it; prefill_mmq_kquant_test is built with the option.
2026-10-01 11:31:20 +02:00
Niko1221 560e4788a1 #290 follow-up: --bf16-embd's output buffer holds the 97 gathered rows, not only the 61-row table
The gather wrote 97 rows into a 61-row device buffer (and read them back into a 61-row vector); the next launch
reported the overrun as "iq_dequant_f32: invalid argument". The buffer is max(gathered, table) rows now.
2026-10-01 11:06:21 +02:00
Niko1221 0239cffde7 #296 follow-up: only the Q5_0 MMQ instance and case stay (Q4_K / Q5_1 come with S5's STRATA_MMQ_KQUANTS)
S5's branch (f-132-q4) compiles the Q4_K, Q5_K and Q5_1 MMQ instances on CUDA and enables them with the private
define STRATA_MMQ_KQUANTS; with both, moe_mmq.cu would have duplicate case labels. STRATA_ORCA_Q4KS_MMQ now adds only
q5_0 (OrcaRouter's Q5_0 expert downs; HIP included) - supported() and run() take Q5_0 under it.
2026-10-01 10:31:23 +02:00
sergiywith d11ea857df PLE: the n-gram table in FP8 E4M3, as Qwen ships it
The engine read the 51.2e9-value n-gram table only as IQ4_NL (ISTA-DASLab's shard 2, 90 B/row), which is 8.1% off the
checkpoint's own values per row (correlation 0.996-0.997 on rows from all 128 shards: same table, same order). The
checkpoint stores it as 128 shards of [2500012, 160] F8_E4M3 plus one weight_scale.

- tools/ple_fp8_pack.py copies those bytes, unchanged, into a one-tensor GGUF: per_layer_token_embd.weight
  [160, 320001536] as I8, with strata.ple.format = f8_e4m3 and strata.ple.scale. 51.2 GB, streamed.
- PleTable opens either format; the row size (90 / 160) and the decode (IQ4_NL codebook / an E4M3 table times the
  scale) follow the file. PleReader takes the row size at open; its cache sizes itself by it. GGUF reader: type I8.
- A PLE-only table (architecture strata-ple) is not added to the dense-projection sources.
- The start line names the table's format.
- ple_fp8_parity: rows through Direct, Mmap and gather_batch match torch's decode of the checkpoint bit for bit.

First-token KL of the IQ4_NL table against the FP8 one: 0.0009 (1K), 0.0013 (2K), 0.0002 (4K), 0.022 (32K); mean 0.0061, top-1 4/4.

Rebased onto 0.1.31 + #317 + #296 (Niko1221): one row size (`rb`) and one decoder in PleTable for the three table
formats - IQ4_NL, #296's Q5_0 (110 B rows, the mapped reader only, as #296 has it) and FP8 (160 B) - and #317's
SSD keep-alive picks its page inside the table at the table's own row size; 0.1.31's shard list for the dense
sources keeps the PLE-only exception; ple_fp8_parity builds with STRATA_BUILD_TESTS beside #296's checks. The
"PLE on" start line stays 0.1.31's.
2026-10-01 10:31:23 +02:00
Niko1221 2ba4504b71 prefill: UD-Q4_K_XL prompts 2.8x faster (16K: 57 -> 160 tok/s on an RTX 5070) - 32 stager threads and a 128-deep ring when the experts are read from the GGUF in place; MMQ for its Q4_K / Q5_K / Q5_1 experts
- The prompt path streams every expert once per 4K chunk; with the GGUF read in place ~35 GB of that comes from
  the SSD as page faults, and 4 copy threads with 16 blobs in flight read it at ~0.6 GB/s. When the expert source
  has transient (file-read) blobs the stager now defaults to 32 threads and a ring of 4 x threads (the env
  overrides stay); every other source keeps 4 / 16. Measured (4K chunk): 71 s -> 34 s (16/64) -> 29 s (32/128);
  16K prompt 273-282 s -> 99 s.
- moe_mmq: Q4_K, Q5_K and Q5_1 in supported() and the dispatcher, their mmq instances compiled for CUDA
  (STRATA_MMQ_KQUANTS; HIP unchanged). The dispatch follows eddoursul/Strata 7706c1b; main's prompt path already
  picks MMQ per layer. GPU time of the experts' products 4x lower (10 s -> 2.4 s per 4K chunk), not visible in
  the wall time on this PC (SSD-bound either way: 29 s with and without); after a 16K prompt the continuation
  agrees with llama.cpp at 92.2% (KL 0.029) against 90.2-90.6% (0.038) with the FP16 products. The other
  models' formats are not affected (their layers' types decide; none uses these three).
- tests/cuda/prefill_mmq_kquant_test: the four expert formats through MMQ against ggml's dequantized weights
  (synthetic, several experts per group, permuted rows, a zero row; rel. L2 <= 0.34%), and Q6_K stays uncovered.
2026-10-01 10:30:41 +02:00
Niko1221 d70df548ad #340: a layer split keeps 0.1.29's own prompt buffers (2048-token chunks, priced into the split search) when they are at most 12% of every card's VRAM; smaller cards keep borrowing (STRATA_SPLIT_OWN=1/0 forces)
Measured on 9070 XT + R9700 (Coder IQ1_M): 2K/4K/8K/16K prompts 1588/1771/1943/2006 tok/s (0.1.29 1568/1730/1870/1935,
0.1.31 993/1212/1350/1852). One GPU unchanged; --split-skip-if-fits keeps the loans.
2026-10-01 10:25:03 +02:00
Niko1221 b7bb142060 #340 prototype: STRATA_SPLIT_SMALL_MAX=M - a split request of at most M prompt tokens reads in the stages' own S-token chunks (nothing lent) 2026-10-01 10:04:08 +02:00
Niko1221 242248ceed setup: Unsloth UD-Q4_K_XL as an experimental choice (--family unsloth) - the four shards pinned at 38bb39e with their sizes and SHA-256, a RAM budget of the PC's RAM less 24 GB, packed with --compat-bf16, engine 0.1.32 or newer
- FAMILIES["unsloth"] (marked [experimental], not the default) and MODELS["UD-Q4_K_XL"] ("budget": True,
  48 GB of RAM or more); HF_REVISIONS pins unsloth/Qwen3.8-Flash-Next-GGUF; families may have more than two
  shards ("shards": 4).
- The download resumes as before; then verify_sha256 checks each shard's size and SHA-256 once (remembered in its
  finish mark; a wrong file is deleted so the next run downloads it again).
- resident_budget_gib: round(RAM) - 24 GiB (40 on 64 GB, the measured setting), at most the 71 GiB of experts, at
  least 8; a KV cache streamed to RAM (64K+) comes out of it. --resident-budget-gib replaces the low-RAM mode for
  this model (no experts.bin; --low-ram is ignored with a warning); one GPU, no images, no speed projection; 8K
  context recommended on GPUs under 14 GB; no --ple-gguf for a 4-shard file (the engine finds the PLE shard).
- The engine version is checked right after the engine step, before the 111 GB download.
- choices_from_config reads a size with a dash (strata-unsloth-ud-q4_k_xl.json).
- tools/test_setup_unsloth.py: pins, budget, SHA-256 handling, config round trip, and setup.main() end to end with
  every outside effect mocked (URLs, pack flags, engine args, old engine, too little RAM, two GPUs + images).
- README and docs/UNSLOTH_Q4.md / DETAILS.md describe it.

The model support itself follows eddoursul/Strata (PR #245).
2026-10-01 09:33:20 +02:00
Niko1221 796655c6ff docs: UD-Q4_K_XL against llama.cpp on the same GGUF - 99.0% argmax agreement on a code answer, 97.5% on a thinking answer, 90-91% after a 16K prompt, every difference where llama.cpp's own top two are close
Same token sequences through Strata (40 GiB budget, greedy, adaptation off, STRATA_LOGPOS_TOPK=20 on the verify
windows) and llama.cpp 3cf0325 (CPU, mmap, top 20 from llama_get_logits_ith): argmax agreement, top-5/10 overlap,
KL over the top 20, perplexity. Code 99.0% / thinking 97.5% (the fork, eddoursul/Strata: 98.2-99.3% / 95.6-95.8%);
after a 16K prompt 90.2% on Strata's greedy continuation and 91.2% on real text, the same real-text positions with
512 tokens of context 89.2% - so not a long-context loss: all positions with a top-1/top-2 gap of 0.5 or more agree
(and every code/thinking position from 0.2), perplexities within 3%.
2026-10-01 09:32:19 +02:00
Niko1221 88f4146c53 #340 prototype: a split's streamed ring is 96 slots when most experts are resident (STRATA_SPLIT_RING); STRATA_SPLIT_SMALL_OWN=S keeps an S-token chunk's buffers per lending stage for the session; --no-prefill-borrow on a split books the ring (it no longer starves the draft head)
One GPU: unchanged (all three rules are for layer splits only).
2026-10-01 09:22:58 +02:00
Niko1221 5fd4f2670f #296 follow-up: ple_q5_parity / q5_projection_parity build only with STRATA_BUILD_TESTS; the doc says what runs where
The two real-weight checks were added to every CUDA build with native experts (a full release build compiled them);
they are test programs. docs/ORCA_Q4_K_S.md: the build flag for them, and that 0.1.31's GPU expert kernels take
Q4_K gate/up with Q5_1 or Q8_0 downs (Q5_0 is not among them yet: the engine refuses such a pack at start, naming the layer).
2026-10-01 08:49:35 +02:00
Suoriks 75a39eef3a feat: support OrcaRouter Q4_K_S
Load three-shard Uncensored weights while preserving Q5_0 PLE rows
and Q4_K/Q5 expert bytes.

Add native CUDA and MMQ paths with real-weight parity checks.

Rebased onto 0.1.31 (Niko1221): 0.1.31 already loads each expert role from its own shard (the per-role shard column
of native_experts.txt, iq_pack.py, expert_source.cpp, native_expert_parity's multi-shard mode) and has its own
Q4_K/Q5_K/Q5_1/Q8_0 GPU expert decoders, so this PR's gguf_role_file / v4 manifest, its iq_pack.py and
test_iq_pack.py changes and its iq_kernels.cu decoders are dropped. Kept: Q5_1 in native_mmvq (type 7 through
0.1.31's iq_mmvq) and in the BF16 dequantizer, the Q5_0 PLE table (mapped reader), the Q4_K/Q5_0/Q5_1 MMQ
instances under the STRATA_ORCA_Q4KS_MMQ option (OFF), ple_q5_parity / q5_projection_parity and the doc.
2026-10-01 08:49:03 +02:00
Niko1221 cf3b351c19 #272 follow-up: --pool-affinity all (the pool's layout so far) is the default; auto and p-cores are opt-in
#272 made Auto the default, which on a hybrid CPU moves the workers (P-core primaries, then SMT siblings, then
E-cores) and cuts their number to P-cores - 1: a speed change nobody has measured here, on the machines most
users have. The default is All - the same cores in the same order as before on every CPU (Windows: the first
logical processor of each core; Linux: one allowed CPU per (package, core)), and the same worker count - in
Options, ExpertPool, physical_cores() and detect_cpu_topology(). --pool-affinity auto | p-cores opts in; the
hybrid line is printed only then. Usage text says so.
2026-10-01 08:47:56 +02:00
Pravesh Khatana 69743d3a5c feat(cpu): add hybrid architecture awareness and --pool-affinity for P/E-core CPUs
- Add detect_cpu_topology() for Windows (GetLogicalProcessorInformationEx) and Linux (/sys/devices/system/cpu/cpu*/cpu_capacity)
- Identify hybrid P/E-core topology and SMT sibling structures
- Prioritize primary P-cores for worker allocation, reserving core 0 for host thread
- Default pool_workers to (p_cores - 1) on hybrid CPUs when unspecified
- Add --pool-affinity auto|p-cores|all CLI option
- Maintain 100% backward compatibility on non-hybrid CPUs and default configs
2026-10-01 08:47:28 +02:00
Niko1221 029e10d9d9 #290 follow-up: a BF16-row parity test (native_expert_parity --bf16-embd)
iq_embed_rows (97 rows gathered out of order, with repeats) and iq_dequant_f32 on a random BF16 table, every value
compared bit for bit with the exact widening (bits << 16); embed_type_supported(30) / iq_supported(30) /
iq_row_bytes(30). ctest native_expert_parity_bf16_embd.
2026-10-01 08:46:48 +02:00
sergiywith 32727a7a94 Token embedding in BF16 from the checkpoint (--embd-gguf)
- tools/embd_bf16_pack.py copies embed_tokens (BF16, as the checkpoint ships it) into a one-tensor GGUF; only the
  safetensors shard that holds it is needed (3 GB for Qwen/Qwen3.8-Flash-Next).
- --embd-gguf PATH: NativeEmbed reads token_embd from that file; iq_embed_rows and iq_dequant_f32 decode BF16
  (embed_type_supported). Mapped host memory as before (1.2 GiB instead of 0.3 for IQ4_XS), no VRAM.

First-token KL of the GGUF's IQ4_XS embedding against the BF16 one: 0.0015 (1K), 0.0089 (2K; the top token changes), 0.0010 (4K), 0.037 (32K); mean 0.012, ~100x the run-to-run noise. On the NVFP4 fork, whose GGUF embedding is Q8_0, the same comparison gave 0.0025. Decode and prompt speed are unchanged (fork); the start takes ~0.2 s more.

Rebased onto 0.1.31 (Niko1221): NativeEmbed::load takes the shard list (one file for --embd-gguf) and checks the
model's architecture since 0.1.31 - the one-tensor file says "strata-embd", so only its tensor is checked there;
the Q4_K/Q5_K/Q5_1/Q8_0 decoders 0.1.31 added stay beside the BF16 one.
2026-10-01 08:46:48 +02:00
Niko1221 c81244d4e9 #293 follow-up: the drafter stores rotated INT8 K/V as INT8; the rotation is part of the snapshot format
- mtp.cpp record_forward: the `if (st_.kv_rot)` branch rotated K and V and then always appended with
  kv_append_q4_step - for INT8 + STRATA_KV_ROT=1 into Q4_0 pools the state does not have. The rotation and the
  append are separate now: rotate when kv_rot, then append in the state's own format (Q4_0, INT8, FP16).
- conversation_snapshot.cpp: rotated INT8 K/V is its own snapshot format (+16), so a conversation snapshot or prompt
  checkpoint taken with the rotation is refused by a state without it and the reverse ("incompatible K/V
  geometry"); without the rotation the format is unchanged. conversation_snapshot_test checks both directions.
- generate: says when STRATA_KV_ROT=1 applies; the q4_0 line's comment back.
2026-10-01 08:45:09 +02:00
sergiywith f133c655a8 KV: optional Hadamard rotation for int8 K/V (STRATA_KV_ROT=1); the drafter and the batched verify rotation-consistent
INT8 K and V can go through the Walsh-Hadamard rotation --kv q4_0 already uses (kv_q4.hpp): it spreads outlier
channels over the 64-value scale groups before quantization; the queries are rotated too (<Hq, Hk> = <q, k>) and the
output rotated back.

- QsaState::kv_rot: Q4_0 always, INT8 with STRATA_KV_ROT=1 (off by default: the same tokens as main).
- Every writer and reader follows it: decode, the verify window, the prompt path, the MTP drafter, and the drafter's
  batched prompt pass (Prefill::draft_kv) - which rotated only for Q4_0.
- verify.cpp: the batched window path (qb) never rotated its queries; it did not matter while Q4_0 was kept off it.

First-token KL to fp16 K/V, 4 prompts incl. 32K: NVFP4 pack 0.0066 -> 0.0051; IQ2_XS 0.0022 -> 0.0054. Hence opt-in.
2026-10-01 08:44:04 +02:00
Niko1221 0f461187d2 #280 follow-up: the float64 RoPE table is opt-in (STRATA_ROPE_TABLE=1); a freed session's table is forgotten
- The table's angles differ from the fast-math cosf/sinf ones in the last bits, so every output moves: off by
  default (the kernels compute the angle exactly as 0.1.31), STRATA_ROPE_TABLE=1 turns it on (replaces the PR's
  STRATA_ROPE_LEGACY A/B switch).
- The per-device registration was a raw pointer into the session's arena that outlived it: QsaState::owns_rope marks
  the state that built the table (not one that borrowed it with share_rope, like the MTP drafter's), and
  session_release() - to be called before a session's memory is freed - clears every device's entry pointing at
  it (rope_table_release). The latest session of a device now wins, instead of the longest table.
2026-10-01 08:43:38 +02:00
sergiywith 16a369b574 RoPE: every kernel reads the session's float64 angle table
The native decode/verify rope and the indexer's pooled keys computed pos * powf(...) with cosf/sinf under
--use_fast_math (0.0014 rad off at 32K, ~0.02 at 262K), the prompt path with precise float libm, and the float64
table the session builds was read only by the non-native path. rope_table_set registers that table per device
(mrope.hpp); rope_cs reads it, or computes in float64 past its end.

Measured on main with IQ2_XS: first-token KL of the old angles against the table 0.0045 on a 32K prompt (two runs of
main: 0 to 0.00013 on short prompts). On an NVFP4 pack: 0.0063 at 32K and at 125K. Speed unchanged.
STRATA_ROPE_LEGACY=1 brings the old float angles back for A/B.

Rebased onto 0.1.31 (Niko1221): 0.1.31's rope scaling (#84: linear / YaRN, rope_scaled_angle) is in every rope
kernel and in the session's table (build_rope_table with the RopeScaling), so a kernel reads the table only when it
was built with the scaling it was given, and otherwise - or past the table's end - computes the angle exactly as
0.1.31 does (no separate float64 device path); rope_table_set registers the scaling with the table.
2026-10-01 08:43:07 +02:00
Niko1221 5f02176997 verify: STRATA_LOGPOS_TOPK=K adds the K most likely tokens and their log-probabilities to the STRATA_LOGPOS rows
For a per-position comparison with another engine on the same tokens (argmax agreement, top-k overlap, KL on the
top K): docs/UNSLOTH_Q4.md compares UD-Q4_K_XL with llama.cpp this way.  Off unless the variable is set; the
eight existing columns are unchanged.
2026-10-01 08:42:54 +02:00
Niko1221 fc2eb78e0a conversation cache: a turn's parked copy supersedes the previous turn's, so a subagent no longer evicts its parent (#342)
Every request that does not continue the live session parks it, and put() never removed older copies of the
same conversation while make_room evicted oldest-first: a subagent's 9 successive turns (each re-rendering the
previous reply) parked 9 copies and pushed the parent conversation out of 4 slots. drop_superseded() now runs
before make_room (park_current) and in put(): an entry whose DEEPEST checkpoint the outgoing chain (or live
state) still holds - the same conversation a turn back, differing only in the stale reply tail - is dropped
(counted apart from evictions, logged). An entry without checkpoints, of the other steering mode, or whose
deepest checkpoint the outgoing chain lacks (another conversation sharing only the system-prompt root) is kept;
an oversized put drops nothing. The cache is opt-in (#189): with it off nothing runs. Tests in
conversation_cache_test (MAIN -> SUB x9 -> MAIN with 4 slots; the kept cases).
2026-10-01 08:42:33 +02:00
Niko1221 c03efab319 serve: AMD readings in the Monitor tab from Linux sysfs; free VRAM on HIP (#301)
With the AMD backend (config backend "hip") telemetry reads the amdgpu driver's sysfs files instead of NVML:
gpu_busy_percent, mem_info_vram_used/_total, and hwmon temp1_input, power1_average (or power1_input) and
power1_cap. The card is found as setup's amd_gpus() numbers it (KFD topology GPU nodes in order, CPU nodes
skipped, drm_render_minor -> /sys/class/drm/renderD<N>/device), which is HIP_VISIBLE_DEVICES' numbering; a
layer split sums/averages as on NVIDIA. Service.free_vram_mib (min_free_vram_mib) uses it on HIP. NVIDIA
paths unchanged. Test: AmdTelemetry (a fake sysfs tree, two cards and a CPU node). Not yet checked on a real
AMD box.
2026-10-01 08:41:14 +02:00
Niko1221 7d746a0887 #283 follow-up: STRATA_PREFILL_BF16X2 defaults to 0 (off) - the prompt path's numbers stay 0.1.31's
The second (remainder) GEMM changes what the prompt path computes, so it is opt-in: 2 = all but the
hyper-connection's projections, 1 = all. With 0 every lo pointer is null: no extra buffers in carve()/bytes_needed(),
the PLE batch size as before, and every kernel writes exactly the BF16 images it wrote before.
2026-10-01 08:40:29 +02:00
sergiywith a86bc853f3 Prompt path: BF16 projections get the activation's BF16 remainder too
The prompt path fed BF16-rounded activations (2^-9 relative) to the BF16-weight projections, where decode feeds FP32:
the router (a discrete top-10), the indexer (a discrete block selection), SSM alpha/beta, the shared-expert gate, the
PLE key/value and the hyper-connection. Each now takes x as hi + lo, both BF16 (lo = bf16(x - hi)), in two GEMMs
summed in FP32: ~16 mantissa bits, decode's FP32 x to within ~1e-5.

STRATA_PREFILL_BF16X2: 2 (default) all but the hyper-connection, 1 all, 0 off.

IQ2_XS, first-token KL to mode 1: short prompts main 0.0028/0.0069/0.0009, mode 2 0.0014/0.0024/0.0012; a 32K prompt
0.074 and 0.072 (the hyper-connection is what matters there).
2026-10-01 08:40:02 +02:00
Niko1221 da95ad29d8 #282 follow-up: chunks above 8192 are opt-in (--prefill auto:16384 / auto:32768, or STRATA_PREFILL_AUTO_MAX)
A bigger chunk reads a long prompt in a different order of chunks (other expert loans, other rounding of the
batched path), so it stays out of the default: plain --prefill auto picks from 8192 down exactly as 0.1.31 did (the
PR's "no chunk past the context" rule, which also moved the choice below 8192 for small contexts, now applies only
to the new sizes). auto:N (16384 or 32768) or STRATA_PREFILL_AUTO_MAX with auto sets the ceiling; o.prefill_chunk
starts at that ceiling for the buffer estimates. Both kAutoChunks lists - plan_lend and the serve path's per-stage
fits() - take the same sizes under the same rule.
2026-10-01 08:39:58 +02:00
sergiywith 1e5e84d919 prefill auto: chunks up to 32768 (was 8192)
Every chunk streams again each expert it routes to, so a long prompt read in 8192-token chunks crossed PCIe with
nearly all experts of every layer four times per 32K. The auto list now starts at 32768 and 16384, still bounded by
the lend rule and by --max-context; a request lends only what its prompt needs, so short prompts are unaffected.

IQ2_XS, RTX 5090, 64K context, a 32K prompt (3 runs each): 5,624 -> 6,465 tok/s, 40K -> 18K experts streamed.
NVFP4 pack at 262K: 3,535 -> 5,201 tok/s.
2026-10-01 08:39:27 +02:00
Niko1221 6280f653c8 #281 follow-up: the saturated FP16 SwiGLU product keeps a NaN a NaN
fmaxf(NaN, -65504) is -65504, so #281's clamp turned a NaN product into -65504 and the prompt path went on with a
plausible value where it used to show the NaN (STRATA_DBG_NAN and the NaN checks find it there). isnan(x) ? x :
clamp(x): only +-inf (and finite values from 65520 up, which rounded to inf) saturate; everything else is unchanged.
2026-10-01 08:38:59 +02:00
sergiywith c517862ce2 numerics: saturate the prompt path's FP16 SwiGLU products; log1pf in the unfused GDN gate
- prefill/kernels.cu: the SwiGLU products that feed the prompt path's FP16 down projection are clamped to FP16's
  range (+-65504) before rounding. A token with a massive activation otherwise becomes inf there and NaN after the
  GEMM, where decode's q8_1 path (range ~8e6) stays finite.
- native_gdn_preprocess.cu: the unfused gate softplus used logf(1 + expf(v)), which returns 0 for v below ~-16
  (1 + e^v rounds to 1); the fused kernels, gdn.cu and verify_kernels.cu already use log1pf(expf(v)). The two paths
  now agree.

On ordinary prompts nothing moves: first-token KL to main 0, 0.00013, 0 (the run-to-run noise).
2026-10-01 08:38:35 +02:00
BlueKingMuch 4da8bfcbf9 ple: keep the SSD awake while rows are read (STRATA_SSD_KEEPALIVE)
Some SSDs (here a WD_BLACK SN7100 on Windows 11) drop into a power state
after ~250 ms without a command and stall the next reads 50-150 ms; the
NVMe idle timeouts of Windows' power plan do not change it. In decode that
hits the first read after a pause: at the start of a request, or after a
few rounds whose rows all came from the row cache. --ple-io ram, which
avoids the reads altogether, is not available on Windows.

The reader's worker now reads one page of the table (a different one each
time) when no read has gone out for 100 ms, until 60 s after the last
issue; then the SSD may sleep until the next request re-arms it. A
keep-alive read counts when it completes and stays out of the row-read
counters and latencies; the "ple io" line adds "SSD kept awake by N reads
(slowest X ms)". A keep-alive read that fails, or cannot be submitted,
turns the keep-alive off instead of failing the reader.
STRATA_SSD_KEEPALIVE=0 turns it off, =50 shortens the period;
STRATA_SSD_KEEPALIVE_WINDOW sets the window in seconds. Only with the I/O
worker (the default), not with --ple-sync-submit or --ple-io mmap/ram.

The reader's statistics are now copied and reset under the worker's lock
(snapshot()), since the worker may be counting a keep-alive read. The
selftest checks the period, the window, the re-arm by a ticket the row
cache serves, that rows and read counters are untouched, and that the
caller-thread mode has none.

A scan on that PC (reads after pauses of every length): 0 of 211 bursts
stalled after pauses under 200 ms, 35 of 73 after 200 ms and more, 0 of 68
of those with the keep-alive on.
2026-10-01 08:38:27 +02:00
Niko1221 9d0b28df54 #315 follow-up: its variants and switch renamed (plain / split / staged, STRATA_HC_SPLIT) - no clash with STRATA_GR_V3
main already has an opt-in "v3" hyper-connection read (#186, STRATA_GR_V3=1, another summation order); #315's
"v2"/"v3" and STRATA_HC_V2 read as the same thing. Now: the plain read (0.1.31's default), split (the norm per
token and stream) and staged (split + the down projection's activations staged by cp.async), kHcPlain/kHcSplit/
kHcStaged, gr_norm_split_kernel / gr_down_staged_kernel, and STRATA_HC_SPLIT: unset or 2 = the newest the card's
check accepts, 1 = at most split, 0 = the plain read. The check compares against the plain read (launch_multi with
kHcPlain) and the single-token read, never against what STRATA_GR_V3 selects; with STRATA_GR_V3=1 that opt-in read
still runs first, unchanged.
2026-10-01 08:38:22 +02:00
Niko1221 d85ff9dfe9 serve: model aliases - the config's aliases in /v1/models and accepted as model names (#297)
`"aliases": [...]` (or a comma-separated string) in strata-<model>.json: /v1/models lists the model with an
`aliases` field and each alias as its own entry (`alias_of`), /props?model= accepts them, and a request naming
an alias is answered under that name (OpenAI, streamed or not, and Anthropic). Any other name is still served
under the model's own name, as before; without aliases the responses are unchanged. Documented in DETAILS.md.
Test: ModelAliases (serve/test_server.py).
2026-10-01 08:37:46 +02:00
Niko1221 469bdaf891 #340 prototype: a split stage with room for its prompt buffers keeps them as its own (no loan, nothing streamed or refilled for it); STRATA_SPLIT_OWN_BUFFERS=0: every stage borrows
One GPU: unchanged (the rule is for layer splits only; the single-cache loan is computed exactly as before).
2026-10-01 08:37:18 +02:00
BlueKingMuch 2cf197f894 hc: the multi-token hyper-connection read split finer, checked bit for bit on each card (STRATA_HC_V2)
The multi-token read (verify windows, the MTP drafter) keeps v1's
arithmetic exactly - every sum over the same elements in the same order -
and only splits the work differently:
- the norm (v2, v3): one block per token and stream instead of one per
  token. Each thread visits the elements of its stream in the order it did
  in v1, so every sum of squares and rs is v1's; R' * w_norm is recomputed
  and scaled once (the same two roundings as v1's store and in-place
  scale). On an RTX 4080 SUPER: 0.58 -> 0.23 ms per 4-token round.
- the down projection (v3): v1's rows per block and lane order, but the
  activations arrive by cp.async in half-stream tiles, two in flight, in a
  bank-conflict-free two-plane layout, and the next tile's weights load
  while the current one is used. A tile is 160 = 5 x 32 chunks, so a lane
  still accumulates its chunks lane + 32 q in ascending order. Before sm_80
  and on HIP the staging is a plain copy (the same bits).

Verifier::init runs fused_gr_check once per card: v1, v2, v3 and the
single-token read on random bf16 weights and inputs (1..8 tokens, with and
without the pending write), every output compared bit for bit; the newest
variant that agrees runs on that card and the log says which. A card that
has not been checked runs v1. STRATA_HC_V2=0 keeps v1, =2 stops at v2.
The down kernels carry as many tokens per launch as the card's shared
memory allows (v3: 10 KB per token), as v1 did.

Rebased onto 0.1.31 (Niko1221): v1 is 0.1.31's default read unchanged - the TILEV 1280/2560 down kernel (sm_75's
small tile), the pre-Volta capacity rule, STRATA_EMULATE_CC - moved into down_chunk()/launch_multi(); main's opt-in
STRATA_GR_V3 path (#186, another summation order) still comes first in fused_gr_read_multi, and the card's check
calls launch_multi(1) directly, so it compares against the default read whatever STRATA_GR_V3 says.
2026-10-01 08:36:04 +02:00
Niko1221 348d65da7b #340 prototype: a layer split refills every stage's prompt loan concurrently (queue all, then wait); STRATA_REFILL_SERIAL=1: stage after stage; STRATA_TRACE times the loan and the refill
One stage: refill_one exactly as before (single-GPU unchanged). The same copies into the same slots either way.
2026-10-01 08:35:57 +02:00
Niko1221 bd84d0bc6d #284 follow-up: wait for the async commit on an event, at every point that touches the session afterwards
The commit graph writes the GDN state and conv tail, the QSA indexer's tail/dead/pooled/block_pos and the PLE
history; with #284 it may still run when commit() returns. Verifier::commit records commit_done_ after it, and
Verifier::wait_commit() synchronizes that event (not the device; a no-op when nothing is pending, recursing into a
layer split's later stages). A layer split's first stage keeps the synchronous commit (next_ set).

Audited, and where the wait now is:
- the serve decode loop's end (end of turn, max tokens, STOP/cancel): wait before the live session, the state
  fingerprint (STRATA_STATE_HASH) and the DONE line - so the next request's park (conversation snapshot capture),
  restore, checkpoint restore and zeroing never see a running commit;
- the prompt read by verify windows (serve): wait at its end - the batched prompt path (other streams), prompt
  checkpoints (cudaDeviceSynchronize already) and snapshots may follow;
- the start of each serve request: an event wait replaces #284's cudaDeviceSynchronize (covers error paths);
- the end of a generate run: wait right after the decode loop, before the stats and the dumps (#284 synchronized
  only later, after the routing dump);
- unchanged and safe: the next window (same stream), the MTP draft (its own stream; reads the window's final rows
  and its own K/V, which commit does not write), the adaptive tier thread (expert slots and residency tables only),
  STRATA_LOGPOS / STRATA_DUMP_FIRST_LOGITS (read run()'s head logits after run() synchronized), QUIT and /unload
  (the Verifier destructor synchronizes its streams before freeing).
2026-10-01 08:34:33 +02:00
Niko1221 2282393234 setup --backend hip: --vision cpu builds and uses the CPU image encoder (#304)
Setup forced images off on the AMD backend. hip_vision() now takes --vision cpu: build_engine_hip builds
tools/vision without CUDA beside the HIP engine (build_vision_cpu, again when its source changes) and records
vision/vision_src in BUILD.json; the start config is the CPU encoder's, as on NVIDIA. --vision yes/gpu stay off
with a hint (no HIP encoder build yet); without --vision nothing changes. Test: tools/test_setup_choices.py.
2026-10-01 08:34:07 +02:00
sergiywith a1e4fb4c80 Verify: the commit graph no longer waits; it overlaps the MTP draft
The commit's cudaStreamSynchronize held the host ~0.45 ms a round. The next window follows it on the same stream and
the drafter (its own stream) reads only this window's final rows and its own K/V, so a single-GPU session
(Verifier::set_commit_async) returns at once. Whatever touches the session from another stream or the host afterwards
synchronizes the device: the start of each --serve request (checkpoint restore, zeroing, the prompt path) and the end
of a generate run; checkpoint saves already did. A layer split keeps the wait, as does STRATA_COMMIT_SYNC=1.

IQ2_XS, 400-token answers, 3 runs each: 128.6 -> 135.8 tok/s decode (+5.6%), the same tokens. NVFP4 pack +0.8%.
2026-10-01 08:33:05 +02:00
Niko1221 3b7a49a6fd setup: Pascal (6.x) and Volta (7.0) with STRATA_EXPERIMENTAL_SM60=1: the community build with CUDA 12.x (#295)
The engine/CMake part shipped in 0.1.31. Setup now admits compute capability 6.x and 7.0 only when
STRATA_EXPERIMENTAL_SM60=1 is set (gpu_problem; without it the message says so), compiles the engine with
-DSTRATA_EXPERIMENTAL_SM60=ON for cards below sm_75 (engine_defs), and takes the newest CUDA 12.x toolkit
(find_nvcc(below=(13, 0)); CUDA 13 cannot build sm_60/sm_70) - stopping with a hint when there is none, or
when an RTX 50 card (CUDA 13) shares the model with such a card. Without the variable nothing changes.
Test: tools/test_setup_choices.py (mocked toolkits and cards).
2026-10-01 08:32:49 +02:00
Niko1221 272c16c767 #332 follow-up: the API request monitor is opt-in ("api_monitor": true / --api-monitor), off by default
It keeps the last 100 requests' prompts, answers and reasoning in memory. Off (the default): begin_request() keeps
nothing, the streams are not wrapped, GET /api/requests and /api-monitor answer 404. Every record write goes through
_note(), which does nothing without a record (the PR's direct self.record[...] writes in the stream error paths
would have failed with the monitor off). A client disconnect in do_POST is marked and then re-raised, as the server
handled it before. The start line says when it is on (and that anyone can read the history without an API key).
test_monitor: turns it on; MonitorOff checks the default; Anthropic requests ask for thinking with "thinking" (#278).
2026-10-01 08:32:01 +02:00
Ricardo Ambrogi 24d011807c serve: add standalone API request monitor 2026-10-01 08:31:48 +02:00
Niko1221 5a18f83a13 setup --gguf-dir: the shard count from the -of-N part of the name, not two (#305)
--gguf-dir built exactly <model>-00001-of-00002.gguf and -00002-of-00002.gguf, so a model split or named
differently (-00001-of-00003, Unsloth's ...-00001-of-00004.gguf) was not found. gguf_dir_shards() takes the
published name when it is there (unchanged for the existing models), else the one first shard in the folder
whose name has the size in it, and names shards 1..N from it as the engine and iq_pack do. Help text updated.
Test: tools/test_setup_choices.py (2- and 4-shard names).
2026-10-01 08:31:13 +02:00
Niko1221 354212421e setup: the CPU image encoder when the ready-made encoder has no code for the card (#331)
The release zip's strata-vision has no sm_75 code (BUILD.json vision_archs 86/89/120), so on an RTX 20 card
setup fell back to compiling the encoder, which fails on most Windows PCs. prebuilt_vision() now chooses the
CPU encoder (the same program without --gpu) with a warning; --build still compiles a GPU one. The next release
zip should build strata-vision with 75-real as well. Test: tools/test_setup_choices.py.
2026-10-01 08:30:06 +02:00
Niko1221 abfb05cfbe native packs: a BF16 (--compat-bf16) PLE key stays in the arena and is not replaced by the GGUF key (#326)
Since 0.1.25 NativeDense treats an IQ3_XXS/IQ4_XS/Q8_0 GGUF key as native, so for a native pack the loader
skipped the pack's key row and then refused the BF16 row iq_pack --compat-bf16 writes for OrcaRouter's IQ3_XXS
key ("native dense: incompatible matrix blk.1.ple_key.weight"). NativeDense::keep_unquantized_ple_key reads the
key row's code_bits from index.txt (WeightTable::index_code_bits) and keeps an unquantized row in the arena;
NativeDense::load does not upload the GGUF key over it, and the PLE uses the BF16 key as before 0.1.25. A
quantized key row (Q2_0, UD-Q4_K_XL packs) is unchanged; the GSQ packs' GGUF keys are BF16 (not eligible), so
they never reach this path. The reporter's fallback (Gen4536). Test: native_dense_ple_key_test (synthetic GGUF
+ pack, CUDA).
2026-10-01 08:29:03 +02:00
Niko1221 75780af235 mtp_fetch: a range read needs 206 + its Content-Range; pinned per-tensor sha256, corrupt installs fetched again (#327)
A mirror that ignores the Range header answers 200 with the shard's start (its JSON header); cut to the asked
length it passed the size check and the manifest hashed the wrong bytes, so the drafter accepted nothing. get()
now requires HTTP 206 with the requested Content-Range. The 31 MTP tensors' sha256 at the pinned revision
(de4b8e4) ship in SHA256 (two independent fetches agree; 29 re-read from the revision, the two expert tensors'
first/last 16 MiB): a wrong tensor is fetched again once, then refused. An inventory read from another
repository/revision is read again and its tensors are kept only when they hash right. `mtp_fetch.py verify`
(offline, cached by size/mtime) finds a corrupt install; setup then fetches the bad tensors again and rebuilds
the draft layer. From PR #324: a refused engine archive no longer keeps its zip and .done mark.
Tests: tools/test_mtp_fetch.py (fake checkpoint behind a mocked urlopen, a mirror that ignores Range),
test_setup_pins (refused archive).
2026-10-01 08:28:45 +02:00
Niko1221 d3bf912ea0 #334 follow-up: jsonschema is an optional, lazily imported package (no new hard dependency)
- The rebase keeps 0.1.31's requirements.txt install in setup.py and the Dockerfile: jsonschema is not added.
- serve/structured.py imports jsonschema on the first json_schema request, not at server start (a server without it
  started fine before #334 and still does). json_object never needs it; json_schema without it is checked to be one
  JSON object, and the server window says once how to get full schema validation.
- test_structured: the two schema-violation tests skip without jsonschema; new tests for the object-only fallback
  and for "import serve.server" not importing jsonschema. docs/DETAILS.md says it is optional.
2026-10-01 08:27:57 +02:00
Ricardo Ambrogi c87a9cb0ce serve: validate JSON response formats before delivery 2026-10-01 08:27:08 +02:00
Niko1221 bd9a1bc126 #333 follow-up: the unload keeps its terminate/kill fallback; EngineStuck instead of a catch-all RuntimeError
- StrataEngine.close() (now also the unload and the restart): QUIT and EOF, then terminate, then kill, each with 20 s
  as the unload had (#333 went from QUIT straight to kill after 10 s; an engine unpinning tens of GB can need more).
  A process that outlives all three raises EngineStuck and stays owned.
- do_POST caught every RuntimeError as a 503 - EngineDied, GpuBusy and ModelBusy are RuntimeErrors too, and any other
  failure was turned into a vague 503. Only EngineStuck is caught now (also around POST /unload, and the idle-unload
  thread survives it); EngineDied keeps its own answer.
- test_lifecycle: terminate before kill, EngineStuck, an EngineDied on load answered as such.
2026-10-01 08:26:28 +02:00
Ricardo Ambrogi 7f3a091895 serve: add lazy startup and reliable Windows model cleanup 2026-10-01 08:24:02 +02:00
Niko1221 a8d5a16c35 #321 follow-up: CORS only on /v1/* for configured origins; no own-page bypass for proxy headers
- The Origin check of /settings and the MCP tools let any page through when the request carried X-Forwarded-For,
  CF-Ray or CF-Connecting-IP (headers every reverse proxy or tunnel adds), and compared hosts without their ports
  (a page on another local port passed): any web page could then change the shared settings or run MCP tools with the
  user's rights. Removed. The Origin must be this server's host:port, or an origin in the config's new
  "trusted_origins" (the web app behind a proxy or tunnel); a proxy header alone opens nothing.
- CORS is opt-in: "cors_origins" in the config (an origin, a list, or "*"). Only /v1/* answers with
  Access-Control-Allow-Origin (the origin itself, or "*"), never /settings, /unload or the app's files; the
  preflight echoes the headers asked for ("*" does not cover Authorization). OPTIONS is answered 204 either way.
- X-Accel-Buffering: no on SSE stays. origins_of() checks both lists at start (scheme://host[:port], no paths;
  "*" only for cors_origins). docs/DETAILS.md; tests for the bypasses, the trusted origin, CORS off/on, the header.
2026-10-01 08:23:27 +02:00
BlitzenCatsandGemini 392e32c46b serve: add CORS preflight (OPTIONS), reverse-proxy header support, and X-Accel-Buffering for SSE
- Implement do_OPTIONS (204 No Content) and add Access-Control-Allow-* headers to allow web-based clients (Open WebUI, LibreChat, browser extensions) to query endpoints.
- Update _own_page to recognize reverse proxies and tunnels (Cloudflare Tunnel, Tailscale Funnel, Nginx) via X-Forwarded-Host, CF-Ray, and forwarded headers, preventing 403 CSRF false-positives when serving remotely.
- Add X-Accel-Buffering: no to SSE streaming responses to prevent reverse proxies from buffering real-time token generation.
- Add unit tests in serve/test_server.py covering CORS preflight, CORS headers, and reverse proxy origin checks.

Co-authored-by: Gemini <[email protected]>
2026-10-01 08:22:10 +02:00
Niko1221 ca85ebdee2 #278 follow-up: an Anthropic request with its own reasoning_budget_tokens still thinks
"thinking" absent meant no thinking, also for a request that gives reasoning_budget_tokens (#123), which asks for
thinking with a cap (serve.test_server's test_anthropic_stream failed: no thinking at all). Such a request renders
as before. test_anthropic_thinks_only_when_asked pins the five cases.
2026-10-01 08:18:19 +02:00
Niko1221 40eaa123d4 serve: a restarting engine is not alive until READY; context 0 is a 503 "starting" (#344)
restart() set ended=False before __init__, which zeroes max_context and blocks until READY, so a request in that
window skipped load() and failed with a 400 "leaves no room to answer in the context (0)". The engine is now
marked alive by __init__ once READY; prepare() answers 503 "the engine is starting" when max_context <= 0. The
output thread is bound to its own process and queue, so a killed engine's thread no longer marks its successor
dead or writes into its queue. Tests: RestartWindow (a fake strata --serve with a held READY).
2026-10-01 08:17:54 +02:00
Developer 6cd29d9850 serve: keep retained K/V through the cache capacity gate
park_current dropped the retained K/V whenever can_fit failed and fell
back to a full snapshot capture. The gate duplicates what make_room
decides immediately after, with harsher arithmetic: the slot term fires
when make_room enforces the same cap, and the byte term compares the
with-reuse estimate against headroom that ignores the parked image
replacing the retained buffers. make_room already implements the
stated policy - pressure drops the optional retained storage before
evicting any parked conversation (the priority the cache tests pin).
With a full cache the fallback buys nothing: the fresh estimate forces
the same or more eviction, plus a whole-snapshot recapture instead of
the growth - hundreds of ms per park at ~100K tokens where one long
conversation round-trips while short-lived conversations keep the
cache full.

The with-reuse estimate stays uncapped: it counts the retained buffers'
capacity and directories, and put() charges that same true size, so a
capped figure would under-evict and overfill the budget.
2026-10-01 08:15:27 +02:00
Pravesh Khatana b0711943b2 feat(mtp): add --coupled-draft and --no-coupled-draft CLI options for coupled speculative sampling
- Add set_coupled_draft() and coupled_draft_state() in include/strata/core/coupled_draft.hpp
- Add --coupled-draft and --no-coupled-draft CLI options to src/program/generate.cpp
- Default option to STRATA_SPEC_COUPLED environment variable for full backward compatibility
- Update usage() help text with option descriptions
2026-10-01 08:15:27 +02:00
Hozák Martin 43cd140ecd bench: BF16 GEMV via Turing tensor cores on sm_75 - measured negative
Isolated benchmark (no inference-path changes) comparing the production
bf16_gemv warp kernel against an mma.sync.m16n8k8 tensor-core variant with
BF16->FP16 conversion, on the real decode GEMV shapes (n_in = 2560). Three
TC variants (W preconverted / inline conversion / fused output) and a full
k-split occupancy sweep; parity against an fp64 reference.

Result: the TC variant is 1.3-2.2x slower on every real shape even at its
best config - the warp kernel is already bandwidth-bound (374 GB/s) and a
single-token GEMV wastes 15/16 of the m16 MMA tile. Keeping the warp
kernel; the benchmark is checked in so this does not have to be measured
twice.
2026-10-01 08:15:27 +02:00
Zac Chen 4e1a7c5982 verify: profile columns stop wrapping (unsigned stamp deltas) and the hc-read second half stops overwriting the next layer's base stamp
kProfPer 32 -> 33: fused_gr_read_multi writes three stamps per half and the second
half's base was 30, so its up-stamp landed at slot 32 = (l+1)*32 + 0, the next layer's
stage-0 base.  Derived columns (gap/head/hc0) also wrapped to ~1.8e19 ns whenever a
slot was unstamped, printing ~1e14 ms per window.  A delta now counts only when both
stamps are nonzero and monotonic; the hc0 split replaces the single hc-read0 column
only when the split chain is complete.  Metrics-only: no computed model value changes.
Reason recorded in PORTING.md 19.
2026-10-01 08:15:27 +02:00
sergiywith 7f2c76e18d iq_pack: keep experts.bin only when its blobs match the GGUF
An existing experts.bin was kept whenever its size matched the layout. A different checkpoint with the same geometry
(a re-quantization or a fine-tune packed into the same folder) has the same size, so the engine silently served the
old experts with the new model's dense weights.

Before keeping the file, the first and last blobs of the first, middle and last layers are now compared with the
GGUF; a mismatch rewrites it. The check reads six blobs, so an unchanged pack is still reused at once.

Test: test_experts_bin_is_kept_only_with_this_ggufs_blobs packs two GGUFs of the same geometry into one folder (it
fails on the previous code).

Rebased onto 0.1.31 (Niko1221): 0.1.31 already refuses an experts.bin whose sidecar (experts.bin.src.json: shard
names and sizes, the hash of native_experts.txt) does not match, so the six-blob comparison runs only when the
sidecar says "reuse" - it catches the case the sidecar cannot (a re-quantized or fine-tuned checkpoint under the same
file names and sizes). It reads each of the six expert blobs on its own instead of concatenating the whole layer.
The test packs the second model under the first one's file name, so it reaches the new check.
2026-10-01 08:15:22 +02:00
Niko1221 d672a5f443 #287 follow-up: setup run again without --draft-vocab keeps the model's earlier choice
The full setup rewrites the model's config and refreshed the MTP folder's subset with `a.draft_vocab or "cjk"`, so
running it again without the flag put the CJK subset back over a cyrillic (or en) choice, and dropped draft_vocab from
the config. saved_draft_vocab() reads the choice the config holds; the flag still wins. tools/test_setup_draft_vocab.py.
2026-10-01 08:14:00 +02:00
sergiywith 79aa0bb11b setup: --draft-vocab cyrillic - the English/code subset plus the whole Cyrillic script
The shipped draft subsets hold 142 of the vocabulary's 18,580 Cyrillic tokens, so an answer in Ukrainian, Russian,
Bulgarian or Serbian drafted almost nothing. data/draft_vocab_cyrillic.bin is draft_vocab_en.bin plus every token
whose text is Cyrillic (58,963 ids), built with the repository's own tool:
  python tools/draft_vocab.py --gguf <IQ2_XS shard 1> --base data/draft_vocab_en.bin --add cyrillic

- tools/draft_vocab.py: a "cyrillic" script (U+0400-052F, 1C80-1C8F, 2DE0-2DFF, A640-A69F).
- setup.py: --draft-vocab cyrillic; docs/DETAILS.md.

On the NVFP4 fork: 1.4 -> 2.1 tokens per round, 83 -> 109 tok/s in Ukrainian answers, English unchanged.
2026-10-01 08:13:17 +02:00
sergiywith fcef1b0dbd strata-vision: --flash-attn on|off|auto; on the CPU no CUDA context, no warm-up, a thread per core
- --flash-attn on|off|auto (mtmd's flash_attn_type): flash attention keeps K and V in FP16. On the NVFP4 fork the
  vision tower's output was 11.2% off with it on the GPU; FP32 attention (CPU) 0.1%.
- On the CPU a CUDA build keeps the GPU unseen (CUDA_VISIBLE_DEVICES=-1 before the runtime starts): it otherwise
  opened a context there, 0.4-0.7 GB of VRAM the expert cache loses.
- On the CPU without --threads: one thread per core (mtmd's default is 4); no warm-up encode (~6 s of start).
- serve/server.py: relative exe/mmproj/model paths in the vision config are the config's cwd's, as the engine's are.
2026-10-01 08:12:47 +02:00
Niko1221 7f49b76680 #278 follow-up: the request-line follower starts once per log; its time field is prompt_read, not ttft
- StrataEngine.restart() runs __init__ again (after a crash, an idle unload's reload), which started one more
  STRATA_REQUEST_LINES follower each time and printed every request line once per restart: a follower is started
  once per log path (the log is opened for append, so the first follower keeps reading the same file).
- The field the follower printed as "ttft" is the engine's prompt read time (the new tokens only, without the queue,
  the template, the first decode step): it is named prompt_read.
2026-10-01 08:12:35 +02:00
sergiywith 4c2cd14f5f serve: /v1/messages/count_tokens, Anthropic thinking only when asked, STRATA_REQUEST_LINES, a relative exe
Found by running Claude Code against the server (claude -p, three tool turns) and by starting a config with a
relative engine path:

- POST /v1/messages/count_tokens answered 404; Claude Code asks it for its context figures. It now renders and
  tokenizes the request exactly as /v1/messages would, without running the model.
- A /v1/messages request with no "thinking" (and no effort) got the template's default, which thinks: Claude Code's
  helper calls (a ~60-token session title) came back with a thinking block and no text. Anthropic's thinking is
  opt-in, so such a request now renders with enable_thinking false. A config's reasoning_effort still applies;
  "thinking" set, or an effort, behave as before.
- STRATA_REQUEST_LINES=1: a thread follows the engine log and re-states each request's summary line on stdout, for
  supervisors that only see the server's stdout (a tray, llama-swap). Off by default.
- A relative "exe" in the config failed in Windows' CreateProcess (WinError 2): it is made absolute against the
  config's cwd, as the engine's cwd already is.

Tests: count_tokens equals the input_tokens /v1/messages reports for the same request; the request line pattern
parses the engine's summary. python -m unittest serve.test_server: 44 OK.
2026-10-01 08:12:11 +02:00
Niko1221 158e85bf43 #289 follow-up: a placeholder GPU name when the properties query fails; HIP builds compile (no device_code_error probe)
- generate.cpp: the startup line names "(an unnamed GPU)" when cudaGetDevice/cudaGetDeviceProperties fail (the
  error is cleared), and the "no code for" message uses the same name; a HIP build prints the gfx architecture
  instead of a CUDA compute capability.
- device.cu: device_code_error() returns "" on HIP - cudaFuncAttributes/cudaFuncGetAttributes have no mapping in
  hip_compat, and gpu_arch_problem() already stops a HIP run on an architecture the build lacks.
- fused_gr.cu: STRATA_EMULATE_CC also answers the two compute-capability queries there (small tile, the sm_70
  capacity rule), as the PR's description promises; with the variable unset nothing changes.
2026-10-01 08:11:39 +02:00
sergiywith a606e3a966 Start: name the GPU and stop at once when the build has no code for it; STRATA_EMULATE_CC for tests
- generate.cpp: before the expert arena loads, the engine names the card and its compute capability and checks that
  the build has code for it (device_code_error: cudaFuncGetAttributes on a kernel). A binary built for other GPUs
  used to fail at the first kernel, after the whole arena had loaded; now it stops in ~0.3 s and says why.
- include/strata/core/emulate.hpp: STRATA_EMULATE_CC=75|80|86|89 makes the host's device queries (compute
  capability, shared memory per block) answer as that generation, for a PTX build of it JIT-compiled on a newer
  card - ggml's MMQ config, the QSA kernels' choice, fused_gr's shared memory. Tests only.
- STRATA_QSA_WARP=1|select|attn: the pre-sm_80 QSA kernels on any card (A/B).
2026-10-01 08:11:23 +02:00
sergiywith aea6e45c64 diagnostics: STRATA_DUMP_FIRST_LOGITS writes the first generated token's logits
STRATA_DUMP_FIRST_LOGITS=<file>: the logits of the first window's first position (the token the prompt predicts),
n_vocab float32, written once per run. Two engine variants run on the same prompt then give a first-token KL
divergence: how far a prompt-path change moves the model's distribution, not only whether its top token changed.
On a layer split the last stage's verifier writes it.
2026-10-01 08:09:42 +02:00
Niko1221 cfb1866ec5 HIP (S6): router_top10.cu - drop a nested #if that left the HIP block unterminated 2026-10-01 08:07:46 +02:00
Niko1221 a2be1670bb HIP (S6): router_top10 without its serial parts on AMD, bitwise the same (default on HIP; STRATA_HIP_ROUTER_OLD=1: old)
On RDNA4 the router took 39 us per call in decode (16% of the decode GPU time): 512 dependent FP64 adds, ten
selection passes with 20 block barriers, a renormalisation re-reading its weights from global memory. The sum's only
use is inv = (float)(1.0 / sum): all terms are positive with the largest exactly 1, so the serial sum and a tree sum
are within 2^-43 of each other; when the bracket tree*(1 -+ 2^-40) maps to one float, that float is the serial sum's
(1/x and the cast are monotone), otherwise thread 0 runs the serial sum as before. The selection runs on wave 0 from
registers (the argmax with the lowest index on ties is unique), the renormalisation from registers in rank order.
hip_router_fast checks ids and weights bitwise against the portable kernel (65,536 rows with ties, near-ties, NaN
rows, the forced serial path; and 256 experts / k 8). CUDA builds unchanged (HIP-only code).
2026-10-01 07:24:19 +02:00
Niko1221 73ba449679 HIP (S6): RDNA4 matrix-core prompt attention for int8 KV, opt-in (STRATA_HIP_WMMA=1, gfx12 only)
The v2 tensor-core design with gfx12's v_wmma_f32_16x16x16_f16: one block per (query, KV head), wave w owns
dims [64w, 64w+64) (int8 scale group w), q and p split into FP16 hi + lo parts, int8 codes exact as FP16, scales in
FP32, the four groups' q.k partials added in a fixed order, online softmax over 32-cell chunks. Masked
(non-resident) cells get no weight, as in the decode kernel. FP32-level accuracy, not bitwise equal to the default
kernel, hence opt-in. hip_prompt_attn_wmma = qsa_prompt_attn_parity built for HIP (skips off gfx12).
NVIDIA builds unchanged (all new code is under __HIPCC__ / the HIP test section).
2026-10-01 06:44:23 +02:00
Niko1221 6ac1a2cc5e Engine 0.1.31: Unsloth UD-Q4_K_XL runs on a 64 GB PC (experimental: split GGUF, Q4_K/Q5_K/Q5_1/Q8_0 experts, RAM budget + SSD tier with routing prefetch), the low-RAM mode reads GGUF experts in place, Windows GGUF load 2x (#230), server status race (#266) and tokenizer (#268) fixes, truncated tool calls (#211/#231), AMD intrinsics (#262); setup requires it 2026-10-01 06:27:52 +02:00
Niko1221 9195d989a4 Merge branch 'f-q4-on242' into r131-final 2026-10-01 03:11:54 +02:00
Niko1221 2903837bbe docs: Unsloth UD-Q4_K_XL manual import (docs/UNSLOTH_Q4.md); DETAILS: the mapped mode without experts.bin, --resident-budget-gib, the tier counters
- docs/UNSLOTH_Q4.md: what UD-Q4_K_XL is (Hugging Face revision 38bb39e, the four shards with sizes and SHA-256),
  disk/RAM/GPU needs (111.3 GB download, 1.4 GB pack, no experts.bin), the iq_pack.py command and why
  --compat-bf16, the numerical policy (native experts/embedding/head/projections/PLE; the converted small tensors
  listed in conversions.json), the MTP draft layer, a server config (--native shard 1, --ple-gguf found by name,
  --resident-budget-gib N with N = RAM minus 20-24 GB), measured speed on an RTX 5070 / 64 GB PC (7-8.5 tok/s at
  40 GiB; ~60 s to the first answer), the switches (STRATA_LOOKAHEAD=0, STRATA_KQ256=1, STRATA_PARTIAL_PIN=1,
  STRATA_FETCH_THREADS), scope and validation, credits (eddoursul #245, gopinath87607 #255, jagsan-cyber #247).
  Experimental, not in setup.
- docs/DETAILS.md: the mapped low-RAM mode reads a native pack's experts from the GGUF when it has no experts.bin
  (checked, identical answers on the Coder); --resident-budget-gib and the routing-aware prefetch; where the tier
  counters are (--stats, the server log, /metrics' ram_blobs / file_blobs / file_mb); a pointer from "Which model?".
2026-10-01 03:11:36 +02:00
Niko1221 0699e466ad Merge branch 'f-q4-on242' into r131-final 2026-10-01 03:03:40 +02:00
Niko1221 a74acb6dd2 CS-T: the partial pin of the RAM tier opt-in (STRATA_PARTIAL_PIN=1)
On the RTX 5070 / 64 GB PC the GPU computing a share of the misses over PCIe measured no faster than the CPU:
7.30 and 7.44 tok/s with 24 and 16 GiB of a 40 GiB budget registered, against 7.05-7.74 unpinned, and
registering costs startup time and driver memory.  The default budget mode is now locked-only; the routing-aware
prefetch (multi-run A/B: 6.93 -> 7.91 tok/s mean, identical answers) stays on with the GGUF in place.
2026-10-01 03:03:17 +02:00
mad9home 140a8730a3 Bench: RTX 3090 / dual RTX 3090 on EPYC 7453
Add preliminary native v0.1.26 results, raw run JSON, scrubbed guest hardware facts, and the local API harness. Prompt and memory topology limitations are documented.
2026-10-01 02:52:39 +02:00
Omar Al-Jadda b73e770212 docs: add RTX 5090 community benchmark results 2026-10-01 02:52:39 +02:00
Omar Al-Jadda e51da24c52 docs: add community benchmark submission guide 2026-10-01 02:52:39 +02:00
Niko1221 0dac2b9aa1 CS-T: routing-aware prefetch of the file tier - the next layer's router on this layer's MoE input warms its predicted experts' pages
- RouterLookahead: when the CPU pool starts layer l, a worker thread applies layer l+1's router (a BF16 host copy
  of ffn_gate_inp, 126 MB for 48 layers) to layer l's MoE input - the router's own input - for each token of the
  window, takes the top STRATA_LOOKAHEAD_K (default 10), drops the experts the GPU cache (host_res) or the RAM
  copy holds, and asks the source to warm the rest.  It never waits: a prediction still running makes the next
  one skip.  STRATA_LOOKAHEAD=0 is the A/B arm.
- ExpertSource::warm / warms(): FileExpertSource with the GGUF in place issues one PrefetchVirtualMemory for the
  predicted slices (madvise(WILLNEED) elsewhere).  Pages only: blob(), the experts computed and their bytes do not
  change (the same answers in every A/B run).  Every other source: no-op, and the predictor is not started.
- bf16_rows_dot_multi (kq_avx2.cpp, AVX2): the router read once for all tokens of the window.
- Stats: experts warmed, how many of the decode's file-tier reads had been warmed, the predictor's time and skips.

UD-Q4_K_XL at a 40 GiB budget (single-token-router version): ~48-54% of the file tier's reads had been warmed;
reading time 850-968 -> 630-730 ms per verify round; decode 5.31/6.60 tok/s off vs 7.08/6.79/6.91 on.
2026-10-01 02:30:24 +02:00
Niko1221 a37491ede4 tests (#264 follow-up): iq_parity skips (exit 3) when no fixture was generated, as its generator does; a partly missing set still fails; the open handle of a half-present fixture is closed 2026-10-01 02:27:40 +02:00
Andy aa0777f7aa decode: hc read v3 is opt-in (STRATA_GR_V3=1: another summation order); its shared memory is sized from the card's opt-in limit - one or two column halves, else the default kernels (Turing/HIP 64 KB fit with two; capability-based split as proposed by @Adamyno); the neutral knobs (DOWN_R2, UP_PF, KSPLIT) dropped (review) 2026-10-01 02:14:16 +02:00
Andy 784cdc5d08 decode: hyper-connection read in 2 kernels - norm folded into a stream-split down kernel (164 blocks), rs/lo/inject in up's prologue (STRATA_GR_V3=0 = old) 2026-10-01 02:14:16 +02:00
Niko1221 7d8fc8fd04 CS-T: the partial pin locks only what it does not register and ends at an expert boundary; the Q4_K/Q5_1/Q8_0 multi-token kernels opt-in (STRATA_KQ256=1)
- Locking the whole 40 GiB arena in the working set and then registering its prefix made the next device
  allocation fail (the prompt path's token id buffer); the registered prefix is page-locked by the driver
  already, so only the rest is locked now.  24 GiB registered out of a 40 GiB budget then starts and runs.
- The registered prefix ends at an expert boundary: a blob that began inside it and ran past it was taken as
  page-locked by cudaMemcpyAsync and refused (an adaptive refill failed, with 16 GiB registered).
- The prompt path's token id buffer error names the CUDA error.
- kq_avx2 multi-token kernels: bit-exact, but no faster in the engine (the rows phases stayed at 72 ms per
  verify round at a 40 GiB budget; a window's expert groups hold ~1.4 tokens and ggml's per-token calls find the
  weights in L1), so they are opt-in with STRATA_KQ256=1; native_expert_parity still checks them bit for bit.
2026-10-01 01:58:30 +02:00
Niko1221 a88904e530 Revert #257 (AVX2 two-block Q2_0 unpack): bit-exact but not faster on an AVX2-only CPU (Ryzen 9 3900X: gate/up -2.6..-4.7% at 1 token, down -3..-5% at 2 tokens)
This reverts commit f121667.
2026-10-01 01:33:15 +02:00
Niko1221 9305322ff5 Merge branch 'f-131-amd' into r131-amd
# Conflicts:
#	src/core/pinned.cu
2026-10-01 01:33:10 +02:00
Niko1221 18ad40c0dc --split-skip-if-fits (opt-in): an auto split runs on the main card alone when it holds every profiled expert + KV
Before any later stage loads, split-auto checks whether CUDA0 alone holds every profiled expert pair plus the whole
session (KV of every layer), the drafter + head, the verify windows and the reserve; if so it clears the split (one
GPU) and logs why, else it logs how much of the profile CUDA0 would hold and keeps the split. Default behaviour is
unchanged: the engine flag is opt-in, and the server passes it only for a config with "split_skip_if_fits": true
(and a GPU list). Not with remote expert caches.

Measured on amdbox (Coder IQ1_M, --expert-cache auto --prefill auto, 128 greedy tokens, gpu [1, 0] = R9700 first,
2 starts per arm, warm = the second request of each size):
  | arm                          | 4K warm   | 16K warm  | decode    |
  | split (flag off)             | 1,244     | 1,897     | 50.5-53.0 |
  | --split-skip-if-fits (on)    | 1,776     | 1,791     | 59.7-61.8 |
  | R9700 alone                  | 1,787     | 1,801     | 59.9-61.3 |
The flag's run is the R9700-alone run (same tokens, all four requests); with the 9070 XT first it keeps the split
("would hold only 9.84 of the profile's 23.42 GiB"). On this pair the split still reads 16K prompts ~5% faster.
2026-10-01 01:31:22 +02:00
Niko1221 9f8fa9088e #253: the 8 GiB arena pin cap only under WDDM; STRATA_ARENA_PIN_GIB; the split's prompt chunk steps down
- The expert arena was pinned at most 8 GiB whenever a layer split (or remote experts) ran, on every OS - a
  Windows/WDDM workaround that cost a Linux 4090 + 3060 split two thirds of its prompt speed (#253,
  bettercallcaleb). The cap now applies only under WDDM (_WIN32, or WSL2 detected by /dev/dxg), for multi_gpu and
  expert_cache_remote alike. STRATA_ARENA_PIN_GIB overrides it on any OS: "0" pins the whole arena, N > 0 at most
  N GiB (arena_pin_cap_gib(), -1 when unset: the same name and meaning as the S2 branch's helper, file-local here).
- The split's prompt chunk no longer stops the start when its buffers do not fit: a prompt path without a loan
  first gets the largest chunk whose buffers (Prefill::bytes_needed) leave 512 MiB free on its device, and an init
  that still fails steps down one size (8192 -> 6144 -> ... -> 2048 -> 1536 -> 1024 -> 512): Prefill::reset() frees
  what the failed init made, the loans are re-priced, and the failed allocation's sticky error is consumed (else the
  next launch check reported "out of memory").
- pinned.cu: the capped note no longer says "for CUDA1".
- docs: MULTI_GPU.md, SECOND_GPU.md.

Measured on amdbox (Linux, R9700 + RX 9070 XT, gpu [1, 0], Coder IQ1_M, 128 greedy tokens; tok/s):
  | cache                  | arm          | 4K cold | 4K warm | 16K cold | 16K warm | decode    |
  | auto (holds ~all)      | 8 GiB cap    | 678     | 1,355   | 1,709    | 1,880    | 44.5-51.5 |
  |                        | whole arena  | 703     | 1,234   | 1,729    | 1,864    | 44.6-51.4 |
  | fixed 1500 on CUDA0    | 8 GiB cap    | 608     | 1,101   | 1,287    |          | 34.5-36.1 |
  |                        | whole arena  | 716     | 1,160   | 1,803    |          | 34.8-36.0 |
(2 starts per arm for auto, 5 for fixed.)  With most experts streamed the whole arena reads a 16K prompt 40%
faster; with every expert already on the cards the two are within noise except 4K warm (-9%: the pinned share
raises the auto lend to 90% and the streamed ring to 384 slots).  Identity: the fixed-cache arms gave the same
tokens in all 5 + 5 starts (4K, 16K, 4K again), and the auto arms 2 + 2.  The step-down was exercised on the
9070 XT with --expert-cache 3000 --no-prefill-borrow --prefill 8192 ("need 4528 MiB, 2910 MiB free: 2048-token
chunks"; with the init retry alone it went 8192 -> ... -> 2048, and 1536 ran all four requests).  Known, also on
main: that own-buffer configuration at 2048 makes hipBLAS pick hipBLASLt kernels whose code objects this ROCm 7.14
lacks (TensileLibrary_..._gfx1201-xnack+.co not found, "launchKernel failed") and the prompt hangs.  The WDDM side (Windows, WSL2) is unchanged and not re-measured here.
2026-10-01 01:31:22 +02:00
Niko1221 d484ec735f CS-T: the GGUF-in-place prefetch asks Windows for all of a layer's missed slices at once (PrefetchVirtualMemory)
The copies' page faults read a few clusters each; one PrefetchVirtualMemory call for every role slice about to
be copied lets the memory manager queue large reads at once, and the parallel copies then find the pages
resident or in flight.  Only the GGUF-in-place source's prefetch uses it; STRATA_FETCH_PVM=0 is the A/B arm.
2026-10-01 01:12:36 +02:00
Niko1221 f8525fa0b0 CS-T: the partial pin at most 24 GiB (STRATA_PARTIAL_PIN_GIB), the Q4_K/Q5_1/Q8_0 multi-token kernels from two tokens on
- Registering 30 GiB of a 40 GiB RAM tier left the driver unable to page-lock the prompt path's token id buffer
  afterwards (RTX 5070, WDDM: "prefill: the token id buffer"); the prefix is now capped at 24 GiB, the size a
  whole 24 GiB budget page-locks with, and STRATA_PARTIAL_PIN_GIB sets it.
- A verify window's expert groups hold ~1.4 tokens on average; one token goes to ggml's own dot (the same bits,
  without the multi-token kernel's per-token arrays).
2026-10-01 01:11:50 +02:00
Niko1221 4167bd17ac Merge branch 'f-q4-on242' into r131-q4
# Conflicts:
#	serve/server.py
#	src/core/expert_source.cpp
2026-10-01 01:01:04 +02:00
Niko1221 13b76cc5f8 Merge branch 'f-131-srv' into r131-q4 2026-10-01 01:00:27 +02:00
Niko1221 003ec62140 CS-T speed: the file tier fetched in parallel, PCIe planning without file reads, a partial pin of the RAM tier, bit-exact AVX2 multi-token kernels for Q4_K / Q5_1 / Q8_0 experts, decode-only tier stats
Where the 288 ms/token at a 40 GiB budget went (UD-Q4_K_XL, --stats): of the 945 ms CPU pool call per verify
round (3.46 tokens), 871 ms were the dispatch thread assembling missed experts from the mapped GGUF one after
another (~391 blobs, 1.3 GB per round, ~1.5 GB/s: page faults from the SSD); the kernels were 42 ms gate/up and
30 ms down.  At 24 GiB, 771 ms/round more went into the PCIe planning, which asked blob() - a file read with the
GGUF in place - of every miss just to learn it was not pinned.

- ExpertSource::prefetch: the dispatch hands the source the layer's missed experts before its jobs loop;
  FileExpertSource with the GGUF in place assembles them on STRATA_FETCH_THREADS threads (default 8) so the
  SSD sees a queue instead of one fault at a time.  A no-op for every other source.  Staging buffers being
  filled are never reused, and a blob asked while its fill runs waits for it.
- The PCIe planning asks pinned() before blob(): the same decisions and bytes for every source.
- --resident-budget-gib: when the driver refuses to page-lock the whole budget, the locked arena's hottest
  prefix (profile order) is registered with cudaHostRegister, as much as it takes (from the whole down in 2 GiB
  steps), so the GPU can read those misses over PCIe and the prompt path can DMA them; pinned() answers for
  that prefix only.  STRATA_PARTIAL_PIN=0 is the A/B arm.
- src/kernels/cpu/kq_avx2.cpp: ggml-cpu's AVX2 vec_dot for Q4_K x Q8_K, Q5_1 x Q8_1 and Q8_0 x Q8_0 with the
  token loop inside the block loop - the weight side decoded once per verify window, each token's integer chain
  and float operations exactly ggml's, so the results are ggml's to the bit for any group size (no #152 rule).
  native_gu_rows / native_down_rows use them for those types (only UD-Q4_K_XL has them); STRATA_NO_KQ256 is the
  A/B arm.  native_expert_parity checks them bit for bit against vec_dot for 1..8 tokens and times 4 tokens.
- Stats: the decode's file tier alone (blobs, MB, MB/round, reading ms/round and GB/s per thread) and the
  prompt path's copies separately.
2026-10-01 00:51:30 +02:00
Niko1221 f73b0e062a pinned (#243 follow-up): the shared-memory-budget cap on the sliced pin is opt-in (STRATA_ARENA_PIN_GIB=auto) - by default the arena pins as in 0.1.30; on this 64 GB PC the cap pinned 26 instead of 30 GiB and cost ~20% prompt speed and 2-4% IQ3_S decode 2026-10-01 00:49:49 +02:00
Niko1221 ebe52edd8b setup: AMD layer splits with --gpus (every chosen card a supported AMD arch; the engine compiled for each)
setup refused AMD GPU lists at install and at start ("NVIDIA only for now"), although the engine's layer split runs
on two AMD cards (0.1.30, from a hand-written config).
- amd_parse_gpus(): --gpus "1,0" (setup's HIP numbering, the first card the main one) or "all" (every supported
  card, the most VRAM first); every card must be in AMD_ARCHS, else a plain message with what can be used.
- install: --backend hip --gpus writes "gpu": [..] + "layer_split" like the NVIDIA path; build_engine_hip compiles
  for the set of the chosen cards' archs (CMAKE_HIP_ARCHITECTURES "gfx1100;gfx1201" already worked) and records
  it in BUILD.json; an engine whose archs cover the cards is not rebuilt; update_installed_engine keeps every arch.
- rocm_root(archs): cards of two families need a system ROCm (TheRock's wheels hold one family) - said plainly.
- start: --gpus on an AMD install is saved like on NVIDIA (refused when the engine has no code for a card);
  --gpus all finds the AMD cards on a PC without NVIDIA cards that can share.
- docs/AMD_HIP.md, README; tools/test_setup_amd.py: lists, "all", refusals, the one-family wheel rule, the arch set
  in the build and BUILD.json.
2026-10-01 00:35:39 +02:00
489623c7d3 AMD: gfx1101 (RX 7800 XT, #254 by jhohertz) and gfx1200 (RX 9060 XT, #256 by Efeisot) as community-validated cards
Cut down from #254 and #256 onto 0.1.30's AMD tables:
- setup.py: AMD_ARCHS / AMD_NAMES / ROCM_INDEXES / AMD_CARDS list gfx1101 (TheRock gfx110X-dgpu) and gfx1200
  (gfx120X-all); amd_gpus() takes the sysfs root so the detection can be tested.
- cmake/hip_backend.cmake: gfx1101 and gfx1200 build without the "not validated" warning (a status line names
  them community-validated); gfx1102 (#192: ctest only) keeps the warning.
- docs/AMD_HIP.md (Community-validated cards: the owners' setups, ctest and numbers) and README.
- tools/test_setup_amd.py: detection on a mocked KFD topology (every family, the CPU node, an iGPU and gfx1102
  listed as not supported, product-name fallbacks, the ROCm index per family).
Left out: the PRs' own cmake/device.cu arch checks (0.1.30's compiled_for covers them), the dp4a change (main has
it), math_constants.h, the bench JSONs, the launcher, and both hipBLASLt tables (neither PR measured the prompt speed
without its table).

Co-Authored-By: Joseph Hohertz <[email protected]>
Co-Authored-By: efeisot <[email protected]>
2026-10-01 00:35:39 +02:00
Niko1221andttio2tech 600d73070c HIP: __byte_perm as v_perm_b32 and SWAR __vsub4/__vsubss4/__vcmpne4 (from #262 by ttio2tech)
Cut down from #262 (ttio2tech): only the intrinsics and their test.
- HIP's __byte_perm indexes a byte array in private memory (scratch traffic in the IQ4_XS/Q2_0 table
  lookups); byte_perm() is the same selection (nibble & 7 of the pair {y:x}) in one v_perm_b32.
- __vsub4, __vsubss4 and __vcmpne4 work on all four byte lanes at once (Hacker's Delight 2-18) instead
  of a per-lane loop.
- tests/hip/intrinsics checks them on 1,024 random operands against host references (passes on gfx1201).
Left out: the arch/setup/device.cu parts (0.1.30 already builds and checks gfx1201; main's dp4a covers
gfx1100-1102/1200/1201) and the gfx1201 hipBLASLt table (none is shipped for gfx1201).

A/B vs main on amdbox (Coder IQ1_M, 128 greedy tokens): identity with a fixed cache (--expert-cache 1500
--prefill 2048), 5 + 5 starts per card, 4K / 16K / 4K again: the modal outputs are identical on the R9700
and on the RX 9070 XT (one start of 20 differed from its arm's mode, the known HIP start drift). Speed with
setup's settings (auto cache/chunk), 2 + 2 starts per card, tok/s:
  | card         | arm  | 4K cold | 4K warm | 16K cold | 16K warm | decode    |
  | R9700        | main | 1,027   | 1,792   | 1,695    | 1,812    | 46.0-52.2 |
  |              | #262 | 1,023   | 1,786   | 1,681    | 1,808    | 53.0-61.0 |
  | RX 9070 XT   | main | 781     | 1,018   | 1,421    | 1,517    | 32.7-41.4 |
  |              | #262 | 780     | 1,017   | 1,424    | 1,517    | 34.9-44.0 |
Decode +15% on the R9700, +5-7% on the 9070 XT; prompts unchanged.

Co-Authored-By: ttio2tech <[email protected]>
2026-10-01 00:35:39 +02:00
Niko1221 5865998af9 verify (#267 follow-up): the window's final wait stays a blocking sync - the cudaStreamQuery poll cost IQ3_S ~3% decode; the stall watchdog's release of every verifier's GPU waits is what keeps a spin kernel from outliving the engine 2026-10-01 00:26:23 +02:00
Niko1221 1e663cc70e CS-T: native packs read their experts from the GGUF shards in place (--mmap-experts without experts.bin), --resident-budget-gib N, per-tier counters
- FileExpertSource: a native pack without experts.bin, given the --native shard, maps every GGUF file
  native_experts.txt names (after check_experts_gguf) and assembles a blob [gate | up | down] from the
  three role slices when asked: into a small pool of buffers for blob() (a buffer is reused once its blob
  has not been asked for during 3 layers (begin_layer) or 256 assemblies), or straight into the caller's
  memory for copy_blob().  No 30-77 GB experts.bin on the disk.  With experts.bin present nothing changes.
- ExpertSource::transient / copy_blob: the prompt path's stager copies a transient blob itself (its queue
  holds a whole chunk's experts), everything else keeps using blob().
- --resident-budget-gib N (the resident mode with a budget): the experts the GPU cache does not hold are
  copied into RAM in expert-profile order while they fit N GiB (clamped to available RAM minus the
  headroom), the rest are read from the files; no lend region then.  Without the flag the resident mode
  and --mmap-experts are unchanged.
- Counters: blobs served from the RAM copy, from the files, and bytes read from the files; in the stats
  table ("expert tiers"), the serve log, and appended to DONE (RAM blobs, file blobs, file MB for the
  request), which serve/server.py puts into /metrics' request history (older DONE lines still parse).
- expert_layout_test: the GGUF-in-place source gives the loaded arena's bytes through blob() and
  copy_blob(), an assembled blob stays put while in use, and experts.bin still wins when present.
2026-09-30 22:51:03 +02:00
Niko1221 ee7c802664 iq_kernels: Q4_K / Q5_K / Q5_1 / Q8_0 native experts (Unsloth UD-Q4_K_XL), per-role format lists, native_expert_supported at startup, Q8_0 embedding and PLE key
- Dots: llama.cpp's vec_dot_q4_K / q5_K / q8_0_q8_1 transcribed (VDR 2), via eddoursul/Strata
  8029fa9 and #255 (gopinath87607, Q8_0), which agree.  Q5_1's min term multiplies the sum of the
  QUANTIZED activations (ggml-cpu's convention, as the fork does), not llama.cpp CUDA's ds.y.
- Dequantizers dq_q4_k / dq_q5_k / dq_q5_1 / dq_q8_0 (llama.cpp's formulas) for the prompt path's FP16
  fallback, f32 dumps and the Q8_0 embedding; iq_row_bytes / is_iq know the four types;
  iq_dequant_gu_f16 now refuses an unknown type instead of leaving its output unwritten.
- The grouped gate/up, down and iq_mmvq switches are generated from STRATA_GU_FMTS /
  STRATA_D_FMTS / STRATA_MMVQ_FMTS; the existing entries launch the same kernels as before.
- native_expert_supported(gu, d, n_embd, n_ff): generate checks every layer of a native pack right
  after expert_layout_load and refuses an unsupported pair by name before anything is allocated
  (it used to exit from inside the first verify window).
- Native PLE key: Q8_0 accepted (NativeDense, generate, ple.cu); native_mmvq already runs it.
- native_expert_parity: --synthetic GU/DOWN (random ggml-quantized blobs at 2560/640; port of the
  fork's mode), GPU dequant f32/f16 and embedding rows vs ggml to_float bit for bit, split models via
  GgufModel, --q5_1-min.  CTests: q4_K/q5_1, q4_K/q8_0, q5_K/q8_0, q8_0/q8_0, the Q5_1 min term, and
  q6_K refused.  RTX 5070: GPU and CPU within 1.25-1.37e-2 of the float reference for all three real
  pairs; every dequantized value identical; Q5_1 GPU vs ggml-cpu 7.5e-5 (vs 1.95e-2 for the ds.y
  variant); IQ3_XXS/IQ4_NL and IQ2_XS/Q2_0 unchanged.
- Not yet: #242's decode-once traits for the new types (they take the per-entry kernel; see
  phaseA-tests/s5_cs3_design.md), prompt MMQ for Q4_K/Q5_K/Q5_1, identity gates.
2026-09-30 22:31:09 +02:00
Niko1221 dc24332249 tests: --real modes for gguf_split_test and expert_layout_test (a real model's shards / a real pack's spans, headers only)
`gguf_split_test --real SHARD` opens a real model's shards (GgufModel), checks the architecture on the
metadata shard and prints where output / token_embd / the PLE table and key / layer 11's experts are.
`expert_layout_test --real PACK NATIVE_SHARD` checks a real pack's native_experts.txt against its model
(check_experts_gguf; no expert byte is read).  Both pass on the Q2_0, IQ3_XXS (v2), IQ3_S, Coder IQ1_M
and Swift IQ2_XS packs and models on the reference PC.
2026-09-30 22:30:11 +02:00
Niko1221 24bba1743b iq_pack: each tensor in the form the engine reads (FORM), exact F32->BF16 by default, PLE conv F32 -> F16 by the loader, conversions.json; the engine refuses a wide conv1d
- FORM (eddoursul/Strata's list of which tensor the engine reads as BF16, F16 or F32) decides the
  pack form; the conversion itself is upstream's bf16_bytes (gguf-py, finite check, round-to-nearest-
  even).  By default only lossless conversions happen: F32 whose values are exactly BF16 (low 16 bits
  zero; before, only the routers) and F16/BF16 widened to F32.  Rounding (inexact F32, Q8_0 hyper-
  connection / PLE value / output_hc, F16 -> BF16) still needs --compat-bf16.  NaN/Inf are refused
  even where the low bits are zero.
- A Q8_0 PLE key stays native (served from the GGUF, like Q2_0); other quantized keys take the BF16
  path as before.  (The engine's native PLE key learns Q8_0 in the formats change.)
- blk.1.ple_conv1d stored F32 (Q8_0 / UD-Q4_K_XL files) goes into dense.bin as index kind 3 and the
  loader narrows it to F16 (#255, gopinath87607), with or without --compat-bf16; a value beyond
  F16's range is refused.  generate refuses a pack whose conv1d is not F16 (#255's check, which also
  accepts the canonical Q2_0 pack's verbatim-F16 kind 0 - #255 as written refuses that pack).
- conversions.json (schema 1): the source shards' names and sizes, and per converted tensor its
  shard, source/destination type, method, exact flag, largest absolute error and source sha256.
  compat-bf16.json is written as before.  Refusals happen before anything is published.
- Byte identity: index.txt, native_experts.txt and dense.bin of Q2_0, IQ3_XXS, IQ3_S, Coder IQ1_M and
  Swift IQ2_XS are identical to main's packer (Swift's 96 exact F32 routers are now listed in
  conversions.json).
- Tests: exact F32->BF16 by default, inexact only with --compat-bf16 (error bound), NaN/+-Inf
  refused with and without the flag (previous pack untouched), conv1d kind 3 (bytes, record, F16
  kept, overflow refused), Q8_0 projections need the flag and are recorded, Q8_0 key native.
2026-09-30 22:30:11 +02:00
Niko1221 21844a3ebf iq_pack: per-role shards and data_start (v4 only for a split layer), split keys checked, experts.bin reused only with its source sidecar, atomic publication
- Each expert role is resolved in the shard that holds it and its offset is absolute in THAT shard
  (the first role's data_start was used for all three; #255, gopinath87607).  A layer whose roles
  are in different shards gets the per-role column `gate,up,down` and the file becomes v4; every
  other pack keeps the v3 header and bytes (checked on Q2_0, IQ3_XXS, IQ3_S, Coder IQ1_M, Swift
  IQ2_XS: index.txt, native_experts.txt and dense.bin identical to main's packer).
- The split keys are checked as the engine does (shard 1 has the metadata; split.count / split.no /
  split.tensors.count consistent).  The expert table is computed and checked before any file of
  the pack changes.
- experts.bin is written under a temporary name and gets experts.bin.src.json (the shards' names
  and sizes, the sha256 of native_experts.txt); it is reused only when that matches, never by size.
  An experts.bin of another source is refused without --experts-bin (the engine would read it).
- dense.bin and index.txt are published together after the old completion marker
  (native_experts.txt) is removed, so a stop part-way never mixes files of two runs.
- .absolute() stays (not .resolve()): symlinked HF snapshot names keep the split naming.
- Tests: a synthetic 4-shard GGUF (shard 1 metadata only, layer 1 split per role; offsets per
  shard, experts.bin byte for byte), v3 kept when nothing is split, missing shard, duplicate tensor,
  a shard of another split, truncated shard, wrong type (pack untouched), interrupted pack (experts
  and index), stale same-size experts.bin.  Idea of per-role names also in #247 (jagsan-cyber).
2026-09-30 22:30:11 +02:00
Niko1221 65a1111e3a Split GGUF artifacts: every shard found (a missing one is an error), tensors from their owning shard, per-role expert files (native_experts.txt v4)
Groundwork for Unsloth's UD-Q4_K_XL (4 shards: shard 1 metadata only, output/token_embd/PLE table in
shard 2, layer 11's down in shard 2 and its gate/up in shard 3).  Existing packs load unchanged.

- include/strata/artifact/gguf_split.hpp: gguf_split_paths (from eddoursul/Strata 8029fa9) finds the
  shards from any shard's name; a missing shard is an error naming it.  It replaces generate.cpp's
  model_shards(), which skipped a shard it could not open.
- gguf_reader.hpp: GgufModel (8029fa9) looks a tensor up across the shards and refuses a name in two
  shards; the split keys are validated as #255 (gopinath87607) does for the head: shard 1 carries the
  architecture, later shards declare split.count / split.no / split.tensors.count consistently, and the
  directories add up to split.tensors.count.  tensor_payload_bytes / in_bounds for payload checks.
- NativeHead::load / NativeEmbed::load take the shard list: the architecture from the metadata shard,
  the tensor from the shard that holds it; the embedding also checks its payload is in the file.
- generate: --native resolves all shards once (native_shards), the head from --native-head-gguf's
  family, the model keys from the metadata shard; --ple-gguf defaults to the shard that holds
  per_layer_token_embd.weight.
- native_experts.txt: the shard column may be per role, `gate,up,down` (#255's comma form; empty =
  the --native shard).  The reader accepts v2-v4 and refuses a higher version; an engine older than
  this one fails to open a "gate,up,down" file loudly.  Fixes the parse's own aliasing hazard
  (parts.assign(3, parts[0])).
- load_experts_gguf reads each role from its file, after check_experts_gguf proved every (file,
  offset) is that tensor, of the pack's type and dimensions, and inside its file.
- Tests (synthetic, no model, no GPU): gguf_split_test (4 shards, missing shard, duplicate, split keys,
  count, truncation); expert_layout_test (copies of the Q2_0/IQ2_XS/IQ3_XXS/IQ3_S/Coder/Swift packs'
  native_experts.txt parse field for field as before; v4 column; v5 / 4 / 2 names refused; the arena
  from split synthetic shards at 2560/640 with Q4_K/Q5_1 and Q5_K/Q8_0, every byte compared, and
  wrong offset / file / type / shape / truncated / missing shard refused).
2026-09-30 22:30:10 +02:00
Niko1221 7dc1fae80b mcp: a server that stops quotes its last log line reliably (the stdout reader waited no time for the stderr reader, so the reason was sometimes missing - the flaky test_a_server_that_fails_is_left_out) 2026-09-30 22:13:46 +02:00
Niko1221 c67c90fa03 Merge branch 'f-131-fix' into r131-fix 2026-09-30 22:03:31 +02:00
Niko1221 cd677f7414 Experimental Pascal/Volta build: admit sm_70, and the device check honours it (#236)
-DSTRATA_EXPERIMENTAL_SM60=ON now names Volta (sm_70) beside Pascal (sm_60)
and is a declared option; below sm_60 is refused even then.  The runtime check
in device_info refused anything below compute capability 7.5 even in that
build, so the flag produced an engine that could not start on the cards it was
built for: strata_core now gets STRATA_EXPERIMENTAL_SM60=1 with the flag and
the check admits 6.0 and up there.  The release engine is unchanged (7.5).

Checked here: configuring for 70-real without the flag still fails with the
7.5 message; with it (CUDA 12.6 - CUDA 13 no longer compiles compute_70, noted
in the comment) it configures and strata-device builds with the define.
2026-09-30 21:07:28 +02:00
Niko1221 e1f12eb852 Refuse a CPU without AVX2 at start, by name
Every CPU expert kernel is AVX2 at least (q2_avx2.cpp, iq_avx2.cpp; the
AVX-512 ones are chosen above them) and so is ggml-cpu in the release build,
but nothing checked for AVX2: a pre-Haswell CPU died of an illegal instruction.
cpu_avx2_ok() (AVX, AVX2, FMA, F16C and the OS's XSAVE state) is checked
before the pack's layout load, and the message names the CPU (cpu_name, the
CPUID brand string).  STRATA_FORCE_AVX2 is unaffected (it only answers
cpu_avx512_ok).
2026-09-30 21:04:53 +02:00
Niko1221 b9f426713a Stall report: name the prompt chunk and layer; mark a finished verify window (#251)
The #251 report stalled in "reading the prompt, from token 0" and printed the
previous request's verify window as if it were the stuck one.

- Verifier::diag says "(last window, not the current stage)" when the stage
  is not a verify window.
- The batched prompt read sets its stage per chunk (preparing, finishing) and
  per layer, with the chunk's first position (Progress::chunk, a third
  progress_at argument; every other call leaves it -1), so the stall report and
  the watchdog line read e.g. "reading the prompt (batched): layer 17 of the
  prompt chunk from token 8192".

Text only: nothing computed changes.
2026-09-30 21:03:36 +02:00
Niko1221 50b4fadb08 Verify window: bounded final wait; release the GPU's flag waits before the engine ends (#267)
A verify window the GPU never finished held the host in an unbounded
cudaStreamSynchronize, and the serve watchdog then aborted the process with
the window's spin kernel (wait_flag_ge / wait_flag_ge_or on a host-mapped
flag) still resident - on Windows the GPU was left "lost" until a power cycle.

- The final wait of Verifier::run polls cudaStreamQuery (the same wait while
  the window runs) and gives up after 20 s like the per-layer wait, through
  the existing error path.
- Verifier::release_gpu_waits writes UINT32_MAX into the mapped flags M/A/B
  (past every ring, so each spin kernel returns; wait_flag_ge_or returns on its
  flag too), then waits for the streams up to 5 s; the verifier refuses later
  windows.  Both timeouts run it before returning their error, and the serve
  watchdog and the expert pool's stall aborts run it (progress.hpp
  release_gpu_fn, every live verifier) before std::abort.
- Test hook: STRATA_TEST_VERIFY_STALL=N withholds the last layer's flag in the
  N-th window; unset it is never taken.

The normal path runs the same kernels in the same order.
2026-09-30 21:02:27 +02:00
Niko1221 00ec1d081d Windows: cap the sliced arena pin at the GPU's shared-memory budget (#243)
When cudaHostRegister refuses the whole expert arena, the sliced fallback
pinned layer after layer until the driver refused one (28 GiB on a 63 GB
single-GPU PC), and WDDM then refused every later device allocation
("native head upload: out of memory").  On Windows the sliced pass now stops
at the adapter's DXGI non-local budget - the process's current usage - 4 GiB
(IDXGIAdapter3::QueryVideoMemoryInfo for the CUDA device's LUID; dxgi.dll is
loaded at run time), or RAM/2 - 8 GiB when that query fails.  The arena line
names the cap and where it came from.

STRATA_ARENA_PIN_GIB: unset = the above; 0 = no cap (the old behaviour);
N > 0 = at most N GiB from the start.  arena_pin_cap_gib() (pinned.hpp)
reads it, -1 when unset, for the multi-GPU cap in generate.cpp as well.
A machine whose whole-arena registration succeeds is unchanged, and a
caller's cap (multi-GPU) still takes precedence.

This PC's whole registration fails too: IQ3_XXS now pins 24 GiB (32 slices;
budget 30.8 GiB - 2.0 in use - 4) instead of 28 GiB (36).
2026-09-30 21:02:17 +02:00
Niko1221 4b8db25763 load_experts_gguf reads with fread on a FILE* (#230)
The GGUF branch of the arena load (a native pack without experts.bin, the
normal install) read through std::ifstream, which MSVC splits into 4095-byte
freads - 0.02 GiB/s on the reporter's PC.  It now uses the same fopen/fread
with a 64-bit seek as load_experts_ranges (#89), with an RAII close.  Same
chunks, same bytes, same scatter.

Measured here (IQ3_XXS pack without experts.bin, RTX 5070, 64 GB): 1.49-1.60
GiB/s before, 3.17-3.25 GiB/s after (start 45-48 s -> 29-34 s); the generated
tokens are the same.
2026-09-30 21:02:08 +02:00
Niko1221 912a931f0f README: where things are stored (#226)
Chats (and the Chat tab's settings and API key) only in the browser's local storage (strata.* keys), the start
config strata-<model>.json and its siblings in the Strata folder, the model files in Strata-data next to it (or
--data-dir), and where that folder is remembered (%APPDATA%\Strata\settings.json, ~/.config/strata/settings.json).
2026-09-30 20:58:59 +02:00
Niko1221 8eff54c845 serve: an opt-in hard thinking budget, reasoning_budget_tokens (#123)
A request (OpenAI or Anthropic) may set "reasoning_budget_tokens": N, and "reasoning_budget_tokens" in
strata-<model>.json sets a default (a request's own value wins; 0 means no budget).  When the thinking reaches N
tokens - at a clean point, no tag held back and no character split across tokens - Service.run stops the engine,
feeds a short wrap-up line and </think> through the detokenizer and parser (the client sees it as the end of the
thinking; it counts as output), and generates again from prompt + what was generated + the wrap-up: a prefix of
what the engine's session already holds, so it continues from it.  With no room left to answer it ends with
"length" as before.  A bad value is a 400 before anything is sent (a bad config value refuses to start).  Off
by default: without the field and the key every request runs exactly as before (one engine pass).  Anthropic's
thinking.budget_tokens still only picks the level.  Documented in docs/DETAILS.md.

Tests (serve/test_server.py ThinkingBudget, a fake engine that continues after </think>): off by default, the
wrap-up and the continued prompt (the first prompt + the kept thinking + the wrap-up), the Anthropic stream, a
budget the thinking stays under, the config default and a request turning it off, thinking off, no room left,
bad values.
2026-09-30 20:58:59 +02:00
Niko1221 afc33c260e setup: reproducible installs - the checkout's own engine release, pinned Hugging Face revisions, pinned Python packages (#214)
- The ready-made engine: with the default --prebuilt, setup looks at releases/download/v<version>/ first (the
  version CMakeLists.txt says, source_version()) and falls back to releases/latest with a message when that
  release is not published (yet).  An explicit --prebuilt / STRATA_PREBUILT_URL is used as before; an
  installed engine new enough is kept without asking the network.
- Hugging Face: every model family's shards and vision encoder come from a fixed commit (HF_REVISIONS, the repos'
  `sha` on 2026-09-30), tools/mtp_fetch.py reads the BF16 checkpoint at its commit (STRATA_MTP_REVISION
  overrides).  A revision a repository no longer has falls back to its current files, with a message.  Files
  already downloaded keep their names and .done marks, so nothing is downloaded again.
- Python: requirements.txt pins the packages and their dependencies (numpy per Python range, 3.10+), used by
  setup's pip step and the Dockerfile.  A venv set up before this (bare names in .strata-pip.json) is left as it
  is; only packages it never had are installed, pinned.

Tests: tools/test_setup_pins.py (mocked network: the tag URL first, latest as the fallback, an installed engine
kept, a gone revision falling back to main in download() and mtp_fetch, the pip step for fresh, old and bumped
installs).
2026-09-30 20:58:44 +02:00
Niko1221 64f30121f4 qsa_prompt_attn (#270 follow-up): the m16n8k8 pair only for sm_75+ CUDA device code (AMD and pre-Turing builds keep the trap, which the host never reaches); Turing chosen per call from the current device instead of a process-wide flag (a split can mix Turing with newer cards) 2026-09-30 20:42:52 +02:00
kenh0u 48ecc6ac3d qsa_prompt_attn: the f16 tensor-core path runs on Turing (sm_75) as two m16n8k8 steps
m16n8k16 needs sm_80, but sm_75 has m16n8k8 with the same A/B/C register mapping, so
each k=16 step becomes two k=8 steps on the fragments as they are already laid out
(a[0]/a[1] with b[0], a[2]/a[3] with b[1]).  The sum now rounds twice, so the two paths
do not agree bit for bit.

cp.async does not exist before sm_80, so Turing takes the v1 kernel (launch<1>, same
accuracy, another summation order) instead of launch_i8; the capability probe now
accepts cc >= 7 and a device without cp.async sets g_turing.

Measured on a Quadro RTX 8000, CUDA 12.9, arch 75: qsa_prompt_attn_parity PASS
(FAILURES: 0; vs FP64 new 6.99e-06, old 2.37e-06, output scale 3.62); the int8 kernel
62.3 -> 19.6 ms per chunk (3.19x), fp16 65.0 -> 25.1 ms (2.59x).  Engine prefill on
three Turing cards: 9.7K-token prompt 1,050 -> 1,177 tok/s, 42K 1,124 -> 1,251 tok/s;
an 80K needle test answers correctly.
2026-09-30 20:42:23 +02:00
Guillaume PUTIER 45f93fc5ee iq_kernels: decode each IQ weight part once for every column and entry
iq_mmvq, native_gu_kernel and native_down_kernel called the format's dot once
per column (or group entry), re-reading the weight words and redoing the grid
lookups and sign unpacking each time. Each dot is now split into load (weight
side) and apply (activation side, same integer chain and float expression), as
native_mmvq.cu's multi-column traits are: the dense kernel takes 1, 2, 4 or 8
columns per pass (8 at a time past 8), the grouped ones 4 entries per pass
(~48 registers; the default verify window, --spec 4 with the split off, fits
in one pass).

Every column keeps the same calls, lane stride, summation order and warp_sum,
so results are bitwise equal to the old kernels, which STRATA_OLD_IQ_MMVQ=1 (or
iq_set_old_kernels) keeps for A/B timing.

Tests: iq_multi_parity (ctest, GPU, synthetic, no model) checks old vs new
bitwise for every format, ncols 1..8 and 11, groups of 0..11 entries; --bench
times both. iq_parity (real rows from tools/iq_fixture.py) now runs the dot for
1 to 8 columns and requires every column of a multi-column call to equal a
one-column call on it bitwise (exact layout, the default). native_expert_parity
runs the GPU expert with both the decode-once and the per-entry kernels on real
blobs and requires the same bits.
2026-09-30 20:41:56 +02:00
Niko1221 abde6fc8c9 s2_expert_grouped (#241 follow-up): the new chunk kernels' dp4a through STRATA_DP4A, so the sm_60 experimental build keeps its exact fallback 2026-09-30 20:41:26 +02:00
Guillaume PUTIER e155b07b9e kernels: faster grouped and per-hit Q2_0 expert kernels, bitwise identical
The grouped kernels (verify window, MTP layer) staged each entry's activations
as xs_q[k][c * 8 + j], an 8-way bank conflict on every read, and recomputed the
chunk sum hx with eight dp4a for every row. The per-hit kernels (token graph)
read each chunk with 44 byte loads.

New kernels, on by default:
- activations regrouped once per chunk so the codes expand with shift+mask
  and hx is summed once per chunk;
- grouped: word-major shared layout xs_w[j][k * NC + c] plus (dx, hx) pairs,
  conflict-free on the staging writes and the reads, two rows per warp;
- per hit: nine aligned word loads per activation chunk, uint2 code loads,
  16-bit scale loads, one warp per (gate, up) pair or pair of down rows.

s, hx and the float expression dw * dx * (float) (s - hx) are unchanged, so
every output matches the previous kernels bit for bit. STRATA_OLD_GROUPED=1
(or moe_grouped_select_old(1)) selects the previous kernels, and so does any
activation row, scratch or blob arena the wide loads cannot take.
STRATA_GROUPED_PAIR_MIN_HITS=N keeps the previous per-hit kernels below N hits
of capacity. moe_grouped_last_path() reports which kernels the last call ran.

The funnel shift that realigns an activation chunk is written as a 64-bit
shift instead of __funnelshift_r, which nothing else in the tree uses.

tests: s2_expert_grouped_parity runs every entry point with the previous
kernels then the new ones on synthetic Q2_0 blobs and Q8_0 activations, checks
the path taken, and requires output and scratch to match byte for byte, plus a
double-precision host reference. It covers the stride and arena fallbacks and
a 2-byte aligned activation row. --bench times previous against new. It
needs a GPU and is registered in ctest.
2026-09-30 20:41:08 +02:00
Niko1221 5a7190de4a setup: the low-RAM mode's one-GPU warning says why, with the RAM math; --low-ram off --yes installs (#250)
Low-RAM mode on a multi-GPU pick dropped to one GPU with only "the low-RAM mode runs on one GPU".  It now says
why: the experts plus ~10 GB for the rest (e.g. 43 + 10 = 53 GB) against this PC's RAM, or that --low-ram was
chosen; that the engine does not split layers in that mode (it refuses --resident-experts with a layer split);
and what keeps all the GPUs (more RAM, a smaller size, --low-ram off).

--low-ram off on a PC short of RAM asked "Install it anyway?" with the default n, so an unattended --yes
install always stopped although the user had turned the mode off explicitly.  With --low-ram off the default is
y (--yes installs, with a warning); with auto the question and its n default are as before (#125), and the stop
message names --low-ram off --yes.  The two blocks are functions now (low_ram_one_gpu_why, confirm_paging);
tests in tools/test_setup_lowram.py with mocked input.
2026-09-30 20:40:02 +02:00
Niko1221 c8e46e80b7 serve: a whole OpenAI answer leaves out a tool call whose arguments don't parse unless it ends in tool_calls (#211)
The follow-up to #231: openai_collect kept a call the output ended inside, with its truncated arguments, in
message.tool_calls (finish_reason "stop" or "length").  It now leaves out every call whose arguments are not
JSON when the finish reason is not "tool_calls" - what anthropic_collect does with such a tool_use block.  The
streamed answers are unchanged.  Tests: the cut call over both whole APIs (at the end of the turn and at the
token limit) and openai_collect directly.
2026-09-30 20:38:29 +02:00
Sunil Srivatsa 67d5ed4277 fix(serve): report a tool call cut off by the end of the output as unfinished
When the model's output ended inside a tool call whose name was already
streamed, finish() closed its JSON and emitted a tool_call event, and the
answer ended with finish_reason "tool_calls" / stop_reason "tool_use", so
clients ran the truncated arguments; an MCP call ran with empty arguments.

The call now stays unfinished: its JSON is not closed and no tool_call
follows its tool_start. Both APIs report "tool_calls" / "tool_use" only when
every streamed call completed, and the non-streamed Anthropic answer leaves
out a call whose input never closed.

Fixes #211
2026-09-30 20:37:57 +02:00
Niko1221 97362183ef tokenizer: a word longer than 64 symbols merges with a heap and a linked list, not a rescan per merge (#268)
_bpe rescanned every adjacent pair after each merge: O(n^2) on one long pre-token piece (a CJK run, a minified
blob).  With the pack's vocabulary a 2,000-character CJK run took 1.6 s and 8K characters tens of seconds;
_bpe_heap takes about 5 ms and 20 ms.  It pops the lowest rank, then the lowest position - the order the scan's
strict `<` picks - and skips pairs whose symbols have merged since they were pushed.  Words up to HEAP_MIN (64)
symbols run the existing scan unchanged.

Tests (serve/test_detok.py HeapBpe): the heap against the scan word by word and through encode (both
parse_special modes, heap forced on for every word and at the default threshold) over random text with CJK and
Hangul runs, conjoining jamo, combining marks, URLs, minified code and specials - with a synthetic vocabulary
(always) and the pack's (when there is one); an 8K-character CJK run round-trips in well under a second.
2026-09-30 20:37:45 +02:00
Niko1221 9556a8dcf4 tests (#264 follow-up): the fixture step skips (exit 3) instead of failing when the vendored gguf-py is absent; no unused SCALE_F16 2026-09-30 20:36:29 +02:00
Niko1221 64dcc59fae gemm (#240 follow-up): setup calls that failed before without a word are logged and survived as before (not fatal - hipBLAS can return not-supported), init_external names its failures too, the MiB stays in the scratch message; no unused resource_failure flag 2026-09-30 20:36:18 +02:00
Niko1221 50d2adaabd serve: a request settles its status, history and totals while it still holds the fifo (#266)
Service.run() recorded the finished request's history row and totals, set busy=False and dropped `tail` in a
finally that ran after `with self.fifo:` had released the lock.  A request waiting for the fifo could start in
that gap: the old request then recorded the NEW request's status as its own, cleared its busy flag and popped
its tail, and the new request crashed in _note (KeyError 'tail').  The block now runs inside the fifo (an
inner try/finally, which also sees the disconnect), and _note reads the tail defensively.  Test: a stream
aborted mid-answer while another request waits, with a fifo that lets the waiter run first on release.
2026-09-30 20:35:46 +02:00
Hozák Martin f121667826 q2_avx2: two-block 256-bit unpack for rows of 1-2 tokens (bit-exact)
Rows that serve 1 or 2 activations (the near-universal shape of routed
decode) read each weight block twice less often: one 256-bit shuffle
ladder covers two consecutive blocks (lanes are per-128-bit, so the
arithmetic is the SSE ladder run twice and the re-homed halves keep the
original byte order) -> the same madd lane mapping, bit-identical
results.  The SSE unpack stays for 3+ tokens: at four accumulators the
extra live unpack vectors spill registers and it measurably loses.
Measured on i7-8700K AVX2, qwen3.8 125B-MoE Q2_0 decode: +10% gate/up and
+5-7% down at 1 token/expert in the standalone harness
(ML-Experiments/bench5/q2_cpu_bench.cpp, bit-exact verified), and -7
ms/verify-window end to end (CPU pool waitCPU ~19 -> ~13 ms), GPU stages
and generation unchanged.
2026-09-30 20:35:28 +02:00
Hozák Martin 765fc13473 fused_gr: sm_75 down kernel with TILE=1280 staging, other archs unchanged
Turing (sm_75) opt-in shared memory is 64 KiB. With the old fixed
TILE=2560 staging the down kernel could hold at most 6 tokens
(2560*6*4 = 60 KiB), so 7+ token windows split into two launches and,
more importantly, a single 40 KiB tile at T=4 filled the SM so only
one block per SM fit next to the resident expert/attention work.

Specialize gr_down_multi_kernel on the per-token tile size:
- sm_75: TILE=1280 -> up to 8 tokens staged in one 40 KiB launch
  (kFusedGrMaxT=8 covered), and T-token tiles fit 1-3 blocks/SM
  depending on T, so concurrent hc lanes can overlap.
- every other arch keeps TILE=2560 exactly as before.

Per-lane weight chunk order within a tile stays strictly increasing
in (tile, chunk), so the accumulation order for every (expert, row)
is identical to the 2560 path and results are bitwise unchanged.

Measured on RTX 2070 (8700K host, engine 0.1.27, Qwen3.6 125B Q2_0,
29K context, temperature 0, identical benchmark): GDN hc0 down
2.73-2.80 -> 1.88-1.98 ms/window (-30%), QSA hc0 down 0.90-0.93 ->
0.62-0.65, up/norm kernels unchanged, GPU util 91.7 -> 93.5%,
decode tok/s slightly higher on average (within per-run noise;
window is CPU expert-scheduling bound).
2026-09-30 20:35:28 +02:00
Jakub Luwierski 2538ed7927 tests: make iq_parity reproducible from a fresh checkout (TODO 24)
The i-quant fixtures were never published, so iq_parity reported ten
"missing fixture" failures on any fresh tree.  tools/iq_fixture.py now
generates them deterministically (seeded rows/cols, RandomState) into
the BUILD directory: for each of the ten types it writes the raw block
bytes (sane fp16 scales at each layout's scale offsets, seeded index and
sub-scale bytes) plus the gguf-py dequantized reference - gguf-py is
dequant-only for the i-quants, so no quantizer is needed, and Q2_0 (the
repository's type 42) uses tools/gguf_writer.py's codec.  The kernel
type ids in the headers match the vendored gguf-py's enum one for one.
Dependencies: python3 with numpy and the vendored gguf-py - nothing is
pip-installed, and CMake probes the configured interpreter and .venv,
registering the tests only when a usable interpreter is found and
saying so otherwise.

CTest now runs iq_parity (previously built but never registered) with
the fixtures as an explicit CTest fixture: generation completes before
the test even under parallel execution, and a generation failure fails
the run.  The missing-fixture diagnostic names both candidate files and
the generating command; the nonzero exit is preserved.
2026-09-30 20:35:02 +02:00
lukmanfauzie 9726c926d6 gemm: name the cuBLAS/CUDA call that failed at init, and flag resource shortages
`Gemm::init` collapsed five distinct failures into three bare strings ("cublasCreate
failed", "workspace", "dequant scratch of N MiB"), so an init failure on a tight machine
could not be told apart from a driver or install problem without a debugger.

Each call is now checked through two small helpers that report the operation and the real
status - `cuBLAS status N` or `cudaGetErrorString` - and optionally set
`resource_failure` when the failure means the machine is out of room
(`CUBLAS_STATUS_ALLOC_FAILED`, `cudaErrorMemoryAllocation`).  A caller can then retry with
a smaller cache or prompt instead of treating a shortage as fatal.

The parameter is defaulted to nullptr, so every existing caller is source-compatible; the
upstream HIP/hipblaslt block is untouched.
2026-09-30 20:35:02 +02:00
Enky 5396360ef7 verify: STRATA_LOGPOS hook for per-position teacher-forced log-probabilities
Verifier::window_logprobs writes one line per row of the last verify window's
head: position, target, its log-probability, the top token and its
log-probability, a hit flag, the log-probability of STRATA_LOGPOS_EXTRA
(default 248046, <|im_end|>) and the target's log-probability renormalized
without that token. read_windows calls it before commit when
STRATA_LOGPOS=<path> is set; otherwise the only cost is one null check.
A layer split's earlier stage forwards to the stage that holds the head,
under OnDevice as commit() does.
2026-09-30 20:35:02 +02:00
221 changed files with 55770 additions and 1358 deletions

No files matched your search

+3
View File
@@ -4,3 +4,6 @@ bench/prompts/** -text
# launchers keep their platform line endings wherever the repository is cloned
*.sh text eol=lf
*.bat text eol=crlf
# copies of real packs' native_experts.txt, parsed byte for byte by tests/core/expert_layout_test.cpp
tests/data/native_experts/** -text
+178 -10
View File
@@ -8,7 +8,7 @@
# below refuses anything older: silently building for a pre-Ampere arch would produce a binary that runs
# and is wrong about its own performance, which is the worst of both outcomes.
cmake_minimum_required(VERSION 3.24)
project(strata VERSION 0.1.30 LANGUAGES CXX)
project(strata VERSION 0.1.32 LANGUAGES CXX)
add_compile_definitions(STRATA_VERSION="${PROJECT_VERSION}")
# issue #31: release builds keep a PDB beside the exe (not shipped in it), so a minidump from a stalled engine can
# be read back to the exact source line
@@ -33,8 +33,13 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
endif()
option(STRATA_ENABLE_CUDA "Build the CUDA targets (Phase 2+)" OFF)
option(STRATA_ENABLE_HIP "Build the HIP targets for wave32 AMD GPUs (gfx1100, gfx1201)" OFF)
option(STRATA_ENABLE_HIP "Build the HIP targets for wave32 AMD GPUs (gfx1100, gfx1201; gfx1030 unvalidated)" OFF)
option(STRATA_PREFILL_MMQ "Build the optional GGML MMQ prefill path for HIP" OFF)
# CUDA: MMQ prompt kernels for Q4_K / Q5_K / Q5_1 (Unsloth's UD-Q4_K_XL experts). Off by default: the engine loads
# every kernel when it starts (CUDA_MODULE_LOADING=EAGER), so these took ~5 MB of VRAM - 1-3 expert slots - from every
# model, and the UD-Q4_K_XL prompt is SSD-bound with or without them (docs/UNSLOTH_Q4.md)
option(STRATA_MMQ_KQUANTS "Build the CUDA MMQ prompt kernels for Q4_K / Q5_K / Q5_1 experts" OFF)
option(STRATA_ORCA_Q4KS_MMQ "Build the GGML Q5_0 MMQ instance for OrcaRouter Q4_K_S" OFF)
if(STRATA_PREFILL_MMQ AND NOT STRATA_ENABLE_HIP)
message(FATAL_ERROR "STRATA_PREFILL_MMQ requires STRATA_ENABLE_HIP=ON")
endif()
@@ -68,6 +73,7 @@ if(STRATA_ENABLE_CUDA)
# `enable_language(CUDA)` gives the .cu compile rules but NOT the imported targets, so `CUDA::cudart` has to
# be brought in explicitly for the host-side tests that call cudaMalloc themselves.
find_package(CUDAToolkit REQUIRED)
option(STRATA_EXPERIMENTAL_SM60 "community build for GPUs below compute capability 7.5: Pascal sm_60, Volta sm_70 (#236)" OFF)
if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
set(CMAKE_CUDA_ARCHITECTURES 120 CACHE STRING "CUDA architectures" FORCE)
endif()
@@ -79,16 +85,22 @@ if(STRATA_ENABLE_CUDA)
if(_base STREQUAL "native" OR _base STREQUAL "all" OR _base STREQUAL "all-major")
continue()
endif()
# STRATA_EXPERIMENTAL_SM60: a Pascal (sm_60, GP100-class) build. It sits below every architecture
# these kernels were written for, so two intrinsics are replaced for it - `__dp4a` (6.1+) and
# `__nanosleep` (7.0+) - in include/strata/kernels/dp4a.hpp, which is bit-exact for the first and
# merely a shorter pause for the second. RTX 20/30/40/50 cards must use the release engine instead.
# STRATA_EXPERIMENTAL_SM60: a Pascal (sm_60, GP100-class) or Volta (sm_70, V100 / Titan V, #236) build.
# These sit below every architecture the kernels were written for, so two intrinsics are replaced below
# their arch - `__dp4a` (6.1+) and `__nanosleep` (7.0+) - in include/strata/kernels/dp4a.hpp, which is
# bit-exact for the first and merely a shorter pause for the second (sm_70 has both). Community-tested,
# not in the ready-made engine; RTX 20/30/40/50 cards must use the release engine instead. It needs a CUDA
# 12.x toolkit: CUDA 13 dropped sm_60 and sm_70 (nvcc fails CMake's compiler test with "compute_70").
if(_base LESS 75 AND NOT STRATA_EXPERIMENTAL_SM60)
message(FATAL_ERROR
"Strata needs an NVIDIA GPU of compute capability 7.5 or newer (RTX 20 / 30 / 40 / 50 series), but "
"CMAKE_CUDA_ARCHITECTURES is '${CMAKE_CUDA_ARCHITECTURES}'. (A Pascal build is "
"CMAKE_CUDA_ARCHITECTURES is '${CMAKE_CUDA_ARCHITECTURES}'. (A Pascal sm_60 or Volta sm_70 build is "
"-DSTRATA_EXPERIMENTAL_SM60=ON; upstream does not support it.)")
endif()
if(_base LESS 60)
message(FATAL_ERROR "CMAKE_CUDA_ARCHITECTURES '${CMAKE_CUDA_ARCHITECTURES}': even the experimental build "
"needs compute capability 6.0 (sm_60) or newer")
endif()
# #220 / #224: RTX 50 engines built with CUDA 12.8 crashed in the prompt path on Linux (13.0 and newer did not)
if(_base GREATER_EQUAL 120 AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 13.0)
message(WARNING "Building for sm_${_base} (RTX 50) with CUDA ${CMAKE_CUDA_COMPILER_VERSION}: engines built with "
@@ -148,6 +160,10 @@ if(STRATA_BUILD_TESTS)
add_executable(gguf_reader_test src/artifact/gguf_reader_test.cpp)
target_link_libraries(gguf_reader_test PRIVATE strata_artifact)
add_test(NAME gguf_reader_test COMMAND gguf_reader_test)
# a split model's shards and their joint view: missing shard, split keys, duplicates, truncation (synthetic)
add_executable(gguf_split_test tests/core/gguf_split_test.cpp)
target_link_libraries(gguf_split_test PRIVATE strata_artifact)
add_test(NAME gguf_split_test COMMAND gguf_split_test)
endif()
# ---- strata_plan ----------------------------------------------------------
@@ -166,6 +182,10 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
add_library(strata_core STATIC src/core/device.cu src/core/pinned.cu src/platform/memory.cpp src/core/graph.cpp src/core/weights.cpp
src/core/layout.cpp)
target_include_directories(strata_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
if(STRATA_ENABLE_CUDA AND STRATA_EXPERIMENTAL_SM60)
# the runtime device check (src/core/device.cu) admits the cards this build was made for (#236)
target_compile_definitions(strata_core PRIVATE STRATA_EXPERIMENTAL_SM60=1)
endif()
# The selected runtime is PUBLIC because graph.cpp is a HOST translation unit that calls cudaGraphLaunch and
# cudaEventQuery: the .cu sources get cudart through the CUDA language rules, a .cpp does not, and the
# linker error ("unresolved external symbol cudaGraphInstantiate") names the function rather than the cause.
@@ -254,6 +274,15 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
target_include_directories(qsa_prompt_attn_parity PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
target_link_libraries(qsa_prompt_attn_parity PRIVATE strata_kernels CUDA::cudart)
endif()
# the QSA selection (block scores on the warp kernel and the tensor-core one, top-k): a GPU bench with a
# scorer-vs-scorer comparison and an FP64 accuracy gate (synthetic, no model); the ctest runs a 32K context under a
# 262144-cell capacity (the top-k dispatch follows the capacity) and exits non-zero on a failed gate
if((STRATA_BUILD_TESTS OR STRATA_PARITY_PROMPT_ATTN) AND STRATA_ENABLE_HIP)
add_executable(qsa_select_bench src/kernels/qsa_select_bench.cpp)
set_source_files_properties(src/kernels/qsa_select_bench.cpp PROPERTIES LANGUAGE HIP)
target_link_libraries(qsa_select_bench PRIVATE strata_kernels strata_hip_runtime)
add_test(NAME qsa_select_bench COMMAND qsa_select_bench 32768 256 3 262144)
endif()
# plan v0.3 P6: llama.cpp's block layouts and codebook grids for the i-quant formats (MIT, third_party/ggml)
target_include_directories(strata_kernels PRIVATE third_party/ggml)
# Match the pinned llama.cpp CUDA arithmetic contract for this adapter only.
@@ -321,6 +350,19 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
add_test(NAME file_expert_source_test COMMAND file_expert_source_test)
set_tests_properties(file_expert_source_test PROPERTIES TIMEOUT 60)
endif()
if(STRATA_BUILD_TESTS AND STRATA_NATIVE_EXPERTS)
# native_experts.txt v2-v4 (the real packs' copies and the per-role shard column) and the arena filled from
# synthetic GGUF shards at the real expert dimensions
add_executable(expert_layout_test tests/core/expert_layout_test.cpp)
target_link_libraries(expert_layout_test PRIVATE strata_engine)
add_test(NAME expert_layout_test COMMAND expert_layout_test ${CMAKE_CURRENT_SOURCE_DIR}/tests/data/native_experts)
set_tests_properties(expert_layout_test PROPERTIES TIMEOUT 60)
# #326: a native pack's BF16 (--compat-bf16) PLE key stays in the arena; a quantized key row loads as before
add_executable(native_dense_ple_key_test tests/core/native_dense_ple_key_test.cpp)
target_link_libraries(native_dense_ple_key_test PRIVATE strata_engine)
add_test(NAME native_dense_ple_key_test COMMAND native_dense_ple_key_test)
set_tests_properties(native_dense_ple_key_test PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 60)
endif()
if(STRATA_BUILD_CONVERSATION_TESTS)
add_executable(conversation_snapshot_test src/core/conversation_snapshot_test.cpp)
target_link_libraries(conversation_snapshot_test PRIVATE strata_engine)
@@ -391,6 +433,17 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
add_test(NAME hip_prefill_native_batch COMMAND hip_prefill_native_batch)
list(APPEND _strata_hip_tests hip_prefill_native_batch)
endif()
# S6: the AMD fast router against the portable kernel, bitwise
add_executable(hip_router_fast tests/hip/router_fast.cpp)
target_link_libraries(hip_router_fast PRIVATE strata_kernels strata_hip_runtime)
add_test(NAME hip_router_fast COMMAND hip_router_fast)
list(APPEND _strata_hip_tests hip_router_fast)
# S6: the RDNA4 matrix-core prompt attention (STRATA_HIP_WMMA) against the FP32 kernel and FP64; skips off gfx12
add_executable(hip_prompt_attn_wmma src/kernels/qsa_prompt_attn_parity.cpp)
target_link_libraries(hip_prompt_attn_wmma PRIVATE strata_kernels strata_hip_runtime)
add_test(NAME hip_prompt_attn_wmma COMMAND hip_prompt_attn_wmma 32768 2048 3)
set_tests_properties(hip_prompt_attn_wmma PROPERTIES TIMEOUT 600 SKIP_RETURN_CODE 77)
list(APPEND _strata_hip_tests hip_prompt_attn_wmma)
if(STRATA_HIPBLASLT_AVAILABLE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/hip/prefill_hipblaslt_gemm.cpp")
add_executable(hip_prefill_hipblaslt_gemm tests/hip/prefill_hipblaslt_gemm.cpp)
target_include_directories(hip_prefill_hipblaslt_gemm PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/prefill")
@@ -426,6 +479,49 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
add_executable(iq_parity src/kernels/iq_parity.cpp)
target_include_directories(iq_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(iq_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
# TODO 24: the i-quant fixtures are generated, not shipped. tools/iq_fixture.py needs python3 + numpy
# and the repository's vendored gguf-py (no pip installs); it writes deterministic fixtures into the
# BUILD directory (the source tree is not touched). The CTest fixture makes generation-to-test order
# explicit even under parallel execution; a fixture-generation failure fails iq_parity with it.
find_package(Python3 COMPONENTS Interpreter QUIET)
# the generator needs an interpreter WITH numpy: probe the configured one, the setup's .venv, and the
# system python3; -DIQ_FIXTURE_PYTHON=... overrides the search outright.
set(_iq_python "")
set(_iq_candidates "")
if(IQ_FIXTURE_PYTHON)
list(APPEND _iq_candidates ${IQ_FIXTURE_PYTHON})
else()
if(Python3_Interpreter_FOUND)
list(APPEND _iq_candidates ${Python3_EXECUTABLE})
endif()
list(APPEND _iq_candidates "${CMAKE_CURRENT_SOURCE_DIR}/.venv/bin/python"
"${CMAKE_CURRENT_SOURCE_DIR}/.venv/Scripts/python.exe"
/usr/bin/python3
python3)
endif()
foreach(_cand IN LISTS _iq_candidates)
if(_cand STREQUAL "")
continue()
endif()
execute_process(COMMAND ${_cand} -c "import numpy" OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE _iq_probe)
if(_iq_probe EQUAL 0)
set(_iq_python "${_cand}")
break()
endif()
endforeach()
if(NOT _iq_python STREQUAL "")
add_test(NAME iq_parity_fixtures
COMMAND ${_iq_python} ${CMAKE_CURRENT_SOURCE_DIR}/tools/iq_fixture.py
--out ${CMAKE_CURRENT_BINARY_DIR}/iq_fixture)
# exit 3: numpy or the vendored gguf-py is missing (a trimmed third_party) - a skip, not a failure
set_tests_properties(iq_parity_fixtures PROPERTIES FIXTURES_SETUP iq_fixture_data SKIP_RETURN_CODE 3)
add_test(NAME iq_parity COMMAND iq_parity ${CMAKE_CURRENT_BINARY_DIR}/iq_fixture)
set_tests_properties(iq_parity PROPERTIES FIXTURES_REQUIRED iq_fixture_data SKIP_RETURN_CODE 3)
else()
message(STATUS "STRATA tests: no python3 with numpy was found (the configured interpreter and .venv "
"were probed) - the iq_parity fixtures and its test are not registered; the fixtures "
"need python3 with numpy and the repository's vendored gguf-py")
endif()
if(STRATA_ENABLE_CUDA)
# native_mmvq's multi_exact contract, bitwise: a T-column call against T single-column calls on the same Q8_1
# bytes, with the flag off as the negative control (synthetic, GPU, no model; the control assumes 32-lane warps)
@@ -434,6 +530,12 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
target_link_libraries(mmvq_multi_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
add_test(NAME mmvq_multi_parity COMMAND mmvq_multi_parity)
endif()
# the IQ kernels that decode a weight part once for every column/entry, bitwise vs the per-column ones
# (GPU, synthetic, no model; --bench adds old/new timings)
add_executable(iq_multi_parity src/kernels/iq_multi_parity.cpp)
target_include_directories(iq_multi_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(iq_multi_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
add_test(NAME iq_multi_parity COMMAND iq_multi_parity)
add_executable(shared_expert_parity src/kernels/shared_expert_parity.cpp)
target_include_directories(shared_expert_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(shared_expert_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
@@ -549,6 +651,13 @@ if(STRATA_ENABLE_CUDA OR STRATA_ENABLE_HIP)
target_link_libraries(cvec_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
add_test(NAME cvec_parity COMMAND cvec_parity)
# The rewritten per-hit and grouped expert kernels vs the previous ones, bitwise (GPU, synthetic, no model).
# `--bench` adds previous/new timings on engine-like shapes.
add_executable(s2_expert_grouped_parity src/kernels/s2_expert_grouped_parity.cpp)
target_include_directories(s2_expert_grouped_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(s2_expert_grouped_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
add_test(NAME s2_expert_grouped_parity COMMAND s2_expert_grouped_parity --selftest)
# Plan v0.3 P3: native MMVQ for 1..8 tokens (bitwise selftest + --bench timing); synthetic data, no model.
if(STRATA_BUILD_TESTS AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/bench/micro/native_mmvq_multi.cpp")
add_executable(native_mmvq_multi bench/micro/native_mmvq_multi.cpp)
@@ -679,6 +788,9 @@ set(STRATA_GGML_DIR "" CACHE PATH "llama.cpp checkout to take ggml from (empty:
if(STRATA_PREFILL_MMQ AND NOT STRATA_NATIVE_EXPERTS)
message(FATAL_ERROR "STRATA_PREFILL_MMQ requires STRATA_NATIVE_EXPERTS=ON for GGML sources")
endif()
if(STRATA_ORCA_Q4KS_MMQ AND NOT STRATA_NATIVE_EXPERTS)
message(FATAL_ERROR "STRATA_ORCA_Q4KS_MMQ requires STRATA_NATIVE_EXPERTS=ON for GGML sources")
endif()
if(STRATA_NATIVE_EXPERTS)
enable_language(C)
set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
@@ -713,18 +825,25 @@ if(STRATA_NATIVE_EXPERTS)
# part of strata_kernels_cpu (the pool calls these and they call its CPU probe: one library, so GNU ld's
# one-pass static linking has no cycle to resolve)
target_sources(strata_kernels_cpu PRIVATE src/kernels/cpu/native_expert.cpp src/kernels/cpu/iq_avx512.cpp
src/kernels/cpu/iq_avx2.cpp)
src/kernels/cpu/iq_avx2.cpp src/kernels/cpu/kq_avx2.cpp)
target_include_directories(strata_kernels_cpu PRIVATE third_party/ggml)
if(MSVC)
set_source_files_properties(src/kernels/cpu/iq_avx512.cpp PROPERTIES COMPILE_OPTIONS "/arch:AVX512")
set_source_files_properties(src/kernels/cpu/iq_avx2.cpp PROPERTIES COMPILE_OPTIONS "/arch:AVX2")
set_source_files_properties(src/kernels/cpu/kq_avx2.cpp PROPERTIES COMPILE_OPTIONS "/arch:AVX2")
else()
set_source_files_properties(src/kernels/cpu/iq_avx512.cpp PROPERTIES COMPILE_OPTIONS
"-mavx512f;-mavx512bw;-mavx512vl;-mavx512dq;-mavx512vnni;-mavx512vbmi;-mf16c;-mfma")
set_source_files_properties(src/kernels/cpu/iq_avx2.cpp PROPERTIES COMPILE_OPTIONS "-mavx2;-mfma;-mf16c")
set_source_files_properties(src/kernels/cpu/kq_avx2.cpp PROPERTIES COMPILE_OPTIONS "-mavx2;-mfma;-mf16c")
endif()
target_link_libraries(strata_kernels_cpu PUBLIC ggml-cpu ggml-base)
target_compile_definitions(strata_kernels_cpu PUBLIC STRATA_NATIVE_EXPERTS=1)
set(_strata_mmq_types q2_0 iq2_xxs iq2_xs iq2_s iq3_xxs iq3_s iq4_nl iq4_xs q8_0)
# #296: OrcaRouter Q4_K_S's Q5_0 experts (Q4_K and Q5_1 come with STRATA_MMQ_KQUANTS on CUDA, S5's branch)
if(STRATA_ORCA_Q4KS_MMQ)
list(APPEND _strata_mmq_types q5_0)
endif()
if(STRATA_ENABLE_CUDA)
# prompt-speed plan step 2b: llama.cpp's MMQ kernels (ggml-cuda, MIT) for the prompt path's experts, compiled
# from the same checkout as ggml above - only mmq.cuh's instances for the packs' types and the quantizer, with
@@ -736,7 +855,14 @@ if(STRATA_NATIVE_EXPERTS)
endif()
set(_strata_mmq ${_strata_gg}/src/ggml-cuda)
add_library(strata_mmq STATIC src/prefill/moe_mmq.cu src/prefill/ggml_cuda_host.cu ${_strata_mmq}/quantize.cu)
foreach(_t q2_0 iq2_xxs iq2_xs iq2_s iq3_xxs iq3_s iq4_nl iq4_xs q8_0) # q8_0: the drafter's matrices (E-9)
# q8_0: the drafter's matrices (E-9); STRATA_ORCA_Q4KS_MMQ adds q5_0 (#296, in _strata_mmq_types), and
# STRATA_MMQ_KQUANTS q4_k q5_k q5_1, the experts of Unsloth's UD-Q4_K_XL (docs/UNSLOTH_Q4.md; the dispatch
# follows eddoursul/Strata 7706c1b)
set(_strata_mmq_cuda_types ${_strata_mmq_types})
if(STRATA_MMQ_KQUANTS)
list(APPEND _strata_mmq_cuda_types q4_k q5_k q5_1)
endif()
foreach(_t IN LISTS _strata_mmq_cuda_types)
target_sources(strata_mmq PRIVATE ${_strata_mmq}/template-instances/mmq-instance-${_t}.cu)
endforeach()
target_include_directories(strata_mmq PRIVATE ${_strata_gg}/include ${_strata_gg}/src ${_strata_mmq}
@@ -746,8 +872,21 @@ if(STRATA_NATIVE_EXPERTS)
target_compile_options(strata_mmq PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=/bigobj>)
endif()
target_link_libraries(strata_mmq PUBLIC ggml-base ${_strata_gpu_runtime_target})
if(STRATA_MMQ_KQUANTS)
target_compile_definitions(strata_mmq PRIVATE STRATA_MMQ_KQUANTS=1)
endif()
if(STRATA_ORCA_Q4KS_MMQ)
target_compile_definitions(strata_mmq PRIVATE STRATA_ORCA_Q4KS_MMQ=1)
endif()
target_link_libraries(strata_prefill PUBLIC strata_mmq)
target_compile_definitions(strata_prefill PUBLIC STRATA_PREFILL_MMQ=1)
if(STRATA_BUILD_TESTS AND STRATA_MMQ_KQUANTS)
# the UD-Q4_K_XL expert formats through MMQ against ggml's dequantized weights (synthetic, a few seconds)
add_executable(prefill_mmq_kquant_test tests/cuda/prefill_mmq_kquant_test.cpp)
target_link_libraries(prefill_mmq_kquant_test PRIVATE strata_mmq ggml-base ${_strata_gpu_runtime_target})
add_test(NAME prefill_mmq_kquant_test COMMAND prefill_mmq_kquant_test)
set_tests_properties(prefill_mmq_kquant_test PROPERTIES TIMEOUT 120)
endif()
elseif(STRATA_PREFILL_MMQ)
# Compile only the pinned GGML MMQ and activation-quantizer sources used by prefill. This uses
# common.cuh's native HIP path without enabling a second GGML HIP backend.
@@ -764,7 +903,7 @@ if(STRATA_NATIVE_EXPERTS)
src/prefill/moe_mmq.cu
src/prefill/ggml_cuda_host.cu
"${_strata_mmq}/quantize.cu")
foreach(_t q2_0 iq2_xxs iq2_xs iq2_s iq3_xxs iq3_s iq4_nl iq4_xs q8_0)
foreach(_t IN LISTS _strata_mmq_types)
list(APPEND _strata_mmq_sources "${_strata_mmq}/template-instances/mmq-instance-${_t}.cu")
endforeach()
set_source_files_properties(${_strata_mmq_sources} PROPERTIES LANGUAGE HIP)
@@ -773,6 +912,9 @@ if(STRATA_NATIVE_EXPERTS)
PRIVATE "${_strata_gg}/include" "${_strata_gg}/src" "${_strata_mmq}"
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
target_compile_definitions(strata_mmq PRIVATE GGML_USE_HIP=1)
if(STRATA_ORCA_Q4KS_MMQ)
target_compile_definitions(strata_mmq PRIVATE STRATA_ORCA_Q4KS_MMQ=1)
endif()
target_link_libraries(strata_mmq PUBLIC ggml-base hip::host roc::hipblas)
target_link_libraries(strata_prefill PUBLIC strata_mmq)
target_compile_definitions(strata_prefill PUBLIC STRATA_PREFILL_MMQ=1)
@@ -794,6 +936,32 @@ if(STRATA_NATIVE_EXPERTS)
add_executable(native_expert_parity src/kernels/native_expert_parity.cpp)
target_include_directories(native_expert_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(native_expert_parity PRIVATE strata_kernels strata_kernels_cpu strata_artifact ${_strata_gpu_runtime_target})
if(STRATA_BUILD_TESTS AND STRATA_ENABLE_CUDA)
# Unsloth UD-Q4_K_XL's three expert pairs (and Q8_0 alone, its embedding) on synthetic ggml-quantized weights
# at 2560/640: GPU and CPU experts against the float reference, GPU dequantizers against to_float
foreach(_pair q4_K/q5_1 q4_K/q8_0 q5_K/q8_0 q8_0/q8_0)
string(REPLACE "/" "_" _name "${_pair}")
add_test(NAME native_expert_parity_${_name} COMMAND native_expert_parity --synthetic ${_pair})
set_tests_properties(native_expert_parity_${_name} PROPERTIES TIMEOUT 120)
endforeach()
add_test(NAME native_expert_parity_q5_1_min COMMAND native_expert_parity --q5_1-min)
# #290: the BF16 token embedding (--embd-gguf) gathered and dequantized bit for bit
add_test(NAME native_expert_parity_bf16_embd COMMAND native_expert_parity --bf16-embd)
# a pair without GPU kernels (Q6_K gate/up) is refused by native_expert_supported, not run
add_test(NAME native_expert_parity_refuses_q6_K COMMAND native_expert_parity --synthetic q6_K/q8_0)
set_tests_properties(native_expert_parity_refuses_q6_K PROPERTIES WILL_FAIL TRUE)
endif()
endif()
# #296's real-weight checks (OrcaRouter Q4_K_S files; docs/ORCA_Q4_K_S.md) - test programs, not part of a release
if(STRATA_ENABLE_CUDA AND STRATA_BUILD_TESTS)
add_executable(ple_q5_parity src/kernels/ple_q5_parity.cpp)
target_link_libraries(ple_q5_parity PRIVATE strata_kernels strata_artifact ggml-base ${_strata_gpu_runtime_target})
add_executable(q5_projection_parity src/kernels/q5_projection_parity.cpp)
target_include_directories(q5_projection_parity PRIVATE ${_strata_gpu_include_directories})
target_link_libraries(q5_projection_parity PRIVATE strata_kernels strata_artifact ggml-base ${_strata_gpu_runtime_target})
# #291: the FP8 PLE table (tools/ple_fp8_pack.py) through PleTable vs the checkpoint's own values
add_executable(ple_fp8_parity src/kernels/ple_fp8_parity.cpp)
target_link_libraries(ple_fp8_parity PRIVATE strata_kernels ${_strata_gpu_runtime_target})
endif()
endif()
+1 -2
View File
@@ -60,8 +60,7 @@ ARG BUILD_VISION=1
RUN python3 -m venv .venv \
&& .venv/bin/pip install --no-cache-dir --upgrade pip \
&& .venv/bin/pip install --no-cache-dir \
numpy jinja2 regex pyyaml tqdm requests cmake ninja pillow psutil \
&& .venv/bin/pip install --no-cache-dir -r requirements.txt \
&& chmod +x setup.sh docker-entrypoint.sh
# llama.cpp at the pinned commit, then the engine and the image encoder, built
+28 -4
View File
@@ -42,6 +42,9 @@ A card with more VRAM is faster, because more of the model fits on the GPU: an R
Every PC is different: `START-HERE.bat --calibrate` measures a few engine settings on yours and keeps the fastest
(about 5-10 minutes; on the PC above it made the Coder 7% faster).
Measured Strata on your own PC? See [Community benchmark results](docs/COMMUNITY_BENCHMARKS.md)
for a report template and how to share your results in a pull request.
**Two or three NVIDIA cards?** Just run `START-HERE.bat`: it lists your cards, says which ones Strata can use, and
asks whether to share the model across them (recommended when two can). An install made on one card asks once at
its next start. Or choose yourself: `START-HERE.bat --gpus 0,2` (both, remembered), `--gpus all`, or `--gpu 0` (one
@@ -84,9 +87,16 @@ one later with `SETUP.bat` (the same as `START-HERE.bat --setup`; on Linux `./se
For **OrcaRouter's Flash-Next Uncensored IQ3_XXS**, see the [manual compatibility setup](docs/ORCA.md).
It needs an explicit packing conversion and is not an installer menu option.
An **AMD Radeon RX 7900 XT / XTX, RX 9070 / 9070 XT or Radeon AI PRO R9700 on Linux** works too (experimental):
**Unsloth's 4-bit UD-Q4_K_XL** (experimental) is the fourth version in setup's menu (`--family unsloth`): the closest
to the full model, but a 111 GB download whose 77 GB of experts do not fit in RAM. Strata keeps your RAM minus 24 GB
of them in RAM and reads the rest from the SSD while it answers: 7-8.5 tokens/s on a 64 GB PC with a 12 GB GPU, several
times slower than the sizes above, and long prompts are slow. It needs 48 GB of RAM or more, an NVMe SSD and one
NVIDIA GPU (no images yet). Details and measurements: [UD-Q4_K_XL](docs/UNSLOTH_Q4.md).
An **AMD Radeon RX 7900 XT / XTX, RX 9070 / 9070 XT or Radeon AI PRO R9700 on Linux** works too (experimental; the
RX 7800 XT / 7700 XT and RX 9060 XT were validated by their owners; the RX 6800 / 6900 series, gfx1030, is community-reported):
`./setup.sh --backend hip`, chosen by itself on a PC with no NVIDIA card Strata can use. It installs ROCm without sudo
and compiles the engine (one GPU, no images yet). Details: [AMD HIP](docs/AMD_HIP.md).
and compiles the engine (no images yet; several cards with `--gpus`). Details: [AMD HIP](docs/AMD_HIP.md).
## Install
@@ -177,6 +187,19 @@ the same way - nothing big is downloaded again.
**Good to know:** it answers one request at a time. The first message of a chat is read in full (about 1 minute per
30,000 tokens); after that it keeps the conversation and reads only what is new, so follow-ups start in seconds.
### Where things are stored
- **Your chats: only in your browser.** The Chat tab keeps the conversation, its settings and the API key you typed
in the browser's local storage (`strata.*` keys) - not on the server and not in the Strata folder. Pictures are not
kept, only their names. Another browser or a private window starts empty; clearing the site's data deletes them.
- **How the model starts:** `strata-<model>.json` in the Strata folder (context, GPUs, host, API key, ...), written
by setup; next to it `run-<model>.bat` / `.sh`, the log `strata-<model>.log` and, when you use "Use for other
apps too", `strata-<model>.shared-settings.json`.
- **The model files** (`models/`, `packs/`, `mtp/`, 70-120 GB): in **`Strata-data` next to the Strata folder**, or
wherever `--data-dir` put them.
- **Where that data folder is:** `%APPDATA%\Strata\settings.json` on Windows, `~/.config/strata/settings.json` on
Linux ([details](docs/DETAILS.md)).
## Something went wrong?
**My PC froze, or got very slow, the first time Strata started.**
@@ -241,8 +264,9 @@ Want the full picture? The [details](docs/DETAILS.md#how-it-works) explain every
- Model: [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) by the Qwen team; compressed versions by
[ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF);
[Swift 1.5](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF) by UkisAI. Their licenses apply
to the model files.
[Swift 1.5](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF) by UkisAI; the experimental
[UD-Q4_K_XL](https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF) by Unsloth (its support follows
[eddoursul/Strata](https://github.com/eddoursul/Strata)). Their licenses apply to the model files.
- Built with parts of [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) (MIT). Ideas from
[Splash](https://github.com/incoai/splash), [ninfer](https://github.com/Neroued/ninfer) and
[HyperQwen](https://github.com/syv-ai/HyperQwen). More in the [details](docs/DETAILS.md#credits-and-licenses).
@@ -0,0 +1,46 @@
# Preliminary native RTX 3090 / EPYC 7453 results
Issue: [#165](https://github.com/Niko1221/Strata/issues/165)
Engine: Strata v0.1.26, source build at `ac8b251`
Status: preliminary; prompt set and harness guidance requested upstream.
## Hardware
| Component | Guest-visible details |
|---|---|
| CPU | AMD EPYC 7453, 20 vCPU, AVX2; AVX-512 not exposed |
| RAM | 165 GiB visible to Ubuntu 24.04.5 KVM guest; physical DIMM layout and bandwidth not verified |
| GPUs | 2x RTX 3090 24 GB; PCIe Gen4 x16 maximum reported per card; driver 595.91.07 |
| Power limit | 280 W configured on each GPU; defaults are 350 W / 420 W, max-adjustable limits 366 W / 450 W |
| Storage | 541 GiB ext4 guest data disk; host storage layout not verified |
The power values above are configured caps, not measured workload draw. Idle draw during the hardware capture was approximately 35 W / 29 W.
## Method
Native Linux setup, local build from v0.1.26, `--prefill auto`, shipped expert profile, automatic expert cache, int8 KV, MTP on, images off, experimental speed projection off. The GPU power limit was 280 W per card. Native runs used a systemd service with `LimitMEMLOCK=infinity`; other llama-swap model containers were stopped.
The local API harness used the public Strata source tree as its prompt corpus, with generated tasks, `temperature: 0`, `reasoning_effort: none`, and `max_tokens: 256`. It is not the upstream code-agent prompt set or harness. Runs use unique request IDs and no conversation reuse in speed mode. Three runs per speed cell are summarized by medians; actual `usage.prompt_tokens` are recorded because nominal context labels can drift. The first decode run is also shown. Several requests ended early on EOS, so actual generated counts are in the raw JSON.
No calibration comparison, upstream prompt comparison, `STRATA_SPLIT_TIMING` stage timing, or under-load power-draw capture has been done. Treat all prompt/decode comparisons with upstream as indicative only until the requested upstream method is available.
## Results
See [`matrix.md`](matrix.md) for summary tables and [`matrix.json`](matrix.json) for all successful run records. Per-run source JSON, logs, the local harness, and scrubbed hardware facts are in [`data/`](data/).
Highlights:
- IQ3_XXS on one 3090: 1K–262K cells, three runs each; 262K prompts were 232,183 / 259,589 / 261,068 tokens and fit within the 262,144 context.
- Coder IQ1_M at 32K: single-GPU median decode 66.8 tok/s; dual-GPU auto (K=19) median 98.6 tok/s.
- Fixed Coder K sweep: K=22 was the highest observed three-run median (103.3 tok/s); independently generated prompts mean this is not a paired ranking.
- IQ3_XXS and IQ3_S dual-GPU auto both selected K=24 at 32K.
- IQ3_XXS and IQ3_S needles passed 3/3 at 8K / 16K / 28K on the tested single/dual configurations; two-turn checkpoint reuse passed for both.
## Limits and follow-up
- Upstream prompts/harness are not yet available; all current speed data uses a local source-tree corpus.
- The guest exposes one NUMA node and 165 GiB RAM, but physical DIMM topology and memory bandwidth are unknown.
- PCIe x16 is the reported maximum link width; the engine probes were about 23–26 GB/s. Verify PCIe generation/width under sustained load before claiming a direct x16-vs-x4 comparison.
- Coder dual-GPU needle/two-turn checks and dual-GPU timing breakdowns are not run yet.
- K=18 has one successful run at 83.1 tok/s; a repeated startup failed while uploading a dense weight with an out-of-memory error, so it is not a three-run median.
- Calibration/default comparisons and IQ3_S single-GPU results remain outstanding.
@@ -0,0 +1,360 @@
{
"label": "native-v0.1.26-Coder-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "6c1252339f83",
"corpus_repeated": false,
"time": "2026-09-29T21:11:07",
"prompt_tokens": 28317,
"completion_tokens": 48,
"ttft_s": 12.868,
"e2e_s": 13.739,
"api_prompt_tps": 2200.5,
"api_decode_tps": 54.0,
"engine_prompt_tps": 2229.2,
"engine_decode_tps": 52.7,
"log_lines": [
"strata serve: prompt 28317 tokens = 0 reused + 28317 read in 12703 ms (2229.2 tok/s), 48 generated in 911 ms (52.7 tok/s), drafts accepted 31 of 38, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.3% (25001 hits / 25956 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 8973,
"expert_cache_mib": 17503,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 369,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716268.10927,
"duration_s": 13.6,
"finish": "stop",
"prompt_tokens": 28317,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 12702.6,
"decode_ms": 910.6,
"decode_tok_s": 52.7,
"hit_rate": 0.963
}
],
"requests_kept": 1,
"totals": {
"since": 1790716256.7391467,
"requests": 1,
"prompt_tokens": 28317,
"reused": 0,
"output_tokens": 48,
"prompt_ms": 12702.6,
"decode_ms": 910.6
},
"hardware": {
"gpu_util": 88,
"gpu_mem_used": 25531711488,
"gpu_mem_total": 25769803776,
"gpu_temp": 46,
"gpu_power": 220.362,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.28515625,
"gpu_pcie_tx_mb": 0.4287109375,
"cpu": 81.3,
"ram_used": 43964985344,
"ram_total": 177175990272,
"disk_read_mb": 2.9148478336133063,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
100,
96,
100,
99,
100,
99,
99,
100,
100,
88
],
"gpu_mem_used": [
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25407979520,
25418465280,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25531711488
],
"gpu_temp": [
43,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
46,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
46
],
"gpu_power": [
148.8,
140.48,
132.59,
119.03,
118.99,
119.03,
119.04,
119.03,
119.12,
119.17,
119.16,
119.15,
119.26,
191.57,
276.49,
276.88,
275.95,
277.04,
277.35,
267.91,
275.37,
276.16,
278.28,
279.07,
220.36
],
"gpu_pcie_rx_mb": [
0.33,
0.33,
0.29,
0.29,
0.33,
0.33,
0.33,
0.29,
0.33,
0.29,
0.33,
0.29,
385.14,
19.88,
1892.23,
13280.39,
85.45,
16838.55,
680.06,
1060.72,
13.45,
15.74,
5013.75,
1194.52,
0.29
],
"cpu": [
0.0,
0.7,
7.3,
15.7,
7.1,
2.0,
1.2,
2.0,
2.1,
1.6,
1.9,
7.4,
13.9,
18.3,
6.1,
6.0,
16.7,
24.9,
13.2,
12.0,
7.1,
6.2,
6.0,
8.8,
81.3
],
"ram_used": [
43381886976,
43381694464,
43410796544,
43434872832,
43483377664,
43485900800,
43484897280,
43481210880,
43469135872,
43462295552,
43458363392,
43496140800,
43624353792,
43648593920,
43633405952,
43641139200,
43635249152,
43689267200,
43846070272,
43924541440,
43924467712,
43918565376,
43883311104,
44002877440,
43964985344
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
25.43,
204.93,
214.14,
7.41,
0.22,
184.19,
135.03,
0.0,
101.27,
0.0,
0.0,
0.0,
0.78,
2.91
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790716282.234284
}
}
@@ -0,0 +1,491 @@
{
"label": "native-v0.1.26-Coder-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "894af0ad69b7",
"corpus_repeated": false,
"time": "2026-09-29T21:11:22",
"prompt_tokens": 31630,
"completion_tokens": 26,
"ttft_s": 12.792,
"e2e_s": 13.164,
"api_prompt_tps": 2472.7,
"api_decode_tps": 67.3,
"engine_prompt_tps": 2506.6,
"engine_decode_tps": 66.8,
"log_lines": [
"strata serve: prompt 31630 tokens = 0 reused + 31630 read in 12619 ms (2506.6 tok/s), 26 generated in 389 ms (66.8 tok/s), drafts accepted 12 of 21, 2 checkpoints",
"strata serve: decode expert cache hit rate: 99.1% (16646 hits / 16791 lookups)"
],
"answer_head": "I don't see any file content in the conversation above. Could you please share the file you'd like me to analyze?",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 8973,
"expert_cache_mib": 17503,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 369,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716282.3818104,
"duration_s": 13.0,
"finish": "stop",
"prompt_tokens": 31630,
"reused": 0,
"output_tokens": 26,
"engine_generated": 26,
"prompt_ms": 12618.8,
"decode_ms": 389.0,
"decode_tok_s": 66.8,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790716268.10927,
"duration_s": 13.6,
"finish": "stop",
"prompt_tokens": 28317,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 12702.6,
"decode_ms": 910.6,
"decode_tok_s": 52.7,
"hit_rate": 0.963
}
],
"requests_kept": 2,
"totals": {
"since": 1790716256.7391467,
"requests": 2,
"prompt_tokens": 59947,
"reused": 0,
"output_tokens": 74,
"prompt_ms": 25321.4,
"decode_ms": 1299.6
},
"hardware": {
"gpu_util": 81,
"gpu_mem_used": 25531711488,
"gpu_mem_total": 25769803776,
"gpu_temp": 45,
"gpu_power": 256.109,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 9.7744140625,
"gpu_pcie_tx_mb": 25.1767578125,
"cpu": 46.1,
"ram_used": 43872071680,
"ram_total": 177175990272,
"disk_read_mb": 1.6222807345356267,
"disk_write_mb": 0.018689870213544086,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
100,
96,
100,
99,
100,
99,
99,
100,
100,
88,
0,
100,
99,
100,
99,
100,
98,
99,
99,
100,
99,
100,
81
],
"gpu_mem_used": [
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25407979520,
25418465280,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488
],
"gpu_temp": [
43,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
46,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
46,
44,
47,
47,
47,
47,
47,
47,
47,
47,
47,
48,
47,
45
],
"gpu_power": [
148.8,
140.48,
132.59,
119.03,
118.99,
119.03,
119.04,
119.03,
119.12,
119.17,
119.16,
119.15,
119.26,
191.57,
276.49,
276.88,
275.95,
277.04,
277.35,
267.91,
275.37,
276.16,
278.28,
279.07,
220.36,
189.89,
258.72,
276.75,
276.67,
277.52,
275.34,
268.93,
277.69,
277.77,
276.91,
278.53,
278.56,
256.11
],
"gpu_pcie_rx_mb": [
0.33,
0.33,
0.29,
0.29,
0.33,
0.33,
0.33,
0.29,
0.33,
0.29,
0.33,
0.29,
385.14,
19.88,
1892.23,
13280.39,
85.45,
16838.55,
680.06,
1060.72,
13.45,
15.74,
5013.75,
1194.52,
0.29,
2531.19,
14.02,
3715.09,
10.68,
13440.37,
8568.48,
14.92,
15.31,
15.69,
6486.56,
17.31,
9674.45,
9.77
],
"cpu": [
0.0,
0.7,
7.3,
15.7,
7.1,
2.0,
1.2,
2.0,
2.1,
1.6,
1.9,
7.4,
13.9,
18.3,
6.1,
6.0,
16.7,
24.9,
13.2,
12.0,
7.1,
6.2,
6.0,
8.8,
81.3,
4.2,
6.8,
6.4,
7.6,
5.5,
6.0,
20.6,
12.9,
6.2,
7.0,
5.7,
5.9,
46.1
],
"ram_used": [
43381886976,
43381694464,
43410796544,
43434872832,
43483377664,
43485900800,
43484897280,
43481210880,
43469135872,
43462295552,
43458363392,
43496140800,
43624353792,
43648593920,
43633405952,
43641139200,
43635249152,
43689267200,
43846070272,
43924541440,
43924467712,
43918565376,
43883311104,
44002877440,
43964985344,
43959267328,
43943862272,
43937861632,
43930320896,
43922284544,
43915001856,
43817238528,
43819147264,
43818729472,
43828027392,
43824201728,
43825434624,
43872071680
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
25.43,
204.93,
214.14,
7.41,
0.22,
184.19,
135.03,
0.0,
101.27,
0.0,
0.0,
0.0,
0.78,
2.91,
0.61,
0.0,
0.0,
0.02,
0.0,
0.0,
79.64,
41.92,
0.0,
0.0,
0.0,
0.0,
1.62
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790716295.9009006
}
}
@@ -0,0 +1,622 @@
{
"label": "native-v0.1.26-Coder-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "a4c63bd599ab",
"corpus_repeated": false,
"time": "2026-09-29T21:11:35",
"prompt_tokens": 31601,
"completion_tokens": 45,
"ttft_s": 12.796,
"e2e_s": 13.243,
"api_prompt_tps": 2469.6,
"api_decode_tps": 98.5,
"engine_prompt_tps": 2502.4,
"engine_decode_tps": 97.4,
"log_lines": [
"strata serve: prompt 31601 tokens = 0 reused + 31601 read in 12628 ms (2502.4 tok/s), 45 generated in 462 ms (97.4 tok/s), drafts accepted 33 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 98.6% (23985 hits / 24333 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 8973,
"expert_cache_mib": 17503,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 369,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716296.0458817,
"duration_s": 13.1,
"finish": "stop",
"prompt_tokens": 31601,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 12628.3,
"decode_ms": 461.9,
"decode_tok_s": 97.4,
"hit_rate": 0.986
},
{
"projection": null,
"time": 1790716282.3818104,
"duration_s": 13.0,
"finish": "stop",
"prompt_tokens": 31630,
"reused": 0,
"output_tokens": 26,
"engine_generated": 26,
"prompt_ms": 12618.8,
"decode_ms": 389.0,
"decode_tok_s": 66.8,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790716268.10927,
"duration_s": 13.6,
"finish": "stop",
"prompt_tokens": 28317,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 12702.6,
"decode_ms": 910.6,
"decode_tok_s": 52.7,
"hit_rate": 0.963
}
],
"requests_kept": 3,
"totals": {
"since": 1790716256.7391467,
"requests": 3,
"prompt_tokens": 91548,
"reused": 0,
"output_tokens": 119,
"prompt_ms": 37949.7,
"decode_ms": 1761.5
},
"hardware": {
"gpu_util": 96,
"gpu_mem_used": 25531711488,
"gpu_mem_total": 25769803776,
"gpu_temp": 47,
"gpu_power": 245.399,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 414.037109375,
"gpu_pcie_tx_mb": 303.36328125,
"cpu": 35.1,
"ram_used": 43772702720,
"ram_total": 177175990272,
"disk_read_mb": 0.6087260569540994,
"disk_write_mb": 0.20539836277592313,
"tok_s": 97.29124144311484,
"tok_s_mean": 96.62332449971758
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
100,
96,
100,
99,
100,
99,
99,
100,
100,
88,
0,
100,
99,
100,
99,
100,
98,
99,
99,
100,
99,
100,
81,
99,
100,
100,
99,
100,
99,
17,
99,
100,
99,
99,
99,
96
],
"gpu_mem_used": [
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25382813696,
25407979520,
25418465280,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25424756736,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488,
25531711488
],
"gpu_temp": [
43,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
42,
46,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
46,
44,
47,
47,
47,
47,
47,
47,
47,
47,
47,
48,
47,
45,
47,
47,
47,
48,
48,
48,
46,
47,
48,
48,
48,
48,
47
],
"gpu_power": [
148.8,
140.48,
132.59,
119.03,
118.99,
119.03,
119.04,
119.03,
119.12,
119.17,
119.16,
119.15,
119.26,
191.57,
276.49,
276.88,
275.95,
277.04,
277.35,
267.91,
275.37,
276.16,
278.28,
279.07,
220.36,
189.89,
258.72,
276.75,
276.67,
277.52,
275.34,
268.93,
277.69,
277.77,
276.91,
278.53,
278.56,
256.11,
199.6,
275.35,
275.49,
276.31,
275.46,
277.78,
266.35,
267.73,
276.71,
276.41,
275.34,
278.17,
245.4
],
"gpu_pcie_rx_mb": [
0.33,
0.33,
0.29,
0.29,
0.33,
0.33,
0.33,
0.29,
0.33,
0.29,
0.33,
0.29,
385.14,
19.88,
1892.23,
13280.39,
85.45,
16838.55,
680.06,
1060.72,
13.45,
15.74,
5013.75,
1194.52,
0.29,
2531.19,
14.02,
3715.09,
10.68,
13440.37,
8568.48,
14.92,
15.31,
15.69,
6486.56,
17.31,
9674.45,
9.77,
2795.22,
4473.69,
14.5,
12.97,
14.92,
7716.66,
2819.78,
4278.33,
12009.48,
17.07,
9916.78,
8518.17,
414.04
],
"cpu": [
0.0,
0.7,
7.3,
15.7,
7.1,
2.0,
1.2,
2.0,
2.1,
1.6,
1.9,
7.4,
13.9,
18.3,
6.1,
6.0,
16.7,
24.9,
13.2,
12.0,
7.1,
6.2,
6.0,
8.8,
81.3,
4.2,
6.8,
6.4,
7.6,
5.5,
6.0,
20.6,
12.9,
6.2,
7.0,
5.7,
5.9,
46.1,
4.0,
6.9,
5.7,
6.2,
7.1,
5.5,
5.6,
9.9,
13.7,
8.4,
7.7,
6.4,
35.1
],
"ram_used": [
43381886976,
43381694464,
43410796544,
43434872832,
43483377664,
43485900800,
43484897280,
43481210880,
43469135872,
43462295552,
43458363392,
43496140800,
43624353792,
43648593920,
43633405952,
43641139200,
43635249152,
43689267200,
43846070272,
43924541440,
43924467712,
43918565376,
43883311104,
44002877440,
43964985344,
43959267328,
43943862272,
43937861632,
43930320896,
43922284544,
43915001856,
43817238528,
43819147264,
43818729472,
43828027392,
43824201728,
43825434624,
43872071680,
43734614016,
43728027648,
43719413760,
43703148544,
43695366144,
43687342080,
43744829440,
43791024128,
43789787136,
43766198272,
43761831936,
43750072320,
43772702720
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
25.43,
204.93,
214.14,
7.41,
0.22,
184.19,
135.03,
0.0,
101.27,
0.0,
0.0,
0.0,
0.78,
2.91,
0.61,
0.0,
0.0,
0.02,
0.0,
0.0,
79.64,
41.92,
0.0,
0.0,
0.0,
0.0,
1.62,
0.72,
0.0,
0.0,
0.05,
0.0,
0.0,
0.18,
0.0,
0.0,
0.0,
0.0,
0.0,
0.61
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.29
]
},
"time": 1790716309.6464093
}
}
@@ -0,0 +1,423 @@
{
"label": "native-v0.1.26-Coder-2x3090-K18",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "052cbcbb7af7",
"corpus_repeated": false,
"time": "2026-09-29T21:21:48",
"prompt_tokens": 28313,
"completion_tokens": 57,
"ttft_s": 12.346,
"e2e_s": 12.991,
"api_prompt_tps": 2293.3,
"api_decode_tps": 86.9,
"engine_prompt_tps": 2324.6,
"engine_decode_tps": 83.1,
"log_lines": [
"strata serve: prompt 28313 tokens = 0 reused + 28313 read in 12180 ms (2324.6 tok/s), 57 generated in 686 ms (83.1 tok/s), drafts accepted 39 of 41, 2 checkpoints",
"strata serve: decode expert cache hit rate: 99.7% (28717 hits / 28800 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 4608,
"expert_cache_mib": 8437,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 9557,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716909.0337873,
"duration_s": 12.9,
"finish": "stop",
"prompt_tokens": 28313,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 12179.9,
"decode_ms": 685.7,
"decode_tok_s": 83.1,
"hit_rate": 0.997
}
],
"requests_kept": 1,
"totals": {
"since": 1790716889.8200681,
"requests": 1,
"prompt_tokens": 28313,
"reused": 0,
"output_tokens": 57,
"prompt_ms": 12179.9,
"decode_ms": 685.7
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 0,
"mem_used": 15823994880,
"mem_total": 25769803776,
"temp": 44,
"power": 161.267
},
{
"index": 1,
"util": 90,
"mem_used": 24208408576,
"mem_total": 25769803776,
"temp": 51,
"power": 278.413
}
],
"gpu_util": 45.0,
"gpu_mem_used": 40032403456,
"gpu_mem_total": 51539607552,
"gpu_temp": 51,
"gpu_power": 439.68,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5.33984375,
"gpu_pcie_tx_mb": 18.5009765625,
"cpu": 16.1,
"ram_used": 44574941184,
"ram_total": 177175990272,
"disk_read_mb": 0.9737281407762519,
"disk_write_mb": 0.11497896865254635,
"tok_s": 36.0,
"tok_s_mean": 64.01736582189179
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
41.5,
68.0,
50.0,
73.0,
87.5,
41.5,
47.0,
50.0,
78.0,
50.5,
45.0
],
"gpu_mem_used": [
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39866728448,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
39965294592,
40032403456
],
"gpu_temp": [
45,
44,
44,
44,
44,
44,
45,
44,
44,
45,
45,
45,
45,
45,
45,
45,
42,
41,
41,
47,
50,
51,
51,
51,
52,
51,
52,
51,
52,
51
],
"gpu_power": [
255.0,
240.14,
239.41,
239.38,
239.55,
239.75,
239.74,
239.65,
239.56,
239.63,
239.71,
239.58,
239.49,
239.62,
239.83,
239.9,
200.58,
138.26,
69.98,
230.69,
516.11,
485.77,
500.33,
518.82,
491.98,
467.22,
490.75,
506.65,
510.68,
439.68
],
"gpu_pcie_rx_mb": [
0.71,
0.62,
0.67,
0.67,
0.67,
0.57,
0.71,
0.62,
0.62,
0.57,
0.67,
0.62,
0.71,
0.67,
0.67,
0.62,
0.76,
0.86,
0.71,
1243.59,
45.3,
2454.38,
77.06,
3382.78,
1099.87,
47.06,
2677.87,
79.25,
1143.26,
5.34
],
"cpu": [
0.0,
1.0,
2.8,
3.4,
1.0,
1.6,
1.6,
1.0,
1.4,
0.7,
3.6,
8.3,
1.0,
8.2,
5.7,
2.6,
3.4,
1.4,
10.1,
12.9,
8.2,
10.3,
10.7,
11.6,
27.0,
14.9,
11.2,
18.3,
15.0,
16.1
],
"ram_used": [
43962929152,
43965493248,
43981484032,
43968327680,
43968602112,
43968954368,
43964538880,
43964022784,
43964801024,
43964657664,
43961843712,
43958075392,
43958878208,
43967004672,
43967807488,
43951247360,
43945017344,
43945320448,
43971616768,
44103409664,
44112924672,
44112818176,
43979321344,
43978510336,
44145692672,
44276580352,
44275351552,
44327723008,
44296556544,
44574941184
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
64.21,
105.78,
24.45,
89.11,
67.32,
92.34,
145.4,
79.43,
98.92,
75.23,
0.0,
0.97
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
36.0
]
},
"time": 1790716922.4098496
}
}
@@ -0,0 +1,270 @@
{
"label": "native-v0.1.26-Coder-2x3090-K22",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "69d919ce1297",
"corpus_repeated": false,
"time": "2026-09-29T21:32:53",
"prompt_tokens": 28316,
"completion_tokens": 57,
"ttft_s": 10.575,
"e2e_s": 11.256,
"api_prompt_tps": 2677.7,
"api_decode_tps": 82.2,
"engine_prompt_tps": 2718.9,
"engine_decode_tps": 79.8,
"log_lines": [
"strata serve: prompt 28316 tokens = 0 reused + 28316 read in 10414 ms (2718.9 tok/s), 57 generated in 715 ms (79.8 tok/s), drafts accepted 37 of 48, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (34080 hits / 34080 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 5632,
"expert_cache_mib": 10325,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 7669,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717573.1737459,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10414.4,
"decode_ms": 714.5,
"decode_tok_s": 79.8,
"hit_rate": 1.0
}
],
"requests_kept": 1,
"totals": {
"since": 1790717571.262619,
"requests": 1,
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"prompt_ms": 10414.4,
"decode_ms": 714.5
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 34,
"mem_used": 17822580736,
"mem_total": 25769803776,
"temp": 49,
"power": 184.581
},
{
"index": 1,
"util": 54,
"mem_used": 22828482560,
"mem_total": 25769803776,
"temp": 52,
"power": 232.993
}
],
"gpu_util": 44.0,
"gpu_mem_used": 40651063296,
"gpu_mem_total": 51539607552,
"gpu_temp": 52,
"gpu_power": 417.57399999999996,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.953125,
"cpu": 6.2,
"ram_used": 44281556992,
"ram_total": 177175990272,
"disk_read_mb": 3.421090719626586,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
0.0,
73.5,
58.5,
96.0,
57.5,
95.5,
47.5,
93.0,
58.5,
50.0,
44.0
],
"gpu_mem_used": [
40449736704,
40449736704,
40449736704,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40651063296
],
"gpu_temp": [
48,
47,
47,
50,
53,
53,
54,
53,
54,
54,
54,
54,
52
],
"gpu_power": [
256.98,
244.54,
244.03,
340.49,
532.78,
528.1,
525.31,
536.01,
504.78,
526.85,
529.86,
484.8,
417.57
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.67,
78.72,
82.54,
76.1,
85.97,
55.17,
62.23,
87.12,
83.54,
85.83,
0.67
],
"cpu": [
0.0,
1.2,
5.4,
10.7,
10.0,
9.8,
14.0,
18.3,
17.8,
18.6,
9.0,
5.8,
6.2
],
"ram_used": [
43564908544,
43556737024,
43564126208,
43739512832,
43734302720,
43734560768,
43735560192,
43898122240,
44013469696,
43991674880,
43978436608,
43974189056,
44281556992
],
"disk_read_mb": [
null,
0.0,
73.94,
96.25,
39.8,
73.77,
144.08,
110.85,
127.27,
131.68,
42.81,
0.0,
3.42
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717584.813652
}
}
@@ -0,0 +1,383 @@
{
"label": "native-v0.1.26-Coder-2x3090-K22",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "8506420b91e1",
"corpus_repeated": false,
"time": "2026-09-29T21:33:04",
"prompt_tokens": 31633,
"completion_tokens": 45,
"ttft_s": 10.85,
"e2e_s": 11.271,
"api_prompt_tps": 2915.4,
"api_decode_tps": 104.6,
"engine_prompt_tps": 2962.7,
"engine_decode_tps": 103.3,
"log_lines": [
"strata serve: prompt 31633 tokens = 0 reused + 31633 read in 10677 ms (2962.7 tok/s), 45 generated in 436 ms (103.3 tok/s), drafts accepted 32 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (24960 hits / 24960 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what the last file does.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 5632,
"expert_cache_mib": 10325,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 7669,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717584.9637764,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10677.2,
"decode_ms": 435.6,
"decode_tok_s": 103.3,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717573.1737459,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10414.4,
"decode_ms": 714.5,
"decode_tok_s": 79.8,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790717571.262619,
"requests": 2,
"prompt_tokens": 59949,
"reused": 0,
"output_tokens": 102,
"prompt_ms": 21091.6,
"decode_ms": 1150.1
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 37,
"mem_used": 17822580736,
"mem_total": 25769803776,
"temp": 49,
"power": 187.064
},
{
"index": 1,
"util": 60,
"mem_used": 22828482560,
"mem_total": 25769803776,
"temp": 53,
"power": 243.674
}
],
"gpu_util": 48.5,
"gpu_mem_used": 40651063296,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 430.738,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.6181640625,
"gpu_pcie_tx_mb": 1.0,
"cpu": 6.1,
"ram_used": 44308209664,
"ram_total": 177175990272,
"disk_read_mb": 0.7959400039611647,
"disk_write_mb": 0.24130307812397303,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
0.0,
73.5,
58.5,
96.0,
57.5,
95.5,
47.5,
93.0,
58.5,
50.0,
44.0,
18.0,
52.0,
95.5,
50.0,
97.0,
24.5,
95.5,
82.0,
96.5,
50.0,
48.5
],
"gpu_mem_used": [
40449736704,
40449736704,
40449736704,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296
],
"gpu_temp": [
48,
47,
47,
50,
53,
53,
54,
53,
54,
54,
54,
54,
52,
49,
54,
54,
54,
54,
52,
54,
54,
54,
54,
53
],
"gpu_power": [
256.98,
244.54,
244.03,
340.49,
532.78,
528.1,
525.31,
536.01,
504.78,
526.85,
529.86,
484.8,
417.57,
353.2,
539.11,
526.73,
525.83,
531.55,
507.76,
523.24,
527.24,
526.07,
501.32,
430.74
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.67,
78.72,
82.54,
76.1,
85.97,
55.17,
62.23,
87.12,
83.54,
85.83,
0.67,
1765.25,
83.88,
85.4,
85.07,
88.59,
82.35,
78.3,
85.16,
61.94,
46.3,
0.62
],
"cpu": [
0.0,
1.2,
5.4,
10.7,
10.0,
9.8,
14.0,
18.3,
17.8,
18.6,
9.0,
5.8,
6.2,
4.4,
6.6,
6.4,
5.8,
6.1,
7.4,
5.9,
6.8,
19.8,
14.2,
6.1
],
"ram_used": [
43564908544,
43556737024,
43564126208,
43739512832,
43734302720,
43734560768,
43735560192,
43898122240,
44013469696,
43991674880,
43978436608,
43974189056,
44281556992,
44278607872,
44263776256,
44251099136,
44242841600,
44235354112,
44232339456,
44218642432,
44210057216,
44216344576,
44288196608,
44308209664
],
"disk_read_mb": [
null,
0.0,
73.94,
96.25,
39.8,
73.77,
144.08,
110.85,
127.27,
131.68,
42.81,
0.0,
3.42,
0.48,
0.01,
0.04,
0.06,
0.02,
0.02,
0.02,
12.53,
104.78,
0.0,
0.8
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717596.5877995
}
}
@@ -0,0 +1,496 @@
{
"label": "native-v0.1.26-Coder-2x3090-K22",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "831d87a1dacc",
"corpus_repeated": false,
"time": "2026-09-29T21:33:16",
"prompt_tokens": 31601,
"completion_tokens": 60,
"ttft_s": 10.877,
"e2e_s": 11.43,
"api_prompt_tps": 2905.4,
"api_decode_tps": 106.7,
"engine_prompt_tps": 2951.6,
"engine_decode_tps": 105.7,
"log_lines": [
"strata serve: prompt 31601 tokens = 0 reused + 31601 read in 10706 ms (2951.6 tok/s), 60 generated in 568 ms (105.7 tok/s), drafts accepted 41 of 46, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (31680 hits / 31680 lookups)"
],
"answer_head": "I'll start by examining the repository structure to understand what the last file does.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 5632,
"expert_cache_mib": 10325,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 7669,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717596.735188,
"duration_s": 11.3,
"finish": "stop",
"prompt_tokens": 31601,
"reused": 0,
"output_tokens": 60,
"engine_generated": 60,
"prompt_ms": 10706.3,
"decode_ms": 567.6,
"decode_tok_s": 105.7,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717584.9637764,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10677.2,
"decode_ms": 435.6,
"decode_tok_s": 103.3,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717573.1737459,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10414.4,
"decode_ms": 714.5,
"decode_tok_s": 79.8,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790717571.262619,
"requests": 3,
"prompt_tokens": 91550,
"reused": 0,
"output_tokens": 162,
"prompt_ms": 31797.899999999998,
"decode_ms": 1717.6999999999998
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 25,
"mem_used": 17822580736,
"mem_total": 25769803776,
"temp": 50,
"power": 201.214
},
{
"index": 1,
"util": 61,
"mem_used": 22828482560,
"mem_total": 25769803776,
"temp": 53,
"power": 238.993
}
],
"gpu_util": 43.0,
"gpu_mem_used": 40651063296,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 440.207,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 4.4,
"ram_used": 44291919872,
"ram_total": 177175990272,
"disk_read_mb": 0.7281688058408962,
"disk_write_mb": 0.01802398034259644,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
0.0,
73.5,
58.5,
96.0,
57.5,
95.5,
47.5,
93.0,
58.5,
50.0,
44.0,
18.0,
52.0,
95.5,
50.0,
97.0,
24.5,
95.5,
82.0,
96.5,
50.0,
48.5,
49.5,
96.0,
48.0,
96.0,
47.5,
94.5,
61.0,
97.5,
47.5,
49.5,
43.0
],
"gpu_mem_used": [
40449736704,
40449736704,
40449736704,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296,
40651063296
],
"gpu_temp": [
48,
47,
47,
50,
53,
53,
54,
53,
54,
54,
54,
54,
52,
49,
54,
54,
54,
54,
52,
54,
54,
54,
54,
53,
50,
54,
54,
54,
55,
54,
54,
54,
55,
55,
53
],
"gpu_power": [
256.98,
244.54,
244.03,
340.49,
532.78,
528.1,
525.31,
536.01,
504.78,
526.85,
529.86,
484.8,
417.57,
353.2,
539.11,
526.73,
525.83,
531.55,
507.76,
523.24,
527.24,
526.07,
501.32,
430.74,
359.38,
510.67,
527.45,
526.85,
532.56,
501.47,
534.58,
526.16,
522.92,
475.95,
440.21
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.67,
78.72,
82.54,
76.1,
85.97,
55.17,
62.23,
87.12,
83.54,
85.83,
0.67,
1765.25,
83.88,
85.4,
85.07,
88.59,
82.35,
78.3,
85.16,
61.94,
46.3,
0.62,
87.45,
41.53,
89.07,
84.21,
76.25,
52.17,
78.29,
83.59,
51.45,
47.92,
0.67
],
"cpu": [
0.0,
1.2,
5.4,
10.7,
10.0,
9.8,
14.0,
18.3,
17.8,
18.6,
9.0,
5.8,
6.2,
4.4,
6.6,
6.4,
5.8,
6.1,
7.4,
5.9,
6.8,
19.8,
14.2,
6.1,
7.3,
6.6,
6.3,
5.7,
6.0,
6.2,
6.3,
6.1,
7.3,
6.4,
4.4
],
"ram_used": [
43564908544,
43556737024,
43564126208,
43739512832,
43734302720,
43734560768,
43735560192,
43898122240,
44013469696,
43991674880,
43978436608,
43974189056,
44281556992,
44278607872,
44263776256,
44251099136,
44242841600,
44235354112,
44232339456,
44218642432,
44210057216,
44216344576,
44288196608,
44308209664,
44011671552,
43989819392,
43978940416,
43970682880,
43962933248,
44045533184,
44039798784,
44039798784,
44047568896,
44044705792,
44291919872
],
"disk_read_mb": [
null,
0.0,
73.94,
96.25,
39.8,
73.77,
144.08,
110.85,
127.27,
131.68,
42.81,
0.0,
3.42,
0.48,
0.01,
0.04,
0.06,
0.02,
0.02,
0.02,
12.53,
104.78,
0.0,
0.8,
0.61,
0.05,
0.03,
0.09,
0.08,
0.04,
0.05,
0.04,
0.15,
0.0,
0.73
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717608.5200934
}
}
@@ -0,0 +1,279 @@
{
"label": "native-v0.1.26-Coder-2x3090-K24",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "87af67edfd2d",
"corpus_repeated": false,
"time": "2026-09-29T21:34:02",
"prompt_tokens": 28314,
"completion_tokens": 256,
"ttft_s": 10.029,
"e2e_s": 12.977,
"api_prompt_tps": 2823.1,
"api_decode_tps": 86.5,
"engine_prompt_tps": 2871.1,
"engine_decode_tps": 85.9,
"log_lines": [
"strata serve: prompt 28314 tokens = 0 reused + 28314 read in 9862 ms (2871.1 tok/s), 256 generated in 2981 ms (85.9 tok/s), drafts accepted 143 of 193, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (147360 hits / 147360 lookups)"
],
"answer_head": "Looking at the last file above, `docs/AMD_HIP_PERFORMANCE.md`, it documents the performance evidence and correctness limits for the experimental AMD HIP backend targeting gfx1100 (RX 7900 XTX). It records:\n\n- The exact build/runtime configuration used for the benchmark (env vars, CLI flags, model pa",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6144,
"expert_cache_mib": 11337,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 6657,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717642.434618,
"duration_s": 12.9,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 9861.8,
"decode_ms": 2981.5,
"decode_tok_s": 85.9,
"hit_rate": 1.0
}
],
"requests_kept": 1,
"totals": {
"since": 1790717640.7776525,
"requests": 1,
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"prompt_ms": 9861.8,
"decode_ms": 2981.5
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 43,
"mem_used": 18898419712,
"mem_total": 25769803776,
"temp": 50,
"power": 244.874
},
{
"index": 1,
"util": 57,
"mem_used": 21758935040,
"mem_total": 25769803776,
"temp": 54,
"power": 254.71
}
],
"gpu_util": 50.0,
"gpu_mem_used": 40657354752,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 499.584,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5.38671875,
"gpu_pcie_tx_mb": 87.7373046875,
"cpu": 11.7,
"ram_used": 44619116544,
"ram_total": 177175990272,
"disk_read_mb": 4.515214018548113,
"disk_write_mb": 0.17657261525048487,
"tok_s": 107.09643367230112,
"tok_s_mean": 83.26979350665239
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
1.0,
93.0,
94.0,
64.0,
94.5,
88.5,
95.5,
92.5,
48.5,
32.0,
48.0,
50.0
],
"gpu_mem_used": [
40447639552,
40447639552,
40476999680,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40657354752,
40657354752,
40657354752
],
"gpu_temp": [
49,
49,
49,
53,
54,
54,
55,
54,
55,
55,
55,
52,
54,
54
],
"gpu_power": [
259.59,
247.18,
245.88,
414.53,
546.71,
547.76,
546.95,
533.57,
531.41,
545.46,
539.14,
402.04,
486.67,
499.58
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
247.86,
81.11,
78.2,
80.92,
83.88,
57.6,
82.87,
79.92,
40.29,
5.39,
9.77,
5.39
],
"cpu": [
0.0,
1.9,
9.1,
8.8,
9.5,
10.7,
13.9,
10.5,
13.9,
11.8,
6.0,
6.3,
12.4,
11.7
],
"ram_used": [
43887411200,
43859918848,
43956232192,
44034678784,
44030210048,
44028076032,
44015280128,
44252610560,
44247789568,
44243210240,
44230340608,
44558966784,
44619108352,
44619116544
],
"disk_read_mb": [
null,
0.0,
126.09,
44.05,
80.0,
93.94,
138.6,
104.01,
156.43,
97.38,
0.0,
1.76,
4.66,
4.52
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
78.74,
81.4,
107.1
]
},
"time": 1790717655.7892108
}
}
@@ -0,0 +1,392 @@
{
"label": "native-v0.1.26-Coder-2x3090-K24",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "b38394f620b3",
"corpus_repeated": false,
"time": "2026-09-29T21:34:15",
"prompt_tokens": 31635,
"completion_tokens": 45,
"ttft_s": 10.269,
"e2e_s": 10.686,
"api_prompt_tps": 3080.5,
"api_decode_tps": 105.5,
"engine_prompt_tps": 3130.4,
"engine_decode_tps": 104.2,
"log_lines": [
"strata serve: prompt 31635 tokens = 0 reused + 31635 read in 10106 ms (3130.4 tok/s), 45 generated in 432 ms (104.2 tok/s), drafts accepted 33 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (24480 hits / 24480 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6144,
"expert_cache_mib": 11337,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 6657,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717655.9301767,
"duration_s": 10.5,
"finish": "stop",
"prompt_tokens": 31635,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10105.9,
"decode_ms": 431.8,
"decode_tok_s": 104.2,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717642.434618,
"duration_s": 12.9,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 9861.8,
"decode_ms": 2981.5,
"decode_tok_s": 85.9,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790717640.7776525,
"requests": 2,
"prompt_tokens": 59949,
"reused": 0,
"output_tokens": 301,
"prompt_ms": 19967.699999999997,
"decode_ms": 3413.3
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 20,
"mem_used": 18898419712,
"mem_total": 25769803776,
"temp": 50,
"power": 191.174
},
{
"index": 1,
"util": 53,
"mem_used": 21758935040,
"mem_total": 25769803776,
"temp": 54,
"power": 238.032
}
],
"gpu_util": 36.5,
"gpu_mem_used": 40657354752,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 429.206,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.6181640625,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 5.3,
"ram_used": 44575621120,
"ram_total": 177175990272,
"disk_read_mb": 2.4688909410966033,
"disk_write_mb": 0.23427432287777988,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
1.0,
93.0,
94.0,
64.0,
94.5,
88.5,
95.5,
92.5,
48.5,
32.0,
48.0,
50.0,
0.0,
84.5,
96.0,
95.5,
79.0,
97.5,
97.0,
95.5,
96.0,
50.0,
36.5
],
"gpu_mem_used": [
40447639552,
40447639552,
40476999680,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752
],
"gpu_temp": [
49,
49,
49,
53,
54,
54,
55,
54,
55,
55,
55,
52,
54,
54,
50,
54,
55,
55,
55,
55,
55,
55,
55,
55,
54
],
"gpu_power": [
259.59,
247.18,
245.88,
414.53,
546.71,
547.76,
546.95,
533.57,
531.41,
545.46,
539.14,
402.04,
486.67,
499.58,
409.59,
480.21,
551.08,
548.0,
547.82,
539.97,
537.72,
548.44,
548.33,
513.55,
429.21
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
247.86,
81.11,
78.2,
80.92,
83.88,
57.6,
82.87,
79.92,
40.29,
5.39,
9.77,
5.39,
45.78,
64.8,
1284.55,
129.94,
83.06,
82.63,
84.78,
73.15,
82.44,
0.57,
0.62
],
"cpu": [
0.0,
1.9,
9.1,
8.8,
9.5,
10.7,
13.9,
10.5,
13.9,
11.8,
6.0,
6.3,
12.4,
11.7,
6.7,
8.3,
6.5,
7.2,
6.1,
6.0,
6.1,
6.5,
11.2,
8.0,
5.3
],
"ram_used": [
43887411200,
43859918848,
43956232192,
44034678784,
44030210048,
44028076032,
44015280128,
44252610560,
44247789568,
44243210240,
44230340608,
44558966784,
44619108352,
44619116544,
44154675200,
44152926208,
44151242752,
44149854208,
44145594368,
44375150592,
44366180352,
44365656064,
44362940416,
44400578560,
44575621120
],
"disk_read_mb": [
null,
0.0,
126.09,
44.05,
80.0,
93.94,
138.6,
104.01,
156.43,
97.38,
0.0,
1.76,
4.66,
4.52,
0.63,
0.02,
0.04,
0.03,
0.05,
0.03,
0.02,
13.87,
103.6,
0.0,
2.47
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
78.74,
81.4,
107.1,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717666.9788535
}
}
@@ -0,0 +1,496 @@
{
"label": "native-v0.1.26-Coder-2x3090-K24",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "3bee1c1e482a",
"corpus_repeated": false,
"time": "2026-09-29T21:34:26",
"prompt_tokens": 31602,
"completion_tokens": 60,
"ttft_s": 10.281,
"e2e_s": 10.865,
"api_prompt_tps": 3073.8,
"api_decode_tps": 101.0,
"engine_prompt_tps": 3123.2,
"engine_decode_tps": 100.2,
"log_lines": [
"strata serve: prompt 31602 tokens = 0 reused + 31602 read in 10118 ms (3123.2 tok/s), 60 generated in 599 ms (100.2 tok/s), drafts accepted 40 of 52, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (34560 hits / 34560 lookups)"
],
"answer_head": "I'll start by examining the repository structure to understand what the last file does.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6144,
"expert_cache_mib": 11337,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 6657,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717667.1193056,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 60,
"engine_generated": 60,
"prompt_ms": 10118.5,
"decode_ms": 599.0,
"decode_tok_s": 100.2,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717655.9301767,
"duration_s": 10.5,
"finish": "stop",
"prompt_tokens": 31635,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10105.9,
"decode_ms": 431.8,
"decode_tok_s": 104.2,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717642.434618,
"duration_s": 12.9,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 9861.8,
"decode_ms": 2981.5,
"decode_tok_s": 85.9,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790717640.7776525,
"requests": 3,
"prompt_tokens": 91551,
"reused": 0,
"output_tokens": 361,
"prompt_ms": 30086.199999999997,
"decode_ms": 4012.3
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 43,
"mem_used": 18898419712,
"mem_total": 25769803776,
"temp": 51,
"power": 178.691
},
{
"index": 1,
"util": 51,
"mem_used": 21758935040,
"mem_total": 25769803776,
"temp": 54,
"power": 244.501
}
],
"gpu_util": 47.0,
"gpu_mem_used": 40657354752,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 423.192,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5.1962890625,
"gpu_pcie_tx_mb": 103.138671875,
"cpu": 6.6,
"ram_used": 44596383744,
"ram_total": 177175990272,
"disk_read_mb": 1.1207609014346964,
"disk_write_mb": 0.0288298624163266,
"tok_s": 110.47676922161895,
"tok_s_mean": 99.0096070780873
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
1.0,
93.0,
94.0,
64.0,
94.5,
88.5,
95.5,
92.5,
48.5,
32.0,
48.0,
50.0,
0.0,
84.5,
96.0,
95.5,
79.0,
97.5,
97.0,
95.5,
96.0,
50.0,
36.5,
49.5,
96.5,
61.0,
94.5,
91.0,
97.0,
95.5,
98.5,
47.5,
47.0
],
"gpu_mem_used": [
40447639552,
40447639552,
40476999680,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40546205696,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752,
40657354752
],
"gpu_temp": [
49,
49,
49,
53,
54,
54,
55,
54,
55,
55,
55,
52,
54,
54,
50,
54,
55,
55,
55,
55,
55,
55,
55,
55,
54,
52,
55,
55,
55,
55,
56,
56,
55,
56,
54
],
"gpu_power": [
259.59,
247.18,
245.88,
414.53,
546.71,
547.76,
546.95,
533.57,
531.41,
545.46,
539.14,
402.04,
486.67,
499.58,
409.59,
480.21,
551.08,
548.0,
547.82,
539.97,
537.72,
548.44,
548.33,
513.55,
429.21,
354.61,
553.75,
546.57,
547.59,
532.21,
535.5,
547.28,
548.49,
534.02,
423.19
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
247.86,
81.11,
78.2,
80.92,
83.88,
57.6,
82.87,
79.92,
40.29,
5.39,
9.77,
5.39,
45.78,
64.8,
1284.55,
129.94,
83.06,
82.63,
84.78,
73.15,
82.44,
0.57,
0.62,
81.82,
83.45,
75.34,
84.16,
82.11,
81.49,
70.95,
73.91,
52.55,
5.2
],
"cpu": [
0.0,
1.9,
9.1,
8.8,
9.5,
10.7,
13.9,
10.5,
13.9,
11.8,
6.0,
6.3,
12.4,
11.7,
6.7,
8.3,
6.5,
7.2,
6.1,
6.0,
6.1,
6.5,
11.2,
8.0,
5.3,
6.7,
12.7,
10.0,
5.9,
6.4,
6.0,
7.1,
5.7,
6.8,
6.6
],
"ram_used": [
43887411200,
43859918848,
43956232192,
44034678784,
44030210048,
44028076032,
44015280128,
44252610560,
44247789568,
44243210240,
44230340608,
44558966784,
44619108352,
44619116544,
44154675200,
44152926208,
44151242752,
44149854208,
44145594368,
44375150592,
44366180352,
44365656064,
44362940416,
44400578560,
44575621120,
44112637952,
44134821888,
44114948096,
44112486400,
44240445440,
44343197696,
44341800960,
44344549376,
44344029184,
44596383744
],
"disk_read_mb": [
null,
0.0,
126.09,
44.05,
80.0,
93.94,
138.6,
104.01,
156.43,
97.38,
0.0,
1.76,
4.66,
4.52,
0.63,
0.02,
0.04,
0.03,
0.05,
0.03,
0.02,
13.87,
103.6,
0.0,
2.47,
0.63,
0.05,
0.08,
0.08,
0.04,
0.07,
0.04,
0.17,
0.0,
1.12
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
78.74,
81.4,
107.1,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
110.48
]
},
"time": 1790717678.3471994
}
}
@@ -0,0 +1,261 @@
{
"label": "native-v0.1.26-Coder-2x3090-K26",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "5ca39dba7489",
"corpus_repeated": false,
"time": "2026-09-29T21:35:22",
"prompt_tokens": 28314,
"completion_tokens": 48,
"ttft_s": 9.79,
"e2e_s": 10.297,
"api_prompt_tps": 2892.2,
"api_decode_tps": 92.7,
"engine_prompt_tps": 2940.2,
"engine_decode_tps": 88.8,
"log_lines": [
"strata serve: prompt 28314 tokens = 0 reused + 28314 read in 9630 ms (2940.2 tok/s), 48 generated in 540 ms (88.8 tok/s), drafts accepted 33 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (25920 hits / 25920 lookups)"
],
"answer_head": "I'll first look at the repository structure to understand what files exist and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6656,
"expert_cache_mib": 12387,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 5607,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717722.129571,
"duration_s": 10.2,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 9630.1,
"decode_ms": 540.5,
"decode_tok_s": 88.8,
"hit_rate": 1.0
}
],
"requests_kept": 1,
"totals": {
"since": 1790717720.412441,
"requests": 1,
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"prompt_ms": 9630.1,
"decode_ms": 540.5
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 47,
"mem_used": 19980550144,
"mem_total": 25769803776,
"temp": 51,
"power": 179.665
},
{
"index": 1,
"util": 28,
"mem_used": 20641153024,
"mem_total": 25769803776,
"temp": 53,
"power": 236.004
}
],
"gpu_util": 37.5,
"gpu_mem_used": 40621703168,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 415.669,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 6.0,
"ram_used": 44539072512,
"ram_total": 177175990272,
"disk_read_mb": 2.97776661958663,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.5,
71.0,
95.5,
96.0,
91.5,
66.5,
95.5,
90.5,
84.5,
37.5
],
"gpu_mem_used": [
40447639552,
40447639552,
40472805376,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40621703168
],
"gpu_temp": [
50,
50,
50,
52,
55,
55,
56,
56,
56,
55,
56,
53
],
"gpu_power": [
261.03,
248.02,
247.5,
351.95,
548.48,
553.77,
555.05,
536.77,
531.38,
552.37,
551.57,
415.67
],
"gpu_pcie_rx_mb": [
0.76,
0.62,
224.64,
86.02,
83.16,
75.62,
86.69,
102.66,
65.66,
83.97,
38.86,
0.67
],
"cpu": [
0.0,
1.1,
8.1,
9.1,
9.3,
12.2,
12.6,
12.6,
23.5,
14.7,
5.9,
6.0
],
"ram_used": [
43871281152,
43867545600,
43958726656,
44040531968,
44041007104,
44033200128,
44032602112,
44244361216,
44250234880,
44236812288,
44233678848,
44539072512
],
"disk_read_mb": [
null,
0.0,
122.8,
47.19,
79.99,
100.77,
127.09,
108.72,
156.54,
97.45,
0.0,
2.98
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717732.8116624
}
}
@@ -0,0 +1,365 @@
{
"label": "native-v0.1.26-Coder-2x3090-K26",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "14c7210ce0e9",
"corpus_repeated": false,
"time": "2026-09-29T21:35:32",
"prompt_tokens": 31635,
"completion_tokens": 45,
"ttft_s": 10.029,
"e2e_s": 10.496,
"api_prompt_tps": 3154.3,
"api_decode_tps": 94.3,
"engine_prompt_tps": 3205.2,
"engine_decode_tps": 93.5,
"log_lines": [
"strata serve: prompt 31635 tokens = 0 reused + 31635 read in 9870 ms (3205.2 tok/s), 45 generated in 481 ms (93.5 tok/s), drafts accepted 31 of 36, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (25440 hits / 25440 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what the last file does.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6656,
"expert_cache_mib": 12387,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 5607,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717732.947479,
"duration_s": 10.4,
"finish": "stop",
"prompt_tokens": 31635,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 9870.0,
"decode_ms": 481.3,
"decode_tok_s": 93.5,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717722.129571,
"duration_s": 10.2,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 9630.1,
"decode_ms": 540.5,
"decode_tok_s": 88.8,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790717720.412441,
"requests": 2,
"prompt_tokens": 59949,
"reused": 0,
"output_tokens": 93,
"prompt_ms": 19500.1,
"decode_ms": 1021.8
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 51,
"mem_used": 19991035904,
"mem_total": 25769803776,
"temp": 51,
"power": 190.866
},
{
"index": 1,
"util": 56,
"mem_used": 20653735936,
"mem_total": 25769803776,
"temp": 55,
"power": 249.813
}
],
"gpu_util": 53.5,
"gpu_mem_used": 40644771840,
"gpu_mem_total": 51539607552,
"gpu_temp": 55,
"gpu_power": 440.679,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 16.44921875,
"gpu_pcie_tx_mb": 82.0625,
"cpu": 6.0,
"ram_used": 44553875456,
"ram_total": 177175990272,
"disk_read_mb": 0.6053434938228842,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.5,
71.0,
95.5,
96.0,
91.5,
66.5,
95.5,
90.5,
84.5,
37.5,
1.5,
97.0,
96.0,
81.0,
86.5,
95.5,
95.0,
96.5,
95.0,
53.5
],
"gpu_mem_used": [
40447639552,
40447639552,
40472805376,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40644771840
],
"gpu_temp": [
50,
50,
50,
52,
55,
55,
56,
56,
56,
55,
56,
53,
51,
56,
56,
56,
56,
56,
56,
56,
56,
55
],
"gpu_power": [
261.03,
248.02,
247.5,
351.95,
548.48,
553.77,
555.05,
536.77,
531.38,
552.37,
551.57,
415.67,
326.37,
532.86,
555.24,
552.15,
555.12,
507.8,
554.85,
554.0,
554.13,
440.68
],
"gpu_pcie_rx_mb": [
0.76,
0.62,
224.64,
86.02,
83.16,
75.62,
86.69,
102.66,
65.66,
83.97,
38.86,
0.67,
3698.35,
132.46,
131.89,
82.06,
85.92,
83.02,
1279.88,
50.4,
86.21,
16.45
],
"cpu": [
0.0,
1.1,
8.1,
9.1,
9.3,
12.2,
12.6,
12.6,
23.5,
14.7,
5.9,
6.0,
4.5,
6.1,
6.0,
6.4,
6.7,
5.9,
6.7,
9.9,
7.4,
6.0
],
"ram_used": [
43871281152,
43867545600,
43958726656,
44040531968,
44041007104,
44033200128,
44032602112,
44244361216,
44250234880,
44236812288,
44233678848,
44539072512,
44064968704,
44058497024,
44058497024,
44058501120,
44175929344,
44294356992,
44294352896,
44295569408,
44291391488,
44553875456
],
"disk_read_mb": [
null,
0.0,
122.8,
47.19,
79.99,
100.77,
127.09,
108.72,
156.54,
97.45,
0.0,
2.98,
0.47,
0.01,
0.04,
0.06,
0.03,
0.03,
12.57,
71.85,
33.12,
0.61
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717743.8106396
}
}
@@ -0,0 +1,469 @@
{
"label": "native-v0.1.26-Coder-2x3090-K26",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "3f243fdb63ee",
"corpus_repeated": false,
"time": "2026-09-29T21:35:43",
"prompt_tokens": 31601,
"completion_tokens": 60,
"ttft_s": 10.026,
"e2e_s": 10.61,
"api_prompt_tps": 3151.9,
"api_decode_tps": 101.0,
"engine_prompt_tps": 3208.3,
"engine_decode_tps": 100.2,
"log_lines": [
"strata serve: prompt 31601 tokens = 0 reused + 31601 read in 9850 ms (3208.3 tok/s), 60 generated in 599 ms (100.2 tok/s), drafts accepted 40 of 50, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (34080 hits / 34080 lookups)"
],
"answer_head": "I'll start by examining the repository structure to understand what the last file is.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 6656,
"expert_cache_mib": 12387,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 5607,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717743.964174,
"duration_s": 10.5,
"finish": "stop",
"prompt_tokens": 31601,
"reused": 0,
"output_tokens": 60,
"engine_generated": 60,
"prompt_ms": 9849.9,
"decode_ms": 598.9,
"decode_tok_s": 100.2,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717732.947479,
"duration_s": 10.4,
"finish": "stop",
"prompt_tokens": 31635,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 9870.0,
"decode_ms": 481.3,
"decode_tok_s": 93.5,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717722.129571,
"duration_s": 10.2,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 9630.1,
"decode_ms": 540.5,
"decode_tok_s": 88.8,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790717720.412441,
"requests": 3,
"prompt_tokens": 91550,
"reused": 0,
"output_tokens": 153,
"prompt_ms": 29350.0,
"decode_ms": 1620.6999999999998
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 46,
"mem_used": 19991035904,
"mem_total": 25769803776,
"temp": 52,
"power": 189.922
},
{
"index": 1,
"util": 52,
"mem_used": 20653735936,
"mem_total": 25769803776,
"temp": 55,
"power": 246.398
}
],
"gpu_util": 49.0,
"gpu_mem_used": 40644771840,
"gpu_mem_total": 51539607552,
"gpu_temp": 55,
"gpu_power": 436.32,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 17.8330078125,
"gpu_pcie_tx_mb": 43.1533203125,
"cpu": 6.0,
"ram_used": 44614168576,
"ram_total": 177175990272,
"disk_read_mb": 0.4973320821900814,
"disk_write_mb": 0.05405783502066102,
"tok_s": 99.26679787882165,
"tok_s_mean": 97.997900113756
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.5,
71.0,
95.5,
96.0,
91.5,
66.5,
95.5,
90.5,
84.5,
37.5,
1.5,
97.0,
96.0,
81.0,
86.5,
95.5,
95.0,
96.5,
95.0,
53.5,
0.0,
95.0,
95.5,
82.0,
94.5,
93.0,
88.5,
96.0,
97.0,
49.0
],
"gpu_mem_used": [
40447639552,
40447639552,
40472805376,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40535719936,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40621703168,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840,
40644771840
],
"gpu_temp": [
50,
50,
50,
52,
55,
55,
56,
56,
56,
55,
56,
53,
51,
56,
56,
56,
56,
56,
56,
56,
56,
55,
52,
55,
56,
56,
56,
56,
56,
56,
56,
55
],
"gpu_power": [
261.03,
248.02,
247.5,
351.95,
548.48,
553.77,
555.05,
536.77,
531.38,
552.37,
551.57,
415.67,
326.37,
532.86,
555.24,
552.15,
555.12,
507.8,
554.85,
554.0,
554.13,
440.68,
363.75,
474.54,
552.72,
554.16,
554.3,
509.24,
555.11,
555.88,
555.36,
436.32
],
"gpu_pcie_rx_mb": [
0.76,
0.62,
224.64,
86.02,
83.16,
75.62,
86.69,
102.66,
65.66,
83.97,
38.86,
0.67,
3698.35,
132.46,
131.89,
82.06,
85.92,
83.02,
1279.88,
50.4,
86.21,
16.45,
38.96,
81.63,
83.25,
84.4,
72.53,
127.22,
48.4,
96.51,
100.71,
17.83
],
"cpu": [
0.0,
1.1,
8.1,
9.1,
9.3,
12.2,
12.6,
12.6,
23.5,
14.7,
5.9,
6.0,
4.5,
6.1,
6.0,
6.4,
6.7,
5.9,
6.7,
9.9,
7.4,
6.0,
11.7,
10.8,
6.2,
11.4,
7.0,
6.7,
5.6,
5.4,
6.0,
6.0
],
"ram_used": [
43871281152,
43867545600,
43958726656,
44040531968,
44041007104,
44033200128,
44032602112,
44244361216,
44250234880,
44236812288,
44233678848,
44539072512,
44064968704,
44058497024,
44058497024,
44058501120,
44175929344,
44294356992,
44294352896,
44295569408,
44291391488,
44553875456,
44129808384,
44180946944,
44184666112,
44182659072,
44296114176,
44404658176,
44394999808,
44386783232,
44374441984,
44614168576
],
"disk_read_mb": [
null,
0.0,
122.8,
47.19,
79.99,
100.77,
127.09,
108.72,
156.54,
97.45,
0.0,
2.98,
0.47,
0.01,
0.04,
0.06,
0.03,
0.03,
12.57,
71.85,
33.12,
0.61,
0.53,
0.06,
0.06,
0.09,
0.08,
0.04,
0.04,
0.04,
0.15,
0.5
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
99.27
]
},
"time": 1790717754.9239163
}
}
@@ -0,0 +1,261 @@
{
"label": "native-v0.1.26-Coder-2x3090-K28",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "0796a1ce12e4",
"corpus_repeated": false,
"time": "2026-09-29T21:36:29",
"prompt_tokens": 28316,
"completion_tokens": 57,
"ttft_s": 10.285,
"e2e_s": 10.86,
"api_prompt_tps": 2753.1,
"api_decode_tps": 97.4,
"engine_prompt_tps": 2798.5,
"engine_decode_tps": 93.7,
"log_lines": [
"strata serve: prompt 28316 tokens = 0 reused + 28316 read in 10118 ms (2798.5 tok/s), 57 generated in 608 ms (93.7 tok/s), drafts accepted 40 of 42, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (28800 hits / 28800 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7168,
"expert_cache_mib": 13437,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 4557,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717789.1846194,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10118.2,
"decode_ms": 608.0,
"decode_tok_s": 93.8,
"hit_rate": 1.0
}
],
"requests_kept": 1,
"totals": {
"since": 1790717787.625935,
"requests": 1,
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"prompt_ms": 10118.2,
"decode_ms": 608.0
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 41,
"mem_used": 21104623616,
"mem_total": 25769803776,
"temp": 52,
"power": 189.832
},
{
"index": 1,
"util": 42,
"mem_used": 19548536832,
"mem_total": 25769803776,
"temp": 54,
"power": 230.563
}
],
"gpu_util": 41.5,
"gpu_mem_used": 40653160448,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 420.395,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 17.1650390625,
"gpu_pcie_tx_mb": 53.119140625,
"cpu": 6.1,
"ram_used": 44503613440,
"ram_total": 177175990272,
"disk_read_mb": 1.946188226381293,
"disk_write_mb": 0.0036040522710764685,
"tok_s": 81.42212134334822,
"tok_s_mean": 78.79383849818437
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
46.5,
96.0,
72.5,
93.0,
90.0,
95.5,
93.5,
97.5,
41.5
],
"gpu_mem_used": [
40447639552,
40447639552,
40495874048,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40653160448
],
"gpu_temp": [
51,
50,
50,
52,
55,
54,
56,
54,
56,
56,
57,
54
],
"gpu_power": [
261.46,
249.04,
248.59,
342.07,
531.07,
533.47,
545.68,
511.29,
533.34,
534.58,
541.51,
420.39
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
182.48,
55.88,
87.02,
80.58,
57.5,
78.87,
83.88,
1294.42,
46.78,
17.17
],
"cpu": [
0.0,
6.6,
18.0,
11.3,
10.5,
9.8,
11.5,
13.9,
11.4,
12.9,
7.4,
6.1
],
"ram_used": [
43799613440,
43777974272,
43950305280,
43962880000,
43939622912,
43930345472,
43932086272,
44071780352,
44183257088,
44182880256,
44179062784,
44503613440
],
"disk_read_mb": [
null,
0.0,
129.59,
40.83,
79.94,
84.92,
115.02,
136.42,
117.79,
106.04,
29.9,
1.95
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
81.42
]
},
"time": 1790717800.421838
}
}
@@ -0,0 +1,374 @@
{
"label": "native-v0.1.26-Coder-2x3090-K28",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "3d5bf2c2aa6f",
"corpus_repeated": false,
"time": "2026-09-29T21:36:40",
"prompt_tokens": 31631,
"completion_tokens": 45,
"ttft_s": 10.58,
"e2e_s": 10.972,
"api_prompt_tps": 2989.7,
"api_decode_tps": 112.3,
"engine_prompt_tps": 3034.9,
"engine_decode_tps": 110.6,
"log_lines": [
"strata serve: prompt 31631 tokens = 0 reused + 31631 read in 10423 ms (3034.9 tok/s), 45 generated in 407 ms (110.6 tok/s), drafts accepted 33 of 34, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (23040 hits / 23040 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7168,
"expert_cache_mib": 13437,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 4557,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717800.5571585,
"duration_s": 10.8,
"finish": "stop",
"prompt_tokens": 31631,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10422.5,
"decode_ms": 406.8,
"decode_tok_s": 110.6,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717789.1846194,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10118.2,
"decode_ms": 608.0,
"decode_tok_s": 93.8,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790717787.625935,
"requests": 2,
"prompt_tokens": 59947,
"reused": 0,
"output_tokens": 102,
"prompt_ms": 20540.7,
"decode_ms": 1014.8
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 46,
"mem_used": 21104623616,
"mem_total": 25769803776,
"temp": 51,
"power": 204.027
},
{
"index": 1,
"util": 12,
"mem_used": 19548536832,
"mem_total": 25769803776,
"temp": 54,
"power": 226.431
}
],
"gpu_util": 29.0,
"gpu_mem_used": 40653160448,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 430.45799999999997,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.6181640625,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 4.3,
"ram_used": 44573519872,
"ram_total": 177175990272,
"disk_read_mb": 0.9768799607845553,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
46.5,
96.0,
72.5,
93.0,
90.0,
95.5,
93.5,
97.5,
41.5,
0.0,
96.0,
93.0,
97.5,
94.5,
97.0,
95.0,
97.0,
93.5,
67.0,
29.0
],
"gpu_mem_used": [
40447639552,
40447639552,
40495874048,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448
],
"gpu_temp": [
51,
50,
50,
52,
55,
54,
56,
54,
56,
56,
57,
54,
52,
55,
54,
56,
56,
56,
56,
57,
57,
56,
54
],
"gpu_power": [
261.46,
249.04,
248.59,
342.07,
531.07,
533.47,
545.68,
511.29,
533.34,
534.58,
541.51,
420.39,
375.37,
452.84,
528.99,
547.53,
532.29,
524.3,
518.92,
543.34,
532.25,
534.03,
430.46
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
182.48,
55.88,
87.02,
80.58,
57.5,
78.87,
83.88,
1294.42,
46.78,
17.17,
42.15,
1288.27,
41.05,
75.34,
70.76,
44.15,
79.87,
61.61,
75.63,
42.06,
0.62
],
"cpu": [
0.0,
6.6,
18.0,
11.3,
10.5,
9.8,
11.5,
13.9,
11.4,
12.9,
7.4,
6.1,
4.2,
6.4,
6.0,
12.9,
11.2,
6.1,
8.2,
8.8,
14.0,
6.4,
4.3
],
"ram_used": [
43799613440,
43777974272,
43950305280,
43962880000,
43939622912,
43930345472,
43932086272,
44071780352,
44183257088,
44182880256,
44179062784,
44503613440,
44015304704,
44019281920,
44021350400,
44034875392,
44111585280,
44348657664,
44344815616,
44359872512,
44334280704,
44327985152,
44573519872
],
"disk_read_mb": [
null,
0.0,
129.59,
40.83,
79.94,
84.92,
115.02,
136.42,
117.79,
106.04,
29.9,
1.95,
1.72,
0.02,
0.02,
0.05,
0.06,
0.01,
0.03,
12.6,
101.64,
2.94,
0.98
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
81.42,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717811.896799
}
}
@@ -0,0 +1,487 @@
{
"label": "native-v0.1.26-Coder-2x3090-K28",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "d22ca9d8c7b8",
"corpus_repeated": false,
"time": "2026-09-29T21:36:51",
"prompt_tokens": 31602,
"completion_tokens": 59,
"ttft_s": 10.575,
"e2e_s": 11.17,
"api_prompt_tps": 2988.5,
"api_decode_tps": 97.4,
"engine_prompt_tps": 3037.5,
"engine_decode_tps": 96.6,
"log_lines": [
"strata serve: prompt 31602 tokens = 0 reused + 31602 read in 10404 ms (3037.5 tok/s), 59 generated in 611 ms (96.6 tok/s), drafts accepted 41 of 52, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (35040 hits / 35040 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7168,
"expert_cache_mib": 13437,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 4557,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717812.0454123,
"duration_s": 11.0,
"finish": "stop",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 59,
"engine_generated": 59,
"prompt_ms": 10404.1,
"decode_ms": 610.6,
"decode_tok_s": 96.6,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717800.5571585,
"duration_s": 10.8,
"finish": "stop",
"prompt_tokens": 31631,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10422.5,
"decode_ms": 406.8,
"decode_tok_s": 110.6,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717789.1846194,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 57,
"engine_generated": 57,
"prompt_ms": 10118.2,
"decode_ms": 608.0,
"decode_tok_s": 93.8,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790717787.625935,
"requests": 3,
"prompt_tokens": 91549,
"reused": 0,
"output_tokens": 161,
"prompt_ms": 30944.800000000003,
"decode_ms": 1625.4
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 48,
"mem_used": 21104623616,
"mem_total": 25769803776,
"temp": 53,
"power": 214.931
},
{
"index": 1,
"util": 0,
"mem_used": 19548536832,
"mem_total": 25769803776,
"temp": 53,
"power": 199.379
}
],
"gpu_util": 24.0,
"gpu_mem_used": 40653160448,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 414.31,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 3.6,
"ram_used": 44545851392,
"ram_total": 177175990272,
"disk_read_mb": 0.7062443272525659,
"disk_write_mb": 0.11530519628613321,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
46.5,
96.0,
72.5,
93.0,
90.0,
95.5,
93.5,
97.5,
41.5,
0.0,
96.0,
93.0,
97.5,
94.5,
97.0,
95.0,
97.0,
93.5,
67.0,
29.0,
50.0,
96.5,
47.5,
95.5,
96.5,
95.5,
62.5,
96.5,
95.5,
50.0,
24.0
],
"gpu_mem_used": [
40447639552,
40447639552,
40495874048,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40542011392,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448,
40653160448
],
"gpu_temp": [
51,
50,
50,
52,
55,
54,
56,
54,
56,
56,
57,
54,
52,
55,
54,
56,
56,
56,
56,
57,
57,
56,
54,
53,
56,
54,
57,
57,
57,
56,
57,
56,
57,
53
],
"gpu_power": [
261.46,
249.04,
248.59,
342.07,
531.07,
533.47,
545.68,
511.29,
533.34,
534.58,
541.51,
420.39,
375.37,
452.84,
528.99,
547.53,
532.29,
524.3,
518.92,
543.34,
532.25,
534.03,
430.46,
354.3,
519.1,
530.52,
534.81,
532.5,
512.45,
532.86,
540.0,
532.72,
513.31,
414.31
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
182.48,
55.88,
87.02,
80.58,
57.5,
78.87,
83.88,
1294.42,
46.78,
17.17,
42.15,
1288.27,
41.05,
75.34,
70.76,
44.15,
79.87,
61.61,
75.63,
42.06,
0.62,
84.64,
74.34,
85.5,
81.54,
0.67,
75.72,
81.82,
82.83,
28.8,
17.74,
0.67
],
"cpu": [
0.0,
6.6,
18.0,
11.3,
10.5,
9.8,
11.5,
13.9,
11.4,
12.9,
7.4,
6.1,
4.2,
6.4,
6.0,
12.9,
11.2,
6.1,
8.2,
8.8,
14.0,
6.4,
4.3,
4.2,
6.6,
6.0,
17.8,
8.5,
6.2,
15.1,
14.3,
6.7,
6.9,
3.6
],
"ram_used": [
43799613440,
43777974272,
43950305280,
43962880000,
43939622912,
43930345472,
43932086272,
44071780352,
44183257088,
44182880256,
44179062784,
44503613440,
44015304704,
44019281920,
44021350400,
44034875392,
44111585280,
44348657664,
44344815616,
44359872512,
44334280704,
44327985152,
44573519872,
44103626752,
44105744384,
44105732096,
44159885312,
44275363840,
44375539712,
44373200896,
44318019584,
44307988480,
44545863680,
44545851392
],
"disk_read_mb": [
null,
0.0,
129.59,
40.83,
79.94,
84.92,
115.02,
136.42,
117.79,
106.04,
29.9,
1.95,
1.72,
0.02,
0.02,
0.05,
0.06,
0.01,
0.03,
12.6,
101.64,
2.94,
0.98,
0.74,
0.02,
0.06,
0.32,
0.08,
0.04,
0.05,
0.04,
0.1,
0.0,
0.71
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
81.42,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717823.5700235
}
}
@@ -0,0 +1,608 @@
{
"label": "native-v0.1.26-Coder-2x3090-K30",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "b4895f87f439",
"corpus_repeated": false,
"time": "2026-09-29T21:28:38",
"prompt_tokens": 28316,
"completion_tokens": 45,
"ttft_s": 9.936,
"e2e_s": 10.4,
"api_prompt_tps": 2849.8,
"api_decode_tps": 94.9,
"engine_prompt_tps": 2892.0,
"engine_decode_tps": 94.1,
"log_lines": [
"strata serve: prompt 28316 tokens = 0 reused + 28316 read in 9791 ms (2892.0 tok/s), 45 generated in 478 ms (94.1 tok/s), drafts accepted 31 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (25440 hits / 25440 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7680,
"expert_cache_mib": 14575,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 3419,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717318.4067442,
"duration_s": 10.3,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 9791.3,
"decode_ms": 478.1,
"decode_tok_s": 94.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717288.2692974,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 10484.4,
"decode_ms": 636.0,
"decode_tok_s": 88.1,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790717276.5105639,
"requests": 2,
"prompt_tokens": 56632,
"reused": 0,
"output_tokens": 101,
"prompt_ms": 20275.699999999997,
"decode_ms": 1114.1
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 53,
"mem_used": 22306291712,
"mem_total": 25769803776,
"temp": 51,
"power": 200.427
},
{
"index": 1,
"util": 46,
"mem_used": 18353160192,
"mem_total": 25769803776,
"temp": 53,
"power": 223.879
}
],
"gpu_util": 49.5,
"gpu_mem_used": 40659451904,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 424.306,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5.8642578125,
"gpu_pcie_tx_mb": 107.4306640625,
"cpu": 6.9,
"ram_used": 44604223488,
"ram_total": 177175990272,
"disk_read_mb": 1.1417042620069329,
"disk_write_mb": 0.04682067951447989,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
50.0,
94.0,
63.0,
95.0,
50.0,
92.0,
95.0,
82.5,
97.0,
35.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
97.5,
49.0,
94.5,
50.0,
96.5,
53.0,
94.5,
97.0,
49.5
],
"gpu_mem_used": [
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40542011392,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40659451904
],
"gpu_temp": [
49,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
50,
52,
53,
53,
53,
52,
54,
51,
54,
52,
50,
49,
49,
49,
49,
49,
49,
48,
49,
48,
48,
48,
49,
49,
49,
49,
46,
46,
53,
52,
54,
52,
54,
52,
54,
54,
53
],
"gpu_power": [
257.9,
244.84,
244.4,
244.1,
244.29,
244.43,
244.32,
244.0,
243.79,
243.86,
244.04,
244.43,
304.5,
504.99,
527.59,
513.34,
519.55,
489.82,
537.3,
515.01,
534.71,
416.26,
390.46,
299.77,
260.05,
241.54,
241.56,
241.75,
241.63,
241.51,
241.46,
241.4,
241.29,
241.13,
241.31,
241.69,
241.72,
221.92,
136.12,
67.69,
469.97,
521.96,
512.77,
514.47,
496.64,
522.43,
513.55,
532.56,
424.31
],
"gpu_pcie_rx_mb": [
0.67,
0.67,
0.62,
0.62,
0.62,
0.62,
0.67,
1.62,
0.67,
0.62,
0.62,
0.62,
4319.14,
134.51,
87.31,
96.37,
111.91,
79.87,
41.53,
80.25,
44.15,
15.88,
0.67,
0.57,
0.57,
0.57,
0.62,
0.62,
0.62,
0.62,
0.62,
0.57,
0.62,
0.62,
0.62,
0.62,
0.57,
0.81,
0.81,
44.34,
97.08,
1308.87,
41.25,
84.97,
155.3,
46.68,
84.26,
3604.32,
5.86
],
"cpu": [
0.0,
1.4,
4.7,
7.8,
13.7,
1.8,
1.4,
1.9,
1.6,
1.4,
1.5,
9.7,
13.3,
10.3,
10.0,
9.4,
23.0,
17.6,
10.6,
13.1,
6.5,
6.2,
1.3,
8.4,
5.4,
1.3,
1.2,
1.8,
1.6,
0.9,
10.0,
4.2,
0.8,
1.8,
1.6,
2.2,
2.6,
1.9,
2.8,
7.4,
8.7,
7.1,
5.6,
6.2,
14.3,
8.5,
5.8,
9.0,
6.9
],
"ram_used": [
43796508672,
43800592384,
43805933568,
43809234944,
43832729600,
43832090624,
43837464576,
43835621376,
43830910976,
43829395456,
43825078272,
43852685312,
44052480000,
44036640768,
44033179648,
44028084224,
44053590016,
44291584000,
44290129920,
44269481984,
44257243136,
44556734464,
44502183936,
44524433408,
44526993408,
44523057152,
44523831296,
44519899136,
44508749824,
44508250112,
44527558656,
44529721344,
44527198208,
44529672192,
44530278400,
44537171968,
44538560512,
44524920832,
44552687616,
44075163648,
44090421248,
44086198272,
44085055488,
44084731904,
44364992512,
44360019968,
44359946240,
44359090176,
44604223488
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
56.63,
73.79,
64.08,
89.26,
71.49,
160.33,
111.7,
115.85,
97.53,
0.0,
3.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.56,
0.02,
0.04,
0.03,
0.05,
0.01,
0.03,
0.01,
0.0,
1.14
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790717329.186504
}
}
@@ -0,0 +1,721 @@
{
"label": "native-v0.1.26-Coder-2x3090-K30",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "f81947893a8b",
"corpus_repeated": false,
"time": "2026-09-29T21:28:49",
"prompt_tokens": 31632,
"completion_tokens": 48,
"ttft_s": 11.011,
"e2e_s": 11.496,
"api_prompt_tps": 2872.7,
"api_decode_tps": 97.0,
"engine_prompt_tps": 2926.4,
"engine_decode_tps": 96.1,
"log_lines": [
"strata serve: prompt 31632 tokens = 0 reused + 31632 read in 10809 ms (2926.4 tok/s), 48 generated in 499 ms (96.1 tok/s), drafts accepted 32 of 38, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (27360 hits / 27360 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7680,
"expert_cache_mib": 14575,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 3419,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717329.364414,
"duration_s": 11.3,
"finish": "stop",
"prompt_tokens": 31632,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 10809.3,
"decode_ms": 499.4,
"decode_tok_s": 96.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717318.4067442,
"duration_s": 10.3,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 9791.3,
"decode_ms": 478.1,
"decode_tok_s": 94.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717288.2692974,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 10484.4,
"decode_ms": 636.0,
"decode_tok_s": 88.1,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790717276.5105639,
"requests": 3,
"prompt_tokens": 88264,
"reused": 0,
"output_tokens": 149,
"prompt_ms": 31084.999999999996,
"decode_ms": 1613.5
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 48,
"mem_used": 22306291712,
"mem_total": 25769803776,
"temp": 51,
"power": 211.949
},
{
"index": 1,
"util": 41,
"mem_used": 18353160192,
"mem_total": 25769803776,
"temp": 54,
"power": 238.158
}
],
"gpu_util": 44.5,
"gpu_mem_used": 40659451904,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 450.10699999999997,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 16.3544921875,
"gpu_pcie_tx_mb": 94.6513671875,
"cpu": 12.9,
"ram_used": 44387663872,
"ram_total": 177175990272,
"disk_read_mb": 0.417992184024029,
"disk_write_mb": 0.0972912842124895,
"tok_s": 101.46942145535564,
"tok_s_mean": 93.06246895838419
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
50.0,
94.0,
63.0,
95.0,
50.0,
92.0,
95.0,
82.5,
97.0,
35.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
97.5,
49.0,
94.5,
50.0,
96.5,
53.0,
94.5,
97.0,
49.5,
50.0,
97.5,
97.0,
98.5,
68.5,
96.0,
49.5,
96.0,
68.5,
97.0,
44.5
],
"gpu_mem_used": [
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40449736704,
40542011392,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904
],
"gpu_temp": [
49,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
50,
52,
53,
53,
53,
52,
54,
51,
54,
52,
50,
49,
49,
49,
49,
49,
49,
48,
49,
48,
48,
48,
49,
49,
49,
49,
46,
46,
53,
52,
54,
52,
54,
52,
54,
54,
53,
50,
54,
54,
55,
54,
55,
52,
55,
54,
55,
54
],
"gpu_power": [
257.9,
244.84,
244.4,
244.1,
244.29,
244.43,
244.32,
244.0,
243.79,
243.86,
244.04,
244.43,
304.5,
504.99,
527.59,
513.34,
519.55,
489.82,
537.3,
515.01,
534.71,
416.26,
390.46,
299.77,
260.05,
241.54,
241.56,
241.75,
241.63,
241.51,
241.46,
241.4,
241.29,
241.13,
241.31,
241.69,
241.72,
221.92,
136.12,
67.69,
469.97,
521.96,
512.77,
514.47,
496.64,
522.43,
513.55,
532.56,
424.31,
362.71,
481.71,
508.96,
525.74,
511.3,
510.79,
506.4,
523.98,
513.03,
516.57,
450.11
],
"gpu_pcie_rx_mb": [
0.67,
0.67,
0.62,
0.62,
0.62,
0.62,
0.67,
1.62,
0.67,
0.62,
0.62,
0.62,
4319.14,
134.51,
87.31,
96.37,
111.91,
79.87,
41.53,
80.25,
44.15,
15.88,
0.67,
0.57,
0.57,
0.57,
0.62,
0.62,
0.62,
0.62,
0.62,
0.57,
0.62,
0.62,
0.62,
0.62,
0.57,
0.81,
0.81,
44.34,
97.08,
1308.87,
41.25,
84.97,
155.3,
46.68,
84.26,
3604.32,
5.86,
45.25,
84.11,
42.39,
128.98,
67.52,
42.77,
92.46,
81.82,
43.3,
95.32,
16.35
],
"cpu": [
0.0,
1.4,
4.7,
7.8,
13.7,
1.8,
1.4,
1.9,
1.6,
1.4,
1.5,
9.7,
13.3,
10.3,
10.0,
9.4,
23.0,
17.6,
10.6,
13.1,
6.5,
6.2,
1.3,
8.4,
5.4,
1.3,
1.2,
1.8,
1.6,
0.9,
10.0,
4.2,
0.8,
1.8,
1.6,
2.2,
2.6,
1.9,
2.8,
7.4,
8.7,
7.1,
5.6,
6.2,
14.3,
8.5,
5.8,
9.0,
6.9,
3.9,
5.5,
5.8,
5.9,
6.4,
7.5,
6.6,
6.1,
8.7,
17.4,
12.9
],
"ram_used": [
43796508672,
43800592384,
43805933568,
43809234944,
43832729600,
43832090624,
43837464576,
43835621376,
43830910976,
43829395456,
43825078272,
43852685312,
44052480000,
44036640768,
44033179648,
44028084224,
44053590016,
44291584000,
44290129920,
44269481984,
44257243136,
44556734464,
44502183936,
44524433408,
44526993408,
44523057152,
44523831296,
44519899136,
44508749824,
44508250112,
44527558656,
44529721344,
44527198208,
44529672192,
44530278400,
44537171968,
44538560512,
44524920832,
44552687616,
44075163648,
44090421248,
44086198272,
44085055488,
44084731904,
44364992512,
44360019968,
44359946240,
44359090176,
44604223488,
44141965312,
44142555136,
44129452032,
44121694208,
44121939968,
44354928640,
44349378560,
44349894656,
44349890560,
44144226304,
44387663872
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
56.63,
73.79,
64.08,
89.26,
71.49,
160.33,
111.7,
115.85,
97.53,
0.0,
3.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.56,
0.02,
0.04,
0.03,
0.05,
0.01,
0.03,
0.01,
0.0,
1.14,
0.4,
0.01,
0.0,
0.03,
0.04,
0.01,
0.03,
12.58,
71.94,
32.9,
0.42
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
101.47
]
},
"time": 1790717341.185252
}
}
@@ -0,0 +1,735 @@
{
"label": "native-v0.1.26-Coder-2x3090-K30",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "cb947708c5cc",
"corpus_repeated": false,
"time": "2026-09-29T21:29:01",
"prompt_tokens": 31602,
"completion_tokens": 45,
"ttft_s": 10.976,
"e2e_s": 11.378,
"api_prompt_tps": 2879.2,
"api_decode_tps": 109.6,
"engine_prompt_tps": 2920.6,
"engine_decode_tps": 108.0,
"log_lines": [
"strata serve: prompt 31602 tokens = 0 reused + 31602 read in 10820 ms (2920.6 tok/s), 45 generated in 417 ms (108.0 tok/s), drafts accepted 33 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (24480 hits / 24480 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 7680,
"expert_cache_mib": 14575,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 3419,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717341.3189692,
"duration_s": 11.2,
"finish": "stop",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 10820.3,
"decode_ms": 416.8,
"decode_tok_s": 108.0,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717329.364414,
"duration_s": 11.3,
"finish": "stop",
"prompt_tokens": 31632,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 10809.3,
"decode_ms": 499.4,
"decode_tok_s": 96.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717318.4067442,
"duration_s": 10.3,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 9791.3,
"decode_ms": 478.1,
"decode_tok_s": 94.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790717288.2692974,
"duration_s": 11.1,
"finish": "stop",
"prompt_tokens": 28316,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 10484.4,
"decode_ms": 636.0,
"decode_tok_s": 88.1,
"hit_rate": 1.0
}
],
"requests_kept": 4,
"totals": {
"since": 1790717276.5105639,
"requests": 4,
"prompt_tokens": 119866,
"reused": 0,
"output_tokens": 194,
"prompt_ms": 41905.299999999996,
"decode_ms": 2030.3
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 5,
"mem_used": 22306291712,
"mem_total": 25769803776,
"temp": 49,
"power": 227.165
},
{
"index": 1,
"util": 42,
"mem_used": 18353160192,
"mem_total": 25769803776,
"temp": 54,
"power": 235.691
}
],
"gpu_util": 23.5,
"gpu_mem_used": 40659451904,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 462.856,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 17.0703125,
"gpu_pcie_tx_mb": 56.361328125,
"cpu": 5.5,
"ram_used": 44383059968,
"ram_total": 177175990272,
"disk_read_mb": 0.38547172180233397,
"disk_write_mb": 0.09366602585851105,
"tok_s": 121.26075785511577,
"tok_s_mean": 112.03069063875886
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
50.0,
94.0,
63.0,
95.0,
50.0,
92.0,
95.0,
82.5,
97.0,
35.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
97.5,
49.0,
94.5,
50.0,
96.5,
53.0,
94.5,
97.0,
49.5,
50.0,
97.5,
97.0,
98.5,
68.5,
96.0,
49.5,
96.0,
68.5,
97.0,
44.5,
50.0,
85.5,
94.5,
73.0,
79.0,
96.0,
48.0,
95.0,
72.5,
95.5,
23.5
],
"gpu_mem_used": [
40449736704,
40542011392,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40548302848,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40636383232,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904,
40659451904
],
"gpu_temp": [
48,
50,
52,
53,
53,
53,
52,
54,
51,
54,
52,
50,
49,
49,
49,
49,
49,
49,
48,
49,
48,
48,
48,
49,
49,
49,
49,
46,
46,
53,
52,
54,
52,
54,
52,
54,
54,
53,
50,
54,
54,
55,
54,
55,
52,
55,
54,
55,
54,
51,
53,
54,
53,
54,
55,
54,
55,
55,
55,
54
],
"gpu_power": [
244.43,
304.5,
504.99,
527.59,
513.34,
519.55,
489.82,
537.3,
515.01,
534.71,
416.26,
390.46,
299.77,
260.05,
241.54,
241.56,
241.75,
241.63,
241.51,
241.46,
241.4,
241.29,
241.13,
241.31,
241.69,
241.72,
221.92,
136.12,
67.69,
469.97,
521.96,
512.77,
514.47,
496.64,
522.43,
513.55,
532.56,
424.31,
362.71,
481.71,
508.96,
525.74,
511.3,
510.79,
506.4,
523.98,
513.03,
516.57,
450.11,
369.53,
481.25,
509.29,
527.58,
511.62,
510.74,
510.07,
527.16,
513.42,
533.96,
462.86
],
"gpu_pcie_rx_mb": [
0.62,
4319.14,
134.51,
87.31,
96.37,
111.91,
79.87,
41.53,
80.25,
44.15,
15.88,
0.67,
0.57,
0.57,
0.57,
0.62,
0.62,
0.62,
0.62,
0.62,
0.57,
0.62,
0.62,
0.62,
0.62,
0.57,
0.81,
0.81,
44.34,
97.08,
1308.87,
41.25,
84.97,
155.3,
46.68,
84.26,
3604.32,
5.86,
45.25,
84.11,
42.39,
128.98,
67.52,
42.77,
92.46,
81.82,
43.3,
95.32,
16.35,
43.1,
79.92,
41.63,
65.23,
80.39,
37.1,
81.92,
1273.96,
41.01,
79.15,
17.07
],
"cpu": [
9.7,
13.3,
10.3,
10.0,
9.4,
23.0,
17.6,
10.6,
13.1,
6.5,
6.2,
1.3,
8.4,
5.4,
1.3,
1.2,
1.8,
1.6,
0.9,
10.0,
4.2,
0.8,
1.8,
1.6,
2.2,
2.6,
1.9,
2.8,
7.4,
8.7,
7.1,
5.6,
6.2,
14.3,
8.5,
5.8,
9.0,
6.9,
3.9,
5.5,
5.8,
5.9,
6.4,
7.5,
6.6,
6.1,
8.7,
17.4,
12.9,
4.0,
6.3,
7.4,
6.1,
5.4,
6.6,
5.7,
6.7,
9.3,
6.7,
5.5
],
"ram_used": [
43852685312,
44052480000,
44036640768,
44033179648,
44028084224,
44053590016,
44291584000,
44290129920,
44269481984,
44257243136,
44556734464,
44502183936,
44524433408,
44526993408,
44523057152,
44523831296,
44519899136,
44508749824,
44508250112,
44527558656,
44529721344,
44527198208,
44529672192,
44530278400,
44537171968,
44538560512,
44524920832,
44552687616,
44075163648,
44090421248,
44086198272,
44085055488,
44084731904,
44364992512,
44360019968,
44359946240,
44359090176,
44604223488,
44141965312,
44142555136,
44129452032,
44121694208,
44121939968,
44354928640,
44349378560,
44349894656,
44349890560,
44144226304,
44387663872,
44206063616,
44194983936,
44169220096,
44150177792,
44142342144,
44137152512,
44138057728,
44126892032,
44160794624,
44161884160,
44383059968
],
"disk_read_mb": [
56.63,
73.79,
64.08,
89.26,
71.49,
160.33,
111.7,
115.85,
97.53,
0.0,
3.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.56,
0.02,
0.04,
0.03,
0.05,
0.01,
0.03,
0.01,
0.0,
1.14,
0.4,
0.01,
0.0,
0.03,
0.04,
0.01,
0.03,
12.58,
71.94,
32.9,
0.42,
0.53,
0.06,
0.03,
0.08,
0.09,
0.04,
0.08,
0.03,
0.02,
0.22,
0.39
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
101.47,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
121.26
]
},
"time": 1790717353.0661266
}
}
@@ -0,0 +1,585 @@
{
"label": "native-v0.1.26-Coder-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "3e44ccd7ec28",
"corpus_repeated": false,
"time": "2026-09-29T21:18:00",
"prompt_tokens": 28314,
"completion_tokens": 48,
"ttft_s": 11.385,
"e2e_s": 11.891,
"api_prompt_tps": 2486.9,
"api_decode_tps": 93.0,
"engine_prompt_tps": 2524.7,
"engine_decode_tps": 88.5,
"log_lines": [
"strata serve: prompt 28314 tokens = 0 reused + 28314 read in 11215 ms (2524.7 tok/s), 48 generated in 542 ms (88.5 tok/s), drafts accepted 34 of 36, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (24958 hits / 24960 lookups)"
],
"answer_head": "I'll first look at the repository structure to understand what files exist and identify the last file.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 4864,
"expert_cache_mib": 8968,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 9025,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716680.7795944,
"duration_s": 11.8,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 11214.6,
"decode_ms": 542.2,
"decode_tok_s": 88.5,
"hit_rate": 1.0
}
],
"requests_kept": 1,
"totals": {
"since": 1790716641.243247,
"requests": 1,
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"prompt_ms": 11214.6,
"decode_ms": 542.2
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 2,
"mem_used": 16383934464,
"mem_total": 25769803776,
"temp": 43,
"power": 147.336
},
{
"index": 1,
"util": 7,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 48,
"power": 266.007
}
],
"gpu_util": 4.5,
"gpu_mem_used": 40611217408,
"gpu_mem_total": 51539607552,
"gpu_temp": 48,
"gpu_power": 413.343,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 16.8310546875,
"gpu_pcie_tx_mb": 71.810546875,
"cpu": 8.4,
"ram_used": 44637356032,
"ram_total": 177175990272,
"disk_read_mb": 2.277384309569965,
"disk_write_mb": 0.07927603609262536,
"tok_s": 96.0473472439008,
"tok_s_mean": 90.3424282028167
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
48.0,
91.5,
69.0,
77.0,
91.0,
93.0,
49.5,
94.0,
50.0,
4.5
],
"gpu_mem_used": [
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40489582592,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40611217408
],
"gpu_temp": [
44,
43,
43,
43,
43,
43,
44,
44,
43,
44,
44,
44,
44,
44,
44,
44,
44,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
43,
49,
50,
50,
50,
50,
50,
50,
51,
51,
48
],
"gpu_power": [
253.73,
239.29,
238.99,
238.62,
238.58,
238.53,
238.39,
238.34,
238.4,
238.51,
238.61,
238.53,
238.49,
238.83,
238.96,
238.97,
226.8,
148.88,
73.97,
64.38,
63.94,
63.69,
63.56,
63.75,
63.53,
63.8,
63.68,
63.62,
63.84,
63.74,
63.81,
64.11,
63.92,
63.72,
63.85,
63.64,
63.78,
139.81,
418.68,
508.54,
520.36,
495.57,
522.4,
506.1,
501.02,
508.77,
509.32,
413.34
],
"gpu_pcie_rx_mb": [
0.67,
0.67,
0.71,
0.57,
0.62,
0.57,
0.67,
0.57,
0.67,
0.62,
0.57,
0.67,
0.62,
0.57,
1.05,
0.57,
0.76,
0.81,
0.81,
0.81,
0.76,
0.76,
0.81,
0.86,
1.43,
0.81,
0.81,
0.76,
0.86,
0.81,
0.76,
0.95,
0.86,
0.86,
0.76,
0.86,
0.86,
70.24,
68.14,
64.66,
75.24,
42.29,
84.73,
70.48,
75.05,
54.45,
44.44,
16.83
],
"cpu": [
0.0,
0.6,
1.0,
1.6,
2.5,
1.0,
3.1,
8.1,
6.5,
1.2,
1.9,
2.1,
1.5,
3.2,
2.4,
1.3,
2.0,
1.4,
1.3,
0.9,
0.9,
14.0,
6.6,
2.5,
2.7,
1.7,
1.2,
0.6,
1.1,
1.2,
1.7,
1.3,
1.4,
2.7,
4.4,
12.3,
12.4,
11.4,
12.5,
10.3,
9.0,
12.2,
12.1,
12.5,
11.3,
10.4,
5.8,
8.4
],
"ram_used": [
43649658880,
43652177920,
43664764928,
43666993152,
43672375296,
43665145856,
43695276032,
43759751168,
43760455680,
43757346816,
43754053632,
43711803392,
43717255168,
43692584960,
43693260800,
43687956480,
43682111488,
43635728384,
43632320512,
43636883456,
43633815552,
43735252992,
43881848832,
43881005056,
43875524608,
43879301120,
43878330368,
43866976256,
43862958080,
43863728128,
43854176256,
43855548416,
43854200832,
43859615744,
43895934976,
43929411584,
43962118144,
44169498624,
44107767808,
44110077952,
44109590528,
44111515648,
44233150464,
44346421248,
44340047872,
44335108096,
44329865216,
44637356032
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
129.56,
55.21,
65.53,
55.86,
128.68,
113.77,
117.74,
106.28,
68.13,
0.0,
2.28
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
96.05
]
},
"time": 1790716693.048385
}
}
@@ -0,0 +1,707 @@
{
"label": "native-v0.1.26-Coder-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "0b6b57dfa6a4",
"corpus_repeated": false,
"time": "2026-09-29T21:18:13",
"prompt_tokens": 31634,
"completion_tokens": 55,
"ttft_s": 11.855,
"e2e_s": 12.398,
"api_prompt_tps": 2668.4,
"api_decode_tps": 99.4,
"engine_prompt_tps": 2704.3,
"engine_decode_tps": 98.6,
"log_lines": [
"strata serve: prompt 31634 tokens = 0 reused + 31634 read in 11698 ms (2704.3 tok/s), 55 generated in 558 ms (98.6 tok/s), drafts accepted 38 of 44, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (29759 hits / 29760 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 4864,
"expert_cache_mib": 8968,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 9025,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716693.1835682,
"duration_s": 12.3,
"finish": "stop",
"prompt_tokens": 31634,
"reused": 0,
"output_tokens": 55,
"engine_generated": 55,
"prompt_ms": 11697.7,
"decode_ms": 557.8,
"decode_tok_s": 98.6,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790716680.7795944,
"duration_s": 11.8,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 11214.6,
"decode_ms": 542.2,
"decode_tok_s": 88.5,
"hit_rate": 1.0
}
],
"requests_kept": 2,
"totals": {
"since": 1790716641.243247,
"requests": 2,
"prompt_tokens": 59948,
"reused": 0,
"output_tokens": 103,
"prompt_ms": 22912.300000000003,
"decode_ms": 1100.0
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 30,
"mem_used": 16392323072,
"mem_total": 25769803776,
"temp": 45,
"power": 154.497
},
{
"index": 1,
"util": 0,
"mem_used": 24241963008,
"mem_total": 25769803776,
"temp": 47,
"power": 250.412
}
],
"gpu_util": 15.0,
"gpu_mem_used": 40634286080,
"gpu_mem_total": 51539607552,
"gpu_temp": 47,
"gpu_power": 404.909,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 19.310546875,
"gpu_pcie_tx_mb": 48.8271484375,
"cpu": 8.6,
"ram_used": 44481728512,
"ram_total": 177175990272,
"disk_read_mb": 1.583864660002197,
"disk_write_mb": 0.12238954190926069,
"tok_s": 112.53532236859756,
"tok_s_mean": 97.92814776699883
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
48.0,
91.5,
69.0,
77.0,
91.0,
93.0,
49.5,
94.0,
50.0,
4.5,
0.5,
94.5,
73.5,
72.5,
96.5,
49.0,
97.5,
97.5,
48.5,
94.0,
48.5,
15.0
],
"gpu_mem_used": [
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40489582592,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40634286080
],
"gpu_temp": [
44,
43,
43,
43,
43,
43,
44,
44,
43,
44,
44,
44,
44,
44,
44,
44,
44,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
43,
49,
50,
50,
50,
50,
50,
50,
51,
51,
48,
45,
51,
51,
50,
51,
51,
51,
51,
51,
51,
51,
47
],
"gpu_power": [
253.73,
239.29,
238.99,
238.62,
238.58,
238.53,
238.39,
238.34,
238.4,
238.51,
238.61,
238.53,
238.49,
238.83,
238.96,
238.97,
226.8,
148.88,
73.97,
64.38,
63.94,
63.69,
63.56,
63.75,
63.53,
63.8,
63.68,
63.62,
63.84,
63.74,
63.81,
64.11,
63.92,
63.72,
63.85,
63.64,
63.78,
139.81,
418.68,
508.54,
520.36,
495.57,
522.4,
506.1,
501.02,
508.77,
509.32,
413.34,
344.59,
491.91,
520.34,
491.14,
524.22,
495.09,
489.28,
512.02,
509.99,
497.54,
503.94,
404.91
],
"gpu_pcie_rx_mb": [
0.67,
0.67,
0.71,
0.57,
0.62,
0.57,
0.67,
0.57,
0.67,
0.62,
0.57,
0.67,
0.62,
0.57,
1.05,
0.57,
0.76,
0.81,
0.81,
0.81,
0.76,
0.76,
0.81,
0.86,
1.43,
0.81,
0.81,
0.76,
0.86,
0.81,
0.76,
0.95,
0.86,
0.86,
0.76,
0.86,
0.86,
70.24,
68.14,
64.66,
75.24,
42.29,
84.73,
70.48,
75.05,
54.45,
44.44,
16.83,
43.1,
73.43,
85.92,
85.16,
1285.6,
83.21,
5496.41,
73.67,
83.68,
89.36,
52.83,
19.31
],
"cpu": [
0.0,
0.6,
1.0,
1.6,
2.5,
1.0,
3.1,
8.1,
6.5,
1.2,
1.9,
2.1,
1.5,
3.2,
2.4,
1.3,
2.0,
1.4,
1.3,
0.9,
0.9,
14.0,
6.6,
2.5,
2.7,
1.7,
1.2,
0.6,
1.1,
1.2,
1.7,
1.3,
1.4,
2.7,
4.4,
12.3,
12.4,
11.4,
12.5,
10.3,
9.0,
12.2,
12.1,
12.5,
11.3,
10.4,
5.8,
8.4,
5.5,
16.9,
8.9,
8.2,
6.7,
6.4,
6.4,
5.5,
7.3,
10.1,
6.1,
8.6
],
"ram_used": [
43649658880,
43652177920,
43664764928,
43666993152,
43672375296,
43665145856,
43695276032,
43759751168,
43760455680,
43757346816,
43754053632,
43711803392,
43717255168,
43692584960,
43693260800,
43687956480,
43682111488,
43635728384,
43632320512,
43636883456,
43633815552,
43735252992,
43881848832,
43881005056,
43875524608,
43879301120,
43878330368,
43866976256,
43862958080,
43863728128,
43854176256,
43855548416,
43854200832,
43859615744,
43895934976,
43929411584,
43962118144,
44169498624,
44107767808,
44110077952,
44109590528,
44111515648,
44233150464,
44346421248,
44340047872,
44335108096,
44329865216,
44637356032,
44551315456,
44588969984,
44562165760,
44546224128,
44540850176,
44543295488,
44547391488,
44375429120,
44370026496,
44363567104,
44368113664,
44481728512
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
129.56,
55.21,
65.53,
55.86,
128.68,
113.77,
117.74,
106.28,
68.13,
0.0,
2.28,
1.11,
0.12,
0.02,
0.05,
0.05,
0.01,
0.03,
0.0,
25.35,
92.15,
0.01,
1.58
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
96.05,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
112.54
]
},
"time": 1790716705.9498026
}
}
@@ -0,0 +1,721 @@
{
"label": "native-v0.1.26-Coder-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "caa0b992dd74",
"corpus_repeated": false,
"time": "2026-09-29T21:18:25",
"prompt_tokens": 31601,
"completion_tokens": 45,
"ttft_s": 11.847,
"e2e_s": 12.249,
"api_prompt_tps": 2667.3,
"api_decode_tps": 109.5,
"engine_prompt_tps": 2704.5,
"engine_decode_tps": 108.1,
"log_lines": [
"strata serve: prompt 31601 tokens = 0 reused + 31601 read in 11684 ms (2704.5 tok/s), 45 generated in 416 ms (108.1 tok/s), drafts accepted 33 of 36, 2 checkpoints",
"strata serve: decode expert cache hit rate: 100.0% (24000 hits / 24000 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what we're working with.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-coder-iq1_m",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 4864,
"expert_cache_mib": 8968,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 9025,
"cvec": 0,
"arena_mib": 23981,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790716706.0904436,
"duration_s": 12.1,
"finish": "stop",
"prompt_tokens": 31601,
"reused": 0,
"output_tokens": 45,
"engine_generated": 45,
"prompt_ms": 11684.5,
"decode_ms": 416.2,
"decode_tok_s": 108.1,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790716693.1835682,
"duration_s": 12.3,
"finish": "stop",
"prompt_tokens": 31634,
"reused": 0,
"output_tokens": 55,
"engine_generated": 55,
"prompt_ms": 11697.7,
"decode_ms": 557.8,
"decode_tok_s": 98.6,
"hit_rate": 1.0
},
{
"projection": null,
"time": 1790716680.7795944,
"duration_s": 11.8,
"finish": "stop",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 11214.6,
"decode_ms": 542.2,
"decode_tok_s": 88.5,
"hit_rate": 1.0
}
],
"requests_kept": 3,
"totals": {
"since": 1790716641.243247,
"requests": 3,
"prompt_tokens": 91549,
"reused": 0,
"output_tokens": 148,
"prompt_ms": 34596.8,
"decode_ms": 1516.2
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 30,
"mem_used": 16392323072,
"mem_total": 25769803776,
"temp": 46,
"power": 161.526
},
{
"index": 1,
"util": 0,
"mem_used": 24241963008,
"mem_total": 25769803776,
"temp": 48,
"power": 223.689
}
],
"gpu_util": 15.0,
"gpu_mem_used": 40634286080,
"gpu_mem_total": 51539607552,
"gpu_temp": 48,
"gpu_power": 385.21500000000003,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.5703125,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 6.1,
"ram_used": 44274470912,
"ram_total": 177175990272,
"disk_read_mb": 0.14419269932051038,
"disk_write_mb": 0.2595468587769187,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
48.0,
91.5,
69.0,
77.0,
91.0,
93.0,
49.5,
94.0,
50.0,
4.5,
0.5,
94.5,
73.5,
72.5,
96.5,
49.0,
97.5,
97.5,
48.5,
94.0,
48.5,
15.0,
0.0,
97.5,
49.0,
93.5,
72.5,
70.5,
97.0,
95.5,
50.0,
96.0,
50.0,
15.0
],
"gpu_mem_used": [
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40426668032,
40489582592,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40521039872,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40611217408,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080,
40634286080
],
"gpu_temp": [
44,
44,
44,
44,
44,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
43,
49,
50,
50,
50,
50,
50,
50,
51,
51,
48,
45,
51,
51,
50,
51,
51,
51,
51,
51,
51,
51,
47,
45,
51,
51,
51,
51,
51,
51,
51,
51,
52,
52,
48
],
"gpu_power": [
238.49,
238.83,
238.96,
238.97,
226.8,
148.88,
73.97,
64.38,
63.94,
63.69,
63.56,
63.75,
63.53,
63.8,
63.68,
63.62,
63.84,
63.74,
63.81,
64.11,
63.92,
63.72,
63.85,
63.64,
63.78,
139.81,
418.68,
508.54,
520.36,
495.57,
522.4,
506.1,
501.02,
508.77,
509.32,
413.34,
344.59,
491.91,
520.34,
491.14,
524.22,
495.09,
489.28,
512.02,
509.99,
497.54,
503.94,
404.91,
336.42,
502.95,
510.85,
498.42,
519.36,
492.86,
501.0,
522.94,
497.46,
508.62,
494.37,
385.22
],
"gpu_pcie_rx_mb": [
0.62,
0.57,
1.05,
0.57,
0.76,
0.81,
0.81,
0.81,
0.76,
0.76,
0.81,
0.86,
1.43,
0.81,
0.81,
0.76,
0.86,
0.81,
0.76,
0.95,
0.86,
0.86,
0.76,
0.86,
0.86,
70.24,
68.14,
64.66,
75.24,
42.29,
84.73,
70.48,
75.05,
54.45,
44.44,
16.83,
43.1,
73.43,
85.92,
85.16,
1285.6,
83.21,
5496.41,
73.67,
83.68,
89.36,
52.83,
19.31,
45.11,
82.73,
85.31,
43.06,
94.36,
41.63,
73.48,
42.01,
87.26,
45.92,
121.97,
0.57
],
"cpu": [
1.5,
3.2,
2.4,
1.3,
2.0,
1.4,
1.3,
0.9,
0.9,
14.0,
6.6,
2.5,
2.7,
1.7,
1.2,
0.6,
1.1,
1.2,
1.7,
1.3,
1.4,
2.7,
4.4,
12.3,
12.4,
11.4,
12.5,
10.3,
9.0,
12.2,
12.1,
12.5,
11.3,
10.4,
5.8,
8.4,
5.5,
16.9,
8.9,
8.2,
6.7,
6.4,
6.4,
5.5,
7.3,
10.1,
6.1,
8.6,
3.1,
6.2,
9.6,
17.9,
6.1,
7.4,
6.0,
6.4,
6.4,
5.7,
5.9,
6.1
],
"ram_used": [
43717255168,
43692584960,
43693260800,
43687956480,
43682111488,
43635728384,
43632320512,
43636883456,
43633815552,
43735252992,
43881848832,
43881005056,
43875524608,
43879301120,
43878330368,
43866976256,
43862958080,
43863728128,
43854176256,
43855548416,
43854200832,
43859615744,
43895934976,
43929411584,
43962118144,
44169498624,
44107767808,
44110077952,
44109590528,
44111515648,
44233150464,
44346421248,
44340047872,
44335108096,
44329865216,
44637356032,
44551315456,
44588969984,
44562165760,
44546224128,
44540850176,
44543295488,
44547391488,
44375429120,
44370026496,
44363567104,
44368113664,
44481728512,
44224720896,
44216463360,
44188299264,
44025966592,
44017278976,
44014284800,
44060004352,
44042358784,
44044165120,
44044423168,
44044165120,
44274470912
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
129.56,
55.21,
65.53,
55.86,
128.68,
113.77,
117.74,
106.28,
68.13,
0.0,
2.28,
1.11,
0.12,
0.02,
0.05,
0.05,
0.01,
0.03,
0.0,
25.35,
92.15,
0.01,
1.58,
0.57,
0.06,
0.06,
0.05,
0.08,
0.04,
0.07,
0.01,
0.04,
0.15,
0.0,
0.14
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
96.05,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
112.54,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790716718.7022452
}
}
@@ -0,0 +1,750 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto-needle",
"mode": "needle",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "1e52cb484c7f",
"corpus_repeated": false,
"time": "2026-09-29T21:55:17",
"prompt_tokens": 17345,
"completion_tokens": 8,
"ttft_s": 23.389,
"e2e_s": 23.454,
"api_prompt_tps": 741.6,
"api_decode_tps": 106.6,
"engine_prompt_tps": 744.7,
"engine_decode_tps": 101.7,
"log_lines": [
"strata serve: prompt 17345 tokens = 0 reused + 17345 read in 23292 ms (744.7 tok/s), 8 generated in 79 ms (101.7 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.3% (4159 hits / 4317 lookups)"
],
"answer_head": "A466BDE8",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718917.8830457,
"duration_s": 23.4,
"finish": "stop",
"prompt_tokens": 17345,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 23292.2,
"decode_ms": 78.7,
"decode_tok_s": 101.7,
"hit_rate": 0.963
},
{
"projection": null,
"time": 1790718906.5660036,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 7491,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 10625.3,
"decode_ms": 109.4,
"decode_tok_s": 73.1,
"hit_rate": 0.902
},
{
"projection": null,
"time": 1790718828.4807332,
"duration_s": 42.6,
"finish": "stop",
"prompt_tokens": 31604,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 42110.8,
"decode_ms": 460.9,
"decode_tok_s": 106.3,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 5,
"totals": {
"since": 1790718725.4039552,
"requests": 5,
"prompt_tokens": 116388,
"reused": 0,
"output_tokens": 237,
"prompt_ms": 157531.5,
"decode_ms": 2436.8
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 5,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 46,
"power": 125.093
},
{
"index": 1,
"util": 0,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 51,
"power": 215.964
}
],
"gpu_util": 2.5,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 51,
"gpu_power": 341.057,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 16.5,
"ram_used": 70477971456,
"ram_total": 177175990272,
"disk_read_mb": 0.17303348536954039,
"disk_write_mb": 0.0036048642785320916,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
37.0,
28.0,
22.5,
30.0,
37.0,
18.0,
29.0,
22.0,
21.0,
0.5,
50.0,
34.5,
25.0,
60.5,
31.5,
26.0,
33.5,
46.5,
25.0,
31.5,
21.0,
30.0,
35.0,
37.0,
32.5,
22.0,
26.5,
19.5,
49.5,
26.5,
21.0,
2.5
],
"gpu_mem_used": [
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
45,
45,
45,
45,
45,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
50,
49,
51,
51,
51,
51,
50,
51,
52,
50,
49,
49,
51,
52,
50,
52,
51,
51,
51,
51,
52,
51,
52,
51,
51,
52,
52,
51,
52,
52,
53,
51
],
"gpu_power": [
242.53,
242.44,
242.38,
242.52,
242.49,
242.46,
242.59,
242.37,
242.36,
242.5,
242.54,
140.5,
84.6,
65.59,
65.03,
64.81,
64.81,
64.9,
64.51,
64.65,
64.87,
64.67,
64.8,
64.5,
64.56,
64.64,
64.52,
64.48,
252.37,
388.02,
363.78,
375.15,
399.66,
368.5,
396.75,
362.75,
365.62,
336.59,
296.73,
407.69,
367.08,
376.76,
397.12,
384.8,
382.99,
408.25,
371.72,
397.41,
373.98,
388.78,
413.99,
362.47,
402.46,
358.68,
403.34,
387.12,
369.06,
426.5,
375.9,
341.06
],
"gpu_pcie_rx_mb": [
0.62,
0.62,
0.67,
0.67,
0.67,
0.62,
0.62,
0.57,
0.62,
0.67,
0.71,
0.81,
0.81,
0.86,
0.81,
0.86,
0.81,
0.86,
0.76,
0.81,
0.86,
0.81,
0.95,
0.81,
0.86,
0.86,
0.86,
0.71,
7078.07,
5438.42,
7891.61,
5618.71,
5824.99,
6656.5,
6553.84,
1295.8,
3929.76,
0.67,
7089.76,
6013.73,
7916.07,
5803.39,
5749.08,
4295.01,
6229.4,
7158.52,
6448.94,
8972.07,
4133.89,
5762.81,
4218.58,
7081.13,
5446.96,
19399.45,
7164.1,
6657.41,
4340.22,
8272.65,
7551.43,
0.67
],
"cpu": [
1.4,
3.7,
2.4,
2.6,
2.2,
1.6,
7.0,
7.8,
0.8,
3.8,
6.2,
1.4,
1.5,
1.3,
0.5,
0.8,
1.4,
1.7,
1.4,
1.5,
8.2,
9.2,
2.9,
5.7,
1.3,
5.6,
1.2,
7.3,
6.3,
9.1,
6.4,
7.4,
6.7,
6.4,
16.3,
9.8,
6.3,
19.7,
4.9,
6.7,
5.5,
6.3,
6.2,
6.4,
7.1,
6.3,
6.6,
6.4,
16.7,
8.7,
6.4,
6.7,
6.7,
6.4,
6.1,
7.1,
5.5,
9.0,
6.7,
16.5
],
"ram_used": [
70616137728,
70634639360,
70632943616,
70619291648,
70622433280,
70624546816,
70651342848,
70754201600,
70754394112,
70772871168,
70811869184,
70806048768,
70788648960,
70775001088,
70770065408,
70761766912,
70762528768,
70758371328,
70767398912,
70768398336,
70723190784,
70684524544,
70713102336,
70694293504,
70656102400,
70685872128,
70679355392,
70251024384,
70250827776,
70240993280,
70217400320,
70216302592,
70220156928,
70211788800,
70218944512,
70240178176,
70232375296,
70472826880,
70432313344,
70401486848,
70392971264,
70382305280,
70365552640,
70356713472,
70348333056,
70341337088,
70134956032,
70120873984,
70109106176,
70101512192,
70084435968,
70076407808,
70066089984,
70059646976,
70027522048,
70087983104,
70087725056,
70115901440,
70239928320,
70477971456
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.04,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.46,
0.01,
0.0,
0.0,
0.82,
0.0,
0.0,
0.0,
0.0,
0.0,
0.2,
0.52,
0.0,
0.0,
0.0,
0.0,
0.59,
0.0,
0.0,
0.02,
0.0,
0.04,
0.0,
0.0,
0.05,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.17
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790718941.76262
}
}
@@ -0,0 +1,764 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto-needle",
"mode": "needle",
"ctx": "28k",
"target_tokens": 28672,
"run": 1,
"run_id": "c61aafff2d90",
"corpus_repeated": false,
"time": "2026-09-29T21:55:41",
"prompt_tokens": 29827,
"completion_tokens": 8,
"ttft_s": 39.958,
"e2e_s": 40.036,
"api_prompt_tps": 746.5,
"api_decode_tps": 89.7,
"engine_prompt_tps": 749.2,
"engine_decode_tps": 85.9,
"log_lines": [
"strata serve: prompt 29827 tokens = 0 reused + 29827 read in 39812 ms (749.2 tok/s), 8 generated in 93 ms (85.9 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.2% (4154 hits / 4318 lookups)"
],
"answer_head": "7BDBA3C1",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718941.8879943,
"duration_s": 39.9,
"finish": "stop",
"prompt_tokens": 29827,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 39812.1,
"decode_ms": 93.1,
"decode_tok_s": 85.9,
"hit_rate": 0.962
},
{
"projection": null,
"time": 1790718917.8830457,
"duration_s": 23.4,
"finish": "stop",
"prompt_tokens": 17345,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 23292.2,
"decode_ms": 78.7,
"decode_tok_s": 101.7,
"hit_rate": 0.963
},
{
"projection": null,
"time": 1790718906.5660036,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 7491,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 10625.3,
"decode_ms": 109.4,
"decode_tok_s": 73.1,
"hit_rate": 0.902
},
{
"projection": null,
"time": 1790718828.4807332,
"duration_s": 42.6,
"finish": "stop",
"prompt_tokens": 31604,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 42110.8,
"decode_ms": 460.9,
"decode_tok_s": 106.3,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 6,
"totals": {
"since": 1790718725.4039552,
"requests": 6,
"prompt_tokens": 146215,
"reused": 0,
"output_tokens": 245,
"prompt_ms": 197343.6,
"decode_ms": 2529.9
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 0,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 47,
"power": 130.942
},
{
"index": 1,
"util": 42,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 53,
"power": 227.639
}
],
"gpu_util": 21.0,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 358.581,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 6.3,
"ram_used": 70479159296,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.014414807554752778,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
50.0,
34.5,
25.0,
60.5,
31.5,
26.0,
33.5,
46.5,
25.0,
31.5,
21.0,
30.0,
35.0,
37.0,
32.5,
22.0,
26.5,
19.5,
49.5,
26.5,
21.0,
2.5,
50.5,
42.0,
43.0,
38.0,
32.0,
21.5,
29.0,
34.0,
13.5,
36.0,
23.0,
30.0,
11.0,
77.5,
34.5,
23.5,
29.0,
17.5,
69.0,
34.5,
23.5,
32.5,
24.5,
57.5,
32.0,
26.0,
33.5,
25.0,
32.0,
32.5,
22.5,
36.0,
37.0,
36.5,
28.5,
42.5,
21.0
],
"gpu_mem_used": [
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
50,
49,
49,
51,
52,
50,
52,
51,
51,
51,
51,
52,
51,
52,
51,
51,
52,
52,
51,
52,
52,
53,
51,
50,
50,
51,
53,
51,
52,
52,
51,
52,
51,
52,
52,
52,
53,
52,
52,
51,
51,
53,
52,
52,
52,
52,
52,
51,
53,
52,
52,
52,
52,
53,
52,
53,
52,
53,
52,
53
],
"gpu_power": [
336.59,
296.73,
407.69,
367.08,
376.76,
397.12,
384.8,
382.99,
408.25,
371.72,
397.41,
373.98,
388.78,
413.99,
362.47,
402.46,
358.68,
403.34,
387.12,
369.06,
426.5,
375.9,
341.06,
316.12,
396.45,
370.14,
378.61,
411.6,
381.87,
383.44,
399.03,
378.32,
399.6,
372.43,
400.43,
390.19,
384.29,
405.22,
398.65,
405.33,
377.77,
347.82,
408.44,
395.16,
399.76,
391.18,
383.68,
395.97,
381.79,
371.58,
387.34,
367.36,
390.18,
377.99,
404.54,
406.77,
371.21,
404.91,
389.57,
358.58
],
"gpu_pcie_rx_mb": [
0.67,
7089.76,
6013.73,
7916.07,
5803.39,
5749.08,
4295.01,
6229.4,
7158.52,
6448.94,
8972.07,
4133.89,
5762.81,
4218.58,
7081.13,
5446.96,
19399.45,
7164.1,
6657.41,
4340.22,
8272.65,
7551.43,
0.67,
5912.64,
6668.66,
4836.32,
15187.07,
6919.96,
7012.13,
4668.04,
8340.98,
5615.52,
6986.24,
8358.29,
8231.35,
7154.13,
6558.46,
5322.65,
14744.81,
6437.3,
7645.75,
4067.04,
5734.82,
1.62,
5507.04,
5994.7,
5715.7,
6093.12,
89.88,
6215.57,
4331.35,
6045.63,
5971.19,
6178.04,
5846.59,
7484.53,
5744.65,
5095.67,
7809.07,
0.67
],
"cpu": [
19.7,
4.9,
6.7,
5.5,
6.3,
6.2,
6.4,
7.1,
6.3,
6.6,
6.4,
16.7,
8.7,
6.4,
6.7,
6.7,
6.4,
6.1,
7.1,
5.5,
9.0,
6.7,
16.5,
4.3,
8.5,
17.0,
10.5,
8.0,
8.5,
6.2,
6.8,
6.0,
6.0,
5.6,
6.4,
7.1,
5.6,
6.3,
11.3,
13.8,
13.6,
7.0,
5.8,
6.1,
6.1,
6.3,
6.2,
6.0,
9.3,
6.5,
6.1,
6.0,
14.5,
11.7,
5.6,
8.6,
7.7,
6.1,
6.7,
6.3
],
"ram_used": [
70472826880,
70432313344,
70401486848,
70392971264,
70382305280,
70365552640,
70356713472,
70348333056,
70341337088,
70134956032,
70120873984,
70109106176,
70101512192,
70084435968,
70076407808,
70066089984,
70059646976,
70027522048,
70087983104,
70087725056,
70115901440,
70239928320,
70477971456,
70343557120,
70337265664,
70309584896,
70434922496,
70428250112,
70420987904,
70412926976,
70409207808,
70400454656,
70391336960,
70383079424,
70374731776,
70367465472,
70359465984,
70354010112,
70334316544,
70343401472,
70345613312,
70344155136,
70340018176,
70356168704,
70375772160,
70372450304,
70371860480,
70366474240,
70373842944,
70374035456,
70365605888,
70363926528,
70340509696,
70341251072,
70340546560,
70343122944,
70346379264,
70347120640,
70345048064,
70479159296
],
"disk_read_mb": [
0.2,
0.52,
0.0,
0.0,
0.0,
0.0,
0.59,
0.0,
0.0,
0.02,
0.0,
0.04,
0.0,
0.0,
0.05,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.17,
0.53,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.6,
0.0,
0.03,
0.0,
0.0,
0.05,
0.0,
0.0,
0.05,
0.0,
0.05,
0.0,
0.0,
0.03,
0.0,
0.04,
0.0,
0.0,
0.18,
0.0,
0.0,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790718982.302463
}
}
@@ -0,0 +1,736 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto-needle",
"mode": "needle",
"ctx": "8k",
"target_tokens": 8192,
"run": 1,
"run_id": "7c040dd4c6d7",
"corpus_repeated": false,
"time": "2026-09-29T21:55:06",
"prompt_tokens": 7491,
"completion_tokens": 8,
"ttft_s": 10.682,
"e2e_s": 10.776,
"api_prompt_tps": 701.3,
"api_decode_tps": 74.7,
"engine_prompt_tps": 705.0,
"engine_decode_tps": 73.1,
"log_lines": [
"strata serve: prompt 7491 tokens = 0 reused + 7491 read in 10625 ms (705.0 tok/s), 8 generated in 109 ms (73.1 tok/s), drafts accepted 6 of 6, 1 checkpoints",
"strata serve: decode expert cache hit rate: 90.2% (3891 hits / 4313 lookups)"
],
"answer_head": "C43C98BD",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718906.5660036,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 7491,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 10625.3,
"decode_ms": 109.4,
"decode_tok_s": 73.1,
"hit_rate": 0.902
},
{
"projection": null,
"time": 1790718828.4807332,
"duration_s": 42.6,
"finish": "stop",
"prompt_tokens": 31604,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 42110.8,
"decode_ms": 460.9,
"decode_tok_s": 106.3,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 4,
"totals": {
"since": 1790718725.4039552,
"requests": 4,
"prompt_tokens": 99043,
"reused": 0,
"output_tokens": 229,
"prompt_ms": 134239.3,
"decode_ms": 2358.1000000000004
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 1,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 46,
"power": 122.865
},
{
"index": 1,
"util": 0,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 50,
"power": 213.727
}
],
"gpu_util": 0.5,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 50,
"gpu_power": 336.592,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 19.7,
"ram_used": 70472826880,
"ram_total": 177175990272,
"disk_read_mb": 0.2018157842351215,
"disk_write_mb": 0.28470440990311785,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
25.0,
33.5,
47.0,
15.5,
32.5,
24.0,
32.5,
29.0,
55.0,
34.0,
48.0,
33.0,
22.5,
31.5,
24.5,
20.0,
20.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
37.0,
28.0,
22.5,
30.0,
37.0,
18.0,
29.0,
22.0,
21.0,
0.5
],
"gpu_mem_used": [
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
51,
50,
51,
51,
51,
51,
51,
51,
51,
50,
52,
52,
52,
51,
52,
52,
50,
49,
49,
49,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
45,
45,
45,
45,
45,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
50,
49,
51,
51,
51,
51,
50,
51,
52,
50
],
"gpu_power": [
380.19,
386.69,
409.76,
359.41,
400.68,
368.54,
396.07,
393.99,
371.52,
407.92,
367.65,
416.33,
386.19,
394.79,
409.75,
373.56,
329.84,
371.48,
309.69,
279.06,
254.32,
242.47,
242.53,
242.44,
242.38,
242.52,
242.49,
242.46,
242.59,
242.37,
242.36,
242.5,
242.54,
140.5,
84.6,
65.59,
65.03,
64.81,
64.81,
64.9,
64.51,
64.65,
64.87,
64.67,
64.8,
64.5,
64.56,
64.64,
64.52,
64.48,
252.37,
388.02,
363.78,
375.15,
399.66,
368.5,
396.75,
362.75,
365.62,
336.59
],
"gpu_pcie_rx_mb": [
5368.61,
7806.78,
7675.93,
8469.58,
5669.88,
14723.06,
5790.85,
6188.01,
6980.23,
7332.23,
12898.87,
6754.21,
6340.74,
6000.61,
6420.09,
4455.66,
19.74,
0.62,
0.62,
0.57,
0.67,
0.62,
0.62,
0.62,
0.67,
0.67,
0.67,
0.62,
0.62,
0.57,
0.62,
0.67,
0.71,
0.81,
0.81,
0.86,
0.81,
0.86,
0.81,
0.86,
0.76,
0.81,
0.86,
0.81,
0.95,
0.81,
0.86,
0.86,
0.86,
0.71,
7078.07,
5438.42,
7891.61,
5618.71,
5824.99,
6656.5,
6553.84,
1295.8,
3929.76,
0.67
],
"cpu": [
7.3,
17.5,
8.0,
7.9,
6.6,
6.2,
6.2,
6.1,
6.6,
5.7,
6.8,
7.1,
7.8,
6.2,
9.8,
15.0,
32.2,
20.2,
4.3,
11.3,
2.0,
1.5,
1.4,
3.7,
2.4,
2.6,
2.2,
1.6,
7.0,
7.8,
0.8,
3.8,
6.2,
1.4,
1.5,
1.3,
0.5,
0.8,
1.4,
1.7,
1.4,
1.5,
8.2,
9.2,
2.9,
5.7,
1.3,
5.6,
1.2,
7.3,
6.3,
9.1,
6.4,
7.4,
6.7,
6.4,
16.3,
9.8,
6.3,
19.7
],
"ram_used": [
70159552512,
70270476288,
70270668800,
70271184896,
70263926784,
70264184832,
70264291328,
70265167872,
70267035648,
70267035648,
70264389632,
70261067776,
70265782272,
70268100608,
70275043328,
70091866112,
70312075264,
70311395328,
70465576960,
70613889024,
70610006016,
70609461248,
70616137728,
70634639360,
70632943616,
70619291648,
70622433280,
70624546816,
70651342848,
70754201600,
70754394112,
70772871168,
70811869184,
70806048768,
70788648960,
70775001088,
70770065408,
70761766912,
70762528768,
70758371328,
70767398912,
70768398336,
70723190784,
70684524544,
70713102336,
70694293504,
70656102400,
70685872128,
70679355392,
70251024384,
70250827776,
70240993280,
70217400320,
70216302592,
70220156928,
70211788800,
70218944512,
70240178176,
70232375296,
70472826880
],
"disk_read_mb": [
0.0,
0.04,
0.0,
0.01,
0.0,
0.02,
0.0,
0.0,
0.01,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.09,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.04,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.46,
0.01,
0.0,
0.0,
0.82,
0.0,
0.0,
0.0,
0.0,
0.0,
0.2
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.75,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790718917.804988
}
}
@@ -0,0 +1,797 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto-two-turn",
"mode": "two-turn",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "2fd93144a29a",
"corpus_repeated": false,
"time": "2026-09-29T21:56:47",
"prompt_tokens": 15639,
"completion_tokens": 83,
"ttft_s": 21.242,
"e2e_s": 22.071,
"api_prompt_tps": 736.2,
"api_decode_tps": 98.8,
"engine_prompt_tps": 739.4,
"engine_decode_tps": 98.3,
"log_lines": [
"strata serve: prompt 15639 tokens = 0 reused + 15639 read in 21151 ms (739.4 tok/s), 83 generated in 844 ms (98.3 tok/s), drafts accepted 53 of 73, 1 checkpoints",
"strata serve: decode expert cache hit rate: 98.5% (48689 hits / 49415 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there.",
"turn2_ttft_s": 0.627,
"turn2_prompt_tokens": 15676,
"turn2_log_lines": [
"strata serve: prompt 15676 tokens = 15632 reused + 44 read in 521 ms (84.4 tok/s), 64 generated in 739 ms (86.6 tok/s), drafts accepted 37 of 52, 2 checkpoints",
"strata serve: decode expert cache hit rate: 97.1% (36768 hits / 37868 lookups)"
],
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790719030.332211,
"duration_s": 1.3,
"finish": "length",
"prompt_tokens": 15676,
"reused": 15632,
"output_tokens": 64,
"engine_generated": 64,
"prompt_ms": 521.0,
"decode_ms": 739.1,
"decode_tok_s": 86.6,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790719007.7458334,
"duration_s": 22.0,
"finish": "stop",
"prompt_tokens": 15639,
"reused": 0,
"output_tokens": 83,
"engine_generated": 83,
"prompt_ms": 21150.9,
"decode_ms": 844.3,
"decode_tok_s": 98.3,
"hit_rate": 0.985
},
{
"projection": null,
"time": 1790718941.8879943,
"duration_s": 39.9,
"finish": "stop",
"prompt_tokens": 29827,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 39812.1,
"decode_ms": 93.1,
"decode_tok_s": 85.9,
"hit_rate": 0.962
},
{
"projection": null,
"time": 1790718917.8830457,
"duration_s": 23.4,
"finish": "stop",
"prompt_tokens": 17345,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 23292.2,
"decode_ms": 78.7,
"decode_tok_s": 101.7,
"hit_rate": 0.963
},
{
"projection": null,
"time": 1790718906.5660036,
"duration_s": 10.7,
"finish": "stop",
"prompt_tokens": 7491,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 10625.3,
"decode_ms": 109.4,
"decode_tok_s": 73.1,
"hit_rate": 0.902
},
{
"projection": null,
"time": 1790718828.4807332,
"duration_s": 42.6,
"finish": "stop",
"prompt_tokens": 31604,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 42110.8,
"decode_ms": 460.9,
"decode_tok_s": 106.3,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 8,
"totals": {
"since": 1790718725.4039552,
"requests": 8,
"prompt_tokens": 177530,
"reused": 15632,
"output_tokens": 392,
"prompt_ms": 219015.5,
"decode_ms": 4113.3
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 41,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 50,
"power": 209.466
},
{
"index": 1,
"util": 49,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 53,
"power": 186.867
}
],
"gpu_util": 45.0,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 396.33299999999997,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 2090.7392578125,
"gpu_pcie_tx_mb": 103.1865234375,
"cpu": 82.0,
"ram_used": 70765735936,
"ram_total": 177175990272,
"disk_read_mb": 3.548661248401337,
"disk_write_mb": 0.003595401467478558,
"tok_s": 85.02069488627261,
"tok_s_mean": 85.60127593635436
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
57.5,
32.0,
26.0,
33.5,
25.0,
32.0,
32.5,
22.5,
36.0,
37.0,
36.5,
28.5,
42.5,
21.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
32.0,
30.5,
25.5,
63.5,
34.5,
24.5,
36.0,
38.0,
28.0,
33.0,
21.5,
25.0,
41.5,
33.0,
30.0,
22.0,
29.5,
19.5,
23.5,
48.0,
0.0,
45.0
],
"gpu_mem_used": [
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
52,
51,
53,
52,
52,
52,
52,
53,
52,
53,
52,
53,
52,
53,
51,
50,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
47,
46,
46,
46,
46,
45,
45,
45,
51,
51,
51,
52,
51,
53,
52,
53,
52,
52,
53,
52,
53,
52,
52,
53,
53,
53,
53,
53,
51,
53
],
"gpu_power": [
383.68,
395.97,
381.79,
371.58,
387.34,
367.36,
390.18,
377.99,
404.54,
406.77,
371.21,
404.91,
389.57,
358.58,
310.16,
278.39,
242.88,
242.69,
242.56,
242.41,
242.25,
242.45,
242.44,
242.38,
242.25,
242.18,
242.52,
242.57,
242.25,
242.23,
197.61,
110.58,
65.55,
65.12,
65.0,
65.02,
65.01,
64.82,
155.28,
410.36,
361.72,
382.57,
404.0,
377.89,
389.35,
407.89,
389.48,
386.49,
371.41,
379.85,
411.79,
387.4,
395.89,
369.99,
400.03,
390.77,
393.61,
354.25,
413.98,
396.33
],
"gpu_pcie_rx_mb": [
5715.7,
6093.12,
89.88,
6215.57,
4331.35,
6045.63,
5971.19,
6178.04,
5846.59,
7484.53,
5744.65,
5095.67,
7809.07,
0.67,
0.71,
0.57,
0.67,
0.62,
0.62,
0.57,
0.71,
0.62,
0.57,
0.67,
0.62,
0.62,
0.57,
0.62,
0.62,
0.71,
0.91,
0.81,
0.76,
0.81,
0.76,
0.81,
0.86,
0.86,
6219.24,
5437.52,
6447.08,
6610.58,
6506.2,
88.93,
6106.14,
6218.53,
5297.85,
8021.88,
67.85,
4886.82,
6395.77,
5794.95,
5961.99,
92.79,
4561.42,
5886.93,
4115.39,
15.07,
6036.38,
2090.74
],
"cpu": [
6.2,
6.0,
9.3,
6.5,
6.1,
6.0,
14.5,
11.7,
5.6,
8.6,
7.7,
6.1,
6.7,
6.3,
15.2,
4.0,
11.7,
1.7,
0.8,
1.6,
10.1,
8.8,
1.8,
3.0,
2.0,
1.1,
3.9,
2.5,
1.2,
1.0,
4.4,
2.2,
2.1,
1.1,
9.2,
4.0,
0.7,
12.8,
6.2,
7.1,
6.6,
6.1,
5.7,
6.8,
7.9,
5.9,
6.1,
7.1,
16.6,
14.8,
6.4,
6.7,
6.6,
7.0,
6.5,
7.1,
6.4,
44.5,
46.9,
82.0
],
"ram_used": [
70371860480,
70366474240,
70373842944,
70374035456,
70365605888,
70363926528,
70340509696,
70341251072,
70340546560,
70343122944,
70346379264,
70347120640,
70345048064,
70479159296,
70572703744,
70652428288,
70736793600,
70729584640,
70733873152,
70729728000,
70753632256,
70894960640,
70882795520,
70887088128,
70877409280,
70896922624,
70917816320,
70944993280,
70949908480,
70948433920,
70969233408,
70968532992,
70973911040,
70965530624,
70981591040,
70982193152,
70979321856,
71007891456,
70533447680,
70536957952,
70444630016,
70438658048,
70435995648,
70428848128,
70422986752,
70424240128,
70404268032,
70411444224,
70518763520,
70541369344,
70539395072,
70538240000,
70528540672,
70514954240,
70316679168,
70304641024,
70310481920,
70539440128,
70546964480,
70765735936
],
"disk_read_mb": [
0.05,
0.0,
0.0,
0.03,
0.0,
0.04,
0.0,
0.0,
0.18,
0.0,
0.0,
0.0,
0.0,
0.0,
0.15,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.48,
0.01,
0.0,
0.0,
0.0,
0.0,
0.02,
0.0,
0.01,
0.0,
0.03,
0.0,
0.0,
0.21,
0.0,
0.0,
0.0,
0.0,
0.0,
0.21,
0.47,
3.55
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
106.42,
0.0,
85.02
]
},
"time": 1790719032.1000419
}
}
@@ -0,0 +1,648 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "e13c9cdd6797",
"corpus_repeated": false,
"time": "2026-09-29T21:52:23",
"prompt_tokens": 28315,
"completion_tokens": 84,
"ttft_s": 39.45,
"e2e_s": 40.422,
"api_prompt_tps": 717.7,
"api_decode_tps": 85.4,
"engine_prompt_tps": 720.7,
"engine_decode_tps": 83.1,
"log_lines": [
"strata serve: prompt 28315 tokens = 0 reused + 28315 read in 39287 ms (720.7 tok/s), 84 generated in 1011 ms (83.1 tok/s), drafts accepted 56 of 67, 2 checkpoints",
"strata serve: decode expert cache hit rate: 94.9% (43073 hits / 45377 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand the context and find the relevant files.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 1,
"totals": {
"since": 1790718725.4039552,
"requests": 1,
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 39,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 45,
"power": 141.739
},
{
"index": 1,
"util": 48,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 50,
"power": 205.268
}
],
"gpu_util": 43.5,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 50,
"gpu_power": 347.007,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 6170.3671875,
"gpu_pcie_tx_mb": 126.7900390625,
"cpu": 85.9,
"ram_used": 70739390464,
"ram_total": 177175990272,
"disk_read_mb": 3.315986845192439,
"disk_write_mb": 0.09340808014626588,
"tok_s": 93.51552437654362,
"tok_s_mean": 85.24938371584437
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
57.0,
32.5,
23.5,
25.0,
22.0,
51.0,
35.5,
33.0,
27.5,
26.0,
41.0,
33.0,
23.5,
29.5,
27.5,
71.0,
31.5,
21.5,
64.0,
36.5,
20.5,
32.5,
30.5,
22.0,
29.0,
24.5,
30.0,
17.5,
76.0,
25.0,
20.5,
30.0,
23.0,
19.0,
24.0,
43.5
],
"gpu_mem_used": [
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49224220672,
49316495360,
49326981120,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49440227328
],
"gpu_temp": [
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
42,
44,
47,
46,
49,
47,
49,
49,
49,
49,
48,
49,
48,
48,
49,
48,
48,
50,
48,
48,
48,
48,
49,
48,
48,
49,
48,
50,
49,
49,
51,
48,
50,
48,
49,
50,
50,
50
],
"gpu_power": [
239.92,
240.19,
239.81,
239.35,
239.3,
239.28,
239.24,
239.29,
239.41,
239.46,
239.45,
239.36,
239.21,
239.26,
239.32,
239.37,
225.06,
145.42,
158.12,
371.86,
384.05,
358.93,
405.61,
381.25,
384.16,
389.93,
395.3,
399.41,
384.35,
363.41,
386.79,
392.7,
344.05,
389.76,
383.66,
397.8,
373.05,
366.9,
391.72,
366.3,
381.76,
387.41,
366.67,
395.88,
403.84,
386.94,
392.83,
352.42,
402.48,
392.8,
357.94,
383.58,
359.24,
350.73,
347.01
],
"gpu_pcie_rx_mb": [
0.62,
0.67,
0.67,
0.62,
0.62,
0.57,
0.57,
0.57,
0.62,
0.67,
0.67,
0.62,
0.62,
0.62,
0.62,
0.62,
0.76,
14.92,
6198.41,
7236.0,
8724.26,
3654.86,
5959.32,
6449.94,
6329.34,
7285.26,
4763.84,
6812.52,
7321.69,
6494.14,
5619.86,
6789.97,
5793.67,
5562.64,
2331.69,
6177.52,
8354.0,
7435.75,
4811.38,
1.43,
7506.18,
7562.16,
2886.44,
7184.17,
6752.54,
7546.95,
7499.69,
4610.3,
6852.1,
6167.22,
5107.31,
7326.55,
4237.65,
0.67,
6170.37
],
"cpu": [
100.0,
1.4,
1.1,
0.9,
1.2,
2.3,
0.9,
1.3,
9.5,
5.4,
6.6,
4.7,
1.3,
1.2,
1.8,
2.0,
0.8,
11.3,
10.6,
10.4,
5.7,
6.8,
17.0,
10.2,
8.1,
7.1,
6.9,
7.6,
9.8,
9.9,
5.8,
6.7,
11.0,
6.0,
9.4,
6.2,
15.2,
12.9,
8.4,
7.2,
10.2,
6.1,
10.5,
6.4,
6.0,
9.0,
7.4,
8.9,
6.9,
8.7,
15.6,
12.0,
6.3,
6.8,
85.9
],
"ram_used": [
70239571968,
70088245248,
70096302080,
70097154048,
70103457792,
70078648320,
70084857856,
70088122368,
70148214784,
70162341888,
70191161344,
70190673920,
70184566784,
70184079360,
70179979264,
70173462528,
70171906048,
70119723008,
70266146816,
70263320576,
70263308288,
70262693888,
70372823040,
70378594304,
70380400640,
70383910912,
70389587968,
70366543872,
70385344512,
70382903296,
70379986944,
70372298752,
70358667264,
70367678464,
70356070400,
70353756160,
70321405952,
70284603392,
70262280192,
70387703808,
70314864640,
70312120320,
70299967488,
70299987968,
70294355968,
70301368320,
70293327872,
70290792448,
70280925184,
70300200960,
70377836544,
70448394240,
70448910336,
70574612480,
70739390464
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
4.75,
124.76,
40.78,
0.0,
7.5,
16.84,
0.0,
55.72,
0.0,
13.03,
20.5,
0.0,
67.32,
0.0,
0.0,
83.74,
0.0,
80.89,
0.0,
0.0,
71.3,
0.0,
0.0,
79.43,
0.0,
72.4,
4.53,
0.0,
54.62,
0.0,
42.73,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
3.32
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
93.52
]
},
"time": 1790718784.6773934
}
}
@@ -0,0 +1,707 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "f953f67441b4",
"corpus_repeated": false,
"time": "2026-09-29T21:53:04",
"prompt_tokens": 31633,
"completion_tokens": 88,
"ttft_s": 42.403,
"e2e_s": 43.165,
"api_prompt_tps": 746.0,
"api_decode_tps": 114.2,
"engine_prompt_tps": 749.3,
"engine_decode_tps": 113.3,
"log_lines": [
"strata serve: prompt 31633 tokens = 0 reused + 31633 read in 42217 ms (749.3 tok/s), 88 generated in 777 ms (113.3 tok/s), drafts accepted 61 of 69, 2 checkpoints",
"strata serve: decode expert cache hit rate: 97.8% (45031 hits / 46048 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the \"last file\" being referenced.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 2,
"totals": {
"since": 1790718725.4039552,
"requests": 2,
"prompt_tokens": 59948,
"reused": 0,
"output_tokens": 172,
"prompt_ms": 81503.2,
"decode_ms": 1787.8000000000002
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 43,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 46,
"power": 127.404
},
{
"index": 1,
"util": 22,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 50,
"power": 202.736
}
],
"gpu_util": 32.5,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 50,
"gpu_power": 330.14,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 50.97265625,
"gpu_pcie_tx_mb": 74.43359375,
"cpu": 47.4,
"ram_used": 70762872832,
"ram_total": 177175990272,
"disk_read_mb": 0.9085358249169909,
"disk_write_mb": 0.21546304148229034,
"tok_s": 110.51273259801776,
"tok_s_mean": 104.51731108020398
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
31.5,
21.5,
64.0,
36.5,
20.5,
32.5,
30.5,
22.0,
29.0,
24.5,
30.0,
17.5,
76.0,
25.0,
20.5,
30.0,
23.0,
19.0,
24.0,
43.5,
0.0,
41.5,
33.5,
27.5,
34.0,
22.0,
61.5,
37.0,
23.5,
24.5,
28.5,
54.0,
41.5,
89.5,
30.5,
21.0,
32.0,
33.5,
24.5,
26.0,
25.5,
38.5,
31.5,
24.5,
30.0,
26.0,
31.5,
19.0,
86.5,
28.0,
22.5,
32.0,
26.0,
77.5,
22.5,
22.5,
34.0,
26.0,
20.5,
32.5
],
"gpu_mem_used": [
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49333272576,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
48,
48,
48,
48,
49,
48,
48,
49,
48,
50,
49,
49,
51,
48,
50,
48,
49,
50,
50,
50,
47,
48,
48,
50,
49,
50,
49,
49,
50,
49,
50,
49,
50,
51,
49,
50,
50,
49,
50,
50,
51,
50,
49,
50,
49,
51,
49,
50,
51,
49,
50,
50,
51,
52,
50,
50,
50,
51,
52,
50
],
"gpu_power": [
397.8,
373.05,
366.9,
391.72,
366.3,
381.76,
387.41,
366.67,
395.88,
403.84,
386.94,
392.83,
352.42,
402.48,
392.8,
357.94,
383.58,
359.24,
350.73,
347.01,
325.66,
372.55,
370.97,
352.05,
397.27,
391.66,
343.17,
403.13,
366.16,
402.14,
390.68,
396.82,
401.28,
360.7,
398.3,
366.48,
382.49,
395.03,
366.16,
401.29,
385.57,
368.88,
396.03,
374.4,
393.23,
385.24,
406.68,
391.86,
364.28,
409.58,
388.38,
389.1,
390.65,
372.81,
415.25,
390.44,
384.85,
382.05,
377.98,
330.14
],
"gpu_pcie_rx_mb": [
6177.52,
8354.0,
7435.75,
4811.38,
1.43,
7506.18,
7562.16,
2886.44,
7184.17,
6752.54,
7546.95,
7499.69,
4610.3,
6852.1,
6167.22,
5107.31,
7326.55,
4237.65,
0.67,
6170.37,
5107.54,
5192.28,
6336.26,
3422.45,
4911.8,
7759.14,
6146.0,
4671.1,
9668.92,
5712.17,
6061.89,
4888.06,
5886.08,
9090.42,
5683.33,
6294.68,
7625.39,
4995.82,
12979.6,
4392.43,
6062.41,
5581.95,
5691.53,
8234.83,
8344.89,
7880.73,
6094.07,
8294.58,
5858.85,
5465.17,
6922.82,
4432.29,
6296.59,
5837.44,
7103.97,
7604.84,
4756.35,
4899.02,
5517.96,
50.97
],
"cpu": [
6.2,
15.2,
12.9,
8.4,
7.2,
10.2,
6.1,
10.5,
6.4,
6.0,
9.0,
7.4,
8.9,
6.9,
8.7,
15.6,
12.0,
6.3,
6.8,
85.9,
9.8,
9.7,
6.7,
6.6,
6.8,
7.4,
7.1,
7.1,
12.2,
13.8,
6.7,
8.5,
6.5,
6.1,
6.4,
6.5,
6.1,
7.2,
6.6,
7.4,
6.1,
6.8,
12.8,
11.1,
6.2,
6.4,
6.4,
6.1,
6.3,
8.7,
7.4,
9.4,
6.3,
7.9,
6.5,
6.4,
15.4,
9.4,
6.3,
47.4
],
"ram_used": [
70353756160,
70321405952,
70284603392,
70262280192,
70387703808,
70314864640,
70312120320,
70299967488,
70299987968,
70294355968,
70301368320,
70293327872,
70290792448,
70280925184,
70300200960,
70377836544,
70448394240,
70448910336,
70574612480,
70739390464,
70512533504,
70533234688,
70513684480,
70496215040,
70484873216,
70469386240,
70452416512,
70445555712,
70424002560,
70434533376,
70424702976,
70408409088,
70395523072,
70388035584,
70353256448,
70333558784,
70326820864,
70357315584,
70361923584,
70355750912,
70357520384,
70490038272,
70530985984,
70524338176,
70524243968,
70525259776,
70528827392,
70526148608,
70526631936,
70541975552,
70541778944,
70536822784,
70537621504,
70537134080,
70534877184,
70532685824,
70529556480,
70530998272,
70534545408,
70762872832
],
"disk_read_mb": [
0.0,
0.0,
71.3,
0.0,
0.0,
79.43,
0.0,
72.4,
4.53,
0.0,
54.62,
0.0,
42.73,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
3.32,
0.6,
0.01,
0.0,
0.01,
0.0,
0.0,
0.02,
0.0,
0.02,
0.0,
0.0,
0.03,
0.0,
0.03,
0.0,
0.0,
0.73,
0.0,
0.01,
0.0,
0.0,
0.01,
0.0,
0.02,
0.0,
0.0,
0.0,
0.0,
12.58,
0.0,
0.0,
71.88,
0.0,
33.04,
0.0,
0.0,
0.0,
0.0,
0.0,
0.91
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
93.52,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
110.51
]
},
"time": 1790718828.3451
}
}
@@ -0,0 +1,721 @@
{
"label": "native-v0.1.26-IQ3_S-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "4e71f26e7fd8",
"corpus_repeated": false,
"time": "2026-09-29T21:53:48",
"prompt_tokens": 31604,
"completion_tokens": 49,
"ttft_s": 42.269,
"e2e_s": 42.716,
"api_prompt_tps": 747.7,
"api_decode_tps": 107.5,
"engine_prompt_tps": 750.5,
"engine_decode_tps": 106.3,
"log_lines": [
"strata serve: prompt 31604 tokens = 0 reused + 31604 read in 42111 ms (750.5 tok/s), 49 generated in 461 ms (106.3 tok/s), drafts accepted 33 of 37, 2 checkpoints",
"strata serve: decode expert cache hit rate: 99.1% (26163 hits / 26396 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand what's there and identify the \"last file\" being referenced.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_s",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 9376,
"expert_cache_mib": 17297,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 635,
"cvec": 0,
"arena_mib": 47962,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718828.4807332,
"duration_s": 42.6,
"finish": "stop",
"prompt_tokens": 31604,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 42110.8,
"decode_ms": 460.9,
"decode_tok_s": 106.3,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790718784.8375118,
"duration_s": 43.0,
"finish": "stop",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 88,
"engine_generated": 88,
"prompt_ms": 42216.7,
"decode_ms": 776.7,
"decode_tok_s": 113.3,
"hit_rate": 0.978
},
{
"projection": null,
"time": 1790718743.8685048,
"duration_s": 40.3,
"finish": "stop",
"prompt_tokens": 28315,
"reused": 0,
"output_tokens": 84,
"engine_generated": 84,
"prompt_ms": 39286.5,
"decode_ms": 1011.1,
"decode_tok_s": 83.1,
"hit_rate": 0.949
}
],
"requests_kept": 3,
"totals": {
"since": 1790718725.4039552,
"requests": 3,
"prompt_tokens": 91552,
"reused": 0,
"output_tokens": 221,
"prompt_ms": 123614.0,
"decode_ms": 2248.7000000000003
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 39,
"mem_used": 25212944384,
"mem_total": 25769803776,
"temp": 47,
"power": 127.526
},
{
"index": 1,
"util": 2,
"mem_used": 24227282944,
"mem_total": 25769803776,
"temp": 50,
"power": 202.315
}
],
"gpu_util": 20.5,
"gpu_mem_used": 49440227328,
"gpu_mem_total": 51539607552,
"gpu_temp": 50,
"gpu_power": 329.841,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 19.740234375,
"gpu_pcie_tx_mb": 54.21484375,
"cpu": 32.2,
"ram_used": 70312075264,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.09328657441898458,
"tok_s": 97.74566314411967,
"tok_s_mean": 97.74268443960047
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
25.5,
38.5,
31.5,
24.5,
30.0,
26.0,
31.5,
19.0,
86.5,
28.0,
22.5,
32.0,
26.0,
77.5,
22.5,
22.5,
34.0,
26.0,
20.5,
32.5,
0.0,
36.5,
37.0,
26.0,
32.0,
37.0,
24.0,
32.5,
20.5,
29.0,
25.0,
27.5,
30.5,
24.0,
35.0,
28.5,
29.0,
30.0,
29.5,
33.5,
44.5,
55.5,
36.0,
25.0,
33.5,
47.0,
15.5,
32.5,
24.0,
32.5,
29.0,
55.0,
34.0,
48.0,
33.0,
22.5,
31.5,
24.5,
20.0,
20.5
],
"gpu_mem_used": [
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328,
49440227328
],
"gpu_temp": [
51,
50,
49,
50,
49,
51,
49,
50,
51,
49,
50,
50,
51,
52,
50,
50,
50,
51,
52,
50,
49,
49,
49,
51,
50,
50,
50,
50,
51,
50,
50,
51,
50,
51,
50,
51,
51,
50,
52,
50,
51,
50,
50,
51,
50,
51,
51,
51,
51,
51,
51,
51,
50,
52,
52,
52,
51,
52,
52,
50
],
"gpu_power": [
385.57,
368.88,
396.03,
374.4,
393.23,
385.24,
406.68,
391.86,
364.28,
409.58,
388.38,
389.1,
390.65,
372.81,
415.25,
390.44,
384.85,
382.05,
377.98,
330.14,
415.76,
348.22,
407.06,
354.03,
392.05,
392.72,
370.96,
399.97,
402.84,
387.68,
394.33,
359.55,
419.05,
403.04,
384.68,
390.64,
393.93,
389.6,
362.93,
373.48,
405.22,
378.6,
399.07,
380.19,
386.69,
409.76,
359.41,
400.68,
368.54,
396.07,
393.99,
371.52,
407.92,
367.65,
416.33,
386.19,
394.79,
409.75,
373.56,
329.84
],
"gpu_pcie_rx_mb": [
6062.41,
5581.95,
5691.53,
8234.83,
8344.89,
7880.73,
6094.07,
8294.58,
5858.85,
5465.17,
6922.82,
4432.29,
6296.59,
5837.44,
7103.97,
7604.84,
4756.35,
4899.02,
5517.96,
50.97,
0.67,
11557.34,
5125.33,
6536.1,
6042.86,
7341.43,
5299.47,
6137.51,
6431.72,
5859.47,
4887.1,
5919.46,
5763.62,
94.17,
6438.59,
7535.84,
6171.89,
7355.36,
4306.32,
5857.37,
4681.59,
5568.03,
5823.33,
5368.61,
7806.78,
7675.93,
8469.58,
5669.88,
14723.06,
5790.85,
6188.01,
6980.23,
7332.23,
12898.87,
6754.21,
6340.74,
6000.61,
6420.09,
4455.66,
19.74
],
"cpu": [
6.1,
6.8,
12.8,
11.1,
6.2,
6.4,
6.4,
6.1,
6.3,
8.7,
7.4,
9.4,
6.3,
7.9,
6.5,
6.4,
15.4,
9.4,
6.3,
47.4,
36.1,
6.3,
6.7,
6.6,
5.7,
7.4,
6.2,
7.4,
6.0,
6.6,
15.5,
14.6,
5.8,
6.4,
6.5,
6.2,
11.6,
8.8,
7.8,
6.2,
6.9,
6.0,
5.5,
7.3,
17.5,
8.0,
7.9,
6.6,
6.2,
6.2,
6.1,
6.6,
5.7,
6.8,
7.1,
7.8,
6.2,
9.8,
15.0,
32.2
],
"ram_used": [
70357520384,
70490038272,
70530985984,
70524338176,
70524243968,
70525259776,
70528827392,
70526148608,
70526631936,
70541975552,
70541778944,
70536822784,
70537621504,
70537134080,
70534877184,
70532685824,
70529556480,
70530998272,
70534545408,
70762872832,
70460293120,
70452703232,
70444961792,
70428729344,
70420193280,
70418821120,
70406471680,
70396342272,
70389112832,
70380965888,
70312722432,
70348423168,
70338981888,
70328791040,
70326034432,
70312820736,
70085947392,
69987848192,
70072119296,
70060589056,
70056861696,
70179471360,
70176550912,
70159552512,
70270476288,
70270668800,
70271184896,
70263926784,
70264184832,
70264291328,
70265167872,
70267035648,
70267035648,
70264389632,
70261067776,
70265782272,
70268100608,
70275043328,
70091866112,
70312075264
],
"disk_read_mb": [
0.0,
0.01,
0.0,
0.02,
0.0,
0.0,
0.0,
0.0,
12.58,
0.0,
0.0,
71.88,
0.0,
33.04,
0.0,
0.0,
0.0,
0.0,
0.0,
0.91,
0.83,
0.04,
0.0,
0.0,
0.01,
0.0,
0.03,
0.0,
0.0,
0.03,
0.0,
0.05,
0.0,
0.0,
0.04,
0.0,
0.04,
0.0,
0.04,
0.0,
0.0,
0.04,
0.0,
0.0,
0.04,
0.0,
0.01,
0.0,
0.02,
0.0,
0.0,
0.01,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
110.51,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.75
]
},
"time": 1790718871.5639336
}
}
@@ -0,0 +1,830 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090-needle",
"mode": "needle",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "e39790e5649d",
"corpus_repeated": false,
"time": "2026-09-29T20:47:57",
"prompt_tokens": 17346,
"completion_tokens": 8,
"ttft_s": 9.075,
"e2e_s": 9.178,
"api_prompt_tps": 1911.3,
"api_decode_tps": 68.2,
"engine_prompt_tps": 1933.6,
"engine_decode_tps": 67.4,
"log_lines": [
"strata serve: prompt 17346 tokens = 0 reused + 17346 read in 8971 ms (1933.6 tok/s), 8 generated in 119 ms (67.4 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 80.6% (3014 hits / 3740 lookups)"
],
"answer_head": "37E3DB14",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714877.4157934,
"duration_s": 9.1,
"finish": "stop",
"prompt_tokens": 17346,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 8971.0,
"decode_ms": 118.7,
"decode_tok_s": 67.4,
"hit_rate": 0.806
},
{
"projection": null,
"time": 1790714872.57582,
"duration_s": 4.3,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 4124.7,
"decode_ms": 123.2,
"decode_tok_s": 64.9,
"hit_rate": 0.748
},
{
"projection": null,
"time": 1790714759.725435,
"duration_s": 63.5,
"finish": "length",
"prompt_tokens": 129913,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59900.8,
"decode_ms": 3556.3,
"decode_tok_s": 72.0,
"hit_rate": 0.956
},
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
}
],
"requests_kept": 24,
"totals": {
"since": 1790713882.6043305,
"requests": 24,
"prompt_tokens": 631825,
"reused": 0,
"output_tokens": 4662,
"prompt_ms": 302982.9,
"decode_ms": 55029.19999999998
},
"hardware": {
"gpu_util": 100,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 49,
"gpu_power": 265.798,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 22367.23828125,
"gpu_pcie_tx_mb": 80.8232421875,
"cpu": 6.2,
"ram_used": 63624777728,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.31474488451743216,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
99,
100,
0,
100,
99,
99,
100,
100,
99,
90,
100
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
46,
45,
45,
44,
45,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
42,
42,
42,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
47,
48,
49,
49,
46,
49,
49,
48,
49,
49,
49,
48,
49
],
"gpu_power": [
162.82,
148.08,
135.02,
121.86,
121.63,
121.78,
121.51,
121.24,
121.16,
121.27,
121.24,
121.23,
121.05,
121.06,
121.26,
121.23,
101.81,
59.35,
35.84,
35.18,
35.01,
35.2,
35.0,
34.94,
35.11,
35.02,
35.03,
35.11,
34.94,
34.9,
35.04,
35.01,
35.02,
35.13,
34.98,
34.93,
35.03,
34.9,
34.91,
35.06,
34.94,
34.94,
35.11,
35.01,
35.09,
34.99,
34.98,
69.69,
278.48,
278.38,
276.27,
201.82,
237.39,
277.05,
276.41,
278.18,
277.05,
276.73,
274.45,
265.8
],
"gpu_pcie_rx_mb": [
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.33,
0.33,
0.38,
0.33,
0.29,
0.29,
0.29,
0.33,
0.33,
0.43,
0.43,
0.43,
0.43,
0.48,
0.52,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.57,
0.43,
0.38,
0.43,
0.43,
0.38,
0.38,
0.43,
0.48,
0.43,
0.43,
0.67,
0.43,
0.43,
0.43,
0.43,
12932.54,
9.63,
46.83,
24945.45,
2343.61,
13238.91,
26700.59,
116.78,
454.76,
16.55,
25179.15,
16555.31,
22367.24
],
"cpu": [
1.7,
6.8,
2.8,
2.2,
1.5,
0.9,
1.8,
5.2,
2.3,
5.5,
8.8,
1.8,
3.7,
1.8,
2.8,
1.4,
3.7,
3.3,
1.7,
1.3,
4.2,
1.2,
1.6,
1.7,
9.9,
2.6,
0.5,
2.0,
1.8,
2.4,
1.5,
0.8,
1.6,
1.2,
0.7,
1.6,
1.6,
2.3,
9.4,
4.7,
1.1,
3.5,
10.5,
1.6,
1.2,
1.3,
4.9,
9.2,
6.2,
7.5,
8.5,
22.5,
12.5,
14.4,
12.6,
8.8,
6.5,
7.5,
6.4,
6.2
],
"ram_used": [
64108949504,
64264835072,
64269873152,
64217538560,
64220250112,
64209580032,
64204328960,
64140402688,
64131928064,
64163700736,
64240553984,
64240898048,
64248393728,
64243052544,
64234790912,
64233521152,
64232390656,
64308101120,
64309403648,
64297762816,
64329601024,
64305721344,
64307060736,
64304783360,
64363835392,
64356347904,
64354099200,
64356909056,
64359067648,
64329744384,
64330743808,
64332496896,
64325115904,
64319610880,
64320966656,
64320552960,
64315297792,
64318357504,
64285126656,
64085762048,
64088686592,
64091111424,
64247578624,
64251699200,
64241737728,
64244289536,
64283144192,
63581208576,
63583793152,
63583657984,
63716282368,
63680327680,
63688806400,
63692079104,
63653728256,
63611449344,
63604965376,
63573368832,
63636836352,
63624777728
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.02,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
59.38,
0.0,
0.0,
0.0,
34.69,
51.95,
0.0,
0.0,
11.38,
0.0,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790714887.0144231
}
}
@@ -0,0 +1,830 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090-needle",
"mode": "needle",
"ctx": "28k",
"target_tokens": 28672,
"run": 1,
"run_id": "94aa92e58ada",
"corpus_repeated": false,
"time": "2026-09-29T20:48:07",
"prompt_tokens": 29820,
"completion_tokens": 8,
"ttft_s": 14.138,
"e2e_s": 14.241,
"api_prompt_tps": 2109.2,
"api_decode_tps": 68.2,
"engine_prompt_tps": 2134.7,
"engine_decode_tps": 66.5,
"log_lines": [
"strata serve: prompt 29820 tokens = 0 reused + 29820 read in 13969 ms (2134.7 tok/s), 8 generated in 120 ms (66.5 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 80.6% (3033 hits / 3764 lookups)"
],
"answer_head": "64EC0999",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714887.1579242,
"duration_s": 14.1,
"finish": "stop",
"prompt_tokens": 29820,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 13969.3,
"decode_ms": 120.3,
"decode_tok_s": 66.5,
"hit_rate": 0.806
},
{
"projection": null,
"time": 1790714877.4157934,
"duration_s": 9.1,
"finish": "stop",
"prompt_tokens": 17346,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 8971.0,
"decode_ms": 118.7,
"decode_tok_s": 67.4,
"hit_rate": 0.806
},
{
"projection": null,
"time": 1790714872.57582,
"duration_s": 4.3,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 4124.7,
"decode_ms": 123.2,
"decode_tok_s": 64.9,
"hit_rate": 0.748
},
{
"projection": null,
"time": 1790714759.725435,
"duration_s": 63.5,
"finish": "length",
"prompt_tokens": 129913,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59900.8,
"decode_ms": 3556.3,
"decode_tok_s": 72.0,
"hit_rate": 0.956
},
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
}
],
"requests_kept": 25,
"totals": {
"since": 1790713882.6043305,
"requests": 25,
"prompt_tokens": 661645,
"reused": 0,
"output_tokens": 4670,
"prompt_ms": 316952.2,
"decode_ms": 55149.499999999985
},
"hardware": {
"gpu_util": 99,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 49,
"gpu_power": 278.531,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 86.068359375,
"gpu_pcie_tx_mb": 76.1982421875,
"cpu": 6.7,
"ram_used": 63515471872,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.08241686128693117,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
99,
100,
0,
100,
99,
99,
100,
100,
99,
90,
100,
0,
99,
99,
100,
96,
100,
99,
99,
99,
100,
99,
100,
99,
99
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
44,
44,
42,
42,
42,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
47,
48,
49,
49,
46,
49,
49,
48,
49,
49,
49,
48,
49,
46,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49
],
"gpu_power": [
121.26,
121.23,
101.81,
59.35,
35.84,
35.18,
35.01,
35.2,
35.0,
34.94,
35.11,
35.02,
35.03,
35.11,
34.94,
34.9,
35.04,
35.01,
35.02,
35.13,
34.98,
34.93,
35.03,
34.9,
34.91,
35.06,
34.94,
34.94,
35.11,
35.01,
35.09,
34.99,
34.98,
69.69,
278.48,
278.38,
276.27,
201.82,
237.39,
277.05,
276.41,
278.18,
277.05,
276.73,
274.45,
265.8,
225.08,
215.47,
277.53,
277.2,
277.77,
276.7,
277.63,
275.8,
266.11,
275.21,
277.53,
275.92,
279.07,
278.53
],
"gpu_pcie_rx_mb": [
0.33,
0.43,
0.43,
0.43,
0.43,
0.48,
0.52,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.57,
0.43,
0.38,
0.43,
0.43,
0.38,
0.38,
0.43,
0.48,
0.43,
0.43,
0.67,
0.43,
0.43,
0.43,
0.43,
12932.54,
9.63,
46.83,
24945.45,
2343.61,
13238.91,
26700.59,
116.78,
454.76,
16.55,
25179.15,
16555.31,
22367.24,
0.29,
6039.81,
15.31,
2050.78,
8.77,
51.02,
14.83,
11.11,
14.88,
25541.35,
21966.98,
22781.28,
20080.71,
86.07
],
"cpu": [
2.8,
1.4,
3.7,
3.3,
1.7,
1.3,
4.2,
1.2,
1.6,
1.7,
9.9,
2.6,
0.5,
2.0,
1.8,
2.4,
1.5,
0.8,
1.6,
1.2,
0.7,
1.6,
1.6,
2.3,
9.4,
4.7,
1.1,
3.5,
10.5,
1.6,
1.2,
1.3,
4.9,
9.2,
6.2,
7.5,
8.5,
22.5,
12.5,
14.4,
12.6,
8.8,
6.5,
7.5,
6.4,
6.2,
20.7,
7.5,
5.6,
6.7,
10.9,
6.4,
7.2,
16.4,
12.9,
5.7,
8.2,
6.5,
6.1,
6.7
],
"ram_used": [
64234790912,
64233521152,
64232390656,
64308101120,
64309403648,
64297762816,
64329601024,
64305721344,
64307060736,
64304783360,
64363835392,
64356347904,
64354099200,
64356909056,
64359067648,
64329744384,
64330743808,
64332496896,
64325115904,
64319610880,
64320966656,
64320552960,
64315297792,
64318357504,
64285126656,
64085762048,
64088686592,
64091111424,
64247578624,
64251699200,
64241737728,
64244289536,
64283144192,
63581208576,
63583793152,
63583657984,
63716282368,
63680327680,
63688806400,
63692079104,
63653728256,
63611449344,
63604965376,
63573368832,
63636836352,
63624777728,
63754727424,
63698673664,
63690715136,
63681667072,
63675179008,
63536058368,
63521837056,
63517446144,
63523024896,
63518388224,
63517155328,
63521734656,
63516585984,
63515471872
],
"disk_read_mb": [
0.0,
0.0,
0.02,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
59.38,
0.0,
0.0,
0.0,
34.69,
51.95,
0.0,
0.0,
11.38,
0.0,
0.0,
0.0,
0.0,
0.11,
4.58,
0.0,
0.0,
97.16,
0.0,
0.0,
0.0,
52.31,
0.0,
0.0,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790714901.7591343
}
}
@@ -0,0 +1,830 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090-needle",
"mode": "needle",
"ctx": "8k",
"target_tokens": 8192,
"run": 1,
"run_id": "3c83d69c2581",
"corpus_repeated": false,
"time": "2026-09-29T20:47:52",
"prompt_tokens": 7493,
"completion_tokens": 8,
"ttft_s": 4.2,
"e2e_s": 4.307,
"api_prompt_tps": 1783.9,
"api_decode_tps": 65.8,
"engine_prompt_tps": 1816.6,
"engine_decode_tps": 64.9,
"log_lines": [
"strata serve: prompt 7493 tokens = 0 reused + 7493 read in 4125 ms (1816.6 tok/s), 8 generated in 123 ms (64.9 tok/s), drafts accepted 6 of 6, 1 checkpoints",
"strata serve: decode expert cache hit rate: 74.8% (2704 hits / 3615 lookups)"
],
"answer_head": "0E6415FF",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714872.57582,
"duration_s": 4.3,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 4124.7,
"decode_ms": 123.2,
"decode_tok_s": 64.9,
"hit_rate": 0.748
},
{
"projection": null,
"time": 1790714759.725435,
"duration_s": 63.5,
"finish": "length",
"prompt_tokens": 129913,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59900.8,
"decode_ms": 3556.3,
"decode_tok_s": 72.0,
"hit_rate": 0.956
},
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
}
],
"requests_kept": 23,
"totals": {
"since": 1790713882.6043305,
"requests": 23,
"prompt_tokens": 614479,
"reused": 0,
"output_tokens": 4654,
"prompt_ms": 294011.9,
"decode_ms": 54910.499999999985
},
"hardware": {
"gpu_util": 100,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 49,
"gpu_power": 276.273,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 24945.44921875,
"gpu_pcie_tx_mb": 2986.287109375,
"cpu": 8.5,
"ram_used": 63716282368,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
100,
99,
100,
99,
99,
85,
91,
96,
95,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
100,
99,
100
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
49,
49,
49,
49,
49,
49,
49,
49,
49,
46,
45,
45,
44,
45,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
42,
42,
42,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
41,
47,
48,
49,
49
],
"gpu_power": [
277.85,
276.09,
278.51,
279.06,
278.13,
239.73,
262.71,
270.73,
273.54,
162.82,
148.08,
135.02,
121.86,
121.63,
121.78,
121.51,
121.24,
121.16,
121.27,
121.24,
121.23,
121.05,
121.06,
121.26,
121.23,
101.81,
59.35,
35.84,
35.18,
35.01,
35.2,
35.0,
34.94,
35.11,
35.02,
35.03,
35.11,
34.94,
34.9,
35.04,
35.01,
35.02,
35.13,
34.98,
34.93,
35.03,
34.9,
34.91,
35.06,
34.94,
34.94,
35.11,
35.01,
35.09,
34.99,
34.98,
69.69,
278.48,
278.38,
276.27
],
"gpu_pcie_rx_mb": [
12025.83,
22118.66,
18928.05,
18.36,
86.12,
284.24,
9240.67,
7805.97,
0.29,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.33,
0.33,
0.38,
0.33,
0.29,
0.29,
0.29,
0.33,
0.33,
0.43,
0.43,
0.43,
0.43,
0.48,
0.52,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.57,
0.43,
0.38,
0.43,
0.43,
0.38,
0.38,
0.43,
0.48,
0.43,
0.43,
0.67,
0.43,
0.43,
0.43,
0.43,
12932.54,
9.63,
46.83,
24945.45
],
"cpu": [
8.2,
6.7,
6.2,
6.0,
13.2,
64.5,
99.9,
99.0,
86.8,
1.7,
6.8,
2.8,
2.2,
1.5,
0.9,
1.8,
5.2,
2.3,
5.5,
8.8,
1.8,
3.7,
1.8,
2.8,
1.4,
3.7,
3.3,
1.7,
1.3,
4.2,
1.2,
1.6,
1.7,
9.9,
2.6,
0.5,
2.0,
1.8,
2.4,
1.5,
0.8,
1.6,
1.2,
0.7,
1.6,
1.6,
2.3,
9.4,
4.7,
1.1,
3.5,
10.5,
1.6,
1.2,
1.3,
4.9,
9.2,
6.2,
7.5,
8.5
],
"ram_used": [
64100171776,
64087904256,
64069447680,
64067096576,
64095731712,
64224346112,
64185745408,
64170352640,
64157536256,
64108949504,
64264835072,
64269873152,
64217538560,
64220250112,
64209580032,
64204328960,
64140402688,
64131928064,
64163700736,
64240553984,
64240898048,
64248393728,
64243052544,
64234790912,
64233521152,
64232390656,
64308101120,
64309403648,
64297762816,
64329601024,
64305721344,
64307060736,
64304783360,
64363835392,
64356347904,
64354099200,
64356909056,
64359067648,
64329744384,
64330743808,
64332496896,
64325115904,
64319610880,
64320966656,
64320552960,
64315297792,
64318357504,
64285126656,
64085762048,
64088686592,
64091111424,
64247578624,
64251699200,
64241737728,
64244289536,
64283144192,
63581208576,
63583793152,
63583657984,
63716282368
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.89,
2.52,
3.25,
2.83,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.02,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
59.38,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
61.23,
76.01,
95.36,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790714877.3325372
}
}
@@ -0,0 +1,835 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090-two-turn",
"mode": "two-turn",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "7aed17dd03cd",
"corpus_repeated": false,
"time": "2026-09-29T20:48:48",
"prompt_tokens": 15636,
"completion_tokens": 256,
"ttft_s": 7.488,
"e2e_s": 10.882,
"api_prompt_tps": 2088.0,
"api_decode_tps": 75.1,
"engine_prompt_tps": 2114.8,
"engine_decode_tps": 75.1,
"log_lines": [
"strata serve: prompt 15636 tokens = 0 reused + 15636 read in 7394 ms (2114.8 tok/s), 256 generated in 3410 ms (75.1 tok/s), drafts accepted 152 of 215, 1 checkpoints",
"strata serve: decode expert cache hit rate: 93.0% (136865 hits / 147168 lookups)"
],
"answer_head": "## What `README.md` does\n\n`README.md` is the project's landing page and primary user-facing documentation. It serves several purposes:\n\n1. **Marketing/overview** \u2014 Opens with a headline claim (\"Run a 125-billion-parameter AI model on a normal gaming PC\") and a visual demo (the pagoda video) to immed",
"turn2_ttft_s": 0.438,
"turn2_prompt_tokens": 15915,
"turn2_log_lines": [
"strata serve: prompt 15915 tokens = 15892 reused + 23 read in 332 ms (69.3 tok/s), 46 generated in 661 ms (69.6 tok/s), drafts accepted 27 of 44, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.4% (29047 hits / 30124 lookups)"
],
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714939.7647502,
"duration_s": 1.0,
"finish": "stop",
"prompt_tokens": 15915,
"reused": 15892,
"output_tokens": 46,
"engine_generated": 46,
"prompt_ms": 331.9,
"decode_ms": 660.8,
"decode_tok_s": 69.6,
"hit_rate": 0.964
},
{
"projection": null,
"time": 1790714928.3706348,
"duration_s": 10.8,
"finish": "length",
"prompt_tokens": 15636,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 7393.6,
"decode_ms": 3409.5,
"decode_tok_s": 75.1,
"hit_rate": 0.93
},
{
"projection": null,
"time": 1790714887.1579242,
"duration_s": 14.1,
"finish": "stop",
"prompt_tokens": 29820,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 13969.3,
"decode_ms": 120.3,
"decode_tok_s": 66.5,
"hit_rate": 0.806
},
{
"projection": null,
"time": 1790714877.4157934,
"duration_s": 9.1,
"finish": "stop",
"prompt_tokens": 17346,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 8971.0,
"decode_ms": 118.7,
"decode_tok_s": 67.4,
"hit_rate": 0.806
},
{
"projection": null,
"time": 1790714872.57582,
"duration_s": 4.3,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 4124.7,
"decode_ms": 123.2,
"decode_tok_s": 64.9,
"hit_rate": 0.748
},
{
"projection": null,
"time": 1790714759.725435,
"duration_s": 63.5,
"finish": "length",
"prompt_tokens": 129913,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59900.8,
"decode_ms": 3556.3,
"decode_tok_s": 72.0,
"hit_rate": 0.956
},
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
}
],
"requests_kept": 27,
"totals": {
"since": 1790713882.6043305,
"requests": 27,
"prompt_tokens": 693196,
"reused": 15892,
"output_tokens": 4972,
"prompt_ms": 324677.7,
"decode_ms": 59219.79999999999
},
"hardware": {
"gpu_util": 94,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 48,
"gpu_power": 197.275,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 822.3525390625,
"gpu_pcie_tx_mb": 183.15234375,
"cpu": 52.4,
"ram_used": 63860678656,
"ram_total": 177175990272,
"disk_read_mb": 1.1632307226246328,
"disk_write_mb": 0.2954830452969325,
"tok_s": 50.58164583911189,
"tok_s_mean": 50.57911214220715
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
100,
99,
99,
100,
100,
99,
90,
100,
0,
99,
99,
100,
96,
100,
99,
99,
99,
100,
99,
100,
99,
99,
96,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
99,
99,
100,
99,
99,
100,
100,
100,
95,
97,
93,
94
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
49,
49,
48,
49,
49,
49,
48,
49,
46,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
48,
46,
45,
45,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
44,
42,
42,
42,
41,
41,
41,
41,
41,
41,
41,
47,
49,
49,
49,
49,
49,
49,
47,
48,
49,
49,
48
],
"gpu_power": [
237.39,
277.05,
276.41,
278.18,
277.05,
276.73,
274.45,
265.8,
225.08,
215.47,
277.53,
277.2,
277.77,
276.7,
277.63,
275.8,
266.11,
275.21,
277.53,
275.92,
279.07,
278.53,
241.13,
171.76,
147.92,
134.65,
121.43,
121.4,
121.36,
121.31,
121.11,
121.03,
121.2,
121.14,
120.8,
121.02,
121.17,
121.22,
102.94,
60.93,
36.12,
35.26,
35.35,
35.31,
35.23,
35.08,
35.09,
35.22,
69.73,
277.07,
276.87,
276.87,
278.61,
277.22,
278.12,
247.41,
259.45,
271.65,
275.28,
197.28
],
"gpu_pcie_rx_mb": [
13238.91,
26700.59,
116.78,
454.76,
16.55,
25179.15,
16555.31,
22367.24,
0.29,
6039.81,
15.31,
2050.78,
8.77,
51.02,
14.83,
11.11,
14.88,
25541.35,
21966.98,
22781.28,
20080.71,
86.07,
0.33,
0.29,
0.29,
0.33,
0.33,
0.29,
0.33,
0.29,
0.33,
0.33,
0.33,
0.33,
0.43,
0.33,
0.33,
0.29,
0.33,
0.38,
0.43,
0.38,
0.43,
0.38,
0.43,
0.43,
0.38,
0.43,
7494.78,
15213.11,
13.83,
86.31,
6.25,
4.48,
7.34,
1956.56,
3779.22,
10756.4,
0.33,
822.35
],
"cpu": [
12.5,
14.4,
12.6,
8.8,
6.5,
7.5,
6.4,
6.2,
20.7,
7.5,
5.6,
6.7,
10.9,
6.4,
7.2,
16.4,
12.9,
5.7,
8.2,
6.5,
6.1,
6.7,
20.8,
2.1,
8.1,
1.0,
2.4,
4.3,
1.2,
15.4,
6.0,
0.7,
1.7,
1.9,
1.9,
1.8,
1.1,
2.0,
2.0,
1.3,
1.6,
1.5,
3.7,
3.2,
9.8,
1.4,
4.8,
1.6,
8.9,
6.6,
7.0,
5.9,
5.6,
7.0,
10.7,
49.0,
100.0,
99.6,
87.8,
52.4
],
"ram_used": [
63688806400,
63692079104,
63653728256,
63611449344,
63604965376,
63573368832,
63636836352,
63624777728,
63754727424,
63698673664,
63690715136,
63681667072,
63675179008,
63536058368,
63521837056,
63517446144,
63523024896,
63518388224,
63517155328,
63521734656,
63516585984,
63515471872,
63598735360,
63575552000,
63746940928,
63743287296,
63744950272,
63746498560,
63748960256,
63781244928,
63777951744,
63778541568,
63778627584,
63784894464,
63788924928,
63789916160,
63785603072,
63778463744,
63786168320,
63781711872,
63785504768,
63775502336,
63798136832,
63833931776,
63825649664,
63827275776,
63826427904,
63833698304,
63620595712,
63618826240,
63602626560,
63602855936,
63603830784,
63609753600,
63610949632,
63683670016,
63692382208,
63679488000,
63682031616,
63860678656
],
"disk_read_mb": [
51.95,
0.0,
0.0,
11.38,
0.0,
0.0,
0.0,
0.0,
0.11,
4.58,
0.0,
0.0,
97.16,
0.0,
0.0,
0.0,
52.31,
0.0,
0.0,
0.0,
0.0,
0.0,
0.15,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.41,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.29,
3.18,
2.31,
2.73,
1.16
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
68.59,
62.69,
101.15,
0.0,
50.58
]
},
"time": 1790714941.2661076
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "128k",
"target_tokens": 129792,
"run": 1,
"run_id": "183f9c0b2a25",
"corpus_repeated": false,
"time": "2026-09-29T20:43:56",
"prompt_tokens": 119256,
"completion_tokens": 256,
"ttft_s": 55.136,
"e2e_s": 58.347,
"api_prompt_tps": 2162.9,
"api_decode_tps": 79.4,
"engine_prompt_tps": 2185.1,
"engine_decode_tps": 79.3,
"log_lines": [
"strata serve: prompt 119256 tokens = 0 reused + 119256 read in 54577 ms (2185.1 tok/s), 256 generated in 3230 ms (79.3 tok/s), drafts accepted 151 of 208, 6 checkpoints",
"strata serve: decode expert cache hit rate: 95.5% (140181 hits / 146787 lookups)"
],
"answer_head": "The last file shown is `include/strata/kernels/cpu/pool.hpp`. It declares the CPU expert pool (`ExpertPool`), which is the engine's mechanism for computing the routed MoE experts that do not fit in VRAM.\n\n**What it does:**\n\n1. **Thread Management:** It creates a pool of worker threads pinned to phy",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
}
],
"requests_kept": 20,
"totals": {
"since": 1790713882.6043305,
"requests": 20,
"prompt_tokens": 346713,
"reused": 0,
"output_tokens": 4134,
"prompt_ms": 170012.5,
"decode_ms": 48004.89999999999
},
"hardware": {
"gpu_util": 0,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 45,
"gpu_power": 245.728,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.3330078125,
"gpu_pcie_tx_mb": 0.4765625,
"cpu": 55.3,
"ram_used": 63994736640,
"ram_total": 177175990272,
"disk_read_mb": 2.173699813344069,
"disk_write_mb": 0.07870292427625078,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
100,
100,
99,
100,
99,
100,
99,
99,
100,
99,
99,
100,
99,
97,
96,
99,
99,
99,
100,
100,
97,
100,
100,
99,
97,
99,
100,
100,
99,
99,
98,
99,
99,
99,
98,
100,
100,
99,
99,
100,
100,
100,
99,
99,
99,
97,
100,
100,
100,
4,
100,
100,
89,
94,
95,
0
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
38,
38,
38,
38,
45,
46,
46,
46,
46,
46,
46,
47,
47,
47,
47,
46,
47,
47,
47,
47,
47,
47,
46,
46,
46,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
47,
46,
47,
47,
46,
47,
47,
45
],
"gpu_power": [
34.95,
35.05,
34.94,
34.95,
146.71,
278.26,
278.02,
277.13,
278.38,
277.26,
277.39,
265.55,
278.37,
277.81,
278.33,
277.55,
276.64,
268.76,
278.4,
278.09,
279.44,
277.89,
278.06,
278.94,
266.27,
278.02,
278.54,
277.25,
277.61,
278.51,
277.09,
267.68,
277.75,
277.97,
277.81,
277.03,
277.2,
278.97,
266.74,
277.84,
277.04,
277.08,
277.19,
277.7,
278.99,
275.31,
278.3,
278.49,
277.62,
278.02,
276.32,
276.96,
277.41,
263.19,
267.16,
277.12,
240.24,
275.77,
278.35,
245.73
],
"gpu_pcie_rx_mb": [
0.43,
0.38,
0.43,
0.62,
11.06,
10427.81,
2646.73,
383.9,
8262.3,
11.68,
24650.05,
893.64,
18094.54,
8958.05,
12.25,
6881.52,
17403.6,
4113.72,
25011.21,
21669.05,
15617.75,
11.78,
26451.63,
0.33,
5449.25,
2654.98,
14.88,
22.22,
15.59,
7.49,
1.29,
17076.97,
2352.29,
26573.8,
19.55,
15.45,
3977.3,
0.29,
16.07,
3622.44,
16839.27,
13.49,
13131.9,
19713.45,
26861.86,
17424.06,
12115.96,
5297.42,
26787.19,
12211.47,
5737.21,
18827.01,
8191.39,
15610.6,
18543.15,
81.97,
3906.87,
3778.6,
4665.28,
0.33
],
"cpu": [
1.5,
6.0,
1.8,
7.9,
6.4,
6.6,
16.7,
12.8,
7.5,
6.4,
5.6,
6.5,
6.9,
6.6,
17.4,
5.9,
5.5,
14.4,
12.9,
6.6,
19.0,
17.6,
6.4,
7.6,
15.3,
10.6,
6.2,
15.5,
14.7,
6.1,
5.9,
17.4,
8.8,
6.2,
15.9,
21.5,
7.2,
7.4,
16.6,
7.1,
6.6,
8.9,
14.9,
6.1,
5.8,
10.7,
14.6,
6.8,
5.9,
19.6,
12.3,
6.2,
7.7,
6.1,
5.9,
6.3,
64.3,
100.0,
100.0,
55.3
],
"ram_used": [
63599173632,
63581626368,
63584313344,
63628144640,
63383064576,
63385989120,
63410585600,
63420211200,
63412383744,
63414505472,
63524802560,
63511179264,
63497076736,
63495684096,
63489646592,
63487651840,
63472156672,
63594835968,
63578550272,
63580782592,
63599607808,
63609155584,
63609020416,
63658397696,
63611748352,
63599493120,
63591612416,
63610773504,
63607812096,
63605293056,
63719862272,
63720685568,
63714033664,
63716544512,
63707664384,
63700750336,
63700516864,
63791661056,
63808417792,
63809699840,
63813054464,
63809191936,
63809736704,
63785721856,
63788429312,
63899906048,
63903354880,
63885254656,
63887302656,
63919407104,
63917928448,
63921512448,
63919017984,
64030937088,
64033521664,
64022724608,
64014991360,
64020590592,
64011530240,
63994736640
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.59,
0.0,
0.0,
0.18,
0.0,
0.0,
0.31,
0.0,
0.0,
5.59,
188.01,
0.0,
0.0,
123.58,
109.11,
0.0,
61.11,
110.87,
0.0,
0.0,
173.38,
90.91,
0.0,
90.3,
151.87,
0.0,
0.0,
198.92,
33.71,
0.0,
100.92,
100.99,
0.0,
0.0,
190.6,
21.65,
0.0,
46.97,
157.79,
0.0,
0.0,
54.2,
150.86,
0.0,
0.0,
89.37,
16.55,
0.0,
0.0,
0.0,
0.0,
0.0,
1.57,
4.0,
4.88,
2.17
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
80.35,
77.04,
74.05,
0.0
]
},
"time": 1790714694.882821
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "128k",
"target_tokens": 129792,
"run": 2,
"run_id": "815c67976126",
"corpus_repeated": false,
"time": "2026-09-29T20:44:54",
"prompt_tokens": 130360,
"completion_tokens": 256,
"ttft_s": 60.567,
"e2e_s": 63.777,
"api_prompt_tps": 2152.3,
"api_decode_tps": 79.4,
"engine_prompt_tps": 2173.6,
"engine_decode_tps": 79.4,
"log_lines": [
"strata serve: prompt 130360 tokens = 0 reused + 130360 read in 59974 ms (2173.6 tok/s), 256 generated in 3226 ms (79.4 tok/s), drafts accepted 158 of 225, 6 checkpoints",
"strata serve: decode expert cache hit rate: 94.5% (142001 hits / 150326 lookups)"
],
"answer_head": "I'll analyze the last file in the repository listing.\n\n## What `include/strata/kernels/gdn.hpp` does\n\nThis header declares the **non-projection parts of the Gated Delta-Net (GDN) layer** \u2014 the \"mixer\" used in 36 of the model's 48 layers (the other 12 are QSA full-attention layers). It is the C++ cou",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
}
],
"requests_kept": 21,
"totals": {
"since": 1790713882.6043305,
"requests": 21,
"prompt_tokens": 477073,
"reused": 0,
"output_tokens": 4390,
"prompt_ms": 229986.4,
"decode_ms": 51230.999999999985
},
"hardware": {
"gpu_util": 95,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 48,
"gpu_power": 278.59,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 1822.99609375,
"gpu_pcie_tx_mb": 282.4296875,
"cpu": 100.0,
"ram_used": 63968800768,
"ram_total": 177175990272,
"disk_read_mb": 3.7524610679737007,
"disk_write_mb": 0.06727519842980738,
"tok_s": 75.51795929153683,
"tok_s_mean": 78.52742680374247
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
99,
100,
97,
99,
100,
3,
99,
100,
98,
100,
99,
100,
100,
99,
99,
98,
100,
100,
15,
99,
100,
100,
99,
100,
99,
100,
99,
100,
99,
98,
99,
100,
11,
99,
99,
100,
100,
99,
99,
99,
99,
100,
99,
100,
100,
100,
100,
99,
100,
99,
100,
99,
100,
100,
100,
49,
97,
93,
95
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
47,
47,
48,
48,
48,
47,
46,
47,
47,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
47,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
46,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
47,
48,
48,
48
],
"gpu_power": [
242.39,
277.2,
277.34,
277.65,
278.23,
277.3,
263.86,
266.5,
276.0,
277.29,
276.57,
277.42,
277.59,
268.12,
277.51,
276.99,
278.25,
276.6,
278.17,
261.67,
270.19,
277.42,
278.17,
277.12,
278.28,
277.75,
275.69,
267.25,
277.04,
278.86,
278.14,
276.63,
278.3,
265.62,
266.61,
278.07,
276.73,
277.66,
277.57,
279.3,
278.07,
267.14,
278.22,
278.47,
276.15,
278.64,
278.86,
277.69,
275.4,
267.11,
276.68,
277.32,
278.12,
277.19,
277.93,
278.16,
257.52,
253.15,
278.1,
278.59
],
"gpu_pcie_rx_mb": [
5309.2,
958.97,
17058.94,
14.64,
4.05,
3010.03,
8.39,
15.12,
15999.51,
15.07,
10772.8,
7160.47,
71.72,
850.39,
14.26,
26414.87,
26332.33,
24917.6,
18346.6,
6700.37,
20833.01,
48.73,
15.64,
11585.24,
10728.5,
4552.75,
22.55,
13.78,
18.55,
13.88,
3975.96,
21618.6,
14728.83,
12107.04,
17.45,
2833.51,
11.78,
14105.51,
21939.33,
26894.86,
0.33,
21545.12,
4351.66,
13.54,
21.36,
50.16,
22.7,
14.26,
24800.11,
17.12,
405.07,
24.65,
15145.21,
16473.29,
23109.39,
24054.19,
24291.28,
1098.68,
2094.22,
1823.0
],
"cpu": [
12.7,
5.7,
13.2,
17.8,
11.5,
8.3,
10.6,
6.0,
6.7,
8.3,
8.0,
5.8,
5.5,
10.0,
7.2,
6.7,
11.2,
15.8,
7.1,
9.4,
8.7,
6.2,
6.3,
10.1,
6.6,
8.2,
8.6,
6.9,
6.0,
6.4,
9.0,
16.5,
8.5,
8.3,
8.3,
6.3,
6.1,
9.9,
6.0,
7.2,
6.1,
8.2,
11.3,
7.1,
7.3,
16.3,
11.9,
6.5,
8.4,
17.1,
6.1,
6.2,
6.3,
6.4,
6.8,
7.5,
7.9,
100.0,
100.0,
100.0
],
"ram_used": [
63257399296,
63250329600,
63299825664,
63294885888,
63299862528,
63298265088,
63372304384,
63374991360,
63367077888,
63366172672,
63358062592,
63355240448,
63368228864,
63471902720,
63463698432,
63469293568,
63458623488,
63534329856,
63535923200,
63653580800,
63646789632,
63642984448,
63647580160,
63642767360,
63650861056,
63672475648,
63778967552,
63777734656,
63777472512,
63771406336,
63775264768,
63864942592,
63851782144,
63977308160,
63971295232,
63971143680,
63971721216,
63963795456,
63959093248,
63937032192,
64053448704,
64054136832,
63885062144,
63887245312,
63892475904,
63940841472,
63943122944,
63941619712,
64051613696,
64039284736,
64037093376,
64025649152,
64001216512,
63998476288,
63988797440,
63985102848,
64024535040,
64006193152,
63985057792,
63968800768
],
"disk_read_mb": [
82.45,
0.0,
0.0,
104.98,
0.0,
0.15,
86.65,
0.0,
0.0,
49.16,
30.63,
0.0,
0.0,
66.33,
0.0,
0.0,
49.25,
0.0,
0.0,
19.87,
53.0,
0.0,
0.0,
65.63,
0.0,
0.0,
49.27,
11.94,
0.0,
0.0,
53.35,
0.0,
0.0,
40.85,
14.45,
0.0,
0.0,
52.4,
0.0,
0.0,
0.0,
51.78,
0.0,
0.0,
14.03,
110.69,
0.0,
0.0,
0.19,
189.89,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.15,
2.91,
2.72,
3.75
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
80.44,
97.1,
75.52
]
},
"time": 1790714759.167411
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "128k",
"target_tokens": 129792,
"run": 3,
"run_id": "317fbfabc24a",
"corpus_repeated": false,
"time": "2026-09-29T20:45:59",
"prompt_tokens": 129913,
"completion_tokens": 256,
"ttft_s": 60.534,
"e2e_s": 64.056,
"api_prompt_tps": 2146.1,
"api_decode_tps": 72.4,
"engine_prompt_tps": 2168.8,
"engine_decode_tps": 72.0,
"log_lines": [
"strata serve: prompt 129913 tokens = 0 reused + 129913 read in 59901 ms (2168.8 tok/s), 256 generated in 3556 ms (72.0 tok/s), drafts accepted 148 of 200, 6 checkpoints",
"strata serve: decode expert cache hit rate: 95.6% (138618 hits / 145073 lookups)"
],
"answer_head": "The last file is `include/strata/kernels/gdn.hpp`. It declares the non-projection parts of the gated delta-net (GDN) layer used by 36 of the model's 48 layers. It defines `GdnShapes` (S=128, h_k=16, h_v=48) and declares `gdn_step`, which performs one in-place step of the delta-rule recurrence: it de",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714759.725435,
"duration_s": 63.5,
"finish": "length",
"prompt_tokens": 129913,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59900.8,
"decode_ms": 3556.3,
"decode_tok_s": 72.0,
"hit_rate": 0.956
},
{
"projection": null,
"time": 1790714695.4286683,
"duration_s": 63.2,
"finish": "length",
"prompt_tokens": 130360,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 59973.9,
"decode_ms": 3226.1,
"decode_tok_s": 79.4,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714636.537164,
"duration_s": 57.8,
"finish": "length",
"prompt_tokens": 119256,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 54577.1,
"decode_ms": 3229.8,
"decode_tok_s": 79.3,
"hit_rate": 0.955
},
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
}
],
"requests_kept": 22,
"totals": {
"since": 1790713882.6043305,
"requests": 22,
"prompt_tokens": 606986,
"reused": 0,
"output_tokens": 4646,
"prompt_ms": 289887.2,
"decode_ms": 54787.29999999999
},
"hardware": {
"gpu_util": 95,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 49,
"gpu_power": 273.544,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.28515625,
"gpu_pcie_tx_mb": 0.4765625,
"cpu": 86.8,
"ram_used": 64157536256,
"ram_total": 177175990272,
"disk_read_mb": 2.8283858363947703,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
99,
99,
99,
100,
100,
99,
99,
100,
97,
99,
100,
98,
100,
100,
100,
100,
99,
100,
99,
99,
99,
100,
100,
100,
100,
100,
99,
100,
100,
100,
99,
100,
97,
100,
100,
100,
99,
99,
99,
99,
100,
100,
100,
97,
99,
99,
100,
100,
100,
99,
100,
99,
100,
99,
99,
85,
91,
96,
95
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
49,
48,
49,
49,
49,
49,
48,
49,
49,
49,
49,
48,
48,
49,
48,
49,
49,
49,
49,
48,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
48,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49
],
"gpu_power": [
277.4,
277.63,
276.55,
277.24,
277.6,
277.7,
267.41,
277.71,
277.73,
277.11,
277.47,
278.48,
265.62,
277.65,
278.51,
277.16,
277.8,
278.42,
276.76,
264.34,
277.83,
278.79,
277.39,
278.33,
279.04,
277.09,
266.43,
277.15,
279.09,
277.12,
278.21,
279.11,
276.87,
266.5,
277.59,
276.92,
277.76,
277.37,
277.95,
278.05,
266.15,
281.14,
276.88,
277.27,
277.03,
278.78,
277.01,
276.66,
264.08,
276.78,
278.41,
277.85,
276.09,
278.51,
279.06,
278.13,
239.73,
262.71,
270.73,
273.54
],
"gpu_pcie_rx_mb": [
11.44,
11737.44,
1061.11,
1303.05,
10.78,
20755.48,
892.69,
12802.27,
17290.83,
13.02,
669.76,
9859.75,
15.88,
26970.96,
27538.78,
8595.9,
10.82,
22491.22,
20098.16,
7703.26,
2655.31,
1810.74,
21.84,
656.7,
7.82,
17247.68,
12383.65,
14706.95,
18027.4,
14.64,
51.02,
23.94,
21140.67,
19852.11,
18272.88,
11345.43,
10748.2,
23.08,
3973.67,
14.35,
15.45,
12245.37,
13872.91,
2994.2,
10277.84,
51.35,
26547.62,
4842.76,
13126.71,
6178.52,
14.73,
12025.83,
22118.66,
18928.05,
18.36,
86.12,
284.24,
9240.67,
7805.97,
0.29
],
"cpu": [
7.6,
6.7,
9.9,
8.5,
6.7,
6.2,
11.3,
5.7,
6.1,
11.0,
7.2,
6.5,
20.9,
10.8,
5.8,
8.9,
8.5,
6.7,
6.4,
11.1,
6.7,
5.6,
11.4,
8.9,
6.1,
6.0,
17.0,
11.4,
6.6,
10.0,
7.3,
6.2,
6.6,
10.7,
6.4,
6.2,
6.7,
9.0,
6.2,
7.0,
9.7,
17.6,
7.3,
7.5,
10.4,
6.7,
6.4,
6.7,
8.5,
6.3,
5.8,
8.2,
6.7,
6.2,
6.0,
13.2,
64.5,
99.9,
99.0,
86.8
],
"ram_used": [
63275466752,
63276769280,
63271755776,
63272300544,
63263879168,
63359676416,
63357374464,
63357542400,
63358373888,
63359791104,
63361323008,
63363457024,
63494107136,
63494156288,
63489257472,
63490707456,
63488667648,
63458295808,
63462985728,
63580164096,
63581151232,
63584616448,
63609655296,
63608074240,
63610007552,
63607758848,
63749599232,
63745466368,
63718805504,
63722086400,
63728562176,
63731232768,
63729074176,
63842201600,
63847124992,
63850708992,
63853719552,
63846064128,
63846113280,
63848321024,
63970734080,
63991717888,
63989817344,
63985319936,
63983939584,
63975882752,
63976255488,
63973568512,
64091373568,
64083685376,
64078811136,
64100171776,
64087904256,
64069447680,
64067096576,
64095731712,
64224346112,
64185745408,
64170352640,
64157536256
],
"disk_read_mb": [
0.0,
0.0,
71.01,
35.58,
0.0,
2.93,
89.18,
0.0,
0.0,
92.41,
0.0,
0.0,
76.71,
3.39,
0.0,
12.48,
48.82,
0.0,
0.0,
92.22,
0.0,
0.0,
44.7,
41.48,
0.0,
0.0,
83.51,
0.0,
0.0,
52.65,
20.67,
0.0,
0.0,
77.14,
0.0,
0.0,
21.58,
52.7,
0.0,
0.0,
74.56,
0.0,
0.0,
0.0,
65.27,
0.0,
0.0,
0.0,
48.73,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.89,
2.52,
3.25,
2.83
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
61.23,
76.01,
95.36,
0.0
]
},
"time": 1790714823.7293081
}
}
@@ -0,0 +1,815 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "1k",
"target_tokens": 1024,
"run": 1,
"run_id": "56b3dec5f002",
"corpus_repeated": false,
"time": "2026-09-29T20:40:39",
"prompt_tokens": 1092,
"completion_tokens": 256,
"ttft_s": 1.378,
"e2e_s": 4.115,
"api_prompt_tps": 792.3,
"api_decode_tps": 93.2,
"engine_prompt_tps": 808.1,
"engine_decode_tps": 93.0,
"log_lines": [
"strata serve: prompt 1092 tokens = 0 reused + 1092 read in 1351 ms (808.1 tok/s), 256 generated in 2753 ms (93.0 tok/s), drafts accepted 159 of 210, 1 checkpoints",
"strata serve: decode expert cache hit rate: 95.4% (137036 hits / 143638 lookups)"
],
"answer_head": "Based on the content of `CMakeLists.txt`, here is an explanation of its function and a proposed improvement.\n\n### Explanation of `CMakeLists.txt`\n\nThis file serves as the top-level build configuration for the **Strata Engine** (version 0.1.26). Its primary responsibilities are:\n\n1. **Project Defini",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
},
{
"projection": null,
"time": 1790714293.0977688,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1288.1,
"decode_ms": 2834.1,
"decode_tok_s": 90.3,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714290.8242896,
"duration_s": 1.8,
"finish": "stop",
"prompt_tokens": 1147,
"reused": 0,
"output_tokens": 40,
"engine_generated": 40,
"prompt_ms": 1304.0,
"decode_ms": 456.3,
"decode_tok_s": 87.7,
"hit_rate": 0.916
},
{
"projection": null,
"time": 1790714285.3293037,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 1094,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1899.7,
"decode_ms": 3080.2,
"decode_tok_s": 83.1,
"hit_rate": 0.946
},
{
"projection": null,
"time": 1790713900.001974,
"duration_s": 0.7,
"finish": "stop",
"prompt_tokens": 22,
"reused": 0,
"output_tokens": 7,
"engine_generated": 7,
"prompt_ms": 482.2,
"decode_ms": 197.4,
"decode_tok_s": 35.5,
"hit_rate": 0.707
}
],
"requests_kept": 11,
"totals": {
"since": 1790713882.6043305,
"requests": 11,
"prompt_tokens": 114775,
"reused": 0,
"output_tokens": 1944,
"prompt_ms": 60083.00000000001,
"decode_ms": 23035.299999999996
},
"hardware": {
"gpu_util": 94,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 45,
"gpu_power": 276.526,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.3330078125,
"gpu_pcie_tx_mb": 0.4765625,
"cpu": 87.0,
"ram_used": 63534440448,
"ram_total": 177175990272,
"disk_read_mb": 3.2598935177561885,
"disk_write_mb": 0.003747004043397918,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
99,
99,
42,
99,
99,
100,
99,
99,
99,
94,
99,
95,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
44,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
45,
42,
42,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45
],
"gpu_power": [
277.8,
276.98,
276.99,
264.47,
274.0,
276.95,
276.96,
277.85,
278.23,
277.83,
242.91,
278.73,
277.1,
247.26,
164.95,
142.09,
130.43,
119.16,
119.05,
119.02,
118.92,
118.89,
118.85,
118.74,
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53
],
"gpu_pcie_rx_mb": [
20099.78,
18385.74,
52.36,
17363.88,
9102.54,
10.44,
87.17,
12174.99,
8.39,
78.63,
439.12,
1555.01,
511.84,
0.33,
0.29,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33
],
"cpu": [
6.7,
5.9,
12.5,
10.7,
6.6,
10.7,
6.2,
7.2,
6.5,
5.9,
52.8,
100.0,
100.0,
46.0,
2.5,
9.7,
2.8,
11.4,
13.4,
2.8,
1.5,
1.3,
2.8,
1.6,
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0
],
"ram_used": [
63341527040,
63336820736,
63366373376,
63501127680,
63474081792,
63398842368,
63397171200,
63396274176,
63387021312,
63380054016,
63501307904,
63504547840,
63499546624,
63490957312,
63502053376,
63600914432,
63612030976,
63779962880,
63785050112,
63794016256,
63795236864,
63794536448,
63786823680,
63781208064,
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448
],
"disk_read_mb": [
0.2,
0.0,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.41,
2.29,
3.94,
1.13,
0.0,
0.0,
0.0,
0.0,
0.1,
0.14,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
91.56,
92.69,
83.62,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0
]
},
"time": 1790714443.884817
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "1k",
"target_tokens": 1024,
"run": 2,
"run_id": "5da89525cd83",
"corpus_repeated": false,
"time": "2026-09-29T20:40:43",
"prompt_tokens": 1149,
"completion_tokens": 256,
"ttft_s": 1.323,
"e2e_s": 4.156,
"api_prompt_tps": 868.4,
"api_decode_tps": 90.0,
"engine_prompt_tps": 885.5,
"engine_decode_tps": 89.9,
"log_lines": [
"strata serve: prompt 1149 tokens = 0 reused + 1149 read in 1298 ms (885.5 tok/s), 256 generated in 2847 ms (89.9 tok/s), drafts accepted 156 of 215, 1 checkpoints",
"strata serve: decode expert cache hit rate: 97.1% (144603 hits / 148933 lookups)"
],
"answer_head": "Based on the content provided, here is an explanation of the `CMakeLists.txt` file and a proposed improvement.\n\n### Explanation of `CMakeLists.txt`\n\nThis file is the top-level build configuration for the **Strata Engine** (specifically Phase 1, Step 1). Its primary responsibilities are:\n\n1. **Proje",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
},
{
"projection": null,
"time": 1790714293.0977688,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1288.1,
"decode_ms": 2834.1,
"decode_tok_s": 90.3,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714290.8242896,
"duration_s": 1.8,
"finish": "stop",
"prompt_tokens": 1147,
"reused": 0,
"output_tokens": 40,
"engine_generated": 40,
"prompt_ms": 1304.0,
"decode_ms": 456.3,
"decode_tok_s": 87.7,
"hit_rate": 0.916
},
{
"projection": null,
"time": 1790714285.3293037,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 1094,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1899.7,
"decode_ms": 3080.2,
"decode_tok_s": 83.1,
"hit_rate": 0.946
},
{
"projection": null,
"time": 1790713900.001974,
"duration_s": 0.7,
"finish": "stop",
"prompt_tokens": 22,
"reused": 0,
"output_tokens": 7,
"engine_generated": 7,
"prompt_ms": 482.2,
"decode_ms": 197.4,
"decode_tok_s": 35.5,
"hit_rate": 0.707
}
],
"requests_kept": 12,
"totals": {
"since": 1790713882.6043305,
"requests": 12,
"prompt_tokens": 115924,
"reused": 0,
"output_tokens": 2200,
"prompt_ms": 61380.600000000006,
"decode_ms": 25882.799999999996
},
"hardware": {
"gpu_util": 95,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 45,
"gpu_power": 273.597,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 1249.6943359375,
"gpu_pcie_tx_mb": 212.6689453125,
"cpu": 97.9,
"ram_used": 63536766976,
"ram_total": 177175990272,
"disk_read_mb": 2.8181744035205307,
"disk_write_mb": 0.014930725316665065,
"tok_s": 76.9743768862725,
"tok_s_mean": 90.24600065341676
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
99,
100,
99,
99,
99,
94,
99,
95,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
45,
45,
45,
45,
45,
45,
45,
45,
45,
42,
42,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45
],
"gpu_power": [
274.0,
276.95,
276.96,
277.85,
278.23,
277.83,
242.91,
278.73,
277.1,
247.26,
164.95,
142.09,
130.43,
119.16,
119.05,
119.02,
118.92,
118.89,
118.85,
118.74,
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6
],
"gpu_pcie_rx_mb": [
9102.54,
10.44,
87.17,
12174.99,
8.39,
78.63,
439.12,
1555.01,
511.84,
0.33,
0.29,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69
],
"cpu": [
6.6,
10.7,
6.2,
7.2,
6.5,
5.9,
52.8,
100.0,
100.0,
46.0,
2.5,
9.7,
2.8,
11.4,
13.4,
2.8,
1.5,
1.3,
2.8,
1.6,
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9
],
"ram_used": [
63474081792,
63398842368,
63397171200,
63396274176,
63387021312,
63380054016,
63501307904,
63504547840,
63499546624,
63490957312,
63502053376,
63600914432,
63612030976,
63779962880,
63785050112,
63794016256,
63795236864,
63794536448,
63786823680,
63781208064,
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.41,
2.29,
3.94,
1.13,
0.0,
0.0,
0.0,
0.0,
0.1,
0.14,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
91.56,
92.69,
83.62,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97
]
},
"time": 1790714448.544591
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "1k",
"target_tokens": 1024,
"run": 3,
"run_id": "3ad6050d1d4c",
"corpus_repeated": false,
"time": "2026-09-29T20:40:48",
"prompt_tokens": 1135,
"completion_tokens": 256,
"ttft_s": 1.33,
"e2e_s": 4.007,
"api_prompt_tps": 853.1,
"api_decode_tps": 95.3,
"engine_prompt_tps": 869.7,
"engine_decode_tps": 95.1,
"log_lines": [
"strata serve: prompt 1135 tokens = 0 reused + 1135 read in 1305 ms (869.7 tok/s), 256 generated in 2691 ms (95.1 tok/s), drafts accepted 159 of 217, 1 checkpoints",
"strata serve: decode expert cache hit rate: 97.2% (145229 hits / 149472 lookups)"
],
"answer_head": "The `CMakeLists.txt` file defines the top-level build configuration for the **Strata Engine** project. Its primary responsibilities include:\n\n1. **Project Definition**: Sets the project name (`strata`), version (`0.1.26`), and language standard (C++20).\n2. **Target Management**: Conditionally adds",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
},
{
"projection": null,
"time": 1790714293.0977688,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1288.1,
"decode_ms": 2834.1,
"decode_tok_s": 90.3,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714290.8242896,
"duration_s": 1.8,
"finish": "stop",
"prompt_tokens": 1147,
"reused": 0,
"output_tokens": 40,
"engine_generated": 40,
"prompt_ms": 1304.0,
"decode_ms": 456.3,
"decode_tok_s": 87.7,
"hit_rate": 0.916
},
{
"projection": null,
"time": 1790714285.3293037,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 1094,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1899.7,
"decode_ms": 3080.2,
"decode_tok_s": 83.1,
"hit_rate": 0.946
}
],
"requests_kept": 13,
"totals": {
"since": 1790713882.6043305,
"requests": 13,
"prompt_tokens": 117059,
"reused": 0,
"output_tokens": 2456,
"prompt_ms": 62685.700000000004,
"decode_ms": 28573.599999999995
},
"hardware": {
"gpu_util": 21,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 43,
"gpu_power": 268.452,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.28515625,
"gpu_pcie_tx_mb": 0.4287109375,
"cpu": 63.3,
"ram_used": 63492075520,
"ram_total": 177175990272,
"disk_read_mb": 1.6601509757982635,
"disk_write_mb": 0.022485114796364742,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
94,
99,
95,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95,
53,
100,
94,
96,
21
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
45,
45,
45,
45,
42,
42,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45,
44,
45,
45,
45,
43
],
"gpu_power": [
277.83,
242.91,
278.73,
277.1,
247.26,
164.95,
142.09,
130.43,
119.16,
119.05,
119.02,
118.92,
118.89,
118.85,
118.74,
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45
],
"gpu_pcie_rx_mb": [
78.63,
439.12,
1555.01,
511.84,
0.33,
0.29,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29
],
"cpu": [
5.9,
52.8,
100.0,
100.0,
46.0,
2.5,
9.7,
2.8,
11.4,
13.4,
2.8,
1.5,
1.3,
2.8,
1.6,
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3
],
"ram_used": [
63380054016,
63501307904,
63504547840,
63499546624,
63490957312,
63502053376,
63600914432,
63612030976,
63779962880,
63785050112,
63794016256,
63795236864,
63794536448,
63786823680,
63781208064,
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520
],
"disk_read_mb": [
0.0,
1.41,
2.29,
3.94,
1.13,
0.0,
0.0,
0.0,
0.0,
0.1,
0.14,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66
],
"tok_s": [
0.0,
91.56,
92.69,
83.62,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0
]
},
"time": 1790714453.0546403
}
}
@@ -0,0 +1,675 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "262k",
"target_tokens": 260864,
"run": 1,
"run_id": "459ef0e5c155",
"corpus_repeated": false,
"time": "2026-09-29T20:52:28",
"prompt_tokens": 232183,
"completion_tokens": 256,
"ttft_s": 131.32,
"e2e_s": 135.339,
"api_prompt_tps": 1768.1,
"api_decode_tps": 63.4,
"engine_prompt_tps": 1784.6,
"engine_decode_tps": 63.0,
"log_lines": [
"strata serve: prompt 232183 tokens = 0 reused + 232183 read in 130101 ms (1784.6 tok/s), 256 generated in 4061 ms (63.0 tok/s), drafts accepted 150 of 240, 6 checkpoints",
"strata serve: decode expert cache hit rate: 93.7% (149829 hits / 159942 lookups)"
],
"answer_head": "The last file is `serve/server.py` (the listing is truncated at the very end, in the `main()` function where it assigns `svc.gpu_index`).\n\n## What it does\n\nIt is the HTTP API layer of Strata: a pure-Python bridge between OpenAI/Anthropic-style clients and the C++ engine. Concretely:\n\n- **Engine adap",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 262144,
"images": false,
"version": "0.1.26",
"context": 262144,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10451,
"expert_cache_mib": 17355,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 385,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790715149.1813676,
"duration_s": 134.2,
"finish": "length",
"prompt_tokens": 232183,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 130101.1,
"decode_ms": 4061.2,
"decode_tok_s": 63.0,
"hit_rate": 0.937
}
],
"requests_kept": 1,
"totals": {
"since": 1790715131.4670517,
"requests": 1,
"prompt_tokens": 232183,
"reused": 0,
"output_tokens": 256,
"prompt_ms": 130101.1,
"decode_ms": 4061.2
},
"hardware": {
"gpu_util": 93,
"gpu_mem_used": 25512837120,
"gpu_mem_total": 25769803776,
"gpu_temp": 50,
"gpu_power": 278.227,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 1220.75,
"gpu_pcie_tx_mb": 478.41015625,
"cpu": 100.0,
"ram_used": 65694810112,
"ram_total": 177175990272,
"disk_read_mb": 3.754966568441275,
"disk_write_mb": 0.0,
"tok_s": 74.58045953935934,
"tok_s_mean": 62.37130450720771
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
100,
99,
100,
99,
100,
98,
100,
100,
100,
100,
100,
99,
99,
100,
99,
99,
100,
99,
100,
100,
98,
100,
100,
100,
97,
100,
100,
99,
99,
98,
97,
100,
100,
100,
99,
100,
100,
99,
99,
99,
100,
100,
100,
100,
100,
99,
100,
100,
100,
100,
100,
100,
3,
100,
100,
93,
94,
96,
93
],
"gpu_mem_used": [
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25412173824,
25512837120,
25512837120,
25512837120,
25512837120
],
"gpu_temp": [
49,
49,
49,
50,
49,
49,
49,
49,
49,
49,
49,
49,
49,
50,
49,
49,
49,
49,
50,
50,
49,
49,
50,
49,
50,
50,
50,
50,
50,
50,
50,
50,
50,
49,
50,
50,
50,
50,
50,
50,
50,
50,
49,
50,
50,
50,
51,
49,
49,
49,
49,
49,
49,
49,
50,
50,
47,
50,
50,
50
],
"gpu_power": [
279.11,
266.12,
276.9,
277.46,
279.35,
277.6,
278.96,
278.2,
276.29,
279.45,
275.58,
268.64,
275.16,
277.98,
275.78,
278.17,
279.67,
276.04,
279.46,
275.1,
265.27,
279.22,
280.54,
276.07,
280.55,
278.32,
274.82,
275.85,
280.08,
279.93,
266.81,
277.79,
274.52,
274.38,
279.74,
277.72,
274.64,
279.65,
280.34,
278.34,
277.27,
274.99,
265.64,
277.06,
278.38,
279.64,
279.6,
273.86,
273.12,
273.61,
275.7,
275.96,
276.36,
266.12,
265.34,
275.53,
242.04,
256.98,
274.43,
278.23
],
"gpu_pcie_rx_mb": [
28.08,
16676.85,
27.75,
7942.58,
15.78,
16.36,
19454.0,
15911.58,
26.8,
41.1,
28.75,
15.21,
24.79,
15.5,
12903.17,
15722.66,
13615.27,
5212.5,
21571.11,
9259.8,
29.85,
15.5,
9701.01,
153.35,
15.64,
30.23,
25023.46,
14.5,
29.71,
26217.94,
17128.85,
9320.26,
28.28,
28.94,
13.54,
87.12,
1377.34,
10125.25,
29.04,
30.52,
15905.0,
8753.63,
7850.26,
26.85,
27.04,
15.31,
3817.42,
27.99,
26.89,
26269.48,
26779.27,
20418.6,
6900.17,
6532.96,
1637.36,
26114.94,
1472.71,
1607.46,
3050.8,
1220.75
],
"cpu": [
6.4,
10.7,
11.7,
16.5,
8.6,
6.3,
18.6,
6.0,
5.9,
5.7,
8.8,
12.7,
5.6,
5.9,
6.6,
12.9,
11.3,
13.4,
13.0,
9.8,
14.3,
23.4,
6.3,
5.9,
7.9,
13.4,
9.7,
6.5,
6.7,
5.9,
10.3,
17.8,
14.9,
7.1,
8.8,
5.8,
16.3,
7.3,
5.7,
7.3,
5.7,
8.0,
14.4,
7.4,
6.6,
5.9,
15.4,
12.5,
6.2,
6.9,
7.8,
7.2,
6.8,
7.1,
5.7,
6.0,
44.6,
99.9,
99.9,
100.0
],
"ram_used": [
65760505856,
65825771520,
65805475840,
65899847680,
65884385280,
65881726976,
65877250048,
65865695232,
65856700416,
65843732480,
65918058496,
65911185408,
65901252608,
65896804352,
65888411648,
65880047616,
65859633152,
65903091712,
65906130944,
65929789440,
65996169216,
65697763328,
65680461824,
65660788736,
65639858176,
65624662016,
65614233600,
65604620288,
65594793984,
65589379072,
65666322432,
65661911040,
65706741760,
65701203968,
65697587200,
65691623424,
65677221888,
65665282048,
65657679872,
65628098560,
65621381120,
65695760384,
65678503936,
65672011776,
65665482752,
65658216448,
65673232384,
65655951360,
65646583808,
65641152512,
65659457536,
65656025088,
65651355648,
65716195328,
65703702528,
65693274112,
65702584320,
65687781376,
65690525696,
65694810112
],
"disk_read_mb": [
0.0,
84.11,
102.3,
0.0,
0.0,
0.0,
175.14,
0.0,
0.0,
0.0,
43.72,
150.32,
0.0,
0.0,
0.0,
118.91,
69.66,
0.0,
0.0,
0.0,
128.82,
137.4,
0.0,
0.0,
0.0,
143.2,
89.93,
0.0,
0.0,
0.0,
81.49,
154.61,
0.0,
0.0,
0.0,
0.0,
196.96,
31.0,
0.0,
0.0,
0.0,
22.35,
158.36,
0.0,
0.0,
0.0,
0.0,
63.48,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.53,
4.38,
2.32,
3.75
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
41.84,
65.33,
69.08,
74.58
]
},
"time": 1790715283.9323688
}
}
@@ -0,0 +1,689 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "262k",
"target_tokens": 260864,
"run": 2,
"run_id": "fbabd65a593d",
"corpus_repeated": false,
"time": "2026-09-29T20:54:43",
"prompt_tokens": 259589,
"completion_tokens": 92,
"ttft_s": 152.099,
"e2e_s": 153.446,
"api_prompt_tps": 1706.7,
"api_decode_tps": 67.5,
"engine_prompt_tps": 1721.6,
"engine_decode_tps": 67.3,
"log_lines": [
"strata serve: prompt 259589 tokens = 0 reused + 259589 read in 150784 ms (1721.6 tok/s), 92 generated in 1367 ms (67.3 tok/s), drafts accepted 61 of 75, 6 checkpoints",
"strata serve: decode expert cache hit rate: 90.0% (43983 hits / 48863 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand the codebase and the last file in detail.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 262144,
"images": false,
"version": "0.1.26",
"context": 262144,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10451,
"expert_cache_mib": 17355,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 385,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790715285.1507986,
"duration_s": 152.2,
"finish": "stop",
"prompt_tokens": 259589,
"reused": 0,
"output_tokens": 92,
"engine_generated": 92,
"prompt_ms": 150783.8,
"decode_ms": 1366.8,
"decode_tok_s": 67.3,
"hit_rate": 0.9
},
{
"projection": null,
"time": 1790715149.1813676,
"duration_s": 134.2,
"finish": "length",
"prompt_tokens": 232183,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 130101.1,
"decode_ms": 4061.2,
"decode_tok_s": 63.0,
"hit_rate": 0.937
}
],
"requests_kept": 2,
"totals": {
"since": 1790715131.4670517,
"requests": 2,
"prompt_tokens": 491772,
"reused": 0,
"output_tokens": 348,
"prompt_ms": 280884.9,
"decode_ms": 5428.0
},
"hardware": {
"gpu_util": 96,
"gpu_mem_used": 25512837120,
"gpu_mem_total": 25769803776,
"gpu_temp": 52,
"gpu_power": 277.319,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5709.8388671875,
"gpu_pcie_tx_mb": 1049.041015625,
"cpu": 99.9,
"ram_used": 65638817792,
"ram_total": 177175990272,
"disk_read_mb": 3.1622365794124767,
"disk_write_mb": 0.03737868297177868,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
100,
100,
99,
100,
100,
100,
99,
100,
100,
99,
99,
97,
100,
100,
100,
99,
99,
97,
100,
100,
100,
100,
60,
100,
100,
99,
99,
100,
98,
99,
99,
100,
100,
100,
100,
100,
100,
100,
100,
100,
98,
100,
100,
99,
99,
100,
98,
100,
99,
100,
100,
100,
100,
100,
99,
100,
99,
96,
96
],
"gpu_mem_used": [
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120
],
"gpu_temp": [
51,
52,
52,
51,
51,
52,
51,
50,
51,
52,
51,
51,
51,
51,
51,
52,
51,
51,
51,
51,
51,
51,
52,
50,
52,
51,
52,
52,
51,
51,
51,
51,
51,
51,
51,
51,
52,
52,
52,
52,
52,
52,
51,
51,
51,
52,
51,
52,
52,
52,
52,
52,
52,
52,
52,
52,
52,
52,
51,
52
],
"gpu_power": [
280.1,
277.72,
269.31,
279.51,
276.6,
277.19,
280.46,
278.19,
275.14,
276.45,
280.49,
278.01,
265.6,
274.96,
274.76,
278.94,
279.21,
278.77,
277.22,
274.11,
273.93,
275.55,
279.88,
274.53,
278.22,
280.08,
279.56,
277.48,
275.9,
276.58,
275.74,
275.62,
274.27,
272.69,
272.53,
276.33,
279.54,
279.3,
279.1,
279.0,
278.24,
279.57,
276.45,
276.52,
276.57,
276.89,
273.45,
267.54,
275.91,
275.91,
277.91,
276.31,
276.26,
279.97,
276.73,
278.79,
274.29,
278.64,
241.5,
277.32
],
"gpu_pcie_rx_mb": [
24.6,
11576.41,
14790.49,
31.66,
20927.76,
28.32,
23015.64,
14269.26,
27.42,
9814.79,
27090.45,
28.08,
29.28,
30.8,
22511.15,
22487.21,
30.47,
74.67,
20330.0,
20889.04,
27.89,
31.8,
55.55,
14868.74,
15.35,
20128.63,
27.13,
26.56,
53.21,
24118.71,
16327.71,
9496.97,
20100.59,
27.75,
15.97,
14788.58,
13.49,
13957.07,
26.13,
27.75,
26181.89,
48.68,
16340.3,
5056.67,
25172.95,
16.36,
87.55,
33.81,
31.28,
31.66,
35.0,
35.09,
8309.17,
6276.99,
31.14,
13669.87,
18489.17,
29.47,
2057.6,
5709.84
],
"cpu": [
6.6,
7.6,
11.4,
12.8,
6.6,
6.0,
6.6,
11.6,
10.6,
6.8,
5.6,
6.1,
9.8,
25.0,
9.1,
5.9,
6.8,
6.1,
16.7,
7.0,
8.8,
6.9,
5.9,
12.8,
11.2,
5.6,
6.5,
14.2,
10.7,
16.4,
8.1,
7.0,
6.2,
5.9,
7.4,
13.8,
6.0,
5.7,
7.0,
6.1,
6.2,
15.3,
15.5,
12.5,
6.3,
6.3,
6.0,
14.9,
7.3,
9.6,
6.6,
6.1,
6.6,
8.6,
5.9,
6.2,
16.0,
9.9,
42.7,
99.9
],
"ram_used": [
65829687296,
65809809408,
65878708224,
65862221824,
65854197760,
65848958976,
65840418816,
65838673920,
65828872192,
65821380608,
65813520384,
65804607488,
65870708736,
65884573696,
65869344768,
65860734976,
65835606016,
65825009664,
65818324992,
65817894912,
65821642752,
65816698880,
65812000768,
65862680576,
65843482624,
65833279488,
65827409920,
65838510080,
65830367232,
65803018240,
65796870144,
65792782336,
65785704448,
65781006336,
65859014656,
65839325184,
65832935424,
65818849280,
65813626880,
65805553664,
65796202496,
65790906368,
65792847872,
65822486528,
65813880832,
65796804608,
65786474496,
65854476288,
65841573888,
65829576704,
65816891392,
65810354176,
65800015872,
65793110016,
65783308288,
65776508928,
65580986368,
65575313408,
65644572672,
65638817792
],
"disk_read_mb": [
0.0,
0.0,
99.27,
135.95,
0.0,
0.0,
0.0,
113.06,
91.94,
0.0,
0.0,
0.0,
46.52,
161.04,
0.0,
0.0,
0.0,
0.0,
199.72,
0.0,
0.0,
0.0,
0.0,
91.5,
66.56,
0.0,
0.0,
0.0,
0.0,
191.98,
0.0,
0.0,
0.0,
0.0,
13.73,
127.69,
0.0,
0.0,
0.0,
0.0,
1.52,
125.36,
0.0,
0.0,
0.0,
0.0,
0.0,
171.54,
7.82,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.75,
3.16
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
69.44,
0.0
]
},
"time": 1790715437.8967788
}
}
@@ -0,0 +1,703 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "262k",
"target_tokens": 260864,
"run": 3,
"run_id": "40a721fd9a17",
"corpus_repeated": false,
"time": "2026-09-29T20:57:17",
"prompt_tokens": 261068,
"completion_tokens": 256,
"ttft_s": 152.605,
"e2e_s": 156.279,
"api_prompt_tps": 1710.7,
"api_decode_tps": 69.4,
"engine_prompt_tps": 1725.6,
"engine_decode_tps": 69.3,
"log_lines": [
"strata serve: prompt 261068 tokens = 0 reused + 261068 read in 151288 ms (1725.6 tok/s), 256 generated in 3693 ms (69.3 tok/s), drafts accepted 151 of 231, 6 checkpoints",
"strata serve: decode expert cache hit rate: 96.3% (153481 hits / 159304 lookups)"
],
"answer_head": "I'll analyze the last file in the repository listing and then propose a concrete improvement.\n\n## What `serve/web/app.js` does\n\nThis file is the **entire client-side logic of the Strata web application** \u2014 a framework-free, single-file JavaScript app that talks only to the local Strata server. It po",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 262144,
"images": false,
"version": "0.1.26",
"context": 262144,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10451,
"expert_cache_mib": 17355,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 385,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790715439.1095636,
"duration_s": 155.1,
"finish": "length",
"prompt_tokens": 261068,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 151288.5,
"decode_ms": 3693.0,
"decode_tok_s": 69.3,
"hit_rate": 0.963
},
{
"projection": null,
"time": 1790715285.1507986,
"duration_s": 152.2,
"finish": "stop",
"prompt_tokens": 259589,
"reused": 0,
"output_tokens": 92,
"engine_generated": 92,
"prompt_ms": 150783.8,
"decode_ms": 1366.8,
"decode_tok_s": 67.3,
"hit_rate": 0.9
},
{
"projection": null,
"time": 1790715149.1813676,
"duration_s": 134.2,
"finish": "length",
"prompt_tokens": 232183,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 130101.1,
"decode_ms": 4061.2,
"decode_tok_s": 63.0,
"hit_rate": 0.937
}
],
"requests_kept": 3,
"totals": {
"since": 1790715131.4670517,
"requests": 3,
"prompt_tokens": 752840,
"reused": 0,
"output_tokens": 604,
"prompt_ms": 432173.4,
"decode_ms": 9121.0
},
"hardware": {
"gpu_util": 92,
"gpu_mem_used": 25512837120,
"gpu_mem_total": 25769803776,
"gpu_temp": 53,
"gpu_power": 277.576,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 3810.1669921875,
"gpu_pcie_tx_mb": 299.7392578125,
"cpu": 100.0,
"ram_used": 65843089408,
"ram_total": 177175990272,
"disk_read_mb": 4.922097648659462,
"disk_write_mb": 0.0,
"tok_s": 68.55526509763148,
"tok_s_mean": 69.76955378630859
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
99,
100,
99,
99,
100,
100,
100,
100,
100,
100,
100,
100,
99,
100,
100,
100,
100,
100,
99,
100,
98,
99,
99,
100,
100,
100,
100,
100,
100,
100,
100,
98,
100,
100,
100,
99,
99,
100,
100,
100,
100,
100,
100,
88,
100,
100,
100,
99,
99,
99,
100,
100,
100,
100,
100,
100,
97,
95,
95,
92
],
"gpu_mem_used": [
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120,
25512837120
],
"gpu_temp": [
53,
52,
53,
52,
52,
52,
53,
53,
52,
52,
53,
53,
53,
52,
52,
53,
53,
53,
53,
53,
53,
53,
53,
52,
52,
53,
53,
53,
53,
53,
53,
52,
52,
52,
52,
53,
53,
53,
53,
53,
53,
53,
53,
52,
53,
53,
52,
53,
53,
53,
53,
53,
53,
53,
53,
53,
53,
53,
53,
53
],
"gpu_power": [
279.28,
276.25,
280.52,
280.21,
276.32,
278.64,
280.39,
275.19,
275.3,
267.01,
278.7,
279.27,
280.07,
277.82,
274.89,
273.96,
277.23,
280.24,
279.4,
277.21,
266.21,
276.82,
277.27,
274.7,
272.68,
273.87,
273.33,
275.44,
276.56,
276.53,
276.52,
263.9,
276.06,
275.76,
276.06,
275.68,
275.74,
273.79,
276.62,
276.84,
276.88,
276.17,
275.71,
273.17,
265.54,
275.78,
273.31,
275.66,
275.72,
276.2,
275.38,
273.99,
273.72,
275.56,
276.07,
276.57,
245.75,
278.73,
277.86,
277.58
],
"gpu_pcie_rx_mb": [
4135.46,
6890.58,
13.64,
3437.09,
30.71,
20378.88,
15.64,
30.99,
20391.65,
19570.21,
4926.97,
27.94,
28.08,
26564.6,
4245.0,
29.13,
28.94,
7148.27,
17857.03,
28.51,
11700.44,
28.28,
27.51,
26015.42,
14.3,
16.36,
11904.38,
29.71,
29.99,
33.33,
14.83,
30.04,
28.8,
28.18,
26.08,
17.07,
26755.14,
31.04,
30.14,
30.8,
29.04,
30.8,
33.24,
27187.54,
19414.33,
9223.17,
54.17,
12.68,
24.32,
33.43,
12868.02,
32.04,
29.66,
34.62,
20107.13,
84.11,
1655.15,
10931.06,
1614.47,
3810.17
],
"cpu": [
12.6,
5.5,
6.4,
6.8,
13.7,
9.3,
10.4,
12.8,
12.2,
11.8,
13.0,
6.1,
6.4,
6.3,
8.4,
15.9,
9.1,
6.5,
7.0,
5.8,
13.8,
18.7,
8.2,
6.0,
7.7,
8.1,
14.9,
5.8,
6.5,
6.5,
5.9,
9.5,
9.8,
6.4,
6.2,
13.8,
11.5,
9.4,
9.4,
6.0,
7.2,
5.8,
6.6,
6.5,
15.9,
8.9,
7.4,
6.0,
6.1,
9.0,
13.9,
6.6,
8.0,
6.2,
6.0,
7.2,
56.6,
100.0,
100.0,
100.0
],
"ram_used": [
65659777024,
65650483200,
65649508352,
65644490752,
65632600064,
65621151744,
65675010048,
65661538304,
65681547264,
65747542016,
65735454720,
65723609088,
65715372032,
65702187008,
65677402112,
65653993472,
65667379200,
65663696896,
65657884672,
65648963584,
65722257408,
65791442944,
65798762496,
65787301888,
65781350400,
65659375616,
65646817280,
65635090432,
65627262976,
65615314944,
65606516736,
65678639104,
65669410816,
65663270912,
65656647680,
65739636736,
65798643712,
65792847872,
65780387840,
65772281856,
65774555136,
65768087552,
65765552128,
65838772224,
65833267200,
65850757120,
65824538624,
65812451328,
65801834496,
65796722688,
65808052224,
65799196672,
65796362240,
65791713280,
65787756544,
65798152192,
65876860928,
65866027008,
65852674048,
65843089408
],
"disk_read_mb": [
116.54,
0.0,
0.0,
0.0,
150.82,
68.05,
0.0,
0.0,
0.0,
84.44,
137.56,
0.0,
0.0,
0.0,
19.83,
193.88,
0.0,
0.0,
0.0,
0.0,
143.92,
24.87,
0.0,
0.0,
0.0,
25.89,
153.9,
0.0,
0.0,
0.0,
0.0,
69.98,
56.36,
0.0,
0.0,
0.0,
0.0,
48.96,
64.15,
0.0,
0.0,
0.0,
0.0,
0.0,
206.65,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.78,
4.65,
4.44,
4.92
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
74.98,
63.75,
72.35,
68.56
]
},
"time": 1790715594.6843412
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "563f1c703ebe",
"corpus_repeated": false,
"time": "2026-09-29T20:41:08",
"prompt_tokens": 34932,
"completion_tokens": 256,
"ttft_s": 16.748,
"e2e_s": 19.56,
"api_prompt_tps": 2085.7,
"api_decode_tps": 90.7,
"engine_prompt_tps": 2110.2,
"engine_decode_tps": 90.6,
"log_lines": [
"strata serve: prompt 34932 tokens = 0 reused + 34932 read in 16554 ms (2110.2 tok/s), 256 generated in 2827 ms (90.6 tok/s), drafts accepted 167 of 216, 3 checkpoints",
"strata serve: decode expert cache hit rate: 94.1% (133137 hits / 141416 lookups)"
],
"answer_head": "I'll analyze the last file in the repository listing and propose an improvement.\n\n## What `docs/DETAILS.md` does\n\nThis is the comprehensive technical documentation file for the Strata project. It serves as the single source of truth for:\n\n1. **Performance benchmarks** \u2014 Detailed tables of prompt-pro",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
}
],
"requests_kept": 17,
"totals": {
"since": 1790713882.6043305,
"requests": 17,
"prompt_tokens": 164273,
"reused": 0,
"output_tokens": 3366,
"prompt_ms": 86199.0,
"decode_ms": 38719.19999999999
},
"hardware": {
"gpu_util": 97,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 46,
"gpu_power": 278.81,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 5630.111328125,
"gpu_pcie_tx_mb": 76.2939453125,
"cpu": 100.0,
"ram_used": 63789760512,
"ram_total": 177175990272,
"disk_read_mb": 2.3587450688100042,
"disk_write_mb": 0.1268945131954749,
"tok_s": 96.52070218780436,
"tok_s_mean": 91.25774344883004
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95,
53,
100,
94,
96,
21,
99,
99,
92,
97,
97,
0,
98,
99,
98,
0,
99,
100,
99,
96,
96,
0,
100,
99,
100,
100,
99,
100,
100,
99,
100,
99,
100,
99,
99,
99,
100,
98,
99,
97
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45,
44,
45,
45,
45,
43,
45,
45,
45,
45,
46,
42,
46,
45,
46,
42,
45,
45,
45,
46,
46,
42,
46,
46,
46,
46,
46,
45,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46
],
"gpu_power": [
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45,
217.39,
278.78,
252.44,
278.12,
278.79,
215.59,
278.37,
251.8,
276.73,
219.4,
271.43,
276.62,
251.66,
277.46,
278.06,
194.1,
265.98,
277.8,
274.38,
278.56,
277.99,
277.15,
264.89,
276.96,
277.37,
277.24,
276.83,
276.94,
278.15,
264.71,
273.73,
243.99,
277.71,
278.81
],
"gpu_pcie_rx_mb": [
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29,
11.78,
84.59,
865.12,
8675.62,
0.33,
3342.49,
34.05,
7461.5,
4551.6,
6961.73,
24513.15,
26324.56,
679.21,
426.48,
0.33,
10.87,
10442.35,
23162.22,
22324.94,
24878.6,
26870.2,
14619.68,
11419.68,
893.4,
13515.52,
20953.08,
7.87,
14.59,
23972.7,
9329.51,
82.11,
7527.59,
4538.68,
5630.11
],
"cpu": [
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3,
5.7,
6.4,
81.2,
100.0,
93.8,
14.8,
15.8,
37.5,
100.0,
32.6,
6.8,
6.6,
96.7,
100.0,
83.5,
5.1,
7.7,
6.8,
5.8,
11.1,
14.6,
9.1,
8.4,
7.3,
7.4,
7.0,
7.1,
6.5,
5.9,
6.0,
6.9,
72.2,
100.0,
100.0
],
"ram_used": [
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520,
63440269312,
63431364608,
63482470400,
63473512448,
63471906816,
63401848832,
63554486272,
63453114368,
63441051648,
63399321600,
63389306880,
63427080192,
63418408960,
63417094144,
63416299520,
63358083072,
63351615488,
63342723072,
63336611840,
63371808768,
63426170880,
63504416768,
63594704896,
63611879424,
63612047360,
63599980544,
63573508096,
63570501632,
63568433152,
63702056960,
63700324352,
63800950784,
63801184256,
63789760512
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66,
0.64,
0.0,
2.25,
2.98,
2.66,
0.64,
0.0,
0.21,
2.1,
1.17,
0.0,
0.0,
1.29,
3.73,
2.96,
0.82,
0.0,
0.0,
0.35,
0.0,
0.0,
0.0,
0.23,
0.0,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.7,
0.31,
2.36
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0,
0.0,
0.0,
102.14,
97.9,
0.0,
0.0,
0.0,
89.96,
98.26,
0.0,
0.0,
0.0,
93.47,
116.21,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.18,
97.71,
96.52
]
},
"time": 1790714488.9946597
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "283cb867e188",
"corpus_repeated": false,
"time": "2026-09-29T20:41:28",
"prompt_tokens": 31582,
"completion_tokens": 256,
"ttft_s": 14.807,
"e2e_s": 18.058,
"api_prompt_tps": 2132.9,
"api_decode_tps": 78.4,
"engine_prompt_tps": 2160.4,
"engine_decode_tps": 78.3,
"log_lines": [
"strata serve: prompt 31582 tokens = 0 reused + 31582 read in 14619 ms (2160.4 tok/s), 256 generated in 3271 ms (78.3 tok/s), drafts accepted 161 of 240, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.0% (151459 hits / 157708 lookups)"
],
"answer_head": "The last file in the provided list is `docs/DETAILS.md`.\n\n### What it does\nThis file serves as the **comprehensive technical manual and reference guide** for the Strata engine. While the `README.md` focuses on quick installation and high-level marketing, `DETAILS.md` provides the deep technical spec",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
}
],
"requests_kept": 18,
"totals": {
"since": 1790713882.6043305,
"requests": 18,
"prompt_tokens": 195855,
"reused": 0,
"output_tokens": 3622,
"prompt_ms": 100817.7,
"decode_ms": 41989.89999999999
},
"hardware": {
"gpu_util": 94,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 47,
"gpu_power": 276.188,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.380859375,
"gpu_pcie_tx_mb": 0.4287109375,
"cpu": 84.0,
"ram_used": 63683891200,
"ram_total": 177175990272,
"disk_read_mb": 2.12697518787369,
"disk_write_mb": 0.05242544477153462,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
21,
98,
95,
53,
100,
94,
96,
21,
99,
99,
92,
97,
97,
0,
98,
99,
98,
0,
99,
100,
99,
96,
96,
0,
100,
99,
100,
100,
99,
100,
100,
99,
100,
99,
100,
99,
99,
99,
100,
98,
99,
97,
0,
99,
99,
99,
99,
99,
99,
98,
100,
99,
100,
99,
99,
99,
73,
98,
97,
94
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
43,
45,
45,
44,
45,
45,
45,
43,
45,
45,
45,
45,
46,
42,
46,
45,
46,
42,
45,
45,
45,
46,
46,
42,
46,
46,
46,
46,
46,
45,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
43,
46,
47,
46,
46,
46,
47,
46,
47,
46,
47,
46,
46,
46,
44,
46,
46,
47
],
"gpu_power": [
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45,
217.39,
278.78,
252.44,
278.12,
278.79,
215.59,
278.37,
251.8,
276.73,
219.4,
271.43,
276.62,
251.66,
277.46,
278.06,
194.1,
265.98,
277.8,
274.38,
278.56,
277.99,
277.15,
264.89,
276.96,
277.37,
277.24,
276.83,
276.94,
278.15,
264.71,
273.73,
243.99,
277.71,
278.81,
203.42,
258.01,
277.13,
277.38,
277.05,
276.55,
275.55,
267.16,
280.52,
277.94,
278.68,
277.45,
276.52,
278.47,
255.06,
250.07,
273.21,
276.19
],
"gpu_pcie_rx_mb": [
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29,
11.78,
84.59,
865.12,
8675.62,
0.33,
3342.49,
34.05,
7461.5,
4551.6,
6961.73,
24513.15,
26324.56,
679.21,
426.48,
0.33,
10.87,
10442.35,
23162.22,
22324.94,
24878.6,
26870.2,
14619.68,
11419.68,
893.4,
13515.52,
20953.08,
7.87,
14.59,
23972.7,
9329.51,
82.11,
7527.59,
4538.68,
5630.11,
6.67,
11788.08,
773.91,
87.02,
13.59,
4.53,
50.21,
7.15,
6744.72,
14.45,
115.11,
2575.49,
26114.03,
3364.04,
3375.15,
957.73,
2766.08,
0.38
],
"cpu": [
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3,
5.7,
6.4,
81.2,
100.0,
93.8,
14.8,
15.8,
37.5,
100.0,
32.6,
6.8,
6.6,
96.7,
100.0,
83.5,
5.1,
7.7,
6.8,
5.8,
11.1,
14.6,
9.1,
8.4,
7.3,
7.4,
7.0,
7.1,
6.5,
5.9,
6.0,
6.9,
72.2,
100.0,
100.0,
19.3,
8.8,
6.1,
7.1,
6.6,
7.1,
6.0,
6.8,
5.6,
5.5,
6.6,
7.8,
6.1,
6.2,
41.1,
99.9,
99.4,
84.0
],
"ram_used": [
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520,
63440269312,
63431364608,
63482470400,
63473512448,
63471906816,
63401848832,
63554486272,
63453114368,
63441051648,
63399321600,
63389306880,
63427080192,
63418408960,
63417094144,
63416299520,
63358083072,
63351615488,
63342723072,
63336611840,
63371808768,
63426170880,
63504416768,
63594704896,
63611879424,
63612047360,
63599980544,
63573508096,
63570501632,
63568433152,
63702056960,
63700324352,
63800950784,
63801184256,
63789760512,
63567470592,
63559606272,
63544537088,
63536496640,
63529500672,
63515496448,
63496245248,
63530811392,
63529254912,
63530737664,
63536521216,
63543078912,
63537020928,
63539232768,
63659114496,
63677952000,
63679279104,
63683891200
],
"disk_read_mb": [
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66,
0.64,
0.0,
2.25,
2.98,
2.66,
0.64,
0.0,
0.21,
2.1,
1.17,
0.0,
0.0,
1.29,
3.73,
2.96,
0.82,
0.0,
0.0,
0.35,
0.0,
0.0,
0.0,
0.23,
0.0,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.7,
0.31,
2.36,
0.74,
0.0,
0.0,
0.0,
0.35,
0.0,
0.0,
0.34,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.15,
1.22,
1.87,
2.13
],
"tok_s": [
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0,
0.0,
0.0,
102.14,
97.9,
0.0,
0.0,
0.0,
89.96,
98.26,
0.0,
0.0,
0.0,
93.47,
116.21,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.18,
97.71,
96.52,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
80.68,
75.74,
112.93,
0.0
]
},
"time": 1790714507.5571826
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "1aba3d88be7a",
"corpus_repeated": false,
"time": "2026-09-29T20:41:47",
"prompt_tokens": 31602,
"completion_tokens": 256,
"ttft_s": 14.833,
"e2e_s": 17.604,
"api_prompt_tps": 2130.5,
"api_decode_tps": 92.0,
"engine_prompt_tps": 2161.9,
"engine_decode_tps": 91.9,
"log_lines": [
"strata serve: prompt 31602 tokens = 0 reused + 31602 read in 14618 ms (2161.9 tok/s), 256 generated in 2785 ms (91.9 tok/s), drafts accepted 160 of 207, 2 checkpoints",
"strata serve: decode expert cache hit rate: 96.5% (137828 hits / 142765 lookups)"
],
"answer_head": "The last file in the provided list is `docs/DETAILS.md`.\n\n### What it does\nThis file serves as the comprehensive technical documentation and user manual for the \"Strata\" engine. It bridges the gap between the high-level marketing pitch in `README.md` and the raw source code. Specifically, it:\n\n1. *",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714507.7469585,
"duration_s": 17.4,
"finish": "length",
"prompt_tokens": 31602,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14617.7,
"decode_ms": 2785.2,
"decode_tok_s": 91.9,
"hit_rate": 0.965
},
{
"projection": null,
"time": 1790714489.1532733,
"duration_s": 17.9,
"finish": "length",
"prompt_tokens": 31582,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14618.7,
"decode_ms": 3270.7,
"decode_tok_s": 78.3,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714469.1007972,
"duration_s": 19.4,
"finish": "length",
"prompt_tokens": 34932,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 16553.9,
"decode_ms": 2826.7,
"decode_tok_s": 90.6,
"hit_rate": 0.941
},
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
}
],
"requests_kept": 19,
"totals": {
"since": 1790713882.6043305,
"requests": 19,
"prompt_tokens": 227457,
"reused": 0,
"output_tokens": 3878,
"prompt_ms": 115435.4,
"decode_ms": 44775.099999999984
},
"hardware": {
"gpu_util": 94,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 47,
"gpu_power": 277.644,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 3986.787109375,
"gpu_pcie_tx_mb": 397.443359375,
"cpu": 99.9,
"ram_used": 63539171328,
"ram_total": 177175990272,
"disk_read_mb": 3.5686025775501298,
"disk_write_mb": 0.3811491758221081,
"tok_s": 96.24470767975828,
"tok_s_mean": 94.09593644569512
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
99,
100,
99,
96,
96,
0,
100,
99,
100,
100,
99,
100,
100,
99,
100,
99,
100,
99,
99,
99,
100,
98,
99,
97,
0,
99,
99,
99,
99,
99,
99,
98,
100,
99,
100,
99,
99,
99,
73,
98,
97,
94,
100,
100,
99,
99,
99,
99,
99,
100,
99,
100,
100,
100,
99,
99,
97,
97,
94
],
"gpu_mem_used": [
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
42,
45,
45,
45,
46,
46,
42,
46,
46,
46,
46,
46,
45,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
46,
43,
46,
47,
46,
46,
46,
47,
46,
47,
46,
47,
46,
46,
46,
44,
46,
46,
47,
46,
46,
47,
46,
46,
47,
47,
47,
47,
47,
47,
47,
47,
47,
46,
47,
47
],
"gpu_power": [
219.4,
271.43,
276.62,
251.66,
277.46,
278.06,
194.1,
265.98,
277.8,
274.38,
278.56,
277.99,
277.15,
264.89,
276.96,
277.37,
277.24,
276.83,
276.94,
278.15,
264.71,
273.73,
243.99,
277.71,
278.81,
203.42,
258.01,
277.13,
277.38,
277.05,
276.55,
275.55,
267.16,
280.52,
277.94,
278.68,
277.45,
276.52,
278.47,
255.06,
250.07,
273.21,
276.19,
200.05,
276.81,
276.45,
275.4,
277.81,
277.45,
277.14,
266.34,
281.85,
279.13,
278.52,
278.21,
279.47,
278.62,
244.74,
278.38,
277.64
],
"gpu_pcie_rx_mb": [
6961.73,
24513.15,
26324.56,
679.21,
426.48,
0.33,
10.87,
10442.35,
23162.22,
22324.94,
24878.6,
26870.2,
14619.68,
11419.68,
893.4,
13515.52,
20953.08,
7.87,
14.59,
23972.7,
9329.51,
82.11,
7527.59,
4538.68,
5630.11,
6.67,
11788.08,
773.91,
87.02,
13.59,
4.53,
50.21,
7.15,
6744.72,
14.45,
115.11,
2575.49,
26114.03,
3364.04,
3375.15,
957.73,
2766.08,
0.38,
16.21,
26374.96,
15489.62,
25149.82,
11.68,
14.21,
14.21,
5900.76,
15.35,
3692.53,
87.59,
8.2,
25347.8,
80.63,
5132.53,
22.03,
3986.79
],
"cpu": [
32.6,
6.8,
6.6,
96.7,
100.0,
83.5,
5.1,
7.7,
6.8,
5.8,
11.1,
14.6,
9.1,
8.4,
7.3,
7.4,
7.0,
7.1,
6.5,
5.9,
6.0,
6.9,
72.2,
100.0,
100.0,
19.3,
8.8,
6.1,
7.1,
6.6,
7.1,
6.0,
6.8,
5.6,
5.5,
6.6,
7.8,
6.1,
6.2,
41.1,
99.9,
99.4,
84.0,
4.7,
8.8,
7.4,
6.1,
6.1,
5.7,
6.3,
7.3,
6.8,
5.8,
8.4,
15.2,
18.1,
6.8,
56.4,
100.0,
99.9
],
"ram_used": [
63399321600,
63389306880,
63427080192,
63418408960,
63417094144,
63416299520,
63358083072,
63351615488,
63342723072,
63336611840,
63371808768,
63426170880,
63504416768,
63594704896,
63611879424,
63612047360,
63599980544,
63573508096,
63570501632,
63568433152,
63702056960,
63700324352,
63800950784,
63801184256,
63789760512,
63567470592,
63559606272,
63544537088,
63536496640,
63529500672,
63515496448,
63496245248,
63530811392,
63529254912,
63530737664,
63536521216,
63543078912,
63537020928,
63539232768,
63659114496,
63677952000,
63679279104,
63683891200,
63526555648,
63547674624,
63533957120,
63515795456,
63502536704,
63493373952,
63485927424,
63556431872,
63548153856,
63549214720,
63593517056,
63649341440,
63479009280,
63476772864,
63577780224,
63546908672,
63539171328
],
"disk_read_mb": [
1.17,
0.0,
0.0,
1.29,
3.73,
2.96,
0.82,
0.0,
0.0,
0.35,
0.0,
0.0,
0.0,
0.23,
0.0,
0.0,
0.22,
0.0,
0.0,
0.0,
0.0,
0.0,
0.7,
0.31,
2.36,
0.74,
0.0,
0.0,
0.0,
0.35,
0.0,
0.0,
0.34,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.15,
1.22,
1.87,
2.13,
0.67,
0.0,
0.0,
0.27,
0.0,
0.0,
0.0,
0.35,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.45,
0.74,
3.57
],
"tok_s": [
0.0,
0.0,
0.0,
93.47,
116.21,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
97.18,
97.71,
96.52,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
80.68,
75.74,
112.93,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
108.5,
87.33,
96.24
]
},
"time": 1790714525.664817
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "4k",
"target_tokens": 4096,
"run": 1,
"run_id": "6c6e9cb15bc9",
"corpus_repeated": false,
"time": "2026-09-29T20:40:53",
"prompt_tokens": 3881,
"completion_tokens": 256,
"ttft_s": 2.267,
"e2e_s": 5.041,
"api_prompt_tps": 1711.6,
"api_decode_tps": 91.9,
"engine_prompt_tps": 1745.2,
"engine_decode_tps": 91.7,
"log_lines": [
"strata serve: prompt 3881 tokens = 0 reused + 3881 read in 2224 ms (1745.2 tok/s), 256 generated in 2791 ms (91.7 tok/s), drafts accepted 155 of 215, 1 checkpoints",
"strata serve: decode expert cache hit rate: 97.3% (146401 hits / 150495 lookups)"
],
"answer_head": "The `CMakeLists.txt` file is the top-level build configuration for the **Strata Engine**. It orchestrates the compilation of the project, handling complex dependencies between CPU-only components, GPU kernels (CUDA/HIP), and testing infrastructure.\n\n### What the file does:\n\n1. **Project Configurati",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
},
{
"projection": null,
"time": 1790714293.0977688,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1288.1,
"decode_ms": 2834.1,
"decode_tok_s": 90.3,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714290.8242896,
"duration_s": 1.8,
"finish": "stop",
"prompt_tokens": 1147,
"reused": 0,
"output_tokens": 40,
"engine_generated": 40,
"prompt_ms": 1304.0,
"decode_ms": 456.3,
"decode_tok_s": 87.7,
"hit_rate": 0.916
}
],
"requests_kept": 14,
"totals": {
"since": 1790713882.6043305,
"requests": 14,
"prompt_tokens": 120940,
"reused": 0,
"output_tokens": 2712,
"prompt_ms": 64909.50000000001,
"decode_ms": 31364.099999999995
},
"hardware": {
"gpu_util": 97,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 46,
"gpu_power": 278.792,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.3330078125,
"gpu_pcie_tx_mb": 0.5244140625,
"cpu": 93.8,
"ram_used": 63471906816,
"ram_total": 177175990272,
"disk_read_mb": 2.6609869128828647,
"disk_write_mb": 0.0037478688913843163,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95,
53,
100,
94,
96,
21,
99,
99,
92,
97,
97
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
42,
41,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45,
44,
45,
45,
45,
43,
45,
45,
45,
45,
46
],
"gpu_power": [
164.95,
142.09,
130.43,
119.16,
119.05,
119.02,
118.92,
118.89,
118.85,
118.74,
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45,
217.39,
278.78,
252.44,
278.12,
278.79
],
"gpu_pcie_rx_mb": [
0.29,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29,
11.78,
84.59,
865.12,
8675.62,
0.33
],
"cpu": [
2.5,
9.7,
2.8,
11.4,
13.4,
2.8,
1.5,
1.3,
2.8,
1.6,
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3,
5.7,
6.4,
81.2,
100.0,
93.8
],
"ram_used": [
63502053376,
63600914432,
63612030976,
63779962880,
63785050112,
63794016256,
63795236864,
63794536448,
63786823680,
63781208064,
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520,
63440269312,
63431364608,
63482470400,
63473512448,
63471906816
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.1,
0.14,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66,
0.64,
0.0,
2.25,
2.98,
2.66
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0,
0.0,
0.0,
102.14,
97.9,
0.0
]
},
"time": 1790714458.598403
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "4k",
"target_tokens": 4096,
"run": 2,
"run_id": "1df8c923675b",
"corpus_repeated": false,
"time": "2026-09-29T20:40:58",
"prompt_tokens": 4200,
"completion_tokens": 142,
"ttft_s": 2.418,
"e2e_s": 4.063,
"api_prompt_tps": 1736.7,
"api_decode_tps": 85.7,
"engine_prompt_tps": 1772.2,
"engine_decode_tps": 85.5,
"log_lines": [
"strata serve: prompt 4200 tokens = 0 reused + 4200 read in 2370 ms (1772.2 tok/s), 142 generated in 1660 ms (85.5 tok/s), drafts accepted 96 of 114, 1 checkpoints",
"strata serve: decode expert cache hit rate: 89.6% (64163 hits / 71608 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand the context better.",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
},
{
"projection": null,
"time": 1790714293.0977688,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1288.1,
"decode_ms": 2834.1,
"decode_tok_s": 90.3,
"hit_rate": 0.966
}
],
"requests_kept": 15,
"totals": {
"since": 1790713882.6043305,
"requests": 15,
"prompt_tokens": 125140,
"reused": 0,
"output_tokens": 2854,
"prompt_ms": 67279.5,
"decode_ms": 33024.09999999999
},
"hardware": {
"gpu_util": 98,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 46,
"gpu_power": 276.727,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 4551.6005859375,
"gpu_pcie_tx_mb": 1681.041015625,
"cpu": 100.0,
"ram_used": 63441051648,
"ram_total": 177175990272,
"disk_read_mb": 2.097570021071815,
"disk_write_mb": 0.10077293695540748,
"tok_s": 98.25687730909294,
"tok_s_mean": 85.16861474502441
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95,
53,
100,
94,
96,
21,
99,
99,
92,
97,
97,
0,
98,
99,
98
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45,
44,
45,
45,
45,
43,
45,
45,
45,
45,
46,
42,
46,
45,
46
],
"gpu_power": [
119.05,
119.02,
118.92,
118.89,
118.85,
118.74,
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45,
217.39,
278.78,
252.44,
278.12,
278.79,
215.59,
278.37,
251.8,
276.73
],
"gpu_pcie_rx_mb": [
0.33,
0.33,
0.33,
0.33,
0.33,
0.29,
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29,
11.78,
84.59,
865.12,
8675.62,
0.33,
3342.49,
34.05,
7461.5,
4551.6
],
"cpu": [
13.4,
2.8,
1.5,
1.3,
2.8,
1.6,
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3,
5.7,
6.4,
81.2,
100.0,
93.8,
14.8,
15.8,
37.5,
100.0
],
"ram_used": [
63785050112,
63794016256,
63795236864,
63794536448,
63786823680,
63781208064,
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520,
63440269312,
63431364608,
63482470400,
63473512448,
63471906816,
63401848832,
63554486272,
63453114368,
63441051648
],
"disk_read_mb": [
0.1,
0.14,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66,
0.64,
0.0,
2.25,
2.98,
2.66,
0.64,
0.0,
0.21,
2.1
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0,
0.0,
0.0,
102.14,
97.9,
0.0,
0.0,
0.0,
89.96,
98.26
]
},
"time": 1790714463.1652913
}
}
@@ -0,0 +1,829 @@
{
"label": "native-v0.1.26-IQ3_XXS-1x3090",
"mode": "speed",
"ctx": "4k",
"target_tokens": 4096,
"run": 3,
"run_id": "777f84f22df4",
"corpus_repeated": false,
"time": "2026-09-29T20:41:03",
"prompt_tokens": 4201,
"completion_tokens": 256,
"ttft_s": 2.409,
"e2e_s": 5.262,
"api_prompt_tps": 1744.1,
"api_decode_tps": 89.4,
"engine_prompt_tps": 1775.8,
"engine_decode_tps": 89.2,
"log_lines": [
"strata serve: prompt 4201 tokens = 0 reused + 4201 read in 2366 ms (1775.8 tok/s), 256 generated in 2868 ms (89.2 tok/s), drafts accepted 161 of 222, 1 checkpoints",
"strata serve: decode expert cache hit rate: 96.0% (144002 hits / 149996 lookups)"
],
"answer_head": "The `CMakeLists.txt` file is the top-level build configuration for the **Strata Engine**. Its primary responsibilities are:\n\n1. **Project Definition**: Sets up the project name (`strata`), version (`0.1.26`), and C++20 standard.\n2. **Backend Selection**: Manages mutually exclusive GPU backends (CU",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 131072,
"images": false,
"version": "0.1.26",
"context": 131072,
"kv": "int8",
"kv_resident": 32768,
"expert_slots": 10584,
"expert_cache_mib": 17583,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 389,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790714463.1913157,
"duration_s": 5.2,
"finish": "length",
"prompt_tokens": 4201,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2365.6,
"decode_ms": 2868.4,
"decode_tok_s": 89.2,
"hit_rate": 0.96
},
{
"projection": null,
"time": 1790714458.6299415,
"duration_s": 4.0,
"finish": "stop",
"prompt_tokens": 4200,
"reused": 0,
"output_tokens": 142,
"engine_generated": 142,
"prompt_ms": 2370.0,
"decode_ms": 1660.0,
"decode_tok_s": 85.5,
"hit_rate": 0.896
},
{
"projection": null,
"time": 1790714453.0791314,
"duration_s": 5.0,
"finish": "length",
"prompt_tokens": 3881,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2223.8,
"decode_ms": 2790.5,
"decode_tok_s": 91.7,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790714448.5537117,
"duration_s": 4.0,
"finish": "length",
"prompt_tokens": 1135,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1305.1,
"decode_ms": 2690.8,
"decode_tok_s": 95.1,
"hit_rate": 0.972
},
{
"projection": null,
"time": 1790714443.8943996,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1149,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1297.6,
"decode_ms": 2847.5,
"decode_tok_s": 89.9,
"hit_rate": 0.971
},
{
"projection": null,
"time": 1790714439.2770011,
"duration_s": 4.1,
"finish": "length",
"prompt_tokens": 1092,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1351.4,
"decode_ms": 2752.6,
"decode_tok_s": 93.0,
"hit_rate": 0.954
},
{
"projection": null,
"time": 1790714377.2599747,
"duration_s": 17.6,
"finish": "length",
"prompt_tokens": 31605,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14608.5,
"decode_ms": 3015.6,
"decode_tok_s": 84.9,
"hit_rate": 0.966
},
{
"projection": null,
"time": 1790714359.1307795,
"duration_s": 17.5,
"finish": "length",
"prompt_tokens": 31589,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 14609.7,
"decode_ms": 2833.5,
"decode_tok_s": 90.3,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714338.0043592,
"duration_s": 20.5,
"finish": "length",
"prompt_tokens": 34942,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 17033.3,
"decode_ms": 3435.7,
"decode_tok_s": 74.5,
"hit_rate": 0.945
},
{
"projection": null,
"time": 1790714334.3235514,
"duration_s": 3.0,
"finish": "stop",
"prompt_tokens": 4199,
"reused": 0,
"output_tokens": 49,
"engine_generated": 49,
"prompt_ms": 2369.7,
"decode_ms": 626.3,
"decode_tok_s": 78.2,
"hit_rate": 0.934
},
{
"projection": null,
"time": 1790714328.2723713,
"duration_s": 5.5,
"finish": "length",
"prompt_tokens": 4214,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 2436.3,
"decode_ms": 3084.4,
"decode_tok_s": 83.0,
"hit_rate": 0.959
},
{
"projection": null,
"time": 1790714324.3220718,
"duration_s": 3.4,
"finish": "stop",
"prompt_tokens": 3736,
"reused": 0,
"output_tokens": 56,
"engine_generated": 56,
"prompt_ms": 2700.1,
"decode_ms": 719.2,
"decode_tok_s": 77.9,
"hit_rate": 0.897
}
],
"requests_kept": 16,
"totals": {
"since": 1790713882.6043305,
"requests": 16,
"prompt_tokens": 129341,
"reused": 0,
"output_tokens": 3110,
"prompt_ms": 69645.1,
"decode_ms": 35892.49999999999
},
"hardware": {
"gpu_util": 96,
"gpu_mem_used": 25517031424,
"gpu_mem_total": 25769803776,
"gpu_temp": 46,
"gpu_power": 278.057,
"gpu_power_limit": 280.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.3330078125,
"gpu_pcie_tx_mb": 0.4287109375,
"cpu": 83.5,
"ram_used": 63416299520,
"ram_total": 177175990272,
"disk_read_mb": 2.956676951508761,
"disk_write_mb": 0.16488439273306146,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090",
"gpu_count": 1,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
100,
98,
94,
94,
100,
21,
98,
95,
53,
100,
94,
96,
21,
99,
99,
92,
97,
97,
0,
98,
99,
98,
0,
99,
100,
99,
96,
96
],
"gpu_mem_used": [
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25514934272,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424,
25517031424
],
"gpu_temp": [
40,
40,
40,
40,
40,
40,
39,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
38,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
37,
45,
45,
45,
45,
45,
43,
45,
45,
44,
45,
45,
45,
43,
45,
45,
45,
45,
46,
42,
46,
45,
46,
42,
45,
45,
45,
46,
46
],
"gpu_power": [
118.81,
118.95,
118.87,
118.88,
119.01,
118.97,
113.29,
37.07,
35.2,
35.1,
35.04,
34.98,
34.86,
34.88,
34.97,
34.79,
34.76,
34.94,
34.9,
34.89,
35.0,
34.87,
34.82,
34.93,
34.86,
34.92,
34.99,
34.83,
34.88,
34.97,
34.89,
34.96,
172.41,
265.41,
275.33,
276.53,
216.14,
263.1,
264.26,
273.6,
211.21,
274.12,
265.58,
276.31,
268.45,
217.39,
278.78,
252.44,
278.12,
278.79,
215.59,
278.37,
251.8,
276.73,
219.4,
271.43,
276.62,
251.66,
277.46,
278.06
],
"gpu_pcie_rx_mb": [
0.29,
0.29,
0.29,
0.33,
0.33,
0.33,
0.57,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.43,
0.43,
0.43,
0.38,
0.38,
0.43,
0.43,
0.38,
0.38,
0.38,
0.43,
0.38,
0.38,
0.43,
0.38,
0.38,
9.97,
22329.52,
3689.24,
4264.07,
0.33,
14955.09,
784.16,
3310.82,
1249.69,
15874.15,
18357.04,
4099.13,
485.18,
0.29,
11.78,
84.59,
865.12,
8675.62,
0.33,
3342.49,
34.05,
7461.5,
4551.6,
6961.73,
24513.15,
26324.56,
679.21,
426.48,
0.33
],
"cpu": [
1.6,
1.6,
2.2,
1.1,
5.2,
2.3,
1.3,
11.2,
3.6,
1.3,
11.5,
1.1,
1.9,
1.2,
1.3,
1.3,
1.0,
0.6,
2.3,
0.8,
1.2,
6.3,
8.9,
0.6,
1.9,
2.2,
2.1,
1.1,
2.2,
4.7,
1.2,
6.8,
7.3,
83.2,
99.8,
87.0,
14.8,
49.9,
100.0,
97.9,
33.3,
7.4,
99.9,
100.0,
63.3,
5.7,
6.4,
81.2,
100.0,
93.8,
14.8,
15.8,
37.5,
100.0,
32.6,
6.8,
6.6,
96.7,
100.0,
83.5
],
"ram_used": [
63760637952,
63756046336,
63757750272,
63751917568,
63784116224,
63784988672,
63783927808,
63781187584,
63772962816,
63781842944,
63808417792,
63797518336,
63793590272,
63788277760,
63788392448,
63791640576,
63791734784,
63793213440,
63793565696,
63794352128,
63793430528,
63799361536,
63590793216,
63591645184,
63583899648,
63571738624,
63579156480,
63572910080,
63581016064,
63625879552,
63626788864,
63427158016,
63429017600,
63532883968,
63535853568,
63534440448,
63490953216,
63544176640,
63529631744,
63536766976,
63443234816,
63502606336,
63508336640,
63509970944,
63492075520,
63440269312,
63431364608,
63482470400,
63473512448,
63471906816,
63401848832,
63554486272,
63453114368,
63441051648,
63399321600,
63389306880,
63427080192,
63418408960,
63417094144,
63416299520
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.35,
0.0,
0.8,
3.91,
3.26,
0.6,
0.0,
1.08,
2.82,
1.34,
0.0,
1.55,
2.4,
1.66,
0.64,
0.0,
2.25,
2.98,
2.66,
0.64,
0.0,
0.21,
2.1,
1.17,
0.0,
0.0,
1.29,
3.73,
2.96
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.98,
98.22,
0.0,
0.0,
112.83,
83.57,
76.97,
0.0,
0.0,
97.69,
87.72,
0.0,
0.0,
0.0,
102.14,
97.9,
0.0,
0.0,
0.0,
89.96,
98.26,
0.0,
0.0,
0.0,
93.47,
116.21,
0.0
]
},
"time": 1790714468.9308503
}
}
@@ -0,0 +1,501 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto-needle",
"mode": "needle",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "8f89dfed9af3",
"corpus_repeated": false,
"time": "2026-09-29T22:00:26",
"prompt_tokens": 17344,
"completion_tokens": 8,
"ttft_s": 15.582,
"e2e_s": 15.663,
"api_prompt_tps": 1113.1,
"api_decode_tps": 86.5,
"engine_prompt_tps": 1119.9,
"engine_decode_tps": 83.8,
"log_lines": [
"strata serve: prompt 17344 tokens = 0 reused + 17344 read in 15487 ms (1119.9 tok/s), 8 generated in 96 ms (83.8 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 97.3% (4205 hits / 4320 lookups)"
],
"answer_head": "05449BFC",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790719226.530526,
"duration_s": 15.6,
"finish": "stop",
"prompt_tokens": 17344,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 15486.8,
"decode_ms": 95.5,
"decode_tok_s": 83.8,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790719217.9333243,
"duration_s": 8.0,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 7861.5,
"decode_ms": 153.7,
"decode_tok_s": 58.6,
"hit_rate": 0.94
}
],
"requests_kept": 2,
"totals": {
"since": 1790719202.7795203,
"requests": 2,
"prompt_tokens": 24837,
"reused": 0,
"output_tokens": 17,
"prompt_ms": 23348.3,
"decode_ms": 249.2
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 0,
"mem_used": 25171001344,
"mem_total": 25769803776,
"temp": 47,
"power": 148.05
},
{
"index": 1,
"util": 40,
"mem_used": 24185339904,
"mem_total": 25769803776,
"temp": 54,
"power": 237.219
}
],
"gpu_util": 20.0,
"gpu_mem_used": 49356341248,
"gpu_mem_total": 51539607552,
"gpu_temp": 54,
"gpu_power": 385.269,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 1.7626953125,
"gpu_pcie_tx_mb": 0.9052734375,
"cpu": 9.1,
"ram_used": 62596341760,
"ram_total": 177175990272,
"disk_read_mb": 0.0,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
73.5,
23.5,
31.0,
56.5,
23.5,
20.5,
0.5,
70.5,
22.5,
26.5,
56.0,
29.0,
77.0,
11.0,
28.5,
59.5,
28.5,
19.5,
17.0,
27.0,
20.0
],
"gpu_mem_used": [
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49274552320,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248
],
"gpu_temp": [
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
51,
53,
52,
52,
52,
53,
49,
51,
52,
52,
53,
53,
53,
52,
53,
51,
53,
53,
53,
53,
54
],
"gpu_power": [
257.56,
245.14,
244.59,
244.41,
244.51,
244.45,
244.36,
244.36,
244.26,
244.16,
244.27,
244.18,
244.09,
243.92,
243.88,
245.24,
443.06,
409.13,
432.67,
433.1,
400.92,
389.08,
278.03,
383.36,
392.74,
440.94,
403.62,
421.29,
427.09,
407.67,
422.11,
423.13,
417.76,
440.15,
377.19,
403.8,
385.27
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.57,
0.62,
0.67,
0.57,
0.62,
0.62,
0.67,
0.62,
0.62,
0.67,
0.62,
0.57,
0.62,
2169.46,
6179.19,
3838.3,
4927.82,
4008.2,
7314.58,
0.95,
1338.19,
7892.51,
3024.72,
5741.74,
2921.96,
5454.83,
5667.49,
3768.87,
6803.13,
8164.64,
2711.1,
5725.29,
6417.89,
0.67,
1.76
],
"cpu": [
0.0,
15.8,
15.7,
6.4,
8.0,
8.1,
4.7,
6.7,
0.9,
1.5,
5.3,
12.5,
1.6,
3.2,
8.4,
14.2,
13.2,
10.5,
10.5,
13.4,
9.0,
12.2,
23.9,
8.1,
16.5,
13.0,
13.0,
9.0,
9.7,
12.8,
8.6,
12.9,
10.4,
8.6,
9.0,
9.4,
9.1
],
"ram_used": [
61827047424,
61871300608,
61941383168,
61960540160,
61978361856,
61977542656,
61984432128,
61992636416,
61992636416,
62000824320,
62002450432,
62005186560,
62006108160,
62014894080,
62023741440,
62230065152,
62246010880,
62250319872,
62234144768,
62227582976,
62226890752,
62392664064,
62490071040,
62486704128,
62515294208,
62517342208,
62467452928,
62510080000,
62495842304,
62471684096,
62463819776,
62459879424,
62443171840,
62374465536,
62303469568,
62390607872,
62596341760
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
28.33,
101.36,
41.6,
10.77,
0.0,
0.01,
0.0,
0.0,
1.06,
0.0,
14.72,
0.0,
56.04,
0.0,
33.79,
66.18,
16.29,
83.86,
33.38,
0.0,
0.0,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790719242.619913
}
}
@@ -0,0 +1,722 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto-needle",
"mode": "needle",
"ctx": "28k",
"target_tokens": 28672,
"run": 1,
"run_id": "93a9a0e32114",
"corpus_repeated": false,
"time": "2026-09-29T22:00:42",
"prompt_tokens": 29825,
"completion_tokens": 9,
"ttft_s": 26.19,
"e2e_s": 26.262,
"api_prompt_tps": 1138.8,
"api_decode_tps": 110.5,
"engine_prompt_tps": 1146.7,
"engine_decode_tps": 103.9,
"log_lines": [
"strata serve: prompt 29825 tokens = 0 reused + 29825 read in 26009 ms (1146.7 tok/s), 9 generated in 87 ms (103.9 tok/s), drafts accepted 6 of 6, 2 checkpoints",
"strata serve: decode expert cache hit rate: 98.2% (4241 hits / 4320 lookups)"
],
"answer_head": "98C00B03",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790719242.7790127,
"duration_s": 26.1,
"finish": "stop",
"prompt_tokens": 29825,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 26008.5,
"decode_ms": 86.6,
"decode_tok_s": 103.9,
"hit_rate": 0.982
},
{
"projection": null,
"time": 1790719226.530526,
"duration_s": 15.6,
"finish": "stop",
"prompt_tokens": 17344,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 15486.8,
"decode_ms": 95.5,
"decode_tok_s": 83.8,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790719217.9333243,
"duration_s": 8.0,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 7861.5,
"decode_ms": 153.7,
"decode_tok_s": 58.6,
"hit_rate": 0.94
}
],
"requests_kept": 3,
"totals": {
"since": 1790719202.7795203,
"requests": 3,
"prompt_tokens": 54662,
"reused": 0,
"output_tokens": 26,
"prompt_ms": 49356.8,
"decode_ms": 335.79999999999995
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 6,
"mem_used": 25171001344,
"mem_total": 25769803776,
"temp": 47,
"power": 141.832
},
{
"index": 1,
"util": 20,
"mem_used": 24185339904,
"mem_total": 25769803776,
"temp": 52,
"power": 243.782
}
],
"gpu_util": 13.0,
"gpu_mem_used": 49356341248,
"gpu_mem_total": 51539607552,
"gpu_temp": 52,
"gpu_power": 385.61400000000003,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 16.6,
"ram_used": 62951010304,
"ram_total": 177175990272,
"disk_read_mb": 0.08651659039933747,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
73.5,
23.5,
31.0,
56.5,
23.5,
20.5,
0.5,
70.5,
22.5,
26.5,
56.0,
29.0,
77.0,
11.0,
28.5,
59.5,
28.5,
19.5,
17.0,
27.0,
20.0,
0.0,
60.5,
25.5,
71.0,
67.0,
26.5,
26.5,
85.0,
26.0,
73.5,
49.5,
25.0,
48.0,
32.0,
76.5,
9.0,
27.5,
47.5,
30.0,
62.5,
15.5,
31.5,
29.0,
39.5,
13.0
],
"gpu_mem_used": [
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49274552320,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248
],
"gpu_temp": [
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
51,
53,
52,
52,
52,
53,
49,
51,
52,
52,
53,
53,
53,
52,
53,
51,
53,
53,
53,
53,
54,
50,
51,
53,
53,
52,
54,
52,
52,
53,
53,
53,
53,
52,
53,
54,
52,
53,
52,
53,
52,
52,
54,
53,
54,
52
],
"gpu_power": [
244.59,
244.41,
244.51,
244.45,
244.36,
244.36,
244.26,
244.16,
244.27,
244.18,
244.09,
243.92,
243.88,
245.24,
443.06,
409.13,
432.67,
433.1,
400.92,
389.08,
278.03,
383.36,
392.74,
440.94,
403.62,
421.29,
427.09,
407.67,
422.11,
423.13,
417.76,
440.15,
377.19,
403.8,
385.27,
299.57,
398.78,
401.71,
449.87,
430.87,
402.83,
439.43,
401.46,
455.62,
425.18,
404.39,
417.35,
406.87,
423.67,
422.86,
404.6,
421.5,
402.4,
422.71,
432.67,
398.05,
455.72,
434.46,
403.83,
385.61
],
"gpu_pcie_rx_mb": [
0.57,
0.62,
0.67,
0.57,
0.62,
0.62,
0.67,
0.62,
0.62,
0.67,
0.62,
0.57,
0.62,
2169.46,
6179.19,
3838.3,
4927.82,
4008.2,
7314.58,
0.95,
1338.19,
7892.51,
3024.72,
5741.74,
2921.96,
5454.83,
5667.49,
3768.87,
6803.13,
8164.64,
2711.1,
5725.29,
6417.89,
0.67,
1.76,
1343.92,
7796.67,
10809.8,
5598.92,
3013.99,
91.89,
4693.79,
5621.38,
5381.87,
7487.25,
2228.12,
7344.77,
3943.44,
0.81,
5476.19,
2437.4,
6693.74,
3836.63,
7843.59,
5638.65,
2853.11,
8215.43,
8500.96,
4445.79,
0.67
],
"cpu": [
15.7,
6.4,
8.0,
8.1,
4.7,
6.7,
0.9,
1.5,
5.3,
12.5,
1.6,
3.2,
8.4,
14.2,
13.2,
10.5,
10.5,
13.4,
9.0,
12.2,
23.9,
8.1,
16.5,
13.0,
13.0,
9.0,
9.7,
12.8,
8.6,
12.9,
10.4,
8.6,
9.0,
9.4,
9.1,
16.9,
17.1,
22.7,
7.5,
10.8,
8.9,
7.3,
7.3,
8.3,
7.7,
9.8,
6.9,
12.4,
6.4,
12.2,
20.6,
19.9,
11.0,
8.1,
10.3,
9.8,
7.6,
8.1,
7.3,
16.6
],
"ram_used": [
61941383168,
61960540160,
61978361856,
61977542656,
61984432128,
61992636416,
61992636416,
62000824320,
62002450432,
62005186560,
62006108160,
62014894080,
62023741440,
62230065152,
62246010880,
62250319872,
62234144768,
62227582976,
62226890752,
62392664064,
62490071040,
62486704128,
62515294208,
62517342208,
62467452928,
62510080000,
62495842304,
62471684096,
62463819776,
62459879424,
62443171840,
62374465536,
62303469568,
62390607872,
62596341760,
62489825280,
62562496512,
62577270784,
62577836032,
62576951296,
62564986880,
62553812992,
62539886592,
62533107712,
62521810944,
62503256064,
62503677952,
62490673152,
62492131328,
62495432704,
62503706624,
62769029120,
62766465024,
62765707264,
62747688960,
62726733824,
62717767680,
62722011136,
62728314880,
62951010304
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
28.33,
101.36,
41.6,
10.77,
0.0,
0.01,
0.0,
0.0,
1.06,
0.0,
14.72,
0.0,
56.04,
0.0,
33.79,
66.18,
16.29,
83.86,
33.38,
0.0,
0.0,
0.0,
0.0,
0.73,
0.0,
0.0,
0.0,
0.22,
0.0,
0.0,
0.14,
0.0,
0.53,
47.85,
0.0,
71.37,
0.0,
78.98,
55.42,
22.25,
53.69,
0.0,
54.32,
39.07,
0.0,
0.0,
0.0,
0.09
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790719269.3852785
}
}
@@ -0,0 +1,352 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto-needle",
"mode": "needle",
"ctx": "8k",
"target_tokens": 8192,
"run": 1,
"run_id": "d1d745f05911",
"corpus_repeated": false,
"time": "2026-09-29T22:00:17",
"prompt_tokens": 7493,
"completion_tokens": 9,
"ttft_s": 7.948,
"e2e_s": 8.057,
"api_prompt_tps": 942.8,
"api_decode_tps": 73.4,
"engine_prompt_tps": 953.1,
"engine_decode_tps": 58.6,
"log_lines": [
"strata serve: prompt 7493 tokens = 0 reused + 7493 read in 7861 ms (953.1 tok/s), 9 generated in 154 ms (58.6 tok/s), drafts accepted 6 of 6, 1 checkpoints",
"strata serve: decode expert cache hit rate: 94.0% (4062 hits / 4320 lookups)"
],
"answer_head": "69231569",
"needle_found": true,
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790719217.9333243,
"duration_s": 8.0,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 7861.5,
"decode_ms": 153.7,
"decode_tok_s": 58.6,
"hit_rate": 0.94
}
],
"requests_kept": 1,
"totals": {
"since": 1790719202.7795203,
"requests": 1,
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 9,
"prompt_ms": 7861.5,
"decode_ms": 153.7
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 0,
"mem_used": 25139544064,
"mem_total": 25769803776,
"temp": 46,
"power": 145.526
},
{
"index": 1,
"util": 41,
"mem_used": 24151785472,
"mem_total": 25769803776,
"temp": 53,
"power": 243.553
}
],
"gpu_util": 20.5,
"gpu_mem_used": 49291329536,
"gpu_mem_total": 51539607552,
"gpu_temp": 53,
"gpu_power": 389.079,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.9521484375,
"gpu_pcie_tx_mb": 4154.1572265625,
"cpu": 12.2,
"ram_used": 62392664064,
"ram_total": 177175990272,
"disk_read_mb": 0.0036010722333241606,
"disk_write_mb": 0.0,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
2.0,
73.5,
23.5,
31.0,
56.5,
23.5,
20.5
],
"gpu_mem_used": [
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49274552320,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49291329536
],
"gpu_temp": [
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
48,
51,
53,
52,
52,
52,
53
],
"gpu_power": [
257.56,
245.14,
244.59,
244.41,
244.51,
244.45,
244.36,
244.36,
244.26,
244.16,
244.27,
244.18,
244.09,
243.92,
243.88,
245.24,
443.06,
409.13,
432.67,
433.1,
400.92,
389.08
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.57,
0.62,
0.67,
0.57,
0.62,
0.62,
0.67,
0.62,
0.62,
0.67,
0.62,
0.57,
0.62,
2169.46,
6179.19,
3838.3,
4927.82,
4008.2,
7314.58,
0.95
],
"cpu": [
0.0,
15.8,
15.7,
6.4,
8.0,
8.1,
4.7,
6.7,
0.9,
1.5,
5.3,
12.5,
1.6,
3.2,
8.4,
14.2,
13.2,
10.5,
10.5,
13.4,
9.0,
12.2
],
"ram_used": [
61827047424,
61871300608,
61941383168,
61960540160,
61978361856,
61977542656,
61984432128,
61992636416,
61992636416,
62000824320,
62002450432,
62005186560,
62006108160,
62014894080,
62023741440,
62230065152,
62246010880,
62250319872,
62234144768,
62227582976,
62226890752,
62392664064
],
"disk_read_mb": [
null,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.01,
0.0,
0.0,
0.0,
0.0,
28.33,
101.36,
41.6,
10.77,
0.0,
0.01,
0.0,
0.0
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
]
},
"time": 1790719226.4537745
}
}
@@ -0,0 +1,755 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto-two-turn",
"mode": "two-turn",
"ctx": "16k",
"target_tokens": 16384,
"run": 1,
"run_id": "dedda4f9d6be",
"corpus_repeated": false,
"time": "2026-09-29T22:01:09",
"prompt_tokens": 15635,
"completion_tokens": 44,
"ttft_s": 13.63,
"e2e_s": 14.13,
"api_prompt_tps": 1147.1,
"api_decode_tps": 86.1,
"engine_prompt_tps": 1154.6,
"engine_decode_tps": 85.6,
"log_lines": [
"strata serve: prompt 15635 tokens = 0 reused + 15635 read in 13541 ms (1154.6 tok/s), 44 generated in 514 ms (85.6 tok/s), drafts accepted 30 of 36, 1 checkpoints",
"strata serve: decode expert cache hit rate: 97.9% (24433 hits / 24957 lookups)"
],
"answer_head": "I'll start by exploring the repository structure to understand the context better.",
"turn2_ttft_s": 0.577,
"turn2_prompt_tokens": 15672,
"turn2_log_lines": [
"strata serve: prompt 15672 tokens = 15628 reused + 44 read in 490 ms (89.8 tok/s), 48 generated in 567 ms (84.6 tok/s), drafts accepted 28 of 43, 2 checkpoints",
"strata serve: decode expert cache hit rate: 98.6% (31236 hits / 31679 lookups)"
],
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790719284.681533,
"duration_s": 1.1,
"finish": "stop",
"prompt_tokens": 15672,
"reused": 15628,
"output_tokens": 48,
"engine_generated": 48,
"prompt_ms": 490.1,
"decode_ms": 567.1,
"decode_tok_s": 84.6,
"hit_rate": 0.986
},
{
"projection": null,
"time": 1790719270.0522854,
"duration_s": 14.1,
"finish": "stop",
"prompt_tokens": 15635,
"reused": 0,
"output_tokens": 44,
"engine_generated": 44,
"prompt_ms": 13541.4,
"decode_ms": 513.7,
"decode_tok_s": 85.7,
"hit_rate": 0.979
},
{
"projection": null,
"time": 1790719242.7790127,
"duration_s": 26.1,
"finish": "stop",
"prompt_tokens": 29825,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 26008.5,
"decode_ms": 86.6,
"decode_tok_s": 103.9,
"hit_rate": 0.982
},
{
"projection": null,
"time": 1790719226.530526,
"duration_s": 15.6,
"finish": "stop",
"prompt_tokens": 17344,
"reused": 0,
"output_tokens": 8,
"engine_generated": 8,
"prompt_ms": 15486.8,
"decode_ms": 95.5,
"decode_tok_s": 83.8,
"hit_rate": 0.973
},
{
"projection": null,
"time": 1790719217.9333243,
"duration_s": 8.0,
"finish": "stop",
"prompt_tokens": 7493,
"reused": 0,
"output_tokens": 9,
"engine_generated": 9,
"prompt_ms": 7861.5,
"decode_ms": 153.7,
"decode_tok_s": 58.6,
"hit_rate": 0.94
}
],
"requests_kept": 5,
"totals": {
"since": 1790719202.7795203,
"requests": 5,
"prompt_tokens": 85969,
"reused": 15628,
"output_tokens": 118,
"prompt_ms": 63388.3,
"decode_ms": 1416.6
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 15,
"mem_used": 25191972864,
"mem_total": 25769803776,
"temp": 48,
"power": 148.771
},
{
"index": 1,
"util": 0,
"mem_used": 24206311424,
"mem_total": 25769803776,
"temp": 51,
"power": 169.566
}
],
"gpu_util": 7.5,
"gpu_mem_used": 49398284288,
"gpu_mem_total": 51539607552,
"gpu_temp": 51,
"gpu_power": 318.337,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 26.1298828125,
"gpu_pcie_tx_mb": 56.265625,
"cpu": 39.7,
"ram_used": 63088369664,
"ram_total": 177175990272,
"disk_read_mb": 1.2843527404984159,
"disk_write_mb": 0.0035875774874257423,
"tok_s": 52.0,
"tok_s_mean": 89.37171592337687
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
23.5,
31.0,
56.5,
23.5,
20.5,
0.5,
70.5,
22.5,
26.5,
56.0,
29.0,
77.0,
11.0,
28.5,
59.5,
28.5,
19.5,
17.0,
27.0,
20.0,
0.0,
60.5,
25.5,
71.0,
67.0,
26.5,
26.5,
85.0,
26.0,
73.5,
49.5,
25.0,
48.0,
32.0,
76.5,
9.0,
27.5,
47.5,
30.0,
62.5,
15.5,
31.5,
29.0,
39.5,
13.0,
0.0,
69.5,
24.0,
30.5,
61.5,
27.0,
62.5,
17.0,
26.5,
53.5,
23.5,
29.5,
29.0,
41.0,
7.5
],
"gpu_mem_used": [
49291329536,
49291329536,
49291329536,
49291329536,
49291329536,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49356341248,
49398284288,
49398284288
],
"gpu_temp": [
53,
52,
52,
52,
53,
49,
51,
52,
52,
53,
53,
53,
52,
53,
51,
53,
53,
53,
53,
54,
50,
51,
53,
53,
52,
54,
52,
52,
53,
53,
53,
53,
52,
53,
54,
52,
53,
52,
53,
52,
52,
54,
53,
54,
52,
50,
51,
53,
54,
52,
54,
53,
53,
54,
53,
53,
54,
55,
53,
51
],
"gpu_power": [
409.13,
432.67,
433.1,
400.92,
389.08,
278.03,
383.36,
392.74,
440.94,
403.62,
421.29,
427.09,
407.67,
422.11,
423.13,
417.76,
440.15,
377.19,
403.8,
385.27,
299.57,
398.78,
401.71,
449.87,
430.87,
402.83,
439.43,
401.46,
455.62,
425.18,
404.39,
417.35,
406.87,
423.67,
422.86,
404.6,
421.5,
402.4,
422.71,
432.67,
398.05,
455.72,
434.46,
403.83,
385.61,
282.41,
360.22,
446.82,
449.66,
410.55,
427.9,
441.96,
389.46,
451.44,
439.2,
402.13,
441.82,
408.98,
365.37,
318.34
],
"gpu_pcie_rx_mb": [
3838.3,
4927.82,
4008.2,
7314.58,
0.95,
1338.19,
7892.51,
3024.72,
5741.74,
2921.96,
5454.83,
5667.49,
3768.87,
6803.13,
8164.64,
2711.1,
5725.29,
6417.89,
0.67,
1.76,
1343.92,
7796.67,
10809.8,
5598.92,
3013.99,
91.89,
4693.79,
5621.38,
5381.87,
7487.25,
2228.12,
7344.77,
3943.44,
0.81,
5476.19,
2437.4,
6693.74,
3836.63,
7843.59,
5638.65,
2853.11,
8215.43,
8500.96,
4445.79,
0.67,
0.62,
4431.82,
4655.12,
7505.13,
4915.86,
7990.69,
6352.23,
3326.13,
3696.82,
7077.12,
4858.06,
5613.99,
7732.68,
0.67,
26.13
],
"cpu": [
10.5,
10.5,
13.4,
9.0,
12.2,
23.9,
8.1,
16.5,
13.0,
13.0,
9.0,
9.7,
12.8,
8.6,
12.9,
10.4,
8.6,
9.0,
9.4,
9.1,
16.9,
17.1,
22.7,
7.5,
10.8,
8.9,
7.3,
7.3,
8.3,
7.7,
9.8,
6.9,
12.4,
6.4,
12.2,
20.6,
19.9,
11.0,
8.1,
10.3,
9.8,
7.6,
8.1,
7.3,
16.6,
7.1,
8.3,
7.7,
7.5,
19.7,
13.3,
9.8,
12.2,
12.2,
11.3,
11.1,
11.3,
11.7,
49.6,
39.7
],
"ram_used": [
62250319872,
62234144768,
62227582976,
62226890752,
62392664064,
62490071040,
62486704128,
62515294208,
62517342208,
62467452928,
62510080000,
62495842304,
62471684096,
62463819776,
62459879424,
62443171840,
62374465536,
62303469568,
62390607872,
62596341760,
62489825280,
62562496512,
62577270784,
62577836032,
62576951296,
62564986880,
62553812992,
62539886592,
62533107712,
62521810944,
62503256064,
62503677952,
62490673152,
62492131328,
62495432704,
62503706624,
62769029120,
62766465024,
62765707264,
62747688960,
62726733824,
62717767680,
62722011136,
62728314880,
62951010304,
62691995648,
62677225472,
62661165056,
62640271360,
62636351488,
62633791488,
62731657216,
62747160576,
62744502272,
62746267648,
62732316672,
62762123264,
62711451648,
62861885440,
63088369664
],
"disk_read_mb": [
10.77,
0.0,
0.01,
0.0,
0.0,
1.06,
0.0,
14.72,
0.0,
56.04,
0.0,
33.79,
66.18,
16.29,
83.86,
33.38,
0.0,
0.0,
0.0,
0.0,
0.73,
0.0,
0.0,
0.0,
0.22,
0.0,
0.0,
0.14,
0.0,
0.53,
47.85,
0.0,
71.37,
0.0,
78.98,
55.42,
22.25,
53.69,
0.0,
54.32,
39.07,
0.0,
0.0,
0.0,
0.09,
0.58,
0.02,
0.01,
0.0,
0.03,
0.0,
2.6,
6.44,
7.35,
8.08,
4.14,
2.09,
0.01,
2.47,
1.28
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
52.0
]
},
"time": 1790719286.2452984
}
}
@@ -0,0 +1,612 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 1,
"run_id": "cfa75b59eb61",
"corpus_repeated": false,
"time": "2026-09-29T21:39:52",
"prompt_tokens": 28314,
"completion_tokens": 256,
"ttft_s": 26.573,
"e2e_s": 29.595,
"api_prompt_tps": 1065.5,
"api_decode_tps": 84.4,
"engine_prompt_tps": 1071.8,
"engine_decode_tps": 83.7,
"log_lines": [
"strata serve: prompt 28314 tokens = 0 reused + 28314 read in 26417 ms (1071.8 tok/s), 256 generated in 3058 ms (83.7 tok/s), drafts accepted 147 of 251, 2 checkpoints",
"strata serve: decode expert cache hit rate: 98.9% (171443 hits / 173268 lookups)"
],
"answer_head": "The last file in the repository listing is `docs/DETAILS.md`.\n\n### What `docs/DETAILS.md` does\n\nIt is the comprehensive technical documentation and reference manual for the Strata engine. While the `README.md` focuses on quick installation and high-level usage, `DETAILS.md` provides the deep technic",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790717992.6885722,
"duration_s": 29.5,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 26416.6,
"decode_ms": 3057.9,
"decode_tok_s": 83.7,
"hit_rate": 0.989
}
],
"requests_kept": 1,
"totals": {
"since": 1790717968.2500567,
"requests": 1,
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"prompt_ms": 26416.6,
"decode_ms": 3057.9
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 44,
"mem_used": 25196167168,
"mem_total": 25769803776,
"temp": 52,
"power": 244.795
},
{
"index": 1,
"util": 0,
"mem_used": 24208408576,
"mem_total": 25769803776,
"temp": 52,
"power": 218.413
}
],
"gpu_util": 22.0,
"gpu_mem_used": 49404575744,
"gpu_mem_total": 51539607552,
"gpu_temp": 52,
"gpu_power": 463.20799999999997,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 0.666015625,
"gpu_pcie_tx_mb": 0.857421875,
"cpu": 60.1,
"ram_used": 62328995840,
"ram_total": 177175990272,
"disk_read_mb": 3.420667733965059,
"disk_write_mb": 0.02523147959721329,
"tok_s": 0.0,
"tok_s_mean": 0.0
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
49.5,
21.5,
58.5,
25.5,
31.5,
24.0,
25.0,
35.0,
27.0,
64.5,
29.0,
24.5,
24.5,
27.0,
16.0,
26.0,
59.5,
24.5,
28.5,
48.0,
26.5,
29.0,
31.0,
3.0,
46.0,
46.0,
22.0
],
"gpu_mem_used": [
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49205346304,
49278746624,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49383604224,
49404575744,
49404575744,
49404575744
],
"gpu_temp": [
50,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
49,
50,
49,
46,
46,
46,
46,
46,
46,
48,
52,
53,
53,
53,
53,
54,
54,
53,
54,
53,
53,
54,
54,
54,
52,
55,
53,
54,
55,
54,
54,
54,
55,
53,
55,
55,
52
],
"gpu_power": [
260.95,
248.93,
247.54,
246.62,
246.82,
246.65,
246.9,
246.83,
246.8,
246.68,
246.72,
246.75,
246.63,
246.53,
246.57,
246.83,
236.89,
159.99,
79.32,
65.35,
64.71,
64.62,
64.91,
91.65,
314.3,
428.65,
367.67,
455.67,
441.66,
390.44,
440.16,
375.92,
453.54,
370.98,
401.8,
438.74,
379.04,
440.69,
353.57,
419.67,
435.26,
406.67,
447.91,
390.07,
459.5,
448.73,
405.61,
374.45,
407.02,
468.77,
463.21
],
"gpu_pcie_rx_mb": [
0.67,
0.62,
0.62,
0.67,
0.57,
7.87,
0.62,
0.62,
0.67,
0.62,
0.62,
0.57,
0.62,
0.62,
1.38,
0.57,
0.76,
0.86,
0.91,
0.81,
0.86,
0.86,
0.81,
539.92,
4704.14,
5432.94,
3021.19,
4790.88,
4142.71,
2301.69,
8161.88,
3244.83,
5099.68,
7126.09,
2825.64,
6742.29,
2064.18,
5534.93,
4369.31,
7614.9,
4834.13,
2332.54,
7141.88,
4942.8,
3514.62,
5720.52,
6970.74,
14.21,
15.78,
30.52,
0.67
],
"cpu": [
0.0,
14.3,
2.7,
0.9,
1.7,
1.5,
2.1,
1.3,
1.5,
1.3,
1.2,
2.2,
1.2,
0.9,
1.2,
19.1,
3.1,
3.2,
2.2,
1.9,
2.8,
2.0,
4.5,
12.1,
9.2,
7.1,
7.5,
5.5,
13.3,
15.7,
18.9,
15.5,
7.4,
9.3,
7.1,
10.1,
9.1,
6.1,
9.7,
7.4,
9.1,
9.2,
13.5,
15.4,
6.6,
8.7,
6.0,
28.4,
94.8,
99.5,
60.1
],
"ram_used": [
61824409600,
61846106112,
61853241344,
61854605312,
61855711232,
61855694848,
61853442048,
61858058240,
61861154816,
61861928960,
61862432768,
61867282432,
61861072896,
61856456704,
61880406016,
61890236416,
61890191360,
61887963136,
61887766528,
61882646528,
61870043136,
61879148544,
61934235648,
61984825344,
62089637888,
62090121216,
62098157568,
62098403328,
62088568832,
62106021888,
61750501376,
61766746112,
61776080896,
61778165760,
61779779584,
61908017152,
61907206144,
61910032384,
62031020032,
62033805312,
62032531456,
61967249408,
61974036480,
61990858752,
61985890304,
61979660288,
61980233728,
62277226496,
62302523392,
62302191616,
62328995840
],
"disk_read_mb": [
null,
0.01,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
103.38,
66.8,
0.0,
24.38,
0.0,
55.65,
33.54,
0.11,
67.43,
0.0,
83.76,
1.78,
79.2,
71.21,
0.0,
79.44,
0.0,
77.02,
53.81,
0.7,
42.73,
0.0,
0.0,
0.0,
1.02,
5.65,
4.98,
3.42
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
48.0,
86.94,
102.06,
0.0
]
},
"time": 1790718022.6741135
}
}
@@ -0,0 +1,707 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 2,
"run_id": "c27c8adc0b65",
"corpus_repeated": false,
"time": "2026-09-29T21:40:22",
"prompt_tokens": 31633,
"completion_tokens": 256,
"ttft_s": 26.904,
"e2e_s": 29.536,
"api_prompt_tps": 1175.8,
"api_decode_tps": 96.9,
"engine_prompt_tps": 1185.2,
"engine_decode_tps": 96.7,
"log_lines": [
"strata serve: prompt 31633 tokens = 0 reused + 31633 read in 26691 ms (1185.2 tok/s), 256 generated in 2648 ms (96.7 tok/s), drafts accepted 160 of 214, 2 checkpoints",
"strata serve: decode expert cache hit rate: 99.1% (147426 hits / 148799 lookups)"
],
"answer_head": "I cannot analyze the last file because the provided repository content is truncated. The `docs/DETAILS.md` file cuts off mid-sentence in the \"Using it\" section (`...if y`), and no subsequent files are shown.\n\nHowever, I can analyze the **`chat.py`** file, which is the last *complete* file provided i",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718022.860633,
"duration_s": 29.4,
"finish": "length",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 26690.6,
"decode_ms": 2648.4,
"decode_tok_s": 96.7,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790717992.6885722,
"duration_s": 29.5,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 26416.6,
"decode_ms": 3057.9,
"decode_tok_s": 83.7,
"hit_rate": 0.989
}
],
"requests_kept": 2,
"totals": {
"since": 1790717968.2500567,
"requests": 2,
"prompt_tokens": 59947,
"reused": 0,
"output_tokens": 512,
"prompt_ms": 53107.2,
"decode_ms": 5706.3
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 37,
"mem_used": 25196167168,
"mem_total": 25769803776,
"temp": 51,
"power": 209.254
},
{
"index": 1,
"util": 55,
"mem_used": 24208408576,
"mem_total": 25769803776,
"temp": 55,
"power": 248.664
}
],
"gpu_util": 46.0,
"gpu_mem_used": 49404575744,
"gpu_mem_total": 51539607552,
"gpu_temp": 55,
"gpu_power": 457.918,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 30.46875,
"gpu_pcie_tx_mb": 164.2216796875,
"cpu": 97.1,
"ram_used": 62326792192,
"ram_total": 177175990272,
"disk_read_mb": 4.657722192080744,
"disk_write_mb": 0.11106875996500236,
"tok_s": 102.58306863780025,
"tok_s_mean": 98.12574884260572
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
49.5,
21.5,
58.5,
25.5,
31.5,
24.0,
25.0,
35.0,
27.0,
64.5,
29.0,
24.5,
24.5,
27.0,
16.0,
26.0,
59.5,
24.5,
28.5,
48.0,
26.5,
29.0,
31.0,
3.0,
46.0,
46.0,
22.0,
59.5,
29.0,
60.0,
26.0,
31.5,
71.0,
32.5,
28.0,
66.0,
23.5,
24.5,
18.5,
29.0,
28.0,
78.0,
30.0,
73.5,
16.0,
28.0,
25.0,
28.0,
29.0,
66.0,
26.5,
18.5,
43.5,
46.0
],
"gpu_mem_used": [
49192763392,
49192763392,
49192763392,
49192763392,
49192763392,
49205346304,
49278746624,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49295523840,
49383604224,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744
],
"gpu_temp": [
46,
46,
46,
46,
46,
48,
52,
53,
53,
53,
53,
54,
54,
53,
54,
53,
53,
54,
54,
54,
52,
55,
53,
54,
55,
54,
54,
54,
55,
53,
55,
55,
52,
52,
54,
54,
54,
55,
55,
55,
54,
54,
54,
54,
54,
54,
54,
55,
55,
55,
54,
55,
54,
55,
55,
55,
55,
53,
55,
55
],
"gpu_power": [
79.32,
65.35,
64.71,
64.62,
64.91,
91.65,
314.3,
428.65,
367.67,
455.67,
441.66,
390.44,
440.16,
375.92,
453.54,
370.98,
401.8,
438.74,
379.04,
440.69,
353.57,
419.67,
435.26,
406.67,
447.91,
390.07,
459.5,
448.73,
405.61,
374.45,
407.02,
468.77,
463.21,
376.39,
436.62,
444.21,
398.6,
447.75,
406.3,
391.79,
452.85,
427.37,
418.5,
444.64,
378.02,
407.95,
435.96,
404.27,
456.87,
440.61,
401.93,
421.84,
438.49,
398.65,
446.07,
421.03,
422.3,
368.39,
434.33,
457.92
],
"gpu_pcie_rx_mb": [
0.91,
0.81,
0.86,
0.86,
0.81,
539.92,
4704.14,
5432.94,
3021.19,
4790.88,
4142.71,
2301.69,
8161.88,
3244.83,
5099.68,
7126.09,
2825.64,
6742.29,
2064.18,
5534.93,
4369.31,
7614.9,
4834.13,
2332.54,
7141.88,
4942.8,
3514.62,
5720.52,
6970.74,
14.21,
15.78,
30.52,
0.67,
4175.19,
7742.45,
4905.89,
4411.55,
4744.0,
6063.36,
4488.9,
7846.78,
7336.33,
4790.3,
4790.26,
4959.82,
3664.44,
6053.92,
4708.72,
5601.93,
6957.58,
5201.77,
7840.16,
7413.0,
3656.91,
7095.34,
5569.93,
6273.89,
9.44,
21.46,
30.47
],
"cpu": [
2.2,
1.9,
2.8,
2.0,
4.5,
12.1,
9.2,
7.1,
7.5,
5.5,
13.3,
15.7,
18.9,
15.5,
7.4,
9.3,
7.1,
10.1,
9.1,
6.1,
9.7,
7.4,
9.1,
9.2,
13.5,
15.4,
6.6,
8.7,
6.0,
28.4,
94.8,
99.5,
60.1,
6.9,
5.7,
6.7,
6.1,
6.3,
13.9,
10.0,
6.4,
7.2,
5.7,
6.4,
6.6,
6.1,
5.5,
6.3,
6.6,
7.5,
6.5,
6.4,
17.9,
10.2,
6.4,
7.9,
6.6,
24.8,
93.3,
97.1
],
"ram_used": [
61887766528,
61882646528,
61870043136,
61879148544,
61934235648,
61984825344,
62089637888,
62090121216,
62098157568,
62098403328,
62088568832,
62106021888,
61750501376,
61766746112,
61776080896,
61778165760,
61779779584,
61908017152,
61907206144,
61910032384,
62031020032,
62033805312,
62032531456,
61967249408,
61974036480,
61990858752,
61985890304,
61979660288,
61980233728,
62277226496,
62302523392,
62302191616,
62328995840,
62040481792,
62030888960,
62024949760,
62010191872,
62003638272,
62026113024,
62011977728,
61980151808,
61970239488,
61954445312,
61954318336,
61948420096,
61997678592,
62080253952,
62075203584,
62075965440,
62076403712,
62076399616,
62070407168,
62091988992,
62091988992,
62093479936,
62097862656,
62095917056,
62331494400,
62325518336,
62326792192
],
"disk_read_mb": [
0.0,
0.0,
0.0,
0.0,
0.0,
103.38,
66.8,
0.0,
24.38,
0.0,
55.65,
33.54,
0.11,
67.43,
0.0,
83.76,
1.78,
79.2,
71.21,
0.0,
79.44,
0.0,
77.02,
53.81,
0.7,
42.73,
0.0,
0.0,
0.0,
1.02,
5.65,
4.98,
3.42,
0.54,
0.0,
0.01,
0.02,
0.0,
0.02,
0.03,
0.0,
0.03,
0.02,
0.0,
0.01,
0.0,
0.01,
0.02,
0.0,
0.0,
12.64,
0.0,
71.65,
32.97,
0.0,
0.0,
0.0,
0.99,
5.21,
4.66
],
"tok_s": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
48.0,
86.94,
102.06,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
56.0,
103.48,
102.58
]
},
"time": 1790718052.712857
}
}
@@ -0,0 +1,721 @@
{
"label": "native-v0.1.26-IQ3_XXS-2x3090-auto",
"mode": "speed",
"ctx": "32k",
"target_tokens": 31488,
"run": 3,
"run_id": "60c6cbe1b14a",
"corpus_repeated": false,
"time": "2026-09-29T21:40:52",
"prompt_tokens": 31603,
"completion_tokens": 256,
"ttft_s": 27.476,
"e2e_s": 30.102,
"api_prompt_tps": 1150.2,
"api_decode_tps": 97.1,
"engine_prompt_tps": 1158.9,
"engine_decode_tps": 96.9,
"log_lines": [
"strata serve: prompt 31603 tokens = 0 reused + 31603 read in 27271 ms (1158.9 tok/s), 256 generated in 2641 ms (96.9 tok/s), drafts accepted 154 of 209, 2 checkpoints",
"strata serve: decode expert cache hit rate: 99.6% (148622 hits / 149275 lookups)"
],
"answer_head": "An analysis of the last file (`docs/DETAILS.md`) and a proposed improvement follows.\n\n### What the file does\n\n`docs/DETAILS.md` serves as the comprehensive technical manual for the Strata engine. It bridges the gap between the high-level marketing in the `README.md` and the raw source code. Specific",
"metrics_after": {
"engine": {
"model": "qwen3.8-flash-next-iq3_xxs",
"max_context": 32768,
"images": false,
"version": "0.1.26",
"context": 32768,
"kv": "int8",
"kv_resident": 0,
"expert_slots": 11883,
"expert_cache_mib": 17564,
"spec": 6,
"mtp_max": 4,
"lookup": 3,
"vram_free_mib": 645,
"cvec": 0,
"arena_mib": 40925,
"pool_workers": 19,
"pcie_frac": "0.55",
"spec_min_p": "0.50",
"engine": "0.1.26"
},
"live": {
"state": "idle",
"queued": 0,
"phase": null,
"prompt_tokens": null,
"prompt_read": null,
"prompt_total": null,
"generated": null,
"max_tokens": null,
"elapsed_s": null,
"tok_s": null,
"tok_s_mean": null,
"tok_s_window_s": null
},
"requests": [
{
"projection": null,
"time": 1790718052.8930452,
"duration_s": 29.9,
"finish": "length",
"prompt_tokens": 31603,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 27270.7,
"decode_ms": 2641.1,
"decode_tok_s": 96.9,
"hit_rate": 0.996
},
{
"projection": null,
"time": 1790718022.860633,
"duration_s": 29.4,
"finish": "length",
"prompt_tokens": 31633,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 26690.6,
"decode_ms": 2648.4,
"decode_tok_s": 96.7,
"hit_rate": 0.991
},
{
"projection": null,
"time": 1790717992.6885722,
"duration_s": 29.5,
"finish": "length",
"prompt_tokens": 28314,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 26416.6,
"decode_ms": 3057.9,
"decode_tok_s": 83.7,
"hit_rate": 0.989
}
],
"requests_kept": 3,
"totals": {
"since": 1790717968.2500567,
"requests": 3,
"prompt_tokens": 91550,
"reused": 0,
"output_tokens": 768,
"prompt_ms": 80377.9,
"decode_ms": 8347.4
},
"hardware": {
"gpus": [
{
"index": 0,
"util": 43,
"mem_used": 25196167168,
"mem_total": 25769803776,
"temp": 52,
"power": 242.95
},
{
"index": 1,
"util": 65,
"mem_used": 24208408576,
"mem_total": 25769803776,
"temp": 55,
"power": 253.875
}
],
"gpu_util": 54.0,
"gpu_mem_used": 49404575744,
"gpu_mem_total": 51539607552,
"gpu_temp": 55,
"gpu_power": 496.825,
"gpu_power_limit": 560.0,
"gpu_pcie_gen": 4,
"gpu_pcie_gen_max": 4,
"gpu_pcie_width": 16,
"gpu_pcie_rx_mb": 11.77734375,
"gpu_pcie_tx_mb": 120.830078125,
"cpu": 85.4,
"ram_used": 62122582016,
"ram_total": 177175990272,
"disk_read_mb": 2.9330443322466575,
"disk_write_mb": 0.08616042102070966,
"tok_s": 82.32972941826796,
"tok_s_mean": 95.05553044960695
},
"hardware_static": {
"gpu_name": "NVIDIA GeForce RTX 3090 + NVIDIA GeForce RTX 3090",
"gpu_count": 2,
"cpu_name": "AMD EPYC 7453 28-Core Processor",
"cores": 20,
"threads": 20,
"psutil": true
},
"history": {
"gpu_util": [
31.0,
3.0,
46.0,
46.0,
22.0,
59.5,
29.0,
60.0,
26.0,
31.5,
71.0,
32.5,
28.0,
66.0,
23.5,
24.5,
18.5,
29.0,
28.0,
78.0,
30.0,
73.5,
16.0,
28.0,
25.0,
28.0,
29.0,
66.0,
26.5,
18.5,
43.5,
46.0,
0.0,
64.5,
26.0,
23.0,
72.5,
27.0,
66.0,
24.5,
76.5,
60.5,
27.5,
57.5,
24.5,
32.0,
66.5,
26.0,
27.0,
64.5,
29.5,
52.5,
65.5,
24.0,
23.5,
85.0,
30.5,
9.5,
46.0,
54.0
],
"gpu_mem_used": [
49295523840,
49383604224,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744,
49404575744
],
"gpu_temp": [
55,
53,
55,
55,
52,
52,
54,
54,
54,
55,
55,
55,
54,
54,
54,
54,
54,
54,
54,
55,
55,
55,
54,
55,
54,
55,
55,
55,
55,
53,
55,
55,
53,
54,
55,
55,
54,
55,
55,
55,
56,
54,
55,
55,
55,
55,
55,
55,
55,
54,
55,
55,
55,
55,
56,
55,
56,
54,
56,
55
],
"gpu_power": [
405.61,
374.45,
407.02,
468.77,
463.21,
376.39,
436.62,
444.21,
398.6,
447.75,
406.3,
391.79,
452.85,
427.37,
418.5,
444.64,
378.02,
407.95,
435.96,
404.27,
456.87,
440.61,
401.93,
421.84,
438.49,
398.65,
446.07,
421.03,
422.3,
368.39,
434.33,
457.92,
400.91,
379.28,
435.92,
440.53,
380.92,
451.07,
408.21,
436.33,
435.94,
414.69,
425.45,
442.33,
389.05,
457.45,
433.14,
411.6,
454.98,
417.2,
434.56,
447.81,
430.75,
413.26,
446.25,
404.97,
437.77,
402.11,
426.81,
496.82
],
"gpu_pcie_rx_mb": [
6970.74,
14.21,
15.78,
30.52,
0.67,
4175.19,
7742.45,
4905.89,
4411.55,
4744.0,
6063.36,
4488.9,
7846.78,
7336.33,
4790.3,
4790.26,
4959.82,
3664.44,
6053.92,
4708.72,
5601.93,
6957.58,
5201.77,
7840.16,
7413.0,
3656.91,
7095.34,
5569.93,
6273.89,
9.44,
21.46,
30.47,
0.67,
4040.72,
6771.71,
4774.76,
3710.08,
6013.11,
4218.43,
89.64,
5065.25,
4264.21,
7538.94,
3521.39,
1962.57,
7673.88,
4194.59,
12185.76,
7580.33,
5805.73,
5337.71,
5530.07,
5019.52,
94.17,
4176.62,
7140.59,
4804.28,
0.62,
11.11,
11.78
],
"cpu": [
6.0,
28.4,
94.8,
99.5,
60.1,
6.9,
5.7,
6.7,
6.1,
6.3,
13.9,
10.0,
6.4,
7.2,
5.7,
6.4,
6.6,
6.1,
5.5,
6.3,
6.6,
7.5,
6.5,
6.4,
17.9,
10.2,
6.4,
7.9,
6.6,
24.8,
93.3,
97.1,
28.6,
7.9,
6.3,
6.6,
5.7,
7.6,
16.1,
12.3,
6.8,
6.9,
6.2,
7.1,
5.6,
6.4,
6.7,
5.7,
7.5,
6.5,
6.0,
8.4,
15.8,
7.4,
8.5,
6.1,
5.7,
7.0,
74.1,
85.4
],
"ram_used": [
61980233728,
62277226496,
62302523392,
62302191616,
62328995840,
62040481792,
62030888960,
62024949760,
62010191872,
62003638272,
62026113024,
62011977728,
61980151808,
61970239488,
61954445312,
61954318336,
61948420096,
61997678592,
62080253952,
62075203584,
62075965440,
62076403712,
62076399616,
62070407168,
62091988992,
62091988992,
62093479936,
62097862656,
62095917056,
62331494400,
62325518336,
62326792192,
62020993024,
62018838528,
62010839040,
62003871744,
61990277120,
61970149376,
61773103104,
61820641280,
61810376704,
61790760960,
61782196224,
61814075392,
61809737728,
61808422912,
61930074112,
61927755776,
61912608768,
61800587264,
61798178816,
61793333248,
61882507264,
61882978304,
61885661184,
61886173184,
61886357504,
62129778688,
62122844160,
62122582016
],
"disk_read_mb": [
0.0,
1.02,
5.65,
4.98,
3.42,
0.54,
0.0,
0.01,
0.02,
0.0,
0.02,
0.03,
0.0,
0.03,
0.02,
0.0,
0.01,
0.0,
0.01,
0.02,
0.0,
0.0,
12.64,
0.0,
71.65,
32.97,
0.0,
0.0,
0.0,
0.99,
5.21,
4.66,
2.02,
0.04,
0.0,
0.02,
0.04,
0.0,
0.04,
0.0,
0.05,
0.05,
0.0,
0.05,
0.04,
0.0,
0.04,
0.04,
0.0,
0.02,
0.03,
0.0,
0.01,
0.0,
0.16,
0.0,
0.0,
0.0,
3.86,
2.93
],
"tok_s": [
0.0,
48.0,
86.94,
102.06,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
56.0,
103.48,
102.58,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
114.9,
82.33
]
},
"time": 1790718083.3185816
}
}
@@ -0,0 +1,304 @@
#!/usr/bin/env python3
"""Strata benchmark harness (contribution plan, PR 1 step 1.2).
Follows the upstream method (bench/results/2026-09-28-speed-0114): one code-agent prompt per
length, greedy, 256 generated tokens, MTP as configured by setup. Every run gets a unique
prefix, so conversation checkpoints cannot skip the prompt. Numbers come from the engine log
lines the owner asks for in issue #74. /metrics and API timing are stored as cross-checks.
Stdlib only. Examples:
./strata-bench.py --label IQ3_XXS-1x3090 --log ./strata-iq3_xxs.log
./strata-bench.py --label Coder-2x3090-auto --contexts 16k,28k --mode needle
./strata-bench.py --url http://127.0.0.1:9292 --model flash-next-strata --label via-llama-swap
"""
import argparse
import json
import os
import re
import statistics
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime
from pathlib import Path
NOMINAL = {"1k": 1024, "2.7k": 2765, "4k": 4096, "8k": 8192, "16k": 16384, "28k": 28672,
"32k": 32768, "64k": 65536, "128k": 131072, "262k": 262144}
CODE_EXT = {".py", ".cpp", ".cc", ".h", ".hpp", ".cu", ".cuh", ".js", ".md", ".txt", ".cmake"}
SKIP_DIRS = {".git", ".venv", "build", "engine", "third_party", "node_modules", "models",
"packs", "mtp", "bench", "data", "__pycache__", "Strata-data"}
LOG_PATTERNS = [
re.compile(r"decode expert cache hit rate", re.I),
re.compile(r"\bPCIe\b"),
re.compile(r"prompt .*tok/s.*generated .*tok/s", re.I),
re.compile(r"reus|checkpoint", re.I),
re.compile(r"layer split", re.I),
]
TOKS_PER_S = re.compile(r"([\d][\d,]*(?:\.\d+)?)\s*tok(?:ens)?/s", re.I)
def load_corpus(dirs):
parts = []
for d in dirs:
root = Path(d)
for p in sorted(root.rglob("*")):
if p.suffix.lower() not in CODE_EXT or not p.is_file():
continue
if any(s in SKIP_DIRS for s in p.relative_to(root).parts[:-1]):
continue
text = p.read_text(encoding="utf-8", errors="ignore")
if text.strip():
parts.append(f"### {p.relative_to(root).as_posix()}\n```\n{text}\n```\n")
if not parts:
sys.exit(f"no source files found in {dirs}")
return parts
def build_text(parts, n_chars):
out, size, i, repeated = [], 0, 0, False
while size < n_chars:
if i and i % len(parts) == 0:
repeated = True
chunk = parts[i % len(parts)]
out.append(chunk)
size += len(chunk)
i += 1
return "".join(out)[:n_chars], repeated
def post_stream(url, payload, api_key, timeout):
req = urllib.request.Request(
f"{url}/v1/chat/completions", data=json.dumps(payload).encode(),
headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key or 'none'}"})
t0 = time.perf_counter()
t_first, text, reasoning, usage, chunks = None, [], [], {}, 0
with urllib.request.urlopen(req, timeout=timeout) as resp:
for raw in resp:
line = raw.decode("utf-8", errors="ignore").strip()
if not line.startswith("data:"):
continue
data = line[5:].strip()
if data == "[DONE]":
break
try:
chunk = json.loads(data)
except json.JSONDecodeError:
continue
if chunk.get("usage"):
usage = chunk["usage"]
for ch in chunk.get("choices") or []:
delta = ch.get("delta") or {}
piece = delta.get("content") or ""
rpiece = delta.get("reasoning_content") or ""
if (piece or rpiece) and t_first is None:
t_first = time.perf_counter()
if piece or rpiece:
chunks += 1
text.append(piece)
reasoning.append(rpiece)
t_end = time.perf_counter()
return {"t_start": t0, "t_first": t_first or t_end, "t_end": t_end, "text": "".join(text),
"reasoning": "".join(reasoning), "usage": usage, "chunks": chunks}
def get_json(url, path, api_key, timeout=10):
try:
req = urllib.request.Request(f"{url}{path}", headers={"Authorization": f"Bearer {api_key or 'none'}"})
with urllib.request.urlopen(req, timeout=timeout) as r:
body = r.read().decode("utf-8", errors="ignore")
try:
return json.loads(body)
except json.JSONDecodeError:
return body
except (urllib.error.URLError, TimeoutError) as e:
return {"error": str(e)}
def wait_healthy(url, api_key, timeout):
deadline = time.time() + timeout
while time.time() < deadline:
h = get_json(url, "/health", api_key, timeout=5)
if not (isinstance(h, dict) and "error" in h):
return True
time.sleep(5)
return False
def log_offset(log):
return log.stat().st_size if log and log.exists() else 0
def log_lines_since(log, offset):
if not log or not log.exists():
return []
time.sleep(0.5)
with log.open("r", encoding="utf-8", errors="ignore") as f:
f.seek(offset)
new = f.read().splitlines()
return [ln for ln in new if any(p.search(ln) for p in LOG_PATTERNS)]
def engine_numbers(lines):
"""Best effort: the last 'prompt ... tok/s ... generated ... tok/s' line -> (prompt, decode)."""
for ln in reversed(lines):
if LOG_PATTERNS[2].search(ln):
vals = [float(v.replace(",", "")) for v in TOKS_PER_S.findall(ln)]
if len(vals) >= 2:
return vals[0], vals[1]
return None, None
def target_tokens(key, max_tokens):
n = NOMINAL[key]
# leave room for the answer, like upstream's 259,943-token "262K" prompt
return n - max_tokens - 1024 if n >= 32768 else n
def make_messages(mode, parts, n_chars, run_id):
body, repeated = build_text(parts, n_chars)
system = f"[bench run {run_id}] You are a coding agent working in the repository shown below."
if mode == "needle":
word = uuid.uuid4().hex[:8].upper()
mid = len(body) // 2
body = f"{body[:mid]}\n# NOTE: the secret code word is {word}.\n{body[mid:]}"
task = "What is the secret code word mentioned in the files above? Answer with the word only."
else:
word = None
task = ("Task: explain what the last file above does, then propose one concrete improvement "
"as a unified diff.")
msgs = [{"role": "system", "content": system},
{"role": "user", "content": f"Repository files:\n\n{body}\n\n{task}"}]
return msgs, word, repeated
def run_once(a, parts, key, run, cpt):
tgt = target_tokens(key, a.max_tokens)
run_id = uuid.uuid4().hex[:12]
msgs, word, repeated = make_messages(a.mode, parts, int(tgt * cpt), run_id)
payload = {"model": a.model, "messages": msgs, "max_tokens": a.max_tokens, "stream": True,
"stream_options": {"include_usage": True}, "temperature": 0,
"reasoning_effort": a.reasoning_effort}
off = log_offset(a.log)
rec = {"label": a.label, "mode": a.mode, "ctx": key, "target_tokens": tgt, "run": run,
"run_id": run_id, "corpus_repeated": repeated, "time": datetime.now().isoformat(timespec="seconds")}
try:
r = post_stream(a.url, payload, a.api_key, a.timeout)
except Exception as e: # noqa: BLE001 - record and continue with the next cell
rec["error"] = str(e)[:300]
return rec, cpt
pt = r["usage"].get("prompt_tokens")
ct = r["usage"].get("completion_tokens") or r["chunks"]
ttft = r["t_first"] - r["t_start"]
dec_t = r["t_end"] - r["t_first"]
lines = log_lines_since(a.log, off)
e_prompt, e_decode = engine_numbers(lines)
rec.update({
"prompt_tokens": pt, "completion_tokens": ct,
"ttft_s": round(ttft, 3), "e2e_s": round(r["t_end"] - r["t_start"], 3),
"api_prompt_tps": round(pt / ttft, 1) if pt and ttft > 0 else None,
"api_decode_tps": round((ct - 1) / dec_t, 1) if ct and ct > 1 and dec_t > 0 else None,
"engine_prompt_tps": e_prompt, "engine_decode_tps": e_decode,
"log_lines": lines, "answer_head": r["text"][:300],
})
if word:
rec["needle_found"] = word in r["text"].upper() or word in r["reasoning"].upper()
if a.mode == "two-turn":
follow = msgs + [{"role": "assistant", "content": r["text"]},
{"role": "user", "content": "Summarize your answer in one sentence."}]
off2 = log_offset(a.log)
r2 = post_stream(a.url, {**payload, "messages": follow, "max_tokens": 64}, a.api_key, a.timeout)
rec["turn2_ttft_s"] = round(r2["t_first"] - r2["t_start"], 3)
rec["turn2_prompt_tokens"] = r2["usage"].get("prompt_tokens")
rec["turn2_log_lines"] = log_lines_since(a.log, off2)
if pt:
cpt = (int(tgt * cpt) + 400) / pt # refine chars per token for the next cells
return rec, cpt
def write_md(path, recs, label):
def med(vals):
vals = [v for v in vals if v is not None]
return round(statistics.median(vals), 1) if vals else None
rows = ["| ctx | prompt tokens | runs | TTFT s (med) | prompt tok/s engine / API (med) "
"| decode tok/s engine / API (run 1) | decode tok/s engine / API (med) | needle |",
"|---|---|---|---|---|---|---|---|"]
for key in dict.fromkeys(r["ctx"] for r in recs):
rs = [r for r in recs if r["ctx"] == key and "error" not in r]
errs = sum(1 for r in recs if r["ctx"] == key and "error" in r)
if not rs:
rows.append(f"| {key} | - | 0 ({errs} errors) | | | | | |")
continue
first = rs[0]
needle = "" if rs[0].get("needle_found") is None else f"{sum(r['needle_found'] for r in rs)}/{len(rs)}"
rows.append(
f"| {key} | {rs[0]['prompt_tokens']} | {len(rs)}{f' ({errs} err)' if errs else ''} "
f"| {med(r['ttft_s'] for r in rs)} "
f"| {med(r['engine_prompt_tps'] for r in rs)} / {med(r['api_prompt_tps'] for r in rs)} "
f"| {first['engine_decode_tps']} / {first['api_decode_tps']} "
f"| {med(r['engine_decode_tps'] for r in rs)} / {med(r['api_decode_tps'] for r in rs)} | {needle} |")
path.write_text(f"# {label}\n\n" + "\n".join(rows) + "\n", encoding="utf-8")
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--url", default="http://127.0.0.1:8090")
ap.add_argument("--model", default="strata", help="model name sent (llama-swap: the model id)")
ap.add_argument("--api-key", default=os.environ.get("STRATA_API_KEY", ""))
ap.add_argument("--label", required=True, help="e.g. IQ3_XXS-1x3090-calibrated")
ap.add_argument("--contexts", default="1k,4k,32k,128k", help=f"comma list of {','.join(NOMINAL)}")
ap.add_argument("--repeats", type=int, default=3)
ap.add_argument("--max-tokens", type=int, default=256)
ap.add_argument("--reasoning-effort", default="none")
ap.add_argument("--mode", choices=["speed", "needle", "two-turn"], default="speed")
ap.add_argument("--source-dir", action="append", default=None,
help="code corpus for the prompts (default: current directory, the Strata repo)")
ap.add_argument("--log", type=Path, default=None,
help="engine log, e.g. ./strata-iq3_xxs.log")
ap.add_argument("--out", type=Path, default=Path(f"./benchmark-output/{datetime.now():%Y-%m-%d}"))
ap.add_argument("--timeout", type=float, default=1800, help="per request, seconds (262K prefill takes minutes)")
ap.add_argument("--chars-per-token", type=float, default=3.4, help="start value, refined after each run")
a = ap.parse_args()
keys = [k.strip().lower() for k in a.contexts.split(",") if k.strip()]
bad = [k for k in keys if k not in NOMINAL]
if bad:
sys.exit(f"unknown context(s): {bad}")
parts = load_corpus(a.source_dir or ["."])
if a.log and not a.log.exists():
print(f"warning: log {a.log} not found; engine numbers will be empty", file=sys.stderr)
if not wait_healthy(a.url, a.api_key, 900):
sys.exit(f"{a.url}/health not reachable")
out = a.out / a.label
(out / "data").mkdir(parents=True, exist_ok=True)
recs, cpt = [], a.chars_per_token
for key in keys:
for run in range(1, a.repeats + 1):
rec, cpt = run_once(a, parts, key, run, cpt)
rec["metrics_after"] = get_json(a.url, "/metrics", a.api_key)
recs.append(rec)
(out / "data" / f"{a.mode}-{key}-{run}.json").write_text(json.dumps(rec, indent=1), encoding="utf-8")
status = rec.get("error") or (f"prompt {rec['prompt_tokens']} tok, TTFT {rec['ttft_s']} s, "
f"decode engine {rec['engine_decode_tps']} / API {rec['api_decode_tps']} tok/s")
print(f"[{a.label}] {a.mode} {key} run {run}: {status}", flush=True)
matrix_path = out / "matrix.json"
merged = {}
if matrix_path.exists():
for record in json.loads(matrix_path.read_text(encoding="utf-8")):
merged[(record["mode"], record["ctx"], record["run"])] = record
for record in recs:
key = (record["mode"], record["ctx"], record["run"])
merged[key] = {k: v for k, v in record.items() if k != "metrics_after"}
combined = list(merged.values())
matrix_path.write_text(json.dumps(combined, indent=1), encoding="utf-8")
write_md(out / "matrix.md", combined, f"{a.label} ({a.mode})")
print(f"written: {out}/matrix.md, matrix.json, data/")
if __name__ == "__main__":
main()
@@ -0,0 +1,86 @@
## date (UTC)
2026-09-29T22:07:24Z
## strata version
v0.1.26
## os
PRETTY_NAME="Ubuntu 24.04.5 LTS"
VERSION_ID="24.04"
6.8.0-139-generic
## virtualization
kvm
## cpu
CPU(s): 20
Model name: AMD EPYC 7453 28-Core Processor
Thread(s) per core: 1
Core(s) per socket: 20
Socket(s): 1
L3 cache: 320 MiB (20 instances)
NUMA node(s): 1
## cpu flags (relevant)
avx2 f16c fma
## numa
available: 1 nodes (0)
node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
node 0 size: 168968 MB
node 0 free: 47460 MB
node distances:
node 0
0: 10
## memory
total used free shared buff/cache available
Mem: 165 14 46 0 105 150
Swap: 0 0 0
## dimms
run as root for dmidecode
(in a VM these are virtual DIMMs: fill in the host section below by hand)
## memlock limit
21627928
## gpu
index, name, driver_version, memory.total [MiB], pcie.link.gen.current, pcie.link.gen.max, pcie.link.width.current, pcie.link.width.max, power.limit [W], power.default_limit [W], power.max_limit [W], power.draw [W], clocks.max.sm [MHz]
0, NVIDIA GeForce RTX 3090, 595.91.07, 24576 MiB, 1, 4, 16, 16, 280.00 W, 350.00 W, 366.00 W, 35.23 W, 2130 MHz
1, NVIDIA GeForce RTX 3090, 595.91.07, 24576 MiB, 1, 4, 16, 16, 280.00 W, 420.00 W, 450.00 W, 28.60 W, 2100 MHz
## gpu topology
GPU0 GPU1 CPU Affinity NUMA Affinity GPU NUMA ID
GPU0 X PHB 0-19 0 N/A
GPU1 PHB X 0-19 0 N/A
Legend:
X = Self
SYS = Connection traversing PCIe as well as the SMP interconnect between NUMA nodes (e.g., QPI/UPI)
NODE = Connection traversing PCIe as well as the interconnect between PCIe Host Bridges within a NUMA node
PHB = Connection traversing PCIe as well as a PCIe Host Bridge (typically the CPU)
PXB = Connection traversing multiple PCIe bridges (without traversing the PCIe Host Bridge)
PIX = Connection traversing at most a single PCIe bridge
NV# = Connection traversing a bonded set of # NVLinks
## gpu processes (must be empty before benchmarking)
pid, process_name, used_gpu_memory [MiB]
## docker
Docker version 29.8.1, build 4a63305
NVIDIA Container Toolkit CLI version 1.18.1
## disk (model data)
Filesystem Size Used Avail Use% Mounted on
/dev/sdb1 541G 409G 106G 80% <storage>
## host (fill in manually)
- Hypervisor: Proxmox VE (KVM guest; host version not visible inside the VM)
- CPU: AMD EPYC 7453 28-Core Processor (Milan); 20 vCPU exposed, AVX2, no AVX-512 visible
- RAM: 165 GiB visible to the guest; physical DIMM layout and bandwidth not measured
- VM: 20 vCPU, 1 socket x 20 cores x 1 thread, 1 NUMA node; ballooning and pinning not verified
- GPUs: 2x RTX 3090 24 GB; PCIe Gen4 x16 maximum reported for each (current idle link generation varies); configured power limit 280 W each
- Storage: ext4 guest data disk, 541 GiB; host storage layout not verified from the guest
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,48 @@
# Native benchmark matrix (v0.1.26)
Prompt speeds are engine tok/s medians; output lists the first-run value and the three-run median. `prompt tokens` is the median measured count. Draft acceptance is the mean of per-run accepted/offered values from engine logs.
## IQ3_XXS, one RTX 3090
| Context | Prompt tokens | Prompt tok/s | Decode first / median tok/s | TTFT median | Draft acceptance |
|---|---:|---:|---:|---:|---:|
| 1K | 1,135 | 869.7 | 93.0 / 93.0 | 1.33 s | 0.738 |
| 4K | 4,200 | 1,772.2 | 91.7 / 89.2 | 2.41 s | 0.763 |
| 32K | 31,602 | 2,160.4 | 90.6 / 90.6 | 14.83 s | 0.739 |
| 128K | 129,913 | 2,173.6 | 79.3 / 79.3 | 60.53 s | 0.723 |
| 262K | 259,589 | 1,725.6 | 63.0 / 67.3 | 152.10 s | 0.697 |
## 32K model and GPU comparison
| Model | GPUs / split | Prompt tokens | Prompt tok/s median | Decode first / median tok/s | TTFT median | Draft acceptance |
|---|---|---:|---:|---:|---:|---:|
| Coder IQ1_M | 1x 3090 | 31,601 | 2,502.4 | 52.7 / 66.8 | 12.80 s | 0.760 |
| Coder IQ1_M | 2x 3090, auto K=19 | 31,601 | 2,704.3 | 88.5 / 98.6 | 11.85 s | 0.908 |
| IQ3_XXS | 2x 3090, auto K=24 | 31,603 | 1,158.9 | 83.7 / 96.7 | 26.90 s | 0.690 |
| IQ3_S | 2x 3090, auto K=24 | 31,604 | 749.3 | 83.1 / 106.3 | 42.27 s | 0.871 |
## Coder IQ1_M fixed layer split
One initial 32K run per K, then three-run repeats for K=22–30. Prompts are independent and adaptive-cache behavior varies; compare the medians cautiously.
| Split | Successful runs | Prompt tok/s median | Decode tok/s median | Notes |
|---|---:|---:|---:|---|
| Auto (K=19) | 3 | 2,704.3 | 98.6 | Layers 0–18 / 19–47 |
| K=18 | 1 | 2,324.6 | 83.1 | Repeat startup OOM while uploading a dense weight |
| K=22 | 3 | 2,951.6 | 103.3 | Layers 0–21 / 22–47 |
| K=24 | 3 | 3,123.2 | 100.2 | Layers 0–23 / 24–47 |
| K=26 | 3 | 3,205.2 | 93.5 | Layers 0–25 / 26–47 |
| K=28 | 3 | 3,034.9 | 96.6 | Layers 0–27 / 28–47 |
| K=30 | 3 | 2,920.6 | 96.1 | Layers 0–29 / 30–47 |
## Correctness
| Model / setup | Check | Result |
|---|---|---|
| IQ3_XXS, 1x 3090 | Needles 8K / 16K / 28K | 3/3 found |
| IQ3_XXS, 1x 3090 | 16K two-turn chat | 15,892 / 15,915 prompt tokens reused on turn two |
| IQ3_XXS, 2x 3090 auto K=24 | Needles 8K / 16K / 28K | 3/3 found |
| IQ3_XXS, 2x 3090 auto K=24 | 16K two-turn chat | 15,628 / 15,672 prompt tokens reused on turn two |
| IQ3_S, 2x 3090 auto K=24 | Needles 8K / 16K / 28K | 3/3 found |
| IQ3_S, 2x 3090 auto K=24 | 16K two-turn chat | 15,632 / 15,676 prompt tokens reused on turn two |
| Coder, 2x 3090 | Needles / two-turn | Not run |
@@ -0,0 +1,14 @@
{
"source": "local",
"version": "0.1.29",
"archs": [
120
],
"vision": "gpu",
"cuda_dirs": [
"/usr/local/cuda/bin",
"/usr/local/cuda/lib64"
],
"src": "1437bc9455f7c0af",
"vision_src": "4b80385716918cce"
}
@@ -0,0 +1,4 @@
FROM nvidia/cuda@sha256:5dc1bca23d05bd37b011be68ec470c03b403a5da07ec3a86e41af9470e9d0cc6
RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends build-essential cmake ninja-build git ca-certificates curl python3 python3-venv python3-dev pkg-config && rm -rf /var/lib/apt/lists/*
ENV HOME=/workspace/home PYTHONUNBUFFERED=1
WORKDIR /workspace/Strata
@@ -0,0 +1,167 @@
# Community benchmark: RTX 5090, Core Ultra 9 285K
Measured on 2026-09-30 by [hagope](https://github.com/hagope), on a Linux
machine called OMAN. This tests Strata 0.1.29 with the original Flash-Next
IQ2_XS, one GPU, and a 131,072-token context limit.
Median decode throughput was **179.4 tok/s at 4,096 prompt tokens, 175.7 tok/s
at 32,768, and 165.0 tok/s at 128,000**. These are synthetic code-explanation
requests with greedy decoding and a 256-token output cap. They do not establish
general answer quality or performance on other workloads.
## Hardware and software
- NVIDIA GeForce RTX 5090; 32,607 MiB reported VRAM; 575 W power limit.
PCIe capability: Gen 5, x16. The engine's startup transfer probe reported
50.0 GB/s host-to-device. GPU clocks were not fixed for this test.
- Intel Core Ultra 9 285K; 24 logical CPUs. The engine selected AVX2 and
23 expert-pool workers plus its host thread.
- 64 GB installed RAM; Linux reported 62.19 GiB usable. Local NVMe storage:
WDC WDS200T2B0C-00PXH0. 8 GiB system swap.
- Ubuntu 24.04.4 LTS, kernel 6.8.0-142-generic, NVIDIA driver 595.84.
- Source commit `d6708a4aae15b4860000d54c8af9e84d684bce09`; engine 0.1.29.
Locally compiled CUDA architecture 120, including the GPU vision helper.
See [BUILD.json](BUILD.json).
- CUDA 13.0.2 container; NVCC 13.0.88; GCC 13.3.0; Python 3.12.3.
Base image: `nvidia/cuda@sha256:5dc1bca23d05bd37b011be68ec470c03b403a5da07ec3a86e41af9470e9d0cc6`.
Installed Python dependencies are listed in [python-packages.txt](python-packages.txt).
- The regular inference server, GPU TTS, and GPU embedding service were paused.
Other CPU services remained running. The GPU was dedicated to Strata and its
vision helper; this was not a completely isolated operating system.
## Model and configuration
Model: `ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF`, revision
`ed59f92082b1e93c0e96d60a8b11aab089b52f09`:
- `IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00001-of-00002.gguf`
- `IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00002-of-00002.gguf`
- `mmproj-Qwen3.8-Flash-Next-BF16.gguf`
All three local GGUF SHA-256 hashes matched the revision's published LFS hashes.
[model-provenance.json](model-provenance.json) contains filenames, byte sizes,
revisions, and verified hashes. MTP was fetched by the installer from
`Qwen/Qwen3.8-Flash-Next`; its API reported revision
`de4b8e4d43b917e7706784d8bb445c9af86a3540` at verification time. The installer
uses `main` for those tensor-range downloads. Their individual output hashes
are retained in [mtp-manifest.json](mtp-manifest.json); the full BF16 upstream
shards were not downloaded or independently hash-verified.
The unmodified installer prepared the native IQ2_XS pack and Q2_0 MTP experts.
[artifact-hashes.json](artifact-hashes.json) identifies the executables,
default expert profile, tokenizer, pack metadata/dense weights, and draft pack.
- Context 131,072; INT8 KV; 32,768 KV cells per attention layer resident on GPU.
- Expert cache `auto`: 17,463 slots, 23.44 GiB VRAM, profile-prefilled with
**no eviction**. The bundled expert profile was used without calibration.
- Prefill `auto` selected chunks of 8,192 tokens, borrowing 3,421 expert-cache
slots during prompt processing.
- MTP `--spec 4 --spec-min-p 0.5`; built-in suffix drafting remained enabled.
- Low-RAM mode off; GPU vision enabled, 1,024 image tokens and a 700 MiB VRAM
reserve. The vision helper warmed up; benchmark requests contained no images.
- Experimental speed projection off; no custom control vectors or calibration.
- Reasoning disabled, temperature 0, maximum 256 generated tokens per speed run.
The complete measured configuration is [strata-iq2_xs.json](strata-iq2_xs.json).
Startup choices and every request's timing/draft statistics are in
[engine.log](engine.log).
## Method and reproduction
Use the attached [Dockerfile](Dockerfile), the pinned source commit, and an empty
data directory. Mount a working directory as `/workspace`, with the checkout
at `/workspace/Strata`. Run setup inside the CUDA container with GPU access,
host IPC, and unlimited memlock:
```bash
bash ./setup.sh --family qwen --model IQ2_XS --context 131072 --kv int8 \
--vision gpu --experimental-speed-projection off --gpu 0 --low-ram off \
--build --yes --no-start --port 18080 --data-dir /workspace/Strata-data
```
Launch the prepared server on loopback inside a container using host networking:
```bash
/workspace/Strata/.venv/bin/python serve/server.py --engine strata \
--config strata-iq2_xs.json --host 127.0.0.1 --port 18080
```
Run [benchmark.py](benchmark.py) inside that container, after placing the script
at `/workspace/benchmark.py`. It generates deterministic synthetic Python
functions, adds a different nonce near the start of each request, and counts the
complete rendered chat prompt using Strata's tokenizer. It adjusts the filler
to the target token count and verifies the count against the server afterward.
The resulting request hashes are in [results.json](results.json).
```bash
/workspace/Strata/.venv/bin/python /workspace/benchmark.py
/workspace/Strata/.venv/bin/python tools/needle_bench.py \
--url http://127.0.0.1:18080 --lengths 32k,128k --depths 10,50,90 \
--out /workspace/results/needles.json
```
One short warm-up request was excluded. Three runs at each length were executed
serially in increasing-length order on the same loaded engine. All nine speed
requests processed their entire prompt: **zero reused tokens**. The GPU expert
cache was filled at startup and retained between requests; no engine restart or
OS page-cache reset separated them. Downloads and file verification had already
warmed the filesystem cache. Loading time is excluded.
The script measures streaming TTFT from immediately before the HTTP request
until the first nonempty text delta, ignoring empty role chunks and keep-alives.
With reasoning off, that delta contains answer text. Total latency ends at
stream completion. Both timings include HTTP and frontend tokenization on OMAN
over loopback. Engine prompt throughput uses freshly read tokens divided by
`prompt_ms`; decode throughput uses `engine_generated / decode_ms`. The JSON
preserves the engine timing values and output text for each run.
## Results
Each cell below is the median **[minimum–maximum]** of three runs. Every request
generated 256 tokens and stopped at the output limit, with no failed or cancelled
speed requests.
| Prompt tokens | Reused | Prompt tok/s | Decode tok/s | TTFT seconds | Total seconds |
| ---: | ---: | ---: | ---: | ---: | ---: |
| 4,096 | 0 | 4,269.8 [3,510.2–4,273.3] | 179.4 [161.3–184.8] | 0.974 [0.973–1.183] | 2.392 [2.351–2.761] |
| 32,768 | 0 | 5,543.2 [5,527.1–5,549.6] | 175.7 [166.1–181.8] | 5.950 [5.942–5.968] | 7.390 [7.348–7.498] |
| 128,000 | 0 | 5,778.7 [5,767.0–5,791.9] | 165.0 [154.8–169.3] | 22.262 [22.212–22.308] | 23.850 [23.765–23.856] |
Raw per-run records: [results.json](results.json). Calculated aggregates:
[summary.json](summary.json). The lower first 4K run is retained in the range.
Decode expert-cache hit rates were 97.8–99.7% for these nine requests.
[monitor.py](monitor.py) sampled the host once per second, starting before model
load and ending after the recall checks. [telemetry.jsonl](telemetry.jsonl)
contains 250 samples over 255.9 seconds, with the following observed peaks:
- GPU memory: **31,785 MiB (31.04 GiB)**, system-wide on the selected GPU.
- Host RAM: **45.54 GiB**, calculated as `MemTotal - MemAvailable`. This includes
Strata, other services, and non-reclaimable system memory; it is not process RSS.
- Swap allocation increased from **0.25 MiB to 425.50 MiB**, including increases
during the speed suite. Swap I/O rates were not measured, so this is not a
claim that inference ran without paging. No out-of-memory error occurred.
Sampling and the server's own telemetry were active during inference. These
are sampled peaks; brief allocation spikes between samples may be missed.
Aggregates are also recorded in [memory-summary.json](memory-summary.json).
## Recall and limitations
The repository's unchanged `tools/needle_bench.py` found **all six needles**:
depths 10%, 50%, and 90% at both requested lengths. Actual prompt lengths were
30,804–30,805 tokens for `32k` and 126,318–126,320 for `128k`. All answers exactly
matched the expected code words. See [needles.json](needles.json).
The final 128K recall case reused 16,384 prompt tokens; the other five reused
zero. Recall latency is therefore not used in the fresh-prompt speed table.
The script chooses needle depth by character position, not token position.
This is one machine, one quantization, one configuration, and a small synthetic
workload. Long output, sampled decoding, thinking, coding-task correctness,
vision, tool use, multi-request concurrency, and a sustained thermal run were
not evaluated. The built-in needle check measures recall on these six inputs,
not general model accuracy. No same-workload baseline on another engine or GPU
was run; do not interpret the README's different-hardware numbers as a controlled
comparison. The 128,000-token speed prompt also does not fill every token of the
131,072-token context window.
@@ -0,0 +1,82 @@
[
{
"file": "Strata-data/mtp/mtp-q2_0.gguf",
"bytes": 889017216,
"sha256": "a22206a4d74eafbf31063a84610292535fb3b49af9a339963817fd04aed81e4d"
},
{
"file": "Strata-data/mtp/rt/dense.bin",
"bytes": 116099072,
"sha256": "c724dc0b0822ada5d2977bf5bde821605feabaa64ea2e0045b67ca656329070a"
},
{
"file": "Strata-data/mtp/rt/dense.txt",
"bytes": 1851,
"sha256": "991456cf4eb266eb8a888c349e548d11bc640f5dbd9149439aa9786af0f732fd"
},
{
"file": "Strata-data/mtp/rt/draft_vocab.bin",
"bytes": 425196,
"sha256": "b1e1d3a7a9e4bf862dcd5923ce661fb59bbd07907e594df5cf86a62ac235cb91"
},
{
"file": "Strata-data/mtp/rt/experts.bin",
"bytes": 707788800,
"sha256": "09398406be61f1f54c93861f449e48b8df0bfccbc9ec9b2b7636775a6ea9244f"
},
{
"file": "Strata-data/packs/iq2_xs/dense.bin",
"bytes": 1538035200,
"sha256": "d2af3d8331e5c7a1985d1d589747230f9d56719a6d33c7cddc9ee6b81cde6b13"
},
{
"file": "Strata-data/packs/iq2_xs/index.txt",
"bytes": 93686,
"sha256": "19e781af360ca3b83fd90fe09e757ac9aa2a9dcada26810ddc9e933bdb112091"
},
{
"file": "Strata-data/packs/iq2_xs/native_experts.txt",
"bytes": 3289,
"sha256": "48df605acb89c7e8c3176a51cec777c2ed344ea439e8f3a37e5ce4f9dcb6946c"
},
{
"file": "Strata-data/packs/iq2_xs/tokenizer/chat_template.jinja",
"bytes": 9993,
"sha256": "12827f24b742ea4e80cdc12dbcf9622227056b9f797252a3149263d4f9aaadce"
},
{
"file": "Strata-data/packs/iq2_xs/tokenizer/merges.txt",
"bytes": 3353258,
"sha256": "4ba698529766c7a2f5052083ea10cdf2485577f5237a332ee291054eb11e3332"
},
{
"file": "Strata-data/packs/iq2_xs/tokenizer/token_type.json",
"bytes": 744960,
"sha256": "5088c8c298fc06af8382ddb3b76c888703ac2634e82263b97eedcc2ad202738b"
},
{
"file": "Strata-data/packs/iq2_xs/tokenizer/tokenizer.json",
"bytes": 541,
"sha256": "c0bd435efbc6c3b28964b47999afe16c4ad268c7c7c4e8cb3af410796a6f30bf"
},
{
"file": "Strata-data/packs/iq2_xs/tokenizer/vocab.json",
"bytes": 5737005,
"sha256": "4ba64f0332abcfb0b600b7df1537d1e836e68009d5fb7cdb77339738dc6365c4"
},
{
"file": "Strata/data/expert-profile.bin",
"bytes": 196632,
"sha256": "8f59b4aa8873209dff11c11e37bcda9529a1335b724a1afeea37bf6388975baf"
},
{
"file": "Strata/engine/strata",
"bytes": 43158256,
"sha256": "b7f18df1314ad438952ca11bb5ce5f23b41e7a572462426383d2ad8209fcf367"
},
{
"file": "Strata/engine/strata-vision",
"bytes": 74993888,
"sha256": "0d4c955f255ba4c3a9f6f456d63292754fae440a8a39cb13b9b6564938448e19"
}
]
@@ -0,0 +1,135 @@
#!/usr/bin/env python3
"""Serial, fresh-prompt Strata benchmark. Run inside its prepared environment."""
import argparse
import hashlib
import json
import statistics
import sys
import time
import urllib.request
from pathlib import Path
def get(url):
with urllib.request.urlopen(url, timeout=30) as response:
return json.load(response)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--root", type=Path, default=Path("/workspace/Strata"))
parser.add_argument("--pack", type=Path, default=Path("/workspace/Strata-data/packs/iq2_xs"))
parser.add_argument("--url", default="http://127.0.0.1:18080")
parser.add_argument("--out", type=Path, default=Path("/workspace/results"))
parser.add_argument("--targets", default="4096,32768,128000")
parser.add_argument("--runs", type=int, default=3)
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
sys.path[:0] = [str(args.root), str(args.root / "tools")]
from strata_tokenizer import Tokenizer
from serve.frontend import ChatTemplate, openai_to_messages
directory = args.pack / "tokenizer"
vocab = json.loads((directory / "vocab.json").read_text())
tokens = [None] * len(vocab)
for token, number in vocab.items():
tokens[number] = token
tokenizer = Tokenizer(tokens, (directory / "merges.txt").read_text().splitlines(),
json.loads((directory / "token_type.json").read_text()))
template = ChatTemplate(directory / "chat_template.jinja")
initial = get(args.url + "/v1/status")
(args.out / "initial-status.json").write_text(json.dumps(initial, indent=2) + "\n")
rows = []
def request(content, maximum=256):
return {"model": "strata", "messages": [{"role": "user", "content": content}],
"temperature": 0, "reasoning_effort": "none", "max_tokens": maximum,
"stream": True, "stream_options": {"include_usage": True}}
def count(req):
messages, tools, kwargs = openai_to_messages(req)
return len(tokenizer.encode(template.render(messages, tools, **kwargs), parse_special=True))
def perform(label, req, expected=None):
body = json.dumps(req).encode()
(args.out / (label + "-request.json")).write_bytes(body + b"\n")
print("start", label, "tokens", expected, flush=True)
chunks, texts, first, finish = [], [], None, None
started = time.perf_counter()
wire = urllib.request.Request(args.url + "/v1/chat/completions", data=body,
headers={"Content-Type": "application/json"})
with urllib.request.urlopen(wire, timeout=1800) as response:
for line in response:
if not line.startswith(b"data: "):
continue
payload = line[6:].strip()
if payload == b"[DONE]":
break
chunk = json.loads(payload)
chunks.append(chunk)
for choice in chunk.get("choices", []):
delta = choice.get("delta", {})
text = (delta.get("content") or "") + (delta.get("reasoning_content") or "")
if text:
first = first if first is not None else time.perf_counter() - started
texts.append(text)
finish = choice.get("finish_reason") or finish
elapsed = time.perf_counter() - started
metrics = get(args.url + "/metrics")
engine = metrics["requests"][0]
usage = next((chunk["usage"] for chunk in reversed(chunks) if "usage" in chunk), {})
row = {"label": label, "expected_prompt_tokens": expected,
"request_sha256": hashlib.sha256(body).hexdigest(),
"client_ttft_s": first, "client_elapsed_s": elapsed, "finish_reason": finish,
"usage": usage, "engine": engine, "text": "".join(texts)}
if expected is not None and engine["prompt_tokens"] != expected:
raise RuntimeError(f"token count mismatch: {expected} vs {engine['prompt_tokens']}")
if not texts:
raise RuntimeError(f"no text received for {label}")
(args.out / (label + "-raw.json")).write_text(json.dumps({"chunks": chunks, "row": row}, indent=2) + "\n")
rows.append(row)
(args.out / "results.json").write_text(json.dumps(rows, indent=2) + "\n")
print("done", label, json.dumps({"ttft_s": first, "elapsed_s": elapsed, "engine": engine}), flush=True)
return row
perform("warmup", request("Reply with exactly the word READY.", 16))
# Each nonce occurs before the filler so previous long prompts cannot be reused.
filler = "\n".join(f"def task_{i:05d}(value: int) -> int: return (value * {(i % 97) + 1} + {i}) % 100003"
for i in range(12000))
ending = ("\n\nWrite a detailed explanation of the code above. Discuss deterministic integer transforms, "
"modulo arithmetic, testing, naming, complexity, and maintainability. Write at least 600 words.")
for target in map(int, args.targets.split(",")):
for run in range(1, args.runs + 1):
prefix = f"Benchmark nonce: series-{target}-trial-{run}.\nReview this synthetic Python module:\n"
lo, hi = 0, len(filler)
while lo < hi:
middle = (lo + hi + 1) // 2
if count(request(prefix + filler[:middle] + ending)) <= target:
lo = middle
else:
hi = middle - 1
req = request(prefix + filler[:lo] + ending)
actual = count(req)
if actual < target - 20 or actual > target:
raise RuntimeError(f"could not construct target {target}: {actual}")
perform(f"tokens-{target}-run-{run}", req, actual)
measured = [row for row in rows if row["label"] != "warmup"]
groups = {}
for target in map(int, args.targets.split(",")):
subset = [r for r in measured if r["label"].startswith(f"tokens-{target}-")]
values = {
"prompt_tokens": [r["engine"]["prompt_tokens"] for r in subset],
"cached_tokens": [r["engine"].get("reused", 0) for r in subset],
"output_tokens": [r["engine"]["engine_generated"] for r in subset],
"client_ttft_s": [r["client_ttft_s"] for r in subset],
"client_elapsed_s": [r["client_elapsed_s"] for r in subset],
"prefill_tok_s": [(r["engine"]["prompt_tokens"] - (r["engine"].get("reused") or 0)) / (r["engine"]["prompt_ms"] / 1000) for r in subset],
"decode_tok_s": [r["engine"]["engine_generated"] / (r["engine"]["decode_ms"] / 1000) for r in subset],
}
groups[str(target)] = {key: {"median": statistics.median(v), "min": min(v), "max": max(v)}
for key, v in values.items()}
(args.out / "summary.json").write_text(json.dumps(groups, indent=2) + "\n")
print("summary", json.dumps(groups), flush=True)
if __name__ == "__main__":
main()
@@ -0,0 +1,91 @@
load_hparams: Qwen-VL models require at minimum 1024 image tokens to function correctly on grounding tasks
load_hparams: if you encounter problems with accuracy, try adding --image-min-tokens 1024
load_hparams: more info: https://github.com/ggml-org/llama.cpp/issues/16842
strata-vision: warmed up at 1024 image tokens
strata generate: PCIe probe: 50.0 GB/s host->device -> pcie_frac 0.55 (default 0.55)
strata generate: this CPU has no AVX-512: the expert kernels run on AVX-2 (multi-token for the i-quant gate/up rows)
strata generate: native pack: /workspace/Strata-data/packs/iq2_xs experts (largest blob 1.51 MB), token embedding type 23 in mapped host memory (322 MiB)
strata generate: 1466 MiB of weights loaded from /workspace/Strata-data/packs/iq2_xs (302 canonical tensors skipped: served natively)
strata generate: 300 native projection matrices, 1474.85 MiB of weights
strata generate: KV streaming: 32768 of 131072 cells per QSA layer in VRAM, the K/V in 1.55 GiB of pinned RAM
strata generate: PLE on, table 320001536 rows of /workspace/Strata-data/models/IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00002-of-00002.gguf
strata mtp: draft layer loaded, 835 MiB of VRAM (experts 675, dense 111), files read in 0.23 s (3441 MiB/s)
strata generate: expert arena: cudaHostRegister PORTABLE ok; MAP_HUGETLB unavailable (no hugetlb pool configured?); using 4 KB pages
strata generate: loaded 33.02 GiB at 2.21 GiB/s
strata generate: profile /workspace/Strata/data/expert-profile.bin: 24576 ranked pairs, built for 24576 slots
strata generate: experimental native Q5_K head, 337715200 bytes
strata generate: expert cache auto: 24.26 GiB free, 700 MiB reserved (+143 MiB for the draft head) -> 16663 slots
strata generate: expert cache 17463 slots, 23.44 GiB of VRAM; policy is
strata generate: the GPU computes the experts in the cache; it rounds differently from the CPU,
so a reply can differ slightly from a run without the cache (same quality:
bench/results/2026-09-27-cache-parity).
PROFILE, ranked by routing frequency, no eviction.
strata generate: pre-filled 17463 of 17463 slots from the profile; slot 0 verified
strata generate: R4 hit path ON - resident experts are computed on the GPU
strata generate: 23 expert-pool workers + the host thread
strata generate: session is up (engine 0.1.29)
strata generate: token graph hit path: 17463 resident experts, decided on the device
strata serve: prompt chunk auto: 8192 tokens
strata serve: the prompt path borrows 3421 cache slots (4.62 GiB)
strata verify: window up to 6 tokens, 57.1 MiB of device buffers
strata mtp: draft head over 106299 tokens (137.9 MiB)
strata serve: 412 MiB of VRAM free with everything loaded
strata verify: captured the 6-token window (upload no error, sync no error)
strata verify: captured the 1-token window (upload no error, sync no error)
strata verify: captured the 4-token window (upload no error, sync no error)
strata serve: prompt 19 tokens = 0 reused + 19 read in 135 ms (140.9 tok/s), 2 generated in 57 ms (34.9 tok/s), drafts accepted 3 of 3, 1 checkpoints
strata serve: decode expert cache hit rate: 90.8% (2037 hits / 2244 lookups)
strata serve: KV streaming: 92.31% of 936 block reads hit VRAM, 0.3 MiB read from RAM
strata verify: captured the 3-token window (upload no error, sync no error)
strata verify: captured the 2-token window (upload no error, sync no error)
strata serve: prompt 4096 tokens = 0 reused + 4096 read in 1167 ms (3510.2 tok/s), 256 generated in 1587 ms (161.3 tok/s), drafts accepted 149 of 226, 1 checkpoints
strata serve: decode expert cache hit rate: 97.8% (155423 hits / 158942 lookups)
strata serve: KV streaming: 99.39% of 2095092 block reads hit VRAM, 51.8 MiB read from RAM
strata serve: suffix drafts: 3 windows, 6 of 9 drafts accepted
strata serve: prompt 4096 tokens = 0 reused + 4096 read in 959 ms (4269.7 tok/s), 256 generated in 1385 ms (184.8 tok/s), drafts accepted 158 of 221, 1 checkpoints
strata serve: decode expert cache hit rate: 99.3% (151655 hits / 152786 lookups)
strata serve: KV streaming: 99.36% of 2002680 block reads hit VRAM, 51.7 MiB read from RAM
strata serve: suffix drafts: 1 windows, 2 of 3 drafts accepted
strata serve: prompt 4096 tokens = 0 reused + 4096 read in 958 ms (4273.4 tok/s), 256 generated in 1427 ms (179.4 tok/s), drafts accepted 160 of 226, 1 checkpoints
strata serve: decode expert cache hit rate: 98.9% (153580 hits / 155293 lookups)
strata serve: KV streaming: 99.37% of 2039616 block reads hit VRAM, 52.0 MiB read from RAM
strata serve: suffix drafts: 2 windows, 2 of 8 drafts accepted
strata serve: prompt 32768 tokens = 0 reused + 32768 read in 5929 ms (5527.1 tok/s), 256 generated in 1541 ms (166.1 tok/s), drafts accepted 148 of 218, 2 checkpoints
strata serve: decode expert cache hit rate: 99.4% (155252 hits / 156260 lookups)
strata serve: KV streaming: 97.72% of 2045772 block reads hit VRAM, 187.5 MiB read from RAM
strata serve: prompt 32768 tokens = 0 reused + 32768 read in 5911 ms (5543.1 tok/s), 256 generated in 1408 ms (181.8 tok/s), drafts accepted 160 of 212, 2 checkpoints
strata serve: decode expert cache hit rate: 99.4% (147298 hits / 148150 lookups)
strata serve: KV streaming: 97.53% of 1941048 block reads hit VRAM, 193.2 MiB read from RAM
strata serve: prompt 32768 tokens = 0 reused + 32768 read in 5905 ms (5549.6 tok/s), 256 generated in 1457 ms (175.7 tok/s), drafts accepted 153 of 206, 2 checkpoints
strata serve: decode expert cache hit rate: 99.5% (148308 hits / 149107 lookups)
strata serve: KV streaming: 97.56% of 1953372 block reads hit VRAM, 191.7 MiB read from RAM
strata serve: suffix drafts: 2 windows, 3 of 8 drafts accepted
strata serve: prompt 128000 tokens = 0 reused + 128000 read in 22100 ms (5791.9 tok/s), 256 generated in 1654 ms (154.8 tok/s), drafts accepted 149 of 218, 6 checkpoints
strata serve: decode expert cache hit rate: 99.4% (155334 hits / 156245 lookups)
strata serve: KV streaming: 96.13% of 2045748 block reads hit VRAM, 318.7 MiB read from RAM
strata serve: prompt 128000 tokens = 0 reused + 128000 read in 22151 ms (5778.7 tok/s), 256 generated in 1512 ms (169.3 tok/s), drafts accepted 159 of 228, 6 checkpoints
strata serve: decode expert cache hit rate: 99.7% (155406 hits / 155913 lookups)
strata serve: KV streaming: 96.26% of 2039616 block reads hit VRAM, 307.0 MiB read from RAM
strata serve: prompt 128000 tokens = 0 reused + 128000 read in 22195 ms (5767.0 tok/s), 256 generated in 1551 ms (165.0 tok/s), drafts accepted 154 of 221, 6 checkpoints
strata serve: decode expert cache hit rate: 99.7% (155405 hits / 155914 lookups)
strata serve: KV streaming: 96.22% of 2039628 block reads hit VRAM, 310.9 MiB read from RAM
strata serve: suffix drafts: 1 windows, 1 of 2 drafts accepted
strata serve: prompt 30804 tokens = 0 reused + 30804 read in 6382 ms (4826.8 tok/s), 9 generated in 55 ms (163.1 tok/s), drafts accepted 6 of 6, 2 checkpoints
strata serve: decode expert cache hit rate: 92.6% (3832 hits / 4139 lookups)
strata serve: KV streaming: 78.28% of 92424 block reads hit VRAM, 80.8 MiB read from RAM
strata serve: prompt 30804 tokens = 0 reused + 30804 read in 5709 ms (5395.4 tok/s), 9 generated in 61 ms (147.0 tok/s), drafts accepted 6 of 6, 2 checkpoints
strata serve: decode expert cache hit rate: 94.7% (3971 hits / 4192 lookups)
strata serve: KV streaming: 78.55% of 92424 block reads hit VRAM, 79.9 MiB read from RAM
strata serve: prompt 30805 tokens = 0 reused + 30805 read in 5718 ms (5387.6 tok/s), 10 generated in 66 ms (150.4 tok/s), drafts accepted 9 of 9, 2 checkpoints
strata serve: decode expert cache hit rate: 96.3% (5885 hits / 6108 lookups)
strata serve: KV streaming: 82.56% of 117072 block reads hit VRAM, 82.3 MiB read from RAM
strata serve: prompt 126320 tokens = 0 reused + 126320 read in 22281 ms (5669.4 tok/s), 10 generated in 65 ms (154.9 tok/s), drafts accepted 7 of 7, 6 checkpoints
strata serve: decode expert cache hit rate: 97.7% (5115 hits / 5233 lookups)
strata serve: KV streaming: 77.02% of 104760 block reads hit VRAM, 97.0 MiB read from RAM
strata serve: prompt 126318 tokens = 0 reused + 126318 read in 22453 ms (5626.0 tok/s), 9 generated in 105 ms (86.0 tok/s), drafts accepted 6 of 14, 6 checkpoints
strata serve: decode expert cache hit rate: 97.4% (9224 hits / 9474 lookups)
strata serve: KV streaming: 82.65% of 160212 block reads hit VRAM, 112.0 MiB read from RAM
strata serve: prompt 126318 tokens = 16384 reused + 109934 read in 19791 ms (5554.7 tok/s), 9 generated in 78 ms (115.2 tok/s), drafts accepted 7 of 9, 6 checkpoints
strata serve: decode expert cache hit rate: 98.1% (6539 hits / 6669 lookups)
strata serve: KV streaming: 87.22% of 283464 block reads hit VRAM, 146.0 MiB read from RAM
@@ -0,0 +1 @@
{"service": "strata", "model": "qwen3.8-flash-next-iq2_xs", "engine": "0.1.29", "started": 1790772696, "uptime_s": 196, "cache_max_tokens": 131072, "context": {"native": 131072, "max_positions": 131072}, "concurrency": {"serving": 1, "requested": 1}, "dialects": ["/v1/chat/completions", "/v1/messages"], "vision": {"enabled": true, "available": true, "error": null}, "activity": {"requests": 16, "in_flight": 0, "last_request_at": 1790772892}, "last_timings": {"cache_n": 16384, "prompt_n": 109934, "prompt_ms": 19791.2, "prompt_per_token_ms": 0.18, "prompt_per_second": 5554.7, "predicted_n": 9, "predicted_ms": 78.1, "predicted_per_token_ms": 8.678, "predicted_per_second": 115.2, "draft_n": 9, "draft_n_accepted": 7, "at": 1790772892}, "machine": {"at": 1790772892, "gpu": {"name": "NVIDIA GeForce RTX 5090", "used_mib": 32281.0, "total_mib": 32607.0, "util_pct": 100, "temp_c": 72, "power_w": 528.823}, "ram": {"used_gib": 45.4, "total_gib": 62.2}}}
@@ -0,0 +1,46 @@
{
"service": "strata",
"model": "qwen3.8-flash-next-iq2_xs",
"engine": "0.1.29",
"started": 1790772696,
"uptime_s": 2,
"cache_max_tokens": 131072,
"context": {
"native": 131072,
"max_positions": 131072
},
"concurrency": {
"serving": 1,
"requested": 1
},
"dialects": [
"/v1/chat/completions",
"/v1/messages"
],
"vision": {
"enabled": true,
"available": true,
"error": null
},
"activity": {
"requests": 0,
"in_flight": 0,
"last_request_at": null
},
"last_timings": null,
"machine": {
"at": 1790772698,
"gpu": {
"name": "NVIDIA GeForce RTX 5090",
"used_mib": 32195.0,
"total_mib": 32607.0,
"util_pct": 0,
"temp_c": 36,
"power_w": 83.403
},
"ram": {
"used_gib": 44.4,
"total_gib": 62.2
}
}
}
@@ -0,0 +1,10 @@
{
"samples": 250,
"sample_duration_s": 255.8539924621582,
"sampling_method": "nominal 1 s; /proc/meminfo and nvidia-smi; startup through recall checks",
"ram_peak_GiB": 45.54487228393555,
"gpu_peak_MiB": 31785.0,
"swap_start_MiB": 0.25,
"swap_peak_MiB": 425.5,
"swap_end_MiB": 425.5
}
@@ -0,0 +1,46 @@
[
{
"repository": "ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF",
"revision": "ed59f92082b1e93c0e96d60a8b11aab089b52f09",
"gguf_files": [
{
"filename": "IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00001-of-00002.gguf",
"lfs": {
"sha256": "92cee27ae5bbadcd732416a0f7a7f0acc092399dbbe8f5a5efa707c2ec0a49d7",
"size": 39225954592,
"pointerSize": 136
},
"size": 39225954592,
"actual_sha256": "92cee27ae5bbadcd732416a0f7a7f0acc092399dbbe8f5a5efa707c2ec0a49d7",
"verified": true
},
{
"filename": "IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00002-of-00002.gguf",
"lfs": {
"sha256": "316b46f3a2dbd68c900f43136ab9449f9dcc3725dfd8c794847c204bc161e113",
"size": 28800138432,
"pointerSize": 136
},
"size": 28800138432,
"actual_sha256": "316b46f3a2dbd68c900f43136ab9449f9dcc3725dfd8c794847c204bc161e113",
"verified": true
},
{
"filename": "mmproj-Qwen3.8-Flash-Next-BF16.gguf",
"lfs": {
"sha256": "b1a82259702816a5330d7bd7607cd9676b11780e79ff7348c21103ff3ce49bd0",
"size": 907543008,
"pointerSize": 134
},
"size": 907543008,
"actual_sha256": "b1a82259702816a5330d7bd7607cd9676b11780e79ff7348c21103ff3ce49bd0",
"verified": true
}
]
},
{
"repository": "Qwen/Qwen3.8-Flash-Next",
"revision": "de4b8e4d43b917e7706784d8bb445c9af86a3540",
"gguf_files": []
}
]
@@ -0,0 +1,18 @@
"""Sample system RAM, swap and GPU memory once per second during the trial."""
import json
import subprocess
import sys
import time
from pathlib import Path
with Path(sys.argv[1] if len(sys.argv) > 1 else 'telemetry.jsonl').open('a') as output:
while True:
memory = {}
for line in Path('/proc/meminfo').read_text().splitlines():
key, value = line.split(':', 1)
if key in ('MemTotal', 'MemAvailable', 'SwapTotal', 'SwapFree'):
memory[key + '_KiB'] = int(value.strip().split()[0])
gpu = subprocess.check_output(['nvidia-smi', '--query-gpu=memory.used,memory.total,utilization.gpu,power.draw,temperature.gpu', '--format=csv,noheader,nounits'], text=True).strip()
output.write(json.dumps({'epoch_s': time.time(), 'memory': memory, 'gpu': gpu}) + '\n')
output.flush()
time.sleep(1)
@@ -0,0 +1,429 @@
[
{
"name": "mtp.fc_embedding.weight",
"shard": "model-00120-of-00131.safetensors",
"dtype": "BF16",
"shape": [
2560,
2560
],
"start": 1935412640,
"end": 1948519839,
"bytes": 13107200,
"file": "tensors/mtp.fc_embedding.weight.bin",
"sha256": "241d6e87ded317a61b1aeb3ca4e28c53f1caba09ad5be66092e91fe5e3e14751"
},
{
"name": "mtp.fc_hidden.weight",
"shard": "model-00124-of-00131.safetensors",
"dtype": "BF16",
"shape": [
2560,
2560
],
"start": 1716599928,
"end": 1729707127,
"bytes": 13107200,
"file": "tensors/mtp.fc_hidden.weight.bin",
"sha256": "97c8e427ad0177e2c713ed24a397d815b523eda15ef453f1ae6463f6c70a8f96"
},
{
"name": "mtp.hyper_connection_mixer.hc_norm.weight",
"shard": "model-00037-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240
],
"start": 1742326680,
"end": 1742347159,
"bytes": 20480,
"file": "tensors/mtp.hyper_connection_mixer.hc_norm.weight.bin",
"sha256": "ce948a398e15aeaa403c424cda34e6eed296ab2570d591bb5ff3da642b255d64"
},
{
"name": "mtp.hyper_connection_mixer.input_mix_weight_down.weight",
"shard": "model-00041-of-00131.safetensors",
"dtype": "BF16",
"shape": [
320,
10240
],
"start": 1935412688,
"end": 1941966287,
"bytes": 6553600,
"file": "tensors/mtp.hyper_connection_mixer.input_mix_weight_down.weight.bin",
"sha256": "c633d2841fda463e82045e0b93fb8cb8d511ec0c9eda616020f01aca18d71947"
},
{
"name": "mtp.hyper_connection_mixer.input_mix_weight_up.weight",
"shard": "model-00043-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240,
320
],
"start": 1832518416,
"end": 1839072015,
"bytes": 6553600,
"file": "tensors/mtp.hyper_connection_mixer.input_mix_weight_up.weight.bin",
"sha256": "6565285f0ba2923703252763cfc11d8a9bda40ab42e7548e12464b04dbdbec13"
},
{
"name": "mtp.layers.0.attn_hyper_connection.block_inject_weight.weight",
"shard": "model-00047-of-00131.safetensors",
"dtype": "BF16",
"shape": [
4,
10240
],
"start": 1716599984,
"end": 1716681903,
"bytes": 81920,
"file": "tensors/mtp.layers.0.attn_hyper_connection.block_inject_weight.weight.bin",
"sha256": "c8afff64e7f54412d02120097c4255033c55245e1c1eed84cc630d428ccb864c"
},
{
"name": "mtp.layers.0.attn_hyper_connection.hc_norm.weight",
"shard": "model-00049-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240
],
"start": 1935412672,
"end": 1935433151,
"bytes": 20480,
"file": "tensors/mtp.layers.0.attn_hyper_connection.hc_norm.weight.bin",
"sha256": "1fb619aeaaf637ccd70f46f1f8f8116e6a46448cb43026b246de8ee8286ed809"
},
{
"name": "mtp.layers.0.attn_hyper_connection.input_mix_weight_down.weight",
"shard": "model-00053-of-00131.safetensors",
"dtype": "BF16",
"shape": [
320,
10240
],
"start": 1832518424,
"end": 1839072023,
"bytes": 6553600,
"file": "tensors/mtp.layers.0.attn_hyper_connection.input_mix_weight_down.weight.bin",
"sha256": "e80ac8bf3e270e9d5a949ec7c913329dc8de017d69851334820fae7b8c86a7f5"
},
{
"name": "mtp.layers.0.attn_hyper_connection.input_mix_weight_up.weight",
"shard": "model-00057-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240,
320
],
"start": 1935412680,
"end": 1941966279,
"bytes": 6553600,
"file": "tensors/mtp.layers.0.attn_hyper_connection.input_mix_weight_up.weight.bin",
"sha256": "f80f1fd44e1183e7764ea496b11ff89ead9dd758f861d4e79a770bf54956b1a5"
},
{
"name": "mtp.layers.0.mlp.experts.down_proj",
"shard": "model-00062-of-00131.safetensors",
"dtype": "BF16",
"shape": [
512,
2560,
640
],
"start": 1832518400,
"end": 3510239999,
"bytes": 1677721600,
"file": "tensors/mtp.layers.0.mlp.experts.down_proj.bin",
"sha256": "539c46234f73bac70450f731f40e715f77ac32faf77def0f3f800e58aaabbbc0"
},
{
"name": "mtp.layers.0.mlp.experts.gate_up_proj",
"shard": "model-00060-of-00131.safetensors",
"dtype": "BF16",
"shape": [
512,
1280,
2560
],
"start": 115918328,
"end": 3471361527,
"bytes": 3355443200,
"file": "tensors/mtp.layers.0.mlp.experts.gate_up_proj.bin",
"sha256": "839e98f9642ebc884b178abd2090b6dc8b0bcd81ed92d7f7a08314c6a68f96d5"
},
{
"name": "mtp.layers.0.mlp.gate.weight",
"shard": "model-00066-of-00131.safetensors",
"dtype": "BF16",
"shape": [
512,
2560
],
"start": 1716599952,
"end": 1719221391,
"bytes": 2621440,
"file": "tensors/mtp.layers.0.mlp.gate.weight.bin",
"sha256": "f0d35fa41b360a08bc0c5b1e5766aa42df960291716ee189208b5d2599462c20"
},
{
"name": "mtp.layers.0.mlp.shared_expert.down_proj.weight",
"shard": "model-00076-of-00131.safetensors",
"dtype": "BF16",
"shape": [
2560,
640
],
"start": 1935412680,
"end": 1938689479,
"bytes": 3276800,
"file": "tensors/mtp.layers.0.mlp.shared_expert.down_proj.weight.bin",
"sha256": "d2ced8c81367cc494599d1a8cdc279c3dd6579b628ded05acd7495e99cee01d8"
},
{
"name": "mtp.layers.0.mlp.shared_expert.gate_proj.weight",
"shard": "model-00072-of-00131.safetensors",
"dtype": "BF16",
"shape": [
640,
2560
],
"start": 1832518528,
"end": 1835795327,
"bytes": 3276800,
"file": "tensors/mtp.layers.0.mlp.shared_expert.gate_proj.weight.bin",
"sha256": "f4a81109165853b3b64f36d809f98094b599763364070f5fa079200e1c386d4c"
},
{
"name": "mtp.layers.0.mlp.shared_expert.up_proj.weight",
"shard": "model-00072-of-00131.safetensors",
"dtype": "BF16",
"shape": [
640,
2560
],
"start": 1835795328,
"end": 1839072127,
"bytes": 3276800,
"file": "tensors/mtp.layers.0.mlp.shared_expert.up_proj.weight.bin",
"sha256": "172586861eea53efbff10afc43ded5b6e49c83879e9efc01e089c652bbb0a156"
},
{
"name": "mtp.layers.0.mlp.shared_expert_gate.weight",
"shard": "model-00070-of-00131.safetensors",
"dtype": "BF16",
"shape": [
1,
2560
],
"start": 1832518400,
"end": 1832523519,
"bytes": 5120,
"file": "tensors/mtp.layers.0.mlp.shared_expert_gate.weight.bin",
"sha256": "acdd306d9996d356e4667a16ff63af6fef086fc7f570f1bc00bbe882a2a93f6e"
},
{
"name": "mtp.layers.0.mlp_hyper_connection.block_inject_weight.weight",
"shard": "model-00078-of-00131.safetensors",
"dtype": "BF16",
"shape": [
4,
10240
],
"start": 1832518424,
"end": 1832600343,
"bytes": 81920,
"file": "tensors/mtp.layers.0.mlp_hyper_connection.block_inject_weight.weight.bin",
"sha256": "c5782dd92b479a1f8ef43d683fe9c917fd9e8fba81f23c1aae8817bfe4b476a6"
},
{
"name": "mtp.layers.0.mlp_hyper_connection.hc_norm.weight",
"shard": "model-00082-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240
],
"start": 1935412656,
"end": 1935433135,
"bytes": 20480,
"file": "tensors/mtp.layers.0.mlp_hyper_connection.hc_norm.weight.bin",
"sha256": "21a504876b5e7b788301557c68dfb757999430eba36c66ec8ab96a63604dbfd1"
},
{
"name": "mtp.layers.0.mlp_hyper_connection.input_mix_weight_down.weight",
"shard": "model-00086-of-00131.safetensors",
"dtype": "BF16",
"shape": [
320,
10240
],
"start": 1935412696,
"end": 1941966295,
"bytes": 6553600,
"file": "tensors/mtp.layers.0.mlp_hyper_connection.input_mix_weight_down.weight.bin",
"sha256": "b71240036dea954e034d5ae04e097bcd7ac51cb28a44e4c93d198af3447278a1"
},
{
"name": "mtp.layers.0.mlp_hyper_connection.input_mix_weight_up.weight",
"shard": "model-00088-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240,
320
],
"start": 1832518424,
"end": 1839072023,
"bytes": 6553600,
"file": "tensors/mtp.layers.0.mlp_hyper_connection.input_mix_weight_up.weight.bin",
"sha256": "40756866bf2a5e82c28e407f717b6fa07614d593f78e79c7ceb2cd4ffe6dda94"
},
{
"name": "mtp.layers.0.self_attn.indexer.index_qk_proj.weight",
"shard": "model-00090-of-00131.safetensors",
"dtype": "BF16",
"shape": [
640,
2560
],
"start": 1832518416,
"end": 1835795215,
"bytes": 3276800,
"file": "tensors/mtp.layers.0.self_attn.indexer.index_qk_proj.weight.bin",
"sha256": "2befafae6e944c1fc651fd73d4d527eb6f138a6c1679065b003128ee3150e859"
},
{
"name": "mtp.layers.0.self_attn.indexer.k_layernorm.weight",
"shard": "model-00094-of-00131.safetensors",
"dtype": "BF16",
"shape": [
128
],
"start": 1935412672,
"end": 1935412927,
"bytes": 256,
"file": "tensors/mtp.layers.0.self_attn.indexer.k_layernorm.weight.bin",
"sha256": "2db621f6a08b4085756fc69d60a4a1bd1d7fbf5d406456d2477075842efaae54"
},
{
"name": "mtp.layers.0.self_attn.indexer.q_layernorm.weight",
"shard": "model-00100-of-00131.safetensors",
"dtype": "BF16",
"shape": [
128
],
"start": 1716599968,
"end": 1716600223,
"bytes": 256,
"file": "tensors/mtp.layers.0.self_attn.indexer.q_layernorm.weight.bin",
"sha256": "afaf59f68e251939970ffdeacad0667dffc657a522bea62cdc44a52816fc49d6"
},
{
"name": "mtp.layers.0.self_attn.k_norm.weight",
"shard": "model-00102-of-00131.safetensors",
"dtype": "BF16",
"shape": [
256
],
"start": 1935412648,
"end": 1935413159,
"bytes": 512,
"file": "tensors/mtp.layers.0.self_attn.k_norm.weight.bin",
"sha256": "8f924b0357cf936e14fc34518205d000e1423aa60626827df81b0804fae8cdfd"
},
{
"name": "mtp.layers.0.self_attn.k_proj.weight",
"shard": "model-00108-of-00131.safetensors",
"dtype": "BF16",
"shape": [
512,
2560
],
"start": 1832518624,
"end": 1835140063,
"bytes": 2621440,
"file": "tensors/mtp.layers.0.self_attn.k_proj.weight.bin",
"sha256": "1a295dc2d6e633e808aeb19e00c97856a1817bbfcc83f5b610e2bfcacfcb8c38"
},
{
"name": "mtp.layers.0.self_attn.o_proj.weight",
"shard": "model-00106-of-00131.safetensors",
"dtype": "BF16",
"shape": [
2560,
6144
],
"start": 1832518400,
"end": 1863975679,
"bytes": 31457280,
"file": "tensors/mtp.layers.0.self_attn.o_proj.weight.bin",
"sha256": "9d2fcf0ac6ac19de87f638f710cfd1af6ad14141e75b7d3d5d29fbd06f374219"
},
{
"name": "mtp.layers.0.self_attn.q_norm.weight",
"shard": "model-00112-of-00131.safetensors",
"dtype": "BF16",
"shape": [
256
],
"start": 1935412664,
"end": 1935413175,
"bytes": 512,
"file": "tensors/mtp.layers.0.self_attn.q_norm.weight.bin",
"sha256": "57957aa1e7c5a3ac628bff0ec5522ad55a39b8c0b8bd2d324ae640e3771617ef"
},
{
"name": "mtp.layers.0.self_attn.q_proj.weight",
"shard": "model-00108-of-00131.safetensors",
"dtype": "BF16",
"shape": [
12288,
2560
],
"start": 1835140064,
"end": 1898054623,
"bytes": 62914560,
"file": "tensors/mtp.layers.0.self_attn.q_proj.weight.bin",
"sha256": "5220aef3d288f40759f7356af9ef453e5ac0256a38749a9bb803a4e9db58150d"
},
{
"name": "mtp.layers.0.self_attn.v_proj.weight",
"shard": "model-00108-of-00131.safetensors",
"dtype": "BF16",
"shape": [
512,
2560
],
"start": 1898054624,
"end": 1900676063,
"bytes": 2621440,
"file": "tensors/mtp.layers.0.self_attn.v_proj.weight.bin",
"sha256": "39cb12f5424e965fa71fb81db0ee230c701b7b1e0b72c36641fde7e0e41bff41"
},
{
"name": "mtp.pre_fc_norm_embedding.weight",
"shard": "model-00114-of-00131.safetensors",
"dtype": "BF16",
"shape": [
2560
],
"start": 1832518392,
"end": 1832523511,
"bytes": 5120,
"file": "tensors/mtp.pre_fc_norm_embedding.weight.bin",
"sha256": "04c4a570850e06f2d8913da8220d54d4c7f87db6eb6d45480b938e8ba41d6a86"
},
{
"name": "mtp.pre_fc_norm_hidden.weight",
"shard": "model-00118-of-00131.safetensors",
"dtype": "BF16",
"shape": [
10240
],
"start": 1716599944,
"end": 1716620423,
"bytes": 20480,
"file": "tensors/mtp.pre_fc_norm_hidden.weight.bin",
"sha256": "b933b44559879449b1baf2af8385c5c237347307e3fd452394870cb53e6eab6d"
}
]
@@ -0,0 +1,56 @@
[
{
"length": "32k",
"depth": 10,
"prompt_tokens": 30804,
"seconds": 6.5,
"found": true,
"word": "meadow-copper-504",
"answer": "meadow-copper-504"
},
{
"length": "32k",
"depth": 50,
"prompt_tokens": 30804,
"seconds": 5.8,
"found": true,
"word": "falcon-quartz-940",
"answer": "falcon-quartz-940"
},
{
"length": "32k",
"depth": 90,
"prompt_tokens": 30805,
"seconds": 5.8,
"found": true,
"word": "willow-cobalt-696",
"answer": "willow-cobalt-696"
},
{
"length": "128k",
"depth": 10,
"prompt_tokens": 126320,
"seconds": 22.5,
"found": true,
"word": "falcon-saffron-138",
"answer": "falcon-saffron-138"
},
{
"length": "128k",
"depth": 50,
"prompt_tokens": 126318,
"seconds": 22.8,
"found": true,
"word": "quartz-tundra-528",
"answer": "quartz-tundra-528"
},
{
"length": "128k",
"depth": 90,
"prompt_tokens": 126318,
"seconds": 20.1,
"found": true,
"word": "quartz-glacier-192",
"answer": "quartz-glacier-192"
}
]
@@ -0,0 +1,15 @@
certifi==2026.7.22
charset-normalizer==3.5.2
cmake==4.4.3
idna==3.20
Jinja2==3.1.6
MarkupSafe==3.0.3
ninja==1.13.2
numpy==2.5.3
pillow==12.3.0
psutil==7.2.2
PyYAML==6.0.3
regex==2026.9.29
requests==2.34.2
tqdm==4.70.1
urllib3==2.8.0
@@ -0,0 +1,312 @@
[
{
"label": "warmup",
"expected_prompt_tokens": null,
"request_sha256": "b63e57873441a996a529b246a66cf12de70a7c671777f99329354d5c195f788f",
"client_ttft_s": 0.15764825499991275,
"client_elapsed_s": 0.19575888999997915,
"finish_reason": "stop",
"usage": {
"prompt_tokens": 19,
"completion_tokens": 2,
"total_tokens": 21,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772698.967025,
"duration_s": 0.2,
"finish": "stop",
"prompt_tokens": 19,
"reused": 0,
"output_tokens": 2,
"engine_generated": 2,
"prompt_ms": 134.9,
"decode_ms": 57.4,
"decode_tok_s": 34.8,
"hit_rate": 0.908
},
"text": "READY"
},
{
"label": "tokens-4096-run-1",
"expected_prompt_tokens": 4096,
"request_sha256": "5d94c652067354bbe72930d2bdad3886564f08cf2546b32411af02d33ad3ce05",
"client_ttft_s": 1.1827884900003482,
"client_elapsed_s": 2.7608979090000503,
"finish_reason": "length",
"usage": {
"prompt_tokens": 4096,
"completion_tokens": 256,
"total_tokens": 4352,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772699.5014164,
"duration_s": 2.8,
"finish": "length",
"prompt_tokens": 4096,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 1166.9,
"decode_ms": 1587.0,
"decode_tok_s": 161.3,
"hit_rate": 0.978
},
"text": "# Analysis of Synthetic Python Module: Deterministic Integer Transforms\n\nThe provided Python module consists of a series of functions, `task_00000` through `task_00112`, each implementing a specific deterministic integer transformation. While the code appears repetitive, it serves as a clear example of modular arithmetic, function design, and the trade-offs between explicit implementation and algorithmic abstraction. Below is a detailed discussion covering the mathematical basis, testing implications, naming conventions, complexity, and maintainability.\n\n## 1. Mathematical Basis: Deterministic Transforms and Modulo Arithmetic\n\nAt its core, every function in this module performs a linear transformation on an input integer `value`. The general pattern for `task_NNNNN` is:\n\n$$ f(x) = (x \\cdot a + b) \\pmod{M} $$\n\nWhere:\n- $M = 100003$ is a fixed modulus.\n- $a$ is the multiplier.\n- $b$ is the additive constant.\n\nFor most functions (e.g., `task_00000` to `task_00096`), the multiplier $a$ and the additive constant $b$ follow a"
},
{
"label": "tokens-4096-run-2",
"expected_prompt_tokens": 4096,
"request_sha256": "8da8a04e70e4d916f6630729082bdfb9d6ebbb47117aad60bc0541bce198a213",
"client_ttft_s": 0.9743533680002656,
"client_elapsed_s": 2.3506501550000394,
"finish_reason": "length",
"usage": {
"prompt_tokens": 4096,
"completion_tokens": 256,
"total_tokens": 4352,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772702.5992615,
"duration_s": 2.3,
"finish": "length",
"prompt_tokens": 4096,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 959.3,
"decode_ms": 1385.0,
"decode_tok_s": 184.8,
"hit_rate": 0.993
},
"text": "# Analysis of Synthetic Python Module: Deterministic Integer Transforms\n\nThe provided Python module consists of a series of functions, `task_00000` through `task_00112`, each implementing a specific deterministic integer transformation. While the code appears repetitive, it serves as a clear example of modular arithmetic, function design, and the trade-offs between explicit implementation and algorithmic abstraction. Below is a detailed discussion of the code's structure, mathematical properties, testing implications, and maintainability.\n\n## 1. Mathematical Structure and Deterministic Transforms\n\nAt its core, every function in this module implements a linear congruential generator (LCG) step or a simple affine transformation modulo a prime number. The general form of each function is:\n\n$$ f_n(x) = (x \\cdot a_n + b_n) \\pmod{M} $$\n\nWhere:\n- $M = 100003$ is a fixed modulus.\n- $a_n$ is the multiplier for function $n$.\n- $b_n$ is the additive constant for function $n$.\n\nFor the first 97 functions (`task_00000` to `task_00096`"
},
{
"label": "tokens-4096-run-3",
"expected_prompt_tokens": 4096,
"request_sha256": "946079edb58e764050805886156dc8f877cc29e1ca8d01c84e9a1e7917d49492",
"client_ttft_s": 0.9733456560002196,
"client_elapsed_s": 2.391696067000339,
"finish_reason": "length",
"usage": {
"prompt_tokens": 4096,
"completion_tokens": 256,
"total_tokens": 4352,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772705.2866879,
"duration_s": 2.4,
"finish": "length",
"prompt_tokens": 4096,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 958.5,
"decode_ms": 1427.2,
"decode_tok_s": 179.4,
"hit_rate": 0.989
},
"text": "# Analysis of Synthetic Python Module: Deterministic Integer Transforms\n\nThe provided Python module consists of a series of functions, `task_00000` through `task_00112`, each implementing a specific deterministic integer transformation. While the code appears repetitive, it serves as a clear example of modular arithmetic, function design, and the trade-offs between explicit implementation and algorithmic abstraction. Below is a detailed discussion of the code\u2019s structure, mathematical properties, testing implications, naming conventions, complexity, and maintainability.\n\n## 1. Mathematical Structure and Deterministic Transforms\n\nEach function follows the general form:\n```python\ndef task_XXXXX(value: int) -> int:\n return (value * multiplier + addend) % MOD\n```\nwhere `MOD = 100003`.\n\nFor most functions, the multiplier and addend are derived from the function index `i`:\n- `multiplier = i + 1`\n- `addend = i`\n\nThus, for `task_00000`, `multiplier = 1`, `addend = 0`.\nFor `task_00001`, `multiplier = 2`, `"
},
{
"label": "tokens-32768-run-1",
"expected_prompt_tokens": 32768,
"request_sha256": "e37cfc2ab9867d91130927440df24a57255a736b8d0d829d07d828e22e3de572",
"client_ttft_s": 5.9679448089996185,
"client_elapsed_s": 7.498308491999978,
"finish_reason": "length",
"usage": {
"prompt_tokens": 32768,
"completion_tokens": 256,
"total_tokens": 33024,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772708.3260226,
"duration_s": 7.5,
"finish": "length",
"prompt_tokens": 32768,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 5928.6,
"decode_ms": 1541.2,
"decode_tok_s": 166.1,
"hit_rate": 0.994
},
"text": "Based on the provided Python module, here is a detailed technical review and explanation.\n\n### Overview of the Module\n\nThe provided code defines a series of functions, `task_00000` through `task_00888`, that perform deterministic integer transformations. Each function takes an integer `value` and returns a new integer based on a specific linear formula involving multiplication, addition, and modulo arithmetic. The benchmark nonce `series-32768-trial-1` suggests this code is part of a larger test suite or performance benchmark, likely designed to evaluate computational consistency, hash generation, or state machine transitions.\n\n### Mathematical Logic and Deterministic Transforms\n\nAt its core, every function in this module implements a linear congruential generator (LCG) style transformation, albeit with varying parameters. The general structure of each function is:\n\n$$ f(x) = (x \\cdot a + b) \\pmod{100003} $$\n\nWhere:\n* $x$ is the input `value`.\n* $a$ is the multiplier (coefficient).\n* $b$ is the additive constant.\n* $100003$ is the modulus."
},
{
"label": "tokens-32768-run-2",
"expected_prompt_tokens": 32768,
"request_sha256": "ed2dfaa11aecad9f4563f33bb5f5d4b8704486508700b8fa572722cc1225ee26",
"client_ttft_s": 5.950024114999906,
"client_elapsed_s": 7.348446455000158,
"finish_reason": "length",
"usage": {
"prompt_tokens": 32768,
"completion_tokens": 256,
"total_tokens": 33024,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772716.4558623,
"duration_s": 7.3,
"finish": "length",
"prompt_tokens": 32768,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 5911.4,
"decode_ms": 1408.3,
"decode_tok_s": 181.8,
"hit_rate": 0.994
},
"text": "Based on the provided synthetic Python module, here is a detailed technical review and explanation.\n\n### 1. Structural Analysis and Pattern Recognition\n\nThe module consists of a series of functions named `task_00000` through `task_00888` (the list appears truncated at `task_00888`, but the pattern implies a larger set). Each function follows a strict, deterministic signature: `def task_XXXXX(value: int) -> int`.\n\nThe core logic within each function is a linear transformation followed by a modulo operation:\n$$ f(x) = (x \\cdot a + b) \\pmod{100003} $$\n\nWhere:\n* $x$ is the input `value`.\n* $a$ is the multiplier.\n* $b$ is the additive constant.\n* $100003$ is the modulus.\n\n#### The Multiplier Pattern ($a$)\nThe multiplier $a$ follows a cyclic pattern. It starts at 1 and increments by 1 for each function until it reaches 97. After `task_00096` (where $a=97$), the"
},
{
"label": "tokens-32768-run-3",
"expected_prompt_tokens": 32768,
"request_sha256": "2a3c7342622e80c3cd8b37e062f0a2f64640c119ece8cccbf168639041eac079",
"client_ttft_s": 5.941602006999801,
"client_elapsed_s": 7.389697677000186,
"finish_reason": "length",
"usage": {
"prompt_tokens": 32768,
"completion_tokens": 256,
"total_tokens": 33024,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772724.435358,
"duration_s": 7.4,
"finish": "length",
"prompt_tokens": 32768,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 5904.6,
"decode_ms": 1457.1,
"decode_tok_s": 175.7,
"hit_rate": 0.995
},
"text": "Based on the provided Python module, here is a detailed technical review and explanation.\n\n### 1. Structural Overview and Pattern Analysis\n\nThe provided code consists of a series of function definitions, ranging from `task_00000` to `task_00888`. Each function follows a strict, repetitive structure:\n\n```python\ndef task_XXXXX(value: int) -> int:\n return (value * A + B) % 100003\n```\n\nThis module is a synthetic representation of a **linear congruential generator (LCG)** or a set of **affine transformations** applied to an integer input. The core logic is consistent across all functions, with only the coefficients `A` (multiplier) and `B` (addend) changing.\n\n### 2. Deterministic Integer Transforms and Modulo Arithmetic\n\nThe mathematical core of this module is the expression `(value * A + B) % 100003`. This is a classic example of a **deterministic integer transform**.\n\n* **Determinism:** For any given input `value`, the output is always the same. There is no randomness, state, or side effects. This makes"
},
{
"label": "tokens-128000-run-1",
"expected_prompt_tokens": 128000,
"request_sha256": "3235aac3f934cf1d889c25973ca172b355509dc2522fdfb463fbefe979a9075d",
"client_ttft_s": 22.212050286999784,
"client_elapsed_s": 23.856042405000153,
"finish_reason": "length",
"usage": {
"prompt_tokens": 128000,
"completion_tokens": 256,
"total_tokens": 128256,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772733.6124191,
"duration_s": 23.8,
"finish": "length",
"prompt_tokens": 128000,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 22099.7,
"decode_ms": 1653.5,
"decode_tok_s": 154.8,
"hit_rate": 0.994
},
"text": "Based on the provided synthetic Python module, here is a detailed technical review and explanation.\n\n### Overview of the Module\n\nThe provided code consists of a massive collection of function definitions, ranging from `task_00000` to `task_03404` (and potentially beyond, as the input cuts off). Each function follows a strict, repetitive pattern. The core logic of every function is identical in structure, differing only in the specific integer constants used for multiplication and addition.\n\nThe general form of any function `task_N` is:\n```python\ndef task_N(value: int) -> int:\n return (value * multiplier + addend) % 100003\n```\n\n### 1. Deterministic Integer Transforms and Modulo Arithmetic\n\nThe primary mechanism in this module is a **deterministic linear transform** followed by a **modulo operation**.\n\n**The Linear Transform:**\nFor any given `value`, the function computes `value * multiplier + addend`. This is an affine transformation. In mathematics, an affine transformation is a function that preserves points, straight lines, and planes. Here, it maps an input integer to an output integer based on a fixed slope (`multiplier`) and"
},
{
"label": "tokens-128000-run-2",
"expected_prompt_tokens": 128000,
"request_sha256": "5f4b8bc9f0afc7765320abd89960c0938e0d7cf5974e962fdbd0613fef31c8d4",
"client_ttft_s": 22.262365384000077,
"client_elapsed_s": 23.764614322999932,
"finish_reason": "length",
"usage": {
"prompt_tokens": 128000,
"completion_tokens": 256,
"total_tokens": 128256,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772759.195895,
"duration_s": 23.7,
"finish": "length",
"prompt_tokens": 128000,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 22150.5,
"decode_ms": 1511.7,
"decode_tok_s": 169.3,
"hit_rate": 0.997
},
"text": "# Analysis of the Synthetic Python Module\n\nThe provided Python module consists of a massive collection of functions, ranging from `task_00000` to `task_03404` (and potentially beyond, as the code is truncated). Each function follows a strict, repetitive pattern: it accepts an integer `value`, applies a linear transformation, and returns the result modulo a fixed prime number, `100003`.\n\n## 1. Mathematical Structure and Deterministic Transforms\n\nAt its core, every function in this module implements a **linear congruential generator (LCG)** step or a simple affine transformation. The general formula for any function `task_N` is:\n\n$$ f_N(x) = (x \\cdot a_N + b_N) \\pmod{M} $$\n\nWhere:\n* $M = 100003$ is the modulus.\n* $a_N$ is the multiplier for task $N$.\n* $b_N$ is the additive constant for task $N$.\n\n### The Modulus: 100003\nThe choice of `100003` is significant. It is a **prime number**. In"
},
{
"label": "tokens-128000-run-3",
"expected_prompt_tokens": 128000,
"request_sha256": "5c3fb71db9f9f44765f28389d1032f2c8b6687d1bf5ca6f33aeb924072cfa6e4",
"client_ttft_s": 22.308453708999878,
"client_elapsed_s": 23.850161715000013,
"finish_reason": "length",
"usage": {
"prompt_tokens": 128000,
"completion_tokens": 256,
"total_tokens": 128256,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"engine": {
"projection": null,
"time": 1790772784.6969988,
"duration_s": 23.8,
"finish": "length",
"prompt_tokens": 128000,
"reused": 0,
"output_tokens": 256,
"engine_generated": 256,
"prompt_ms": 22195.2,
"decode_ms": 1551.4,
"decode_tok_s": 165.0,
"hit_rate": 0.997
},
"text": "Based on the provided synthetic Python module, here is a detailed technical review and explanation.\n\n### Overview of the Module\n\nThe provided code consists of a massive collection of function definitions, ranging from `task_00000` to `task_03404`. Each function accepts a single integer argument `value` and returns an integer. The core logic within every function is identical in structure, differing only in the specific coefficients used for multiplication and addition.\n\nThe general pattern for any function `task_N` is:\n```python\ndef task_N(value: int) -> int:\n return (value * multiplier + addend) % 100003\n```\n\n### Deterministic Integer Transforms and Modulo Arithmetic\n\nThe functions implement a **deterministic linear transform** over the integers. In mathematics, this is an affine transformation defined by $f(x) = ax + b$. However, the code applies this transformation within a finite field defined by the modulus $M = 100003$.\n\n1. **Modulo Arithmetic**: The use of `% 100003` ensures that the output is always within the range $[0, 100002"
}
]
@@ -0,0 +1,50 @@
{
"exe": "/workspace/Strata/engine/strata",
"args": [
"--pack",
"/workspace/Strata-data/packs/iq2_xs",
"--native",
"/workspace/Strata-data/models/IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00001-of-00002.gguf",
"--ple-gguf",
"/workspace/Strata-data/models/IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00002-of-00002.gguf",
"--expert-profile",
"/workspace/Strata/data/expert-profile.bin",
"--expert-cache",
"auto",
"--prefill",
"auto",
"--spec",
"4",
"--spec-min-p",
"0.5",
"--mtp",
"/workspace/Strata-data/mtp/rt",
"--max-context",
"131072",
"--kv",
"int8",
"--kv-resident",
"32768",
"--vision",
"--vram-reserve-mib",
"700"
],
"cwd": "/workspace/Strata",
"tokenizer": "/workspace/Strata-data/packs/iq2_xs/tokenizer",
"model_name": "qwen3.8-flash-next-iq2_xs",
"log": "/workspace/Strata/strata-iq2_xs.log",
"lib_dirs": [
"/usr/local/cuda/bin",
"/usr/local/cuda/lib64"
],
"port": 18080,
"gpu": 0,
"gpus_asked": true,
"vision": {
"exe": "/workspace/Strata/engine/strata-vision",
"mmproj": "/workspace/Strata-data/models/mmproj-Qwen3.8-Flash-Next-BF16.gguf",
"model": "/workspace/Strata-data/models/IQ2_XS/Qwen3.8-Flash-Next-GSQ-RCO-IQ2_XS-00001-of-00002.gguf",
"gpu": true,
"max_tokens": 1024
}
}
@@ -0,0 +1,113 @@
{
"4096": {
"prompt_tokens": {
"median": 4096,
"min": 4096,
"max": 4096
},
"cached_tokens": {
"median": 0,
"min": 0,
"max": 0
},
"output_tokens": {
"median": 256,
"min": 256,
"max": 256
},
"client_ttft_s": {
"median": 0.9743533680002656,
"min": 0.9733456560002196,
"max": 1.1827884900003482
},
"client_elapsed_s": {
"median": 2.391696067000339,
"min": 2.3506501550000394,
"max": 2.7608979090000503
},
"prefill_tok_s": {
"median": 4269.780047951632,
"min": 3510.1551118347757,
"max": 4273.343766301513
},
"decode_tok_s": {
"median": 179.37219730941703,
"min": 161.31064902331443,
"max": 184.8375451263538
}
},
"32768": {
"prompt_tokens": {
"median": 32768,
"min": 32768,
"max": 32768
},
"cached_tokens": {
"median": 0,
"min": 0,
"max": 0
},
"output_tokens": {
"median": 256,
"min": 256,
"max": 256
},
"client_ttft_s": {
"median": 5.950024114999906,
"min": 5.941602006999801,
"max": 5.9679448089996185
},
"client_elapsed_s": {
"median": 7.389697677000186,
"min": 7.348446455000158,
"max": 7.498308491999978
},
"prefill_tok_s": {
"median": 5543.187738945089,
"min": 5527.105893465573,
"max": 5549.571520509433
},
"decode_tok_s": {
"median": 175.69144190515408,
"min": 166.10433428497274,
"max": 181.77945040119295
}
},
"128000": {
"prompt_tokens": {
"median": 128000,
"min": 128000,
"max": 128000
},
"cached_tokens": {
"median": 0,
"min": 0,
"max": 0
},
"output_tokens": {
"median": 256,
"min": 256,
"max": 256
},
"client_ttft_s": {
"median": 22.262365384000077,
"min": 22.212050286999784,
"max": 22.308453708999878
},
"client_elapsed_s": {
"median": 23.850161715000013,
"min": 23.764614322999932,
"max": 23.856042405000153
},
"prefill_tok_s": {
"median": 5778.6505947947,
"min": 5767.012687427912,
"max": 5791.933827156025
},
"decode_tok_s": {
"median": 165.01224700270723,
"min": 154.82310250982763,
"max": 169.34576966329297
}
}
}
@@ -0,0 +1,250 @@
{"epoch_s": 1790772668.438457, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 58332840, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "2, 32607, 1, 60.13, 36"}
{"epoch_s": 1790772669.461572, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 57749256, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "1374, 32607, 25, 53.81, 36"}
{"epoch_s": 1790772670.483304, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 56952232, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "3719, 32607, 2, 130.61, 36"}
{"epoch_s": 1790772671.5050805, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 56947812, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "3719, 32607, 3, 86.30, 36"}
{"epoch_s": 1790772672.5268102, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 56930224, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "4949, 32607, 3, 62.43, 36"}
{"epoch_s": 1790772673.5491986, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 54141020, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6875, 32607, 2, 59.82, 36"}
{"epoch_s": 1790772674.584606, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 46827008, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6875, 32607, 0, 58.26, 36"}
{"epoch_s": 1790772675.6100278, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 39487436, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6875, 32607, 0, 57.70, 36"}
{"epoch_s": 1790772676.6331685, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 32761416, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6875, 32607, 0, 57.36, 36"}
{"epoch_s": 1790772677.6556065, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 24833136, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6875, 32607, 0, 57.03, 36"}
{"epoch_s": 1790772679.1176229, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 20348260, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6893, 32607, 0, 57.33, 36"}
{"epoch_s": 1790772680.1513186, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19836220, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 58.46, 36"}
{"epoch_s": 1790772681.18351, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19863628, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 57.35, 36"}
{"epoch_s": 1790772682.2173855, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19918256, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 56.50, 36"}
{"epoch_s": 1790772683.2403264, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19836728, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 57.14, 36"}
{"epoch_s": 1790772684.263194, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19812576, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 57.01, 36"}
{"epoch_s": 1790772685.2866416, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19832496, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8388348}, "gpu": "6941, 32607, 0, 56.75, 36"}
{"epoch_s": 1790772686.3135202, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19950804, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8387324}, "gpu": "6941, 32607, 0, 56.74, 36"}
{"epoch_s": 1790772687.3367112, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19874724, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8386812}, "gpu": "6941, 32607, 0, 56.90, 36"}
{"epoch_s": 1790772688.3587284, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19842500, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8386556}, "gpu": "6941, 32607, 0, 57.05, 36"}
{"epoch_s": 1790772689.3818972, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19944936, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8384252}, "gpu": "6941, 32607, 0, 57.04, 36"}
{"epoch_s": 1790772690.406354, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19871504, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8379900}, "gpu": "6941, 32607, 0, 56.74, 36"}
{"epoch_s": 1790772691.4390683, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19883588, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8376316}, "gpu": "6941, 32607, 0, 31.70, 35"}
{"epoch_s": 1790772692.470097, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19895676, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8372220}, "gpu": "6941, 32607, 0, 20.18, 35"}
{"epoch_s": 1790772693.5028179, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 20038008, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8203772}, "gpu": "6941, 32607, 0, 11.67, 35"}
{"epoch_s": 1790772694.5281374, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 20156748, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8075004}, "gpu": "31267, 32607, 33, 28.99, 35"}
{"epoch_s": 1790772695.5503595, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 19302012, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8075004}, "gpu": "31351, 32607, 1, 96.33, 36"}
{"epoch_s": 1790772696.5729709, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18691716, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8075004}, "gpu": "31699, 32607, 1, 88.24, 36"}
{"epoch_s": 1790772697.5949724, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18600496, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8075004}, "gpu": "31699, 32607, 0, 83.40, 36"}
{"epoch_s": 1790772698.6135545, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18594848, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8075004}, "gpu": "31699, 32607, 0, 56.88, 36"}
{"epoch_s": 1790772699.6351354, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18384636, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31729, 32607, 38, 71.98, 36"}
{"epoch_s": 1790772700.6604307, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18135500, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31769, 32607, 99, 227.76, 45"}
{"epoch_s": 1790772701.682456, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18126208, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 95, 359.78, 43"}
{"epoch_s": 1790772702.706684, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18118008, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 2, 244.34, 38"}
{"epoch_s": 1790772703.7335, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18095652, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 98, 409.97, 43"}
{"epoch_s": 1790772704.7526512, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18096236, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 97, 346.22, 45"}
{"epoch_s": 1790772705.7763088, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18088644, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 99, 290.87, 48"}
{"epoch_s": 1790772706.799191, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18089132, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 100, 370.80, 45"}
{"epoch_s": 1790772707.8183546, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18072284, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 97, 348.14, 45"}
{"epoch_s": 1790772708.8408382, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18071772, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31783, 32607, 99, 204.77, 49"}
{"epoch_s": 1790772709.8652713, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18084484, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31785, 32607, 99, 502.69, 49"}
{"epoch_s": 1790772710.8869991, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18091232, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31785, 32607, 99, 477.46, 52"}
{"epoch_s": 1790772711.9077418, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18051376, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31785, 32607, 100, 453.75, 50"}
{"epoch_s": 1790772712.945486, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18059000, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31785, 32607, 98, 483.63, 48"}
{"epoch_s": 1790772713.9662626, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18068208, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 8013308}, "gpu": "31785, 32607, 99, 482.43, 53"}
{"epoch_s": 1790772714.9933336, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17987384, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 93, 346.04, 47"}
{"epoch_s": 1790772716.0165942, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17960560, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 96, 347.16, 48"}
{"epoch_s": 1790772717.039366, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18132960, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 211.30, 51"}
{"epoch_s": 1790772718.0643644, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18138544, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 508.40, 53"}
{"epoch_s": 1790772719.0876768, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18147832, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 475.77, 55"}
{"epoch_s": 1790772720.1091926, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18103444, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 457.60, 53"}
{"epoch_s": 1790772721.1299815, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18100992, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 507.29, 54"}
{"epoch_s": 1790772722.1500635, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18112212, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 476.48, 52"}
{"epoch_s": 1790772723.1765406, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18011920, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 97, 382.48, 50"}
{"epoch_s": 1790772724.1962311, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18017628, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 0, 274.45, 45"}
{"epoch_s": 1790772725.21881, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18114148, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 365.93, 54"}
{"epoch_s": 1790772726.2438593, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18128360, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 479.71, 54"}
{"epoch_s": 1790772727.2632627, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18143844, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 510.50, 56"}
{"epoch_s": 1790772728.2869742, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18150700, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 459.35, 56"}
{"epoch_s": 1790772729.3204784, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18162336, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 480.67, 58"}
{"epoch_s": 1790772730.3480747, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18062716, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 98, 494.31, 53"}
{"epoch_s": 1790772731.3745997, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18056756, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 94, 311.79, 52"}
{"epoch_s": 1790772732.3941443, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18080332, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 0, 272.26, 47"}
{"epoch_s": 1790772733.4142647, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18087264, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 0, 134.10, 46"}
{"epoch_s": 1790772734.4370096, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18208276, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 222.96, 54"}
{"epoch_s": 1790772735.4588313, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18211508, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 513.78, 58"}
{"epoch_s": 1790772736.4805841, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18202380, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 513.06, 58"}
{"epoch_s": 1790772737.503986, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18205432, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 494.72, 57"}
{"epoch_s": 1790772738.5267396, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18196648, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 514.25, 59"}
{"epoch_s": 1790772739.5491192, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18054812, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 496.71, 60"}
{"epoch_s": 1790772740.5723188, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18048512, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 515.80, 58"}
{"epoch_s": 1790772741.5950322, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17928312, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 513.71, 58"}
{"epoch_s": 1790772742.6171873, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17944052, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 496.11, 60"}
{"epoch_s": 1790772743.639043, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17940264, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 513.91, 60"}
{"epoch_s": 1790772744.6600034, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17833128, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 52, 496.12, 54"}
{"epoch_s": 1790772745.6818032, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17835068, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 497.48, 61"}
{"epoch_s": 1790772746.7033856, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17830900, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 516.30, 62"}
{"epoch_s": 1790772747.7276258, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17715960, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 496.96, 61"}
{"epoch_s": 1790772748.7482834, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17719684, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 513.01, 60"}
{"epoch_s": 1790772749.7694225, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17610640, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 507.09, 59"}
{"epoch_s": 1790772750.7923675, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17603368, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 485.92, 60"}
{"epoch_s": 1790772751.812411, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17595640, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 479.74, 64"}
{"epoch_s": 1790772752.8319893, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17586396, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 515.18, 63"}
{"epoch_s": 1790772753.8533502, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17622816, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 458.79, 63"}
{"epoch_s": 1790772754.8752813, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17623492, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 479.38, 61"}
{"epoch_s": 1790772755.9013746, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17629392, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 49, 450.65, 56"}
{"epoch_s": 1790772756.922106, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17626016, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 308.26, 58"}
{"epoch_s": 1790772757.9418297, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17607068, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 0, 295.22, 53"}
{"epoch_s": 1790772758.9605587, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17603144, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 0, 130.95, 52"}
{"epoch_s": 1790772759.9839687, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18282120, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 210.90, 61"}
{"epoch_s": 1790772761.006678, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18282984, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 515.74, 62"}
{"epoch_s": 1790772762.0434818, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18162840, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 520.51, 62"}
{"epoch_s": 1790772763.067759, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18150136, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 501.61, 62"}
{"epoch_s": 1790772764.089317, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18166848, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 520.68, 64"}
{"epoch_s": 1790772765.1115272, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18031696, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 500.77, 64"}
{"epoch_s": 1790772766.1324067, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18034652, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 521.99, 64"}
{"epoch_s": 1790772767.1545649, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17937296, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 521.65, 66"}
{"epoch_s": 1790772768.176144, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17929464, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 501.06, 64"}
{"epoch_s": 1790772769.198718, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17920788, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 520.32, 65"}
{"epoch_s": 1790772770.236203, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17799416, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 497.43, 64"}
{"epoch_s": 1790772771.257868, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17792564, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 523.67, 66"}
{"epoch_s": 1790772772.2799609, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17801924, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 520.28, 67"}
{"epoch_s": 1790772773.3021274, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17687256, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 498.60, 66"}
{"epoch_s": 1790772774.335996, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17678064, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 521.94, 66"}
{"epoch_s": 1790772775.35813, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17557356, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 521.58, 67"}
{"epoch_s": 1790772776.3823485, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17565428, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 489.46, 66"}
{"epoch_s": 1790772777.405725, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17569088, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 100, 487.07, 68"}
{"epoch_s": 1790772778.4254801, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17570184, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7990524}, "gpu": "31785, 32607, 99, 520.51, 66"}
{"epoch_s": 1790772779.4490557, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17625120, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 470.02, 67"}
{"epoch_s": 1790772780.473841, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17616188, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 487.32, 64"}
{"epoch_s": 1790772781.499789, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17505864, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 488.28, 67"}
{"epoch_s": 1790772782.523191, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17517408, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 98, 328.98, 62"}
{"epoch_s": 1790772783.5435653, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17539636, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 303.74, 57"}
{"epoch_s": 1790772784.565325, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17527416, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 136.73, 56"}
{"epoch_s": 1790772785.5888178, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18242896, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 217.75, 64"}
{"epoch_s": 1790772786.612396, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18244028, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 524.56, 66"}
{"epoch_s": 1790772787.6342883, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18194804, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 526.80, 66"}
{"epoch_s": 1790772788.6568644, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18203332, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 507.39, 67"}
{"epoch_s": 1790772789.6793633, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18191904, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 521.05, 67"}
{"epoch_s": 1790772790.7027128, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18079592, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 503.11, 67"}
{"epoch_s": 1790772791.7242851, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18083776, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 527.45, 67"}
{"epoch_s": 1790772792.7456532, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17980956, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 98, 505.96, 67"}
{"epoch_s": 1790772793.768554, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17984860, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 521.32, 68"}
{"epoch_s": 1790772794.7907064, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17972956, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 527.85, 66"}
{"epoch_s": 1790772795.8138406, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17850288, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 505.34, 68"}
{"epoch_s": 1790772796.8353448, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17848116, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 527.36, 69"}
{"epoch_s": 1790772797.8563817, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17846184, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 526.18, 69"}
{"epoch_s": 1790772798.8780813, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17723912, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 503.19, 68"}
{"epoch_s": 1790772799.899205, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17715168, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 523.83, 69"}
{"epoch_s": 1790772800.9237013, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17593528, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 526.99, 70"}
{"epoch_s": 1790772801.9461932, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17589112, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 492.53, 69"}
{"epoch_s": 1790772802.9673676, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17602032, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 497.32, 69"}
{"epoch_s": 1790772803.9868026, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17581748, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 524.68, 70"}
{"epoch_s": 1790772805.006854, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17479100, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 467.85, 71"}
{"epoch_s": 1790772806.027366, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17469612, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 98, 494.48, 66"}
{"epoch_s": 1790772807.054402, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17465264, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 508.83, 66"}
{"epoch_s": 1790772808.0764651, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17451560, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 98, 341.96, 65"}
{"epoch_s": 1790772809.0972805, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18242708, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 326.58, 60"}
{"epoch_s": 1790772810.1193252, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18224312, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 231.55, 67"}
{"epoch_s": 1790772811.1443434, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18251360, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 98, 513.76, 65"}
{"epoch_s": 1790772812.1641836, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18257168, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 507.31, 68"}
{"epoch_s": 1790772813.188216, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18264160, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 475.36, 68"}
{"epoch_s": 1790772814.2106729, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18280248, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 491.24, 70"}
{"epoch_s": 1790772815.2351635, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18226696, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 43, 408.46, 65"}
{"epoch_s": 1790772816.2571764, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18232216, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 516.37, 70"}
{"epoch_s": 1790772817.2793994, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18237844, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 492.67, 71"}
{"epoch_s": 1790772818.3027427, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18258420, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 85, 480.93, 69"}
{"epoch_s": 1790772819.3249714, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18262736, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 520.06, 70"}
{"epoch_s": 1790772820.3447847, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18263392, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 495.94, 70"}
{"epoch_s": 1790772821.3689287, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18252008, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 387.84, 70"}
{"epoch_s": 1790772822.391625, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18251760, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 530.36, 70"}
{"epoch_s": 1790772823.4142845, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18246696, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 499.02, 69"}
{"epoch_s": 1790772824.4363837, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18255784, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 474.00, 72"}
{"epoch_s": 1790772825.4570014, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18249508, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 534.05, 68"}
{"epoch_s": 1790772826.4777033, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18265224, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 488.60, 68"}
{"epoch_s": 1790772827.5001867, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18241316, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 338.84, 69"}
{"epoch_s": 1790772828.5244417, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18234208, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 529.48, 69"}
{"epoch_s": 1790772829.5457335, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18255808, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 532.12, 72"}
{"epoch_s": 1790772830.5685184, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18259268, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 507.47, 71"}
{"epoch_s": 1790772831.5907855, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18256224, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 532.53, 71"}
{"epoch_s": 1790772832.613174, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18178900, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.43, 64"}
{"epoch_s": 1790772833.6395922, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18163872, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 510.42, 72"}
{"epoch_s": 1790772834.660667, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18164500, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 529.48, 72"}
{"epoch_s": 1790772835.682373, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18067600, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 514.49, 71"}
{"epoch_s": 1790772836.7051973, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18067096, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 530.68, 71"}
{"epoch_s": 1790772837.7258525, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17941220, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 52, 511.56, 71"}
{"epoch_s": 1790772838.747495, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17946888, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 532.64, 72"}
{"epoch_s": 1790772839.7696228, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17948264, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 529.32, 72"}
{"epoch_s": 1790772840.7897382, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17841772, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 513.67, 71"}
{"epoch_s": 1790772841.811278, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17838756, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 528.76, 72"}
{"epoch_s": 1790772842.8329659, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17838812, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.90, 71"}
{"epoch_s": 1790772843.8551986, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17717288, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 490.94, 72"}
{"epoch_s": 1790772844.8746738, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17722396, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 528.11, 71"}
{"epoch_s": 1790772845.8973172, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17723676, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 493.89, 72"}
{"epoch_s": 1790772846.91816, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17609420, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 85, 479.12, 71"}
{"epoch_s": 1790772847.939702, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17606604, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 528.62, 70"}
{"epoch_s": 1790772848.9587715, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17605816, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 482.68, 71"}
{"epoch_s": 1790772849.9811416, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18225312, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 2, 287.55, 62"}
{"epoch_s": 1790772851.0086215, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18219312, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 495.29, 70"}
{"epoch_s": 1790772852.0307431, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18212012, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 532.53, 73"}
{"epoch_s": 1790772853.0534828, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18241908, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 513.63, 71"}
{"epoch_s": 1790772854.0752146, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18240392, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 534.22, 71"}
{"epoch_s": 1790772855.0970914, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18192424, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 531.69, 73"}
{"epoch_s": 1790772856.119393, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18176072, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 511.80, 72"}
{"epoch_s": 1790772857.1404707, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18174816, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 531.85, 73"}
{"epoch_s": 1790772858.1629918, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18066588, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 52, 512.33, 71"}
{"epoch_s": 1790772859.1853132, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18066664, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 512.57, 72"}
{"epoch_s": 1790772860.206362, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18066844, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 532.25, 71"}
{"epoch_s": 1790772861.2286925, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17941852, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 511.81, 74"}
{"epoch_s": 1790772862.2505696, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17961916, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 530.91, 72"}
{"epoch_s": 1790772863.2736192, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17842052, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 52, 515.36, 72"}
{"epoch_s": 1790772864.2948847, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17837396, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 530.06, 72"}
{"epoch_s": 1790772865.315923, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17838760, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.20, 71"}
{"epoch_s": 1790772866.3383734, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17722852, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 77, 489.91, 74"}
{"epoch_s": 1790772867.3589919, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17723784, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.00, 72"}
{"epoch_s": 1790772868.3802085, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17724116, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 492.00, 72"}
{"epoch_s": 1790772869.4032836, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17610436, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 519.67, 68"}
{"epoch_s": 1790772870.4251704, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17593928, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 482.79, 71"}
{"epoch_s": 1790772871.446933, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17625500, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 490.11, 71"}
{"epoch_s": 1790772872.4693067, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18115856, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 42, 376.82, 63"}
{"epoch_s": 1790772873.4927008, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18130848, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 413.33, 71"}
{"epoch_s": 1790772874.517678, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18129660, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.46, 71"}
{"epoch_s": 1790772875.539969, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18122464, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 96, 513.83, 71"}
{"epoch_s": 1790772876.5611775, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18124472, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 525.10, 73"}
{"epoch_s": 1790772877.5850198, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18126548, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 533.66, 72"}
{"epoch_s": 1790772878.6076293, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18073280, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 511.73, 72"}
{"epoch_s": 1790772879.629884, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 18098184, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 535.61, 74"}
{"epoch_s": 1790772880.6510599, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17972812, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 531.98, 73"}
{"epoch_s": 1790772881.675439, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17976576, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 507.68, 72"}
{"epoch_s": 1790772882.699754, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17973148, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 533.44, 72"}
{"epoch_s": 1790772883.722258, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17861120, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 508.82, 72"}
{"epoch_s": 1790772884.745278, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17864404, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 531.88, 72"}
{"epoch_s": 1790772885.769315, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17866576, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 530.83, 74"}
{"epoch_s": 1790772886.7924066, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17752540, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 488.78, 72"}
{"epoch_s": 1790772887.817747, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17751168, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 99, 527.99, 69"}
{"epoch_s": 1790772888.8397095, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17735964, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 496.67, 72"}
{"epoch_s": 1790772889.8620257, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17625844, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 470.64, 71"}
{"epoch_s": 1790772890.884023, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17629264, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 528.82, 72"}
{"epoch_s": 1790772891.9039407, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17631268, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 100, 475.71, 71"}
{"epoch_s": 1790772892.925761, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17658484, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 242.06, 62"}
{"epoch_s": 1790772893.947652, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17660788, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 124.52, 62"}
{"epoch_s": 1790772894.9685812, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17662644, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 94.57, 60"}
{"epoch_s": 1790772895.9877603, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17666884, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 70.56, 59"}
{"epoch_s": 1790772897.009143, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17675152, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 69.94, 59"}
{"epoch_s": 1790772898.0305054, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17677208, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 69.68, 58"}
{"epoch_s": 1790772899.0518734, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17686920, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 69.10, 58"}
{"epoch_s": 1790772900.0737712, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17694368, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 68.64, 57"}
{"epoch_s": 1790772901.0949237, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17701040, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 68.54, 57"}
{"epoch_s": 1790772902.1162262, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17704052, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 68.07, 56"}
{"epoch_s": 1790772903.1371994, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17716036, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 67.54, 56"}
{"epoch_s": 1790772904.1573613, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17729424, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 66.79, 56"}
{"epoch_s": 1790772905.178784, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17734376, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 66.78, 55"}
{"epoch_s": 1790772906.2002432, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17741828, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 66.73, 55"}
{"epoch_s": 1790772907.2226708, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17744104, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 66.62, 54"}
{"epoch_s": 1790772908.2435381, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17741708, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 65.50, 54"}
{"epoch_s": 1790772909.2710078, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17724256, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 40.74, 53"}
{"epoch_s": 1790772910.2964864, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17746392, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 31.75, 53"}
{"epoch_s": 1790772911.3218958, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17745548, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 19.67, 53"}
{"epoch_s": 1790772912.3480182, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17746012, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.41, 52"}
{"epoch_s": 1790772913.3754818, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17733056, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.42, 52"}
{"epoch_s": 1790772914.402011, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17739736, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.55, 52"}
{"epoch_s": 1790772915.4289236, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17733576, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.24, 51"}
{"epoch_s": 1790772916.4575953, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17753656, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.35, 51"}
{"epoch_s": 1790772917.4829435, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17752892, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.47, 51"}
{"epoch_s": 1790772918.5089724, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17753536, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 12.31, 51"}
{"epoch_s": 1790772919.5349586, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17755604, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 12.49, 51"}
{"epoch_s": 1790772920.5655951, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17766328, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.14, 50"}
{"epoch_s": 1790772921.5931342, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 17743004, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "31785, 32607, 0, 14.21, 50"}
{"epoch_s": 1790772922.637384, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 20934704, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "30128, 32607, 4, 16.71, 50"}
{"epoch_s": 1790772924.2924495, "memory": {"MemTotal_KiB": 65208820, "MemAvailable_KiB": 37200652, "SwapTotal_KiB": 8388604, "SwapFree_KiB": 7952892}, "gpu": "2, 32607, 0, 60.26, 50"}
@@ -0,0 +1,57 @@
# BF16 GEMV on Turing tensor cores (sm_75): measured negative
i7-8700K + RTX 2070 8 GB (sm_75, 36 SMs), engine 0.1.27 tree (`bf16_gemv.cu` is unchanged through 0.1.30),
qwen3.8-flash-next (~125.7B MoE, GGUF-verified) Q2_0 in production. Isolated benchmark only -
[`bench_tc_gemv.cu`](bench_tc_gemv.cu) touches nothing in the inference path. Question: the QSA prompt attention
already rides the Turing tensor cores (`mma.sync.m16n8k8`, the #270 path); can the decode GEMVs do the same?
## Setup
- Baseline: the production `bf16_gemv` warp kernel, transcribed verbatim
- TC variant: `mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32` on BF16->FP16 (the sm_75 MMA has native f16 only).
BF16->FP16 conversion is exact (0 / 2,000,000 values inexact - bf16's 7-bit mantissa fits in fp16's 10 bits); the
A-fragment packing is the same one #270 validated (`a0` = row `gid`, k columns `2t..2t+1`; broadcast makes
`a0 == a1 == {x[2t], x[2t+1]}`)
- Three TC variants to cover the conversion overhead from every angle: W preconverted to fp16 once at load
(`pc`), W converted in-register every call (`in`), and a fused ks=1 form that writes the output directly and skips
the reduce kernel (`fused`)
- The k-split across blocks (`ks`) is swept over all values that divide n_in, and the best is reported - the TC
kernel gets its best occupancy
- Parity against an fp64 host reference; 2000 iterations x 3 reps, warmed CUDA events
## Results (best TC config per shape)
| Shape (decode, n_in = 2560, BF16 W) | Baseline us | Best TC us | Speedup | Config |
| --- | ---: | ---: | ---: | --- |
| ssm_alpha/beta [2560, 48] | 8.73 | 11.32 | 0.77x | pc, ks=16 |
| indexer.k_proj [2560, 128] | 7.14 | 12.09 | 0.59x | pc, ks=16 |
| indexer.q_proj / router [2560, 512] | 9.48 | 15.78 | 0.60x | pc, ks=4 |
| ple_value [2560, 2560] | 35.08 | 77.73 | 0.45x | pc, ks=40 |
- Numerics pass: TC max error vs fp64 reference 1.7e-6 .. 7.2e-6 (fp16-accumulation level), baseline
0.7e-6 .. 2.3e-6. The TC variant computes the same thing, it is just slower.
- The warp kernel is already bandwidth-bound at 276-374 GB/s effective W bandwidth (374 GB/s on the 13 MB
[2560, 2560] shape); the TC path reaches only 166-169 GB/s (4-byte lane loads, conversion instructions, in-tile
launch overhead).
- A single-token GEMV broadcasts one token across the whole m16 MMA tile, so 15/16 of the MMA throughput is thrown
away - but the baseline is not compute-bound, so the wasted throughput buys nothing. The k-split sweep and the
fused variant do not recover it.
- One-time W conversion cost is negligible (2 ms for 13 MB), so preconverting W for the TC path does not help.
## How to rerun
```
nvcc -arch=sm_75 -O3 -o bench_tc_gemv.exe bench_tc_gemv.cu
./bench_tc_gemv.exe
```
Prints the table above, per-shape latency/parity and the conversion exactness scan. On a newer card, adjust
`-arch`; the packed-A layout comment in the source documents the fragment mapping it relies on.
## Conclusion
**Keep the warp kernel. Tensor cores are not a promising direction for the decode GEMVs on sm_75**, and this was a
measured loss (1.3-2.2x slower), not a failed attempt to optimize. The Turing MMA stays worthwhile where the input
really has m16 rows of work: the QSA prompt-attention tiles, which is where #270 uses it. Someone looking to
re-evaluate on future hardware (a card with native bf16 or denser GEMV batching) can rerun this instead of
rebuilding it.
@@ -0,0 +1,305 @@
// bench_tc_gemv.cu - ISOLATED benchmark: BF16 GEMV baseline vs Tensor Core (mma.m16n8k8, BF16->FP16) on sm_75.
// Nothing in the engine changes. Shapes are the REAL Strata decode GEMVs (BF16 weights, n_in = n_embd = 2560):
// ssm_alpha / ssm_beta [2560, 48] project_bf16(split=true) -> bf16_gemv_split(TPR=32) -> warp kernel
// indexer.k_proj [2560, 128] project_bf16(split=false) -> bf16_gemv -> warp kernel
// indexer.q_proj / ffn_gate_inp / mlp.gate [2560, 512] warp / split(TPR=32) -> warp kernel
// ple_value [2560, 2560] warp
// Baseline = bf16_gemv_warp_kernel transcribed verbatim from src/kernels/cuda/bf16_gemv.cu (production).
// TC variant = same maths; A = x broadcast down m16 (single-token GEMV), k-chunk = 8;
// (a) W preconverted bf16->fp16 once, x converted in-kernel (timed) [tc_preconv]
// (b) fully inline: W read as bf16 and converted in-register [tc_inline]
// Numerics: fp64 host reference; max abs err for baseline and both TC variants; bf16->fp16 exactness scan.
#include <cuda_runtime.h>
#include <cuda_fp16.h>
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <functional>
#include <algorithm>
#define CHECK(e) do { cudaError_t err_ = (e); if (err_ != cudaSuccess) { \
fprintf(stderr, "CUDA %s:%d %s\n", __FILE__, __LINE__, cudaGetErrorString(err_)); exit(1); } } while (0)
__device__ __forceinline__ float bf16_f32(uint16_t v) { return __int_as_float((int) ((unsigned) v << 16)); }
static float bf16_f32_host(uint16_t v) { unsigned u = (unsigned) v << 16; float f; memcpy(&f, &u, 4); return f; }
static uint16_t f32_bf16_host(float f) {
unsigned u, r; memcpy(&u, &f, 4);
r = ((u >> 16) ^ (u >> 15)) & 1; u += 0x7fff + r;
return (uint16_t) (u >> 16);
}
// ============ baseline: production warp kernel (verbatim semantics from bf16_gemv.cu) ============
__global__ void gemv_warp(const uint16_t* __restrict__ x, const uint16_t* __restrict__ w,
float* __restrict__ y, long long n_in, long long n_out) {
const long long o = (long long) blockIdx.x * (blockDim.x >> 5) + (threadIdx.x >> 5);
if (o >= n_out) return;
const int lane = threadIdx.x & 31;
const uint16_t* row = w + o * n_in;
float acc = 0.0f;
for (long long i = lane; i < n_in; i += 32)
acc += bf16_f32(x[i]) * bf16_f32(row[i]);
for (int off = 16; off > 0; off >>= 1) acc += __shfl_down_sync(0xFFFFFFFFu, acc, off);
if (lane == 0) y[o] = acc;
}
// ============ TC: A(x) broadcast, k-split over blocks, partial D row 0 -> scratch ============
// A fragment (m16n8k8, .f16): lane l: a0 = A[m=l>>2][k=2(l&3)], a1 = A[m][k=2(l&3)+1],
// a2/a3 = same cols at row m+8. Broadcast => a2=a0, a3=a1.
// B fragment (.f16, col-major): lane l: b0 = B[k=2(l&3)][n=(l>>2)], b1 = B[k=2(l&3)+1][n].
// B[k][n] = W[n][k], so lane l loads W[n][2(l&3)], W[n][2(l&3)+1] - coalesced within the row.
// D fragment: c0/c1 = D[m=l>>2][cols 2(l&3), +1], c2/c3 = row m+8. All m rows identical -> row 0.
__global__ void tc_preconv(const uint16_t* __restrict__ x_b, const uint16_t* __restrict__ w_f,
float* __restrict__ partials, long long n_in, long long n_out, int ks) {
const int tile = blockIdx.x, ks_i = blockIdx.y, lane = threadIdx.x & 31;
const long long n_base = (long long) tile * 8;
const long long k_per = n_in / (long long) ks;
const long long k0 = (long long) ks_i * k_per;
const int t2 = 2 * (lane & 3);
float c0 = 0.f, c1 = 0.f, c2 = 0.f, c3 = 0.f;
for (long long kk0 = k0; kk0 < k0 + k_per; kk0 += 8) {
// A (2 x f16x2): a0 = {A[m][2t], A[m+8][2t]}, a1 = {A[m][2t+1], A[m+8][2t+1]} (broadcast -> dup halves)
unsigned xh = (unsigned) x_b[kk0 + t2] | ((unsigned) x_b[kk0 + t2 + 1] << 16);
// fp16 conversion in-register: bf16 -> f32 -> f16 (exact within fp16 range)
__half2 ha = __floats2half2_rn(bf16_f32((uint16_t) (xh & 0xFFFF)), bf16_f32((uint16_t) (xh >> 16)));
__half2 hb = __floats2half2_rn(bf16_f32((uint16_t) (xh & 0xFFFF)), bf16_f32((uint16_t) (xh >> 16)));
unsigned a0 = *reinterpret_cast<unsigned*>(&ha);
unsigned a1 = *reinterpret_cast<unsigned*>(&hb);
// B is already fp16 here: load as __half2 directly (bf16 path must NOT convert twice)
__half2 wbh = *reinterpret_cast<const __half2*>(&w_f[(n_base + (lane >> 2)) * n_in + kk0 + t2]);
unsigned b0 = *reinterpret_cast<unsigned*>(&wbh);
asm volatile("mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32 {%0,%1,%2,%3}, {%4,%5}, {%6}, {%0,%1,%2,%3};\n"
: "+f"(c0), "+f"(c1), "+f"(c2), "+f"(c3)
: "r"(a0), "r"(a1), "r"(b0));
}
if (lane < 4) { float* p = partials + (size_t) (tile * ks + ks_i) * 8; p[t2] = c0; p[t2 + 1] = c1; }
}
// same, but W stays bf16 and converts in-register (fully fair per-call cost)
__global__ void tc_inline(const uint16_t* __restrict__ x_b, const uint16_t* __restrict__ w_b,
float* __restrict__ partials, long long n_in, long long n_out, int ks) {
const int tile = blockIdx.x, ks_i = blockIdx.y, lane = threadIdx.x & 31;
const long long n_base = (long long) tile * 8;
const long long k_per = n_in / (long long) ks;
const long long k0 = (long long) ks_i * k_per;
const int t2 = 2 * (lane & 3);
float c0 = 0.f, c1 = 0.f, c2 = 0.f, c3 = 0.f;
for (long long kk0 = k0; kk0 < k0 + k_per; kk0 += 8) {
unsigned xh = (unsigned) x_b[kk0 + t2] | ((unsigned) x_b[kk0 + t2 + 1] << 16);
__half2 ha = __floats2half2_rn(bf16_f32((uint16_t) (xh & 0xFFFF)), bf16_f32((uint16_t) (xh >> 16)));
__half2 hb = __floats2half2_rn(bf16_f32((uint16_t) (xh & 0xFFFF)), bf16_f32((uint16_t) (xh >> 16)));
unsigned a0 = *reinterpret_cast<unsigned*>(&ha);
unsigned a1 = *reinterpret_cast<unsigned*>(&hb);
const uint16_t* wbv = w_b + (n_base + (lane >> 2)) * n_in + kk0 + t2;
__half2 wbh = __floats2half2_rn(bf16_f32(wbv[0]), bf16_f32(wbv[1]));
unsigned b0 = *reinterpret_cast<unsigned*>(&wbh);
asm volatile("mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32 {%0,%1,%2,%3}, {%4,%5}, {%6}, {%0,%1,%2,%3};\n"
: "+f"(c0), "+f"(c1), "+f"(c2), "+f"(c3)
: "r"(a0), "r"(a1), "r"(b0));
}
if (lane < 4) { float* p = partials + (size_t) (tile * ks + ks_i) * 8; p[t2] = c0; p[t2 + 1] = c1; }
}
__global__ void tc_reduce(const float* __restrict__ partials, float* __restrict__ y, long long n_out, int ks) {
const long long o = blockIdx.x * blockDim.x + threadIdx.x;
if (o >= n_out) return;
float s = 0.f;
for (int q = 0; q < ks; ++q) s += partials[(size_t) ((o >> 3) * ks + q) * 8 + (o & 7)];
y[o] = s;
}
// variant with the OTHER candidate A layout: a0 = {A[gid][2t], A[gid+8][2t]} (same k-col, two rows),
// a1 = same for col 2t+1. Broadcast => both halves of a0 hold x[2t], both halves of a1 hold x[2t+1].
__global__ void tc_dupcol(const uint16_t* __restrict__ x_b, const uint16_t* __restrict__ w_b,
float* __restrict__ partials, long long n_in, long long n_out, int ks) {
const int tile = blockIdx.x, ks_i = blockIdx.y, lane = threadIdx.x & 31;
const long long n_base = (long long) tile * 8;
const long long k_per = n_in / (long long) ks;
const long long k0 = (long long) ks_i * k_per;
const int t2 = 2 * (lane & 3);
float c0 = 0.f, c1 = 0.f, c2 = 0.f, c3 = 0.f;
for (long long kk0 = k0; kk0 < k0 + k_per; kk0 += 8) {
__half2 ha = __floats2half2_rn(bf16_f32(x_b[kk0 + t2]), bf16_f32(x_b[kk0 + t2]));
__half2 hb = __floats2half2_rn(bf16_f32(x_b[kk0 + t2 + 1]), bf16_f32(x_b[kk0 + t2 + 1]));
unsigned a0 = *reinterpret_cast<unsigned*>(&ha);
unsigned a1 = *reinterpret_cast<unsigned*>(&hb);
const uint16_t* wbv = w_b + (n_base + (lane >> 2)) * n_in + kk0 + t2;
__half2 wbh = __floats2half2_rn(bf16_f32(wbv[0]), bf16_f32(wbv[1]));
unsigned b0 = *reinterpret_cast<unsigned*>(&wbh);
asm volatile("mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32 {%0,%1,%2,%3}, {%4,%5}, {%6}, {%0,%1,%2,%3};\n"
: "+f"(c0), "+f"(c1), "+f"(c2), "+f"(c3)
: "r"(a0), "r"(a1), "r"(b0));
}
if (lane < 4) { float* p = partials + (size_t) (tile * ks + ks_i) * 8; p[t2] = c0; p[t2 + 1] = c1; }
}
// FUSED, ks=1 only: with a single k-fragment the partial IS the answer -> write y directly, no reduce kernel,
// no scratch. Fully inline bf16 W conversion (fairest per-call TC cost).
__global__ void tc_fused(const uint16_t* __restrict__ x_b, const uint16_t* __restrict__ w_b,
float* __restrict__ y, long long n_in, long long n_out) {
const int tile = blockIdx.x, lane = threadIdx.x & 31;
const long long n_base = (long long) tile * 8;
const int t2 = 2 * (lane & 3);
float c0 = 0.f, c1 = 0.f, c2 = 0.f, c3 = 0.f;
for (long long kk0 = 0; kk0 < n_in; kk0 += 8) {
__half2 ha = __floats2half2_rn(bf16_f32(x_b[kk0 + t2]), bf16_f32(x_b[kk0 + t2 + 1]));
__half2 hb = ha; // broadcast: row gid+8 = row gid (single-token GEMV)
unsigned a0 = *reinterpret_cast<unsigned*>(&ha);
unsigned a1 = *reinterpret_cast<unsigned*>(&hb);
const uint16_t* wbv = w_b + (n_base + (lane >> 2)) * n_in + kk0 + t2;
__half2 wbh = __floats2half2_rn(bf16_f32(wbv[0]), bf16_f32(wbv[1]));
unsigned b0 = *reinterpret_cast<unsigned*>(&wbh);
asm volatile("mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32 {%0,%1,%2,%3}, {%4,%5}, {%6}, {%0,%1,%2,%3};\n"
: "+f"(c0), "+f"(c1), "+f"(c2), "+f"(c3)
: "r"(a0), "r"(a1), "r"(b0));
}
if (lane < 4) { y[n_base + t2] = c0; y[n_base + t2 + 1] = c1; }
}
int main() {
CHECK(cudaSetDevice(0));
cudaDeviceProp prop; CHECK(cudaGetDeviceProperties(&prop, 0));
printf("device: %s, SMs %d, capability %d.%d\n", prop.name, prop.multiProcessorCount, prop.major, prop.minor);
struct Shape { const char* name; long long n_in, n_out; };
Shape shapes[] = {
{"ssm_alpha/beta [2560,48]", 2560, 48},
{"indexer.k_proj [2560,128]", 2560, 128},
{"q_proj/router [2560,512]", 2560, 512},
{"ple_value [2560,2560]", 2560, 2560},
};
auto rng = [](unsigned& s) { s = s * 1664525u + 1013904223u; return (float) ((s >> 8) & 0xFFFF) / 65535.0f - 0.5f; };
const int ITERS = 2000, WARM = 300;
printf("\n%-26s %13s | %s\n", "shape", "baseline us", "tc variants (pc = W preconverted, in = inline conversion, fused = no reduce), speedup vs baseline");
printf("%s\n", std::string(150, '-').c_str());
for (auto& sh : shapes) {
const long long n_in = sh.n_in, n_out = sh.n_out;
const size_t wn = (size_t) n_out * n_in;
std::vector<uint16_t> hw(wn), hx(n_in), hf(wn);
std::vector<float> hyb(n_out), hypc(n_out), hyin(n_out), hyfu(n_out);
std::vector<double> href(n_out);
unsigned seed = 991u + (unsigned) (n_out & 0xFFF);
for (size_t i = 0; i < wn; ++i) hw[i] = f32_bf16_host(rng(seed) * 0.3f);
for (long long i = 0; i < n_in; ++i) hx[i] = f32_bf16_host(rng(seed) * 3.0f);
for (long long o = 0; o < n_out; ++o) {
double s = 0.0;
for (long long i = 0; i < n_in; ++i) s += (double) bf16_f32_host(hx[i]) * (double) bf16_f32_host(hw[(size_t) o * n_in + i]);
href[o] = s;
}
// preconvert W to fp16 (bf16 -> fp16 is exact within fp16 range)
for (size_t i = 0; i < wn; ++i) { __half h = __float2half_rn(bf16_f32_host(hw[i])); memcpy(&hf[i], &h, 2); }
uint16_t *dx, *dw, *dwf; float *dy, *dyp;
CHECK(cudaMalloc(&dx, n_in * 2));
CHECK(cudaMalloc(&dw, wn * 2)); CHECK(cudaMalloc(&dwf, wn * 2));
CHECK(cudaMalloc(&dy, n_out * 4));
CHECK(cudaMalloc(&dyp, (size_t)(n_out / 8) * 65 * 8 * 4));
CHECK(cudaMemcpy(dx, hx.data(), n_in * 2, cudaMemcpyHostToDevice));
CHECK(cudaMemcpy(dw, hw.data(), wn * 2, cudaMemcpyHostToDevice));
CHECK(cudaMemcpy(dwf, hf.data(), wn * 2, cudaMemcpyHostToDevice));
// one-time W conversion cost (host->device, reported separately; the engine would fold this
// into the weight load exactly like Gemm::bf16 does for sm<80)
{
cudaEvent_t e0, e1; CHECK(cudaEventCreate(&e0)); CHECK(cudaEventCreate(&e1));
CHECK(cudaEventRecord(e0));
CHECK(cudaMemcpy(dwf, hf.data(), wn * 2, cudaMemcpyHostToDevice));
CHECK(cudaEventRecord(e1)); CHECK(cudaEventSynchronize(e1));
float ms = 0; CHECK(cudaEventElapsedTime(&ms, e0, e1));
printf("%-26s one-time W convert: %.2f ms (%.1f MB), tiles=%lld\n", sh.name, ms, wn * 2 / 1e6, n_out / 8);
}
int tiles = (int) (n_out / 8);
// valid ks must divide n_in so each k-chunk is a multiple of 8; sweep ALL of them, report the best
const int cands[11] = {1, 2, 4, 5, 8, 10, 16, 20, 32, 40, 64};
auto timeit = [&](const char* tag, const std::function<void()>& fn) -> double {
for (int i = 0; i < WARM; ++i) fn();
CHECK(cudaDeviceSynchronize());
double best = 1e30;
for (int rep = 0; rep < 3; ++rep) {
cudaEvent_t e0, e1; CHECK(cudaEventCreate(&e0)); CHECK(cudaEventCreate(&e1));
CHECK(cudaEventRecord(e0));
for (int i = 0; i < ITERS; ++i) fn();
CHECK(cudaEventRecord(e1)); CHECK(cudaEventSynchronize(e1));
float ms = 0; CHECK(cudaEventElapsedTime(&ms, e0, e1));
double us = ms * 1000.0 / ITERS;
if (us < best) best = us;
}
(void) tag; return best;
};
double t_base = timeit("base", [&]{ gemv_warp<<<(unsigned) ((n_out + 7) / 8), 256>>>(dx, dw, dy, n_in, n_out); });
gemv_warp<<<(unsigned) ((n_out + 7) / 8), 256>>>(dx, dw, dy, n_in, n_out);
CHECK(cudaMemcpy(hyb.data(), dy, n_out * 4, cudaMemcpyDeviceToHost));
// occupancy sweep over k-chunk count for the preconverted-W TC kernel
int best_ks = 1; double t_pc = 1e30;
for (int i = 0; i < 11; ++i) {
const int ksv = cands[i];
if (n_in % ksv != 0) continue;
dim3 g((unsigned) tiles, (unsigned) ksv);
double t = timeit("pcs", [&]{ tc_preconv<<<g, 32>>>(dx, dwf, dyp, n_in, n_out, ksv);
tc_reduce<<<(unsigned) ((n_out + 255) / 256), 256>>>(dyp, dy, n_out, ksv); });
if (t < t_pc) { t_pc = t; best_ks = ksv; }
}
dim3 gtc((unsigned) tiles, (unsigned) best_ks);
tc_preconv<<<gtc, 32>>>(dx, dwf, dyp, n_in, n_out, best_ks);
tc_reduce<<<(unsigned) ((n_out + 255) / 256), 256>>>(dyp, dy, n_out, best_ks);
CHECK(cudaMemcpy(hypc.data(), dy, n_out * 4, cudaMemcpyDeviceToHost));
double t_ti = timeit("tci", [&]{ tc_inline<<<gtc, 32>>>(dx, dw, dyp, n_in, n_out, best_ks);
tc_reduce<<<(unsigned) ((n_out + 255) / 256), 256>>>(dyp, dy, n_out, best_ks); });
tc_inline<<<gtc, 32>>>(dx, dw, dyp, n_in, n_out, best_ks);
tc_reduce<<<(unsigned) ((n_out + 255) / 256), 256>>>(dyp, dy, n_out, best_ks);
CHECK(cudaMemcpy(hyin.data(), dy, n_out * 4, cudaMemcpyDeviceToHost));
double t_fu = timeit("tcf", [&]{ tc_fused<<<(unsigned) tiles, 32>>>(dx, dw, dy, n_in, n_out); });
tc_fused<<<(unsigned) tiles, 32>>>(dx, dw, dy, n_in, n_out);
CHECK(cudaMemcpy(hyfu.data(), dy, n_out * 4, cudaMemcpyDeviceToHost));
double best_tc = t_pc; const char* best_var = "preconv";
if (t_ti < best_tc) { best_tc = t_ti; best_var = "inline"; }
if (t_fu < best_tc) { best_tc = t_fu; best_var = "fused"; }
double e_tc = 0, e_base = 0, sc = 0;
if (strcmp(best_var, "preconv") == 0) {
for (long long o = 0; o < n_out; ++o) { e_tc = std::max(e_tc, std::fabs((double) hypc[o] - href[o])); }
} else if (strcmp(best_var, "inline") == 0) {
for (long long o = 0; o < n_out; ++o) { e_tc = std::max(e_tc, std::fabs((double) hyin[o] - href[o])); }
} else {
for (long long o = 0; o < n_out; ++o) { e_tc = std::max(e_tc, std::fabs((double) hyfu[o] - href[o])); }
}
for (long long o = 0; o < n_out; ++o) {
e_base = std::max(e_base, std::fabs((double) hyb[o] - href[o]));
sc = std::max(sc, std::fabs(href[o]));
}
double gb_base = (double) (wn * 2) / t_base / 1e3;
double gb_tc = (double) (wn * 2) / best_tc / 1e3;
printf("%-26s %13.3f | pc %13.3f (ks=%d) | in %13.3f | fused %13.3f | BEST %s %7.3fx | maxerr tc %.2e base %.2e (scale %.1f, BW base %.0f tc %.0f GB/s)\n",
sh.name, t_base, t_pc, best_ks, t_ti, t_fu, best_var, t_base / best_tc,
e_tc, e_base, sc, gb_base, gb_tc);
CHECK(cudaFree(dx)); CHECK(cudaFree(dw)); CHECK(cudaFree(dwf)); CHECK(cudaFree(dy)); CHECK(cudaFree(dyp));
}
{ // bf16 -> fp16 exactness scan
unsigned seed = 777u; double worst = 0; int bad = 0, n = 2000000;
for (int i = 0; i < n; ++i) {
float f = (rng(seed) * 2.0f - 1.0f) * 100.0f;
uint16_t b = f32_bf16_host(f);
__half h = __float2half_rn(bf16_f32_host(b));
if ((double) __half2float(h) != (double) bf16_f32_host(b)) {
bad++; worst = std::max(worst, std::fabs((double) __half2float(h) - (double) bf16_f32_host(b)));
}
}
printf("\nbf16->fp16 conversion exactness: %d / %d inexact, worst %.3g\n", bad, n, worst);
}
printf("BENCH_DONE\n");
return 0;
}
+12 -7
View File
@@ -1,23 +1,28 @@
# Opt-in HIP configuration. Strata's CUDA-shaped kernels target wave32 RDNA3 / RDNA4 (64 KiB LDS per workgroup,
# the signed dot4 instruction). CMake/compiler discovery stays machine-independent; pass CMAKE_HIP_COMPILER when it
# Opt-in HIP configuration. Strata's CUDA-shaped kernels target wave32 RDNA2 / RDNA3 / RDNA4 (64 KiB LDS per
# workgroup, a signed dot4 instruction). CMake/compiler discovery stays machine-independent; pass CMAKE_HIP_COMPILER when it
# is not on PATH.
if(NOT DEFINED CMAKE_HIP_ARCHITECTURES OR CMAKE_HIP_ARCHITECTURES STREQUAL "")
set(CMAKE_HIP_ARCHITECTURES gfx1100 CACHE STRING "Strata HIP target architecture(s), e.g. gfx1100 or gfx1100;gfx1201")
endif()
# Validated on real cards: gfx1100 (RX 7900 XT / XTX) and gfx1201 (RX 9070 / 9070 XT, Radeon AI PRO R9700).
# The other RDNA3 / RDNA4 wave32 chips have the same LDS limit and dot4 instruction and build the same code, but
# the maintainers have not run them (community reports: gfx1102 #192, gfx1200 #176).
# Validated on real cards: gfx1100 (RX 7900 XT / XTX) and gfx1201 (RX 9070 / 9070 XT, Radeon AI PRO R9700) by the
# maintainers; gfx1101 (RX 7800 XT, #254) and gfx1200 (RX 9060 XT, #256) by their owners. gfx1102 (RX 7600) has the
# same LDS limit and dot4 instruction and passed ctest (#192), but no model run has been reported yet. RDNA2 gfx1030 (RX 6800 / 6900) has the
# same LDS limit and wave32 but an older dot4 instruction (v_dot4_i32_i8, hip_compat/intrinsics.hpp); a community
# report ran it (#311), the maintainers have not.
set(_strata_hip_validated gfx1100 gfx1201)
set(_strata_hip_unvalidated gfx1101 gfx1102 gfx1200)
set(_strata_hip_community gfx1101 gfx1200)
set(_strata_hip_unvalidated gfx1102 gfx1030)
set(STRATA_HIP_ARCH_LIST "")
foreach(_arch IN LISTS CMAKE_HIP_ARCHITECTURES)
string(REGEX REPLACE ":.*$" "" _base "${_arch}") # gfx1100:xnack- -> gfx1100
if(_base IN_LIST _strata_hip_validated)
elseif(_base IN_LIST _strata_hip_community)
message(STATUS "Strata HIP: ${_base} was validated by community reports (docs/AMD_HIP.md)")
elseif(_base IN_LIST _strata_hip_unvalidated)
message(WARNING "Strata HIP: ${_base} builds, but it is not validated on a real card yet; please report results")
else()
message(FATAL_ERROR
"Strata HIP supports wave32 gfx1100 and gfx1201 (unvalidated: ${_strata_hip_unvalidated}); "
"Strata HIP supports wave32 gfx1100, gfx1101, gfx1200 and gfx1201 (unvalidated: ${_strata_hip_unvalidated}); "
"CMAKE_HIP_ARCHITECTURES is '${CMAKE_HIP_ARCHITECTURES}'")
endif()
list(APPEND STRATA_HIP_ARCH_LIST "${_base}")
Binary file not shown.
+126 -23
View File
@@ -1,12 +1,13 @@
# Experimental AMD HIP backend (gfx1100, gfx1201)
# Experimental AMD HIP backend (gfx1100, gfx1101, gfx1200, gfx1201, gfx1030)
This is a Linux source build for the RX 7900 XT / XTX (RDNA3, gfx1100) and the
RX 9070 / 9070 XT / Radeon AI PRO R9700 (RDNA4, gfx1201; see [RDNA4](#rdna4-gfx1201)).
It is opt-in; the NVIDIA installer and CUDA build remain the default. Other AMD
RX 9070 / 9070 XT / Radeon AI PRO R9700 (RDNA4, gfx1201; see [RDNA4](#rdna4-gfx1201)). The RX 7800 XT / 7700 XT
(gfx1101) and the RX 9060 XT (gfx1200) were validated by their owners (see [Community-validated
cards](#community-validated-cards)); the RX 6800 / 6900 series (RDNA2, gfx1030) builds and runs too, reported by a community machine and not yet validated by the maintainers (see [RDNA2](#rdna2-gfx1030)). It is opt-in; the NVIDIA installer and CUDA build remain the default. Other AMD
architectures, wave64, Windows HIP, and mixed AMD/NVIDIA execution are outside this contribution.
The backend maps the CUDA-shaped runtime and BLAS calls to HIP/hipBLAS, uses
RDNA3/RDNA4's signed integer dot instruction for quantized kernels, and supplies
RDNA2/RDNA3/RDNA4's signed integer dot instruction for quantized kernels, and supplies
wave32 shuffle/packed-byte operations. CUDA-only QSA matrix instructions have
an ordered FP32 fallback. Prefill supports both dequantization plus hipBLAS GEMM and opt-in HIP ggml MMQ.
An optional, calibrated hipBLASLt path accelerates dense projections (per-architecture tables in `tools/hip`).
@@ -15,8 +16,8 @@ This does not claim bit-identical model answers across backends. See
## Install with setup (recommended)
On Linux with an RX 7900 XT / XTX or an RX 9070 / 9070 XT / Radeon AI PRO R9700 and the kernel's amdgpu driver
(no ROCm install needed):
On Linux with an RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT or Radeon AI PRO R9700 and
the kernel's amdgpu driver (no ROCm install needed):
```sh
./setup.sh --backend hip
@@ -26,8 +27,10 @@ On Linux with an RX 7900 XT / XTX or an RX 9070 / 9070 XT / Radeon AI PRO R9700
supported. On a PC without an NVIDIA card Strata can use, `--backend hip` is chosen automatically.
- **ROCm:** a system ROCm 7 in `/opt/rocm` (or `$ROCM_PATH`) with hipcc and hipBLAS is used when present. Otherwise
(or when it is older than 7.0) ROCm is installed into `.venv` from AMD's TheRock wheels (~10 GB, no sudo), pinned
to the version this backend was tested with, from the card family's index: `gfx110X-dgpu` for gfx1100,
`gfx120X-all` for gfx1201 (`STRATA_ROCM_VERSION` / `STRATA_ROCM_INDEX` override them).
to the version this backend was tested with, from the card family's index: `gfx110X-dgpu` for gfx1100 / gfx1101,
`gfx120X-all` for gfx1200 / gfx1201, `gfx103X-all` for gfx1030 (`STRATA_ROCM_VERSION` /
`STRATA_ROCM_INDEX` override them; the gfx1030 index is not checked to carry the pinned version: a system
ROCm 7 is the tested path there).
- **Engine:** compiled on your PC for the card's architecture (10-20 minutes, once; again after a `git pull` that
changes it, or when you pick a card of another architecture). This needs a C++ compiler and git
(`sudo apt install build-essential git`).
@@ -35,7 +38,14 @@ On Linux with an RX 7900 XT / XTX or an RX 9070 / 9070 XT / Radeon AI PRO R9700
card's architecture and the installed hipBLASLt version (read from `hipblaslt-version.h`; 1.2.0 is `100200`).
Otherwise it says so and the prompt's dense matrix products use plain hipBLAS (slower prompts, same answers).
A table's solution ids are valid only for that pair, and the engine refuses any other table.
- **Limits for now:** one GPU, no images, no calibration. The Monitor shows no GPU statistics.
- **Several cards:** setup takes one card (the one with the most VRAM, or `--gpu N`) unless you name more:
`./setup.sh --backend hip --gpus 1,0` splits the model's layers across them, the first one the main card (numbers
as setup lists them; `--gpus all` = every supported card, the most VRAM first). Every chosen card must be one of the
architectures above; the engine is compiled for each of them (cards of two families, e.g. gfx1100 + gfx1201, need
a system ROCm 7: AMD's wheels hold one family). A split pays only when no single card holds the model's experts
(see RDNA4 below).
- **Limits for now:** images only through the CPU encoder (`--vision cpu`, 0.1.32), no calibration. The Monitor
shows the card's load, VRAM, temperature and power from Linux sysfs (0.1.32).
The rest of setup is the same as on NVIDIA: the model download, the start script, the server.
@@ -54,9 +64,9 @@ cmake -S . -B build-hip \
cmake --build build-hip --target strata -j2
```
`CMAKE_HIP_ARCHITECTURES` is `gfx1100`, `gfx1201`, or a list such as `"gfx1100;gfx1201"` (one binary for both).
gfx1101, gfx1102 and gfx1200 (the same wave32, 64 KiB LDS and dot4 instruction) build with a warning: they have
not been validated on a real card here. At startup the engine and `strata-device` compare each GPU they use
`CMAKE_HIP_ARCHITECTURES` is `gfx1100`, `gfx1101`, `gfx1200`, `gfx1201`, or a list such as `"gfx1100;gfx1201"`
(one binary for both). gfx1102 (the same wave32, 64 KiB LDS and dot4 instruction) builds with a warning: it passed
ctest (#192) but no model run has been reported; so does gfx1030 (RDNA2: the older `v_dot4_i32_i8`, a community run in #311). At startup the engine and `strata-device` compare each GPU they use
(`gcnArchName` up to the `:` feature suffix) with the architectures the binary was compiled for, and require
wave32. A binary carried to another card stops with the card's name, its architecture and the build's list,
instead of failing later with "invalid device function".
@@ -114,8 +124,7 @@ The 4K context is a smoke-test starting point, not a model limit. The expert cac
sizes itself automatically and leaves 1 GiB of VRAM headroom.
The installer supports this backend (see "Install with setup" above). The vision helper is NVIDIA-only for now.
Setup installs one AMD card; the engine's layer split also runs on two AMD cards when the config is written by hand
(see RDNA4 below).
Setup installs one AMD card, or several with `--gpus` (the engine's layer split; see RDNA4 below).
## RDNA4 (gfx1201)
@@ -145,12 +154,16 @@ an RX 9070 XT 16 GB and a Radeon AI PRO R9700 32 GB (both gfx1201), a Ryzen 9 39
| RX 9070 XT 16 GB | 4,931 slots, 9.4 GiB | 15.6 GiB | 782 tok/s | 30.8 tok/s | 1,235 tok/s | 35.4 tok/s |
| R9700, TheRock 7.10 wheels | 12,288 slots | | 957 tok/s | 44.2 tok/s | 1,284 tok/s | 43.9 tok/s |
The engine's resident memory was about 26 GB in every run.
- **hipBLASLt:** there is no gfx1201 table in `tools/hip`. A table calibrated on the R9700 at the engine's shapes
(hipBLASLt 1.4.1; 0.98-1.76x per GEMM over hipBLAS) changed the end-to-end prompt speed by 0-3%, within noise,
so none is shipped: on gfx1201 the plain hipBLAS path is already close.
The engine's resident memory was about 26 GB in every run. Since 0.1.31 `__byte_perm` is one `v_perm_b32` and the
packed byte subtracts/compare work on four lanes at once (#262, ttio2tech): decode +15% on the R9700 (46.0 -> 53.0
tok/s on a 4K prompt, 52.0 -> 60.5 warm) and +5-7% on the 9070 XT, prompts unchanged, the same tokens.
- **hipBLASLt:** the validation above used hipBLASLt 1.4.1. A table calibrated on the R9700 at the engine's shapes
with that version (0.98-1.76x per GEMM over hipBLAS) changed the end-to-end prompt speed by 0-3%, within noise,
so none was shipped for it: there the plain hipBLAS path is already close. For hipBLASLt 1.5.0 (ROCm
10.2.0a nightly) `tools/hip/gfx1201-hipblaslt-100500.txt` is shipped (see "Tuning table" below); on one R9700 it
measured +3.9% prompt speed on 4,210-token prompts (1,590 vs 1,531 tok/s), a modest gain.
- **Both cards in one run (layer split, engine 0.1.30):** the config's `"backend": "hip", "gpu": [1, 0]` (R9700
first) runs through `serve/server.py`; setup does not offer it yet. Auto split put layers 0-27 on the R9700 and
first) runs through `serve/server.py` (setup writes it with `--gpus 1,0` since 0.1.31). Auto split put layers 0-27 on the R9700 and
28-47 on the 9070 XT. With every expert on the GPUs the split gives exactly the tokens of the R9700 alone (4K and
16K prompts); checkpoints on the split (second turn, rewind, a prompt sharing a prefix, a cancelled prompt
retried) give exactly the tokens of a fresh read. The conversation cache refuses a split at start (exit 2).
@@ -162,12 +175,88 @@ an RX 9070 XT 16 GB and a Radeon AI PRO R9700 32 GB (both gfx1201), a Ryzen 9 39
| R9700 + 9070 XT, auto split | 1,384 tok/s | 1,906 tok/s | 42-43 tok/s |
| RX 9070 XT alone | 1,016 tok/s | 1,519 tok/s | 38-40 tok/s |
A split is worth it when no single card holds the model's experts. On Linux the split pins at most 8 GiB of the
expert arena (a Windows limit that also applies here).
A split is worth it when no single card holds the model's experts. Since 0.1.31 a split pins the whole expert
arena on Linux (the 8 GiB cap is for Windows/WSL2 only, #253): with an expert cache of 1,500 on the R9700 (most
experts streamed) the split read a 16K prompt at 1,803 tok/s instead of 1,287, with the same tokens in 5 + 5
starts. `"split_skip_if_fits": true` in the config (0.1.31, opt-in) runs such a pair on the first card alone when it
holds every profiled expert: with the R9700 first, 4K prompts 1,776 tok/s (split: 1,244) and decode ~60 tok/s
(split: ~51), the tokens of the R9700 alone (docs/MULTI_GPU.md).
- **Speed switches (engine 0.1.32, measured on the R9700 / 9070 XT with the Coder IQ1_M pack):**
- the MoE router (`router_top10`) runs a HIP kernel without its serial FP64 sum and block barriers by default: the
same ids and weights bit for bit (`hip_router_fast` checks 65,536 rows), 39 -> 9-12 us per call, decode
62.4 -> 70.0 tok/s on the R9700 and +4% on the 9070 XT, the same greedy tokens (5 + 5 starts).
`STRATA_HIP_ROUTER_OLD=1` runs the portable kernel.
- `STRATA_HIP_WMMA=1` (opt-in, gfx12 only, int8 KV): the prompt path's QSA attention on RDNA4 matrix cores
(`v_wmma_f32_16x16x16_f16`, FP16 hi + lo halves like the CUDA tensor-core kernel; `hip_prompt_attn_wmma` bounds it
against the FP32 kernel and FP64). 7.2-7.5x the portable kernel; R9700 prompts 4K 1,784 -> 2,427 tok/s, 16K
1,797 -> 2,700. Not bitwise: greedy text differs from token ~50 on, as with the CUDA tensor-core attention. With it
the prompt path's expert ring is 96 slots (as STRATA_PREFILL_RING=96): with the default 384 the 9070 XT's 4K
prompts fell to 718 tok/s; with 96 they gain (1,017 -> 1,211; 16K 1,518 -> 2,032). PR #329
(bsorensen110) contributed an equivalent gfx12 WMMA kernel of the same speed (within 1%); this one also masks KV
pages that KV streaming has not made resident, as the decode kernel does.
- The prompt path's QSA top-k picks its kernel by the blocks a query actually has, not the cache's capacity (#337,
bsorensen110): the same ids, on by default with AMD (NVIDIA keeps its capacity rule: there the 64K prompts read
1-3% slower with it). `STRATA_SELECT_WMMA=1` (opt-in, gfx12) adds #337's
matrix-core block scorer; it selects slightly differently (254 of 256 queries the same) and gained +1.5% on 16K
prompts at a 262K context on the R9700.
- **Known:** rarely (about 1 start in 10) a HIP run's greedy output differs from another start's at some token, on
one card or two and on engine 0.1.29 as well; not yet explained.
- **Not validated:** gfx1200 (RX 9060 XT; a community report is #176), images, long contexts beyond 16K,
answer-quality benchmarks.
- **Not validated:** images, long contexts beyond 16K, answer-quality benchmarks.
## Community-validated cards
Run by their owners, not on the maintainers' machines; setup accepts them like gfx1100 / gfx1201. No hipBLASLt table
is shipped for them (make one with [Tuning table](#tuning-table) and compare the prompt speed with and without it).
- **gfx1101, RX 7800 XT 16 GB** (jhohertz, #254; engine 0.1.29, Ryzen 9 5950X, 121 GiB RAM, system ROCm with
hipBLASLt 1.4.1): `./setup.sh --backend hip` detected the card and compiled the engine; `strata-device --selftest`
passed; ctest 30/32 (`ple_parity` needs the Q2_0 fixture, `platform_memory_test` the memlock limit). Coder IQ1_M,
64K context, MTP, with a table the owner calibrated: fresh prompts of 4K-9K tokens at 898-953 tok/s, decode
38-44 tok/s (128 tokens).
- **gfx1200, RX 9060 XT 16 GB** (Efeisot, #256 after #176; engine 0.1.29, Ryzen 9 7950X, 64 GiB RAM, ROCm 7.2 with
hipBLASLt 1.2.2): ctest 32/32 (without `ple_parity` and `platform_memory_test`). Coder IQ1_M, greedy, MTP
`--spec 4 --spec-min-p 0.5`, with a table the owner calibrated:
| prompt | prompt speed | decode |
|---|---|---|
| 2,374 tokens | 540 tok/s | 27.1 tok/s (0.69 draft acceptance; 31.0 at 1.00) |
| 65K (`--kv int8 --kv-resident 65536 --prefill 16384`) | 748-753 tok/s | 26-40 tok/s by acceptance |
| 130K (the same flags) | 725 tok/s | - |
Greedy output was the same across runs. For comparison, llama.cpp's HIP build measured 20 tok/s decode and
450 tok/s prompt on that card.
## RDNA2 (gfx1030)
The RX 6800 / 6800 XT / 6900 XT / 6950 XT run the same kernels: wave32 and 64 KiB of LDS per workgroup. The one
difference is the dot instruction: RDNA2 has no `v_dot4_i32_iu8` (gfx11 and newer), so
`dp4a` uses the plain signed `v_dot4_i32_i8` through `__builtin_amdgcn_sdot4`, which compiles to a single
`v_dot4c_i32_i8` (same signed x signed byte products, modulo 2^32). There is no WMMA; the QSA scorer takes the
same ordered FP32 fallback as gfx1100. CMake lists gfx1030 as unvalidated (the build warns) until a maintainer has
run it; the report below is from a community machine: an RX 6900 XT 16 GB (gfx1030), an i7-13700KF (8 P-cores and
8 E-cores, AVX2, no AVX-512), 63 GB RAM, NixOS, ROCm 7.2.3 from nixpkgs (clang 22, hipBLAS 3.2).
- **Build and tests** (engine 0.1.26): a complete HIP build for gfx1030, made by hand with cmake and ROCm's own
`clang++` (the nixpkgs ROCm is not an `/opt/rocm` tree, so setup's `build_engine_hip` was not exercised; the
binary was placed in `engine/` for setup to use). All 28 registered ctest tests pass on the card, including
`hip_device_selftest`. An engine 0.1.30 build of this branch configures, builds and runs clean on the same card;
the speeds below are measured on it.
- **End to end** (Swift 1.5 IQ3_XXS, `--context 131072` with `--kv-resident 32768 --adapt-every 1
--vram-reserve-mib 1024`, 200 greedy tokens): 38-42 tok/s decode with the default 15 CPU pool workers (one per
physical core except the host thread; 8 workers: 36; 24 = every logical core: 27), consistent even with the
131,072-token context full.
- **Prefill** (the same 15-worker configuration): 246 tok/s on a 2,000-token prompt, 330-339 tok/s at the auto
8,192-token chunk (7,997 and 15,967 tokens; time to first token 8.9 and 48.3 s), 133 tok/s on a 522-token
prompt - short prompts are fixed overhead (19-25 tok/s on 34 tokens). Decode after a 16K prefill holds at
45.5 tok/s.
- **16 GB card:** the expert cache holds 6,310 slots (10.2 GiB) at 16K context and 5,247 slots at 131,072, where
setup keeps the KV cache in VRAM because IQ3_XXS needs about 60 GB of RAM plus the cache to stream it. The
`--pcie-frac 0` and `--adapt-every 0` of the 7900 XTX configuration in
[AMD_HIP_PERFORMANCE.md](AMD_HIP_PERFORMANCE.md) cost 8.6 and 13.6 tok/s here (30 with the defaults): keep the
defaults on a 16 GB card.
- **hipBLASLt:** ROCm's hipBLASLt ships no gfx1030 kernels, so there is no table and the plain hipBLAS path runs.
- **Not validated:** gfx1031 / gfx1032 (the same `dp4a` path, no hardware report), setup's own build path and the
`gfx103X-all` wheels on gfx1030, images, answer-quality benchmarks.
## Tuning table
@@ -185,6 +274,20 @@ The file's second line names the architecture and version (`STRATA_HIPBLASLT_TUN
as `tools/hip/<arch>-hipblaslt-<version>.txt` for setup, or point `STRATA_HIPBLASLT_TUNING` at it. Compare the
prompt speed with and without it before keeping it.
Shipped tables:
- `gfx1100-hipblaslt-100100.txt`, `gfx1100-hipblaslt-100200.txt`: RX 7900 XTX.
- `gfx1201-hipblaslt-100500.txt`: Radeon AI PRO R9700 (gfx1201, 32 GB), calibrated with ROCm 10.2.0a20260914
(AMD's `gfx120X-all` nightly, hipBLASLt 1.5.0, library build `d3164197`). 16 dense GEMM geometries at T=4096 and
T=8192, 32 rows. setup uses it only when the installed hipBLASLt reports 1.5.0 (it is found in `/opt/rocm`
when that is a system ROCm 7 or newer). The version number is the only thing the engine can check, so another
1.5.0 build could number its solutions differently. `hip_prefill_hipblaslt_gemm` (with `STRATA_HIPBLASLT_TUNING`
set) is a smoke test: it refuses a table for another architecture or version and checks that one BF16 and one
F16 row exist and agree with hipBLASEx, which covers 2 of the 32 rows. It does not prove that a solution id is
valid: the engine falls back to hipBLASEx for an id the library rejects, and the test still passes. Run it with
`STRATA_HIPBLASLT_VERBOSE=1` and look for `fallbacks=0` in its summary line, and recalibrate with
`tune_hipblaslt` before using this table with a different 1.5.0 build.
## Original backend validation (PR #94)
The following is historical validation of the original backend, not a fresh
+167
View File
@@ -0,0 +1,167 @@
# Community benchmark results
Share measurements from your own hardware so other users can judge how Strata
might run on a similar machine. This guide suggests a report format and a pull
request workflow; a single model, GPU, or context length is enough to contribute.
Existing [benchmark reports](../bench/results/) provide examples. The
[engine 0.1.26 speed report](../bench/results/2026-09-29-speed-0126/README.md)
includes hardware, settings, and per-run JSON. The
[technical details](DETAILS.md#speed-measured) explain the published measurements
and their limits. Report what you actually measured and label estimates separately.
## Community reports
- [2026-09-30: RTX 5090, Core Ultra 9 285K, 64 GB RAM](../bench/results/2026-09-30-community-rtx-5090/README.md):
Strata 0.1.29, original Flash-Next IQ2_XS, 131,072-token context; three runs
each at 4,096, 32,768, and 128,000 prompt tokens, plus six recall checks.
## What to record
Include enough information for someone else to repeat your run:
- **Hardware:** GPU model, VRAM, selected GPUs for a multi-GPU run, CPU, installed
RAM, and storage type. Include PCIe link speed and width, GPU power limits, and
other workloads when known or relevant.
- **Software:** OS, Strata commit and engine version, driver and CUDA version
(or ROCm for HIP), and release binary or source build. Include changed build options.
- **Model:** exact repository and revision when available, quantization, GGUF
filenames, and vision encoder if enabled. Identify custom packs, expert
profiles, or draft vocabularies, with hashes or reproducible preparation steps.
- **Settings:** launch command and relevant run configuration, context limit, KV
type and streaming window, expert cache, low-RAM mode, prefill size, CPU workers,
MTP, reasoning effort, sampling, and vision. State whether calibration or
experimental speed projection was enabled; attach the resulting settings.
- **Workload:** benchmark command or script, shareable prompts or instructions to
build them, actual prompt and generated token counts, output cap, repetitions,
and cache state for each run.
Use GB or GiB consistently and name the unit. Mark unavailable values explicitly
instead of guessing. Remove credentials and private content from configurations,
prompts, and logs before publishing them.
## How to measure
Start with a configuration that already works on your machine. You do not need to
download every model or test the largest context. A useful initial speed report
tests one short prompt and one longer prompt that fits, with a fixed output cap
(for example, 256 tokens). Record the actual output length if the model ends early.
For each configuration, try at least three measured runs and publish all of them
with a median and range. If you only have one run, say so. Explain any warm-up and
whether model loading is included in the timing.
Strata reuses conversation prefixes and adapts its expert cache. Separate prompts
that are fully processed from follow-ups that reuse tokens, and report the number
of reused and freshly read tokens from the engine log. Describe how you reset or
retained state between runs. A warmed expert cache and a reused prompt prefix are
different conditions; record both when possible.
Keep these measurements separate:
- **Prompt throughput:** freshly processed prompt tokens per second, from the
engine's timing output. Keep the corresponding token count and duration.
- **Decode throughput:** generated tokens per second, from the engine's timing
output. Count reasoning tokens too, or explain any different convention.
- **Time to first token:** seconds from sending the request to its first generated
token. For a streaming API measurement, ignore keep-alives and empty deltas and
state whether the first token is reasoning or answer text.
- **Total latency:** elapsed seconds for the whole request. State whether measured
at the engine or client, and whether loading, vision encoding, or queueing is included.
- **Memory:** observed RAM and VRAM usage, including whether the value is a startup
snapshot or a peak during inference. Report paging or out-of-memory failures.
Attach the engine timing lines and your measurement script if you used one. Avoid
calculating decode throughput by dividing generated tokens by total request time,
which also includes prompt processing. Cancelled or failed requests belong in the
report as failures, outside the successful throughput summary.
When comparing versions or settings, run both on the same machine and workload
and list every changed setting. Preserve the per-run results: output text and
draft acceptance can change speed even when the input is identical.
## Optional correctness checks
Speed measurements alone do not establish answer quality. Include a small check
relevant to your workload, such as a completed coding task with test results, a
tool call followed by its result, or an image question with an expected answer.
For long-context recall, the repository includes
[`tools/needle_bench.py`](../tools/needle_bench.py). With a running local server,
from the repository root:
```bash
python tools/needle_bench.py --help
python tools/needle_bench.py --url http://127.0.0.1:8080 --lengths 32k,128k --depths 10,50,90 --out needles.json
```
Choose lengths your configured context can hold. The script supports `--api-key`
for an authenticated server; keep that key out of published commands. Save the
reported actual prompt lengths, misses, errors, and skipped cases as well as
successes. A needle test measures recall on those inputs, not overall model quality.
## Submit a report
1. Fork Strata and create a branch for your report.
2. Add a folder such as `bench/results/YYYY-MM-DD-community-rtx-5090/`. Use the
measurement date and a short hardware label; add a suffix if the name exists.
3. Put a `README.md` based on the template below in that folder, together with
per-run JSON or CSV and small scripts or prompts needed to repeat it. Use your
own data format and document its fields and units. Keep large model files and
generated packs out of the PR.
4. Open a pull request against `Niko1221/Strata:main`. Summarize the hardware,
model, configurations tested, and limitations. Keep a results-only submission
separate from engine changes so reviewers can assess the measurements directly.
Maintainers can review the report and decide where to include it. Adding a report
does not require changing the README's headline performance claims. For a failed
run or a suspected bug, a GitHub issue with the configuration and relevant logs
may be more useful than a benchmark PR.
## Report template
Copy this into your report's `README.md`, replace the placeholders, and remove
sections that do not apply. Use `not measured` for missing measurements; the table
contains no example performance numbers.
````markdown
# Community benchmark on GPU name
Measured on DATE by HANDLE. State what was tested and the main limitation.
## Hardware and software
- GPU and VRAM; CPU; installed RAM; storage; PCIe link if known:
- OS; driver; CUDA or ROCm:
- Strata commit; engine version; release binary or source build:
- Background workloads and any power limits:
## Model and configuration
- Model repository and revision; quantization; GGUF filenames:
- Vision encoder; custom packs or profiles:
- Context; KV type and streaming; cache; prefill; low-RAM mode:
- MTP; reasoning; sampling; calibration; experimental speed projection:
```text
Exact launch command and relevant configuration, with credentials removed.
```
## Method
Link prompts and scripts. Describe output cap, repetitions, warm-up, loading,
prompt reuse, expert-cache state, timing boundaries, and memory measurement.
## Results
| Configuration | Actual prompt tokens | Reused tokens | Generated tokens | Runs | Prompt tok/s median and range | Decode tok/s median and range | TTFT seconds median and range |
| --- | ---: | ---: | ---: | ---: | --- | --- | --- |
| Fill in measured values | | | | | | | |
Link per-run data and logs. Include total latency and memory observations when
measured, with units and timing boundaries. List failures and skipped cases.
## Correctness and limitations
Describe checks, expected answers, observed results, and untested behavior.
````
+111 -2
View File
@@ -83,7 +83,10 @@ of the vocabulary (`mtp/rt/draft_vocab.bin`). Since 0.1.27 the subset includes e
token (106,299 ids), so answers in those languages are 15-38% faster (Q2_0, RTX 5070). Its head takes ~180 MiB of
VRAM, which the expert cache leaves free for it (0.1.28). `START-HERE.bat --setup --draft-vocab en` keeps the
English/code subset from before (40,525 ids, ~110 MiB less VRAM, English answers 1-2% faster; CJK answers get
almost no drafts). `tools/draft_vocab.py` builds and inspects subsets.
almost no drafts). `--draft-vocab cyrillic` takes the English/code subset plus the whole Cyrillic script (58,963
ids): the shipped subsets hold 142 of the vocabulary's 18,580 Cyrillic tokens, so Ukrainian or Russian answers got
1.4 tokens a round; with it 2.1, and 83 -> 109 tokens/s (RTX 5090, the NVFP4 fork), English unchanged.
`tools/draft_vocab.py` builds and inspects subsets.
**Low-RAM mode (engine 0.1.26, chosen by setup):** normally all of a model's experts are copied into RAM (23-50 GB,
pinned) and the GPU holds a copy of the most-used ones. On a PC whose RAM cannot hold them beside the system (the
@@ -112,6 +115,32 @@ other ~18 GB), a 32 GB PC with a 12-16 GB GPU the Coder; IQ3_XXS on a 32 GB PC s
reads went to the file (`resident RAM: ... blob reads from the file`: 0 in steady use).
- `--low-ram resident|mmap` forces one variant (also on a PC with enough RAM, e.g. to try it).
**Low-RAM mode without `experts.bin` (engine 0.1.31):** for the native packs (IQ2_XS, IQ3_XXS, IQ3_S, the Coder, Swift,
Q2_0 packed by `tools/iq_pack.py`; not the canonical Q2_0 pack setup makes for AVX-512 CPUs) the mapped mode no longer
needs the pack's `experts.bin`: when the pack has none, the engine
maps the model's GGUF files themselves and reads each expert's gate, up and down rows from where `native_experts.txt`
says they are (the files are checked against it first: every tensor's name, type, shape, offset and bounds). That
saves the 23-50 GB copy on the disk. The answers are the same: on the Coder, 64 greedy tokens from `experts.bin` and
from the GGUF gave identical tokens and logits. An expert read from the GGUF is three reads instead of one, so the
engine fetches a layer's missing experts on 8 threads (`STRATA_FETCH_THREADS`) with one batched page request
(Windows `PrefetchVirtualMemory`). With an `experts.bin` in the pack, nothing changes. Setup does not use this yet.
**A RAM budget (engine 0.1.31, `--resident-budget-gib N`):** the resident variant for a model whose experts do not all
fit: the N GiB of experts the GPU cache does not hold that the expert profile ranks hottest are copied into RAM at
start (locked; page-locked when the driver allows the whole budget), and the rest are read from the files through the
OS file cache. It implies `--mmap-experts` and leaves 4 GB of free RAM (a larger N is clamped, with a message). With
the GGUF read in place it also warms the next layer's likely experts: while the CPU works on a layer, a thread applies
the next layer's router to this layer's input and asks the OS for the pages of the predicted experts that neither the
GPU nor the RAM budget holds (only pages - the experts computed are the same; `STRATA_LOOKAHEAD=0` turns it off). This
is what runs [Unsloth's UD-Q4_K_XL](UNSLOTH_Q4.md) (72 GiB of experts) on a 64 GB PC: 7-8.5 tokens/s at N = 40 on an
RTX 5070, against ~3 tokens/s before these changes.
**How much came from where:** with `--stats` the engine prints the tiers of the decode (`expert tiers`: blobs from the
RAM copy, blobs and MB from the files, the time spent reading them; `routing prefetch`: how many of the file reads had
been warmed). The server log has the same per request (`expert tiers: GPU ... hits ...; RAM ... blobs, files ...
blobs ... MB read`), and `GET /metrics` lists `ram_blobs`, `file_blobs` and `file_mb` for each recent request (with
engine 0.1.31 or newer).
Time to first token is prompt length / prompt speed: with Q2_0 about 4 s at 4K, 25 s at 32K, under 2 minutes at 128K
and 4.5 minutes at 262K (engine 0.1.13 made long prompts about twice as fast, below).
@@ -195,6 +224,15 @@ thought about for 1,524 tokens. Not a benchmark, but consistent with the claim.
START-HERE.bat --setup --family swift --model IQ2_XS
```
### Experimental: Unsloth's UD-Q4_K_XL
A 4-bit quantization of the same model (111 GB, 72 GiB of experts). Setup offers it from engine 0.1.32
(`--family unsloth --model UD-Q4_K_XL`: a RAM budget of your RAM less 24 GB, the rest read from the SSD); what it
does and the manual workflow are in **[docs/UNSLOTH_Q4.md](UNSLOTH_Q4.md)**. On a 64 GB PC with a 12 GB RTX 5070 it writes 7-8.5
tokens/s, most experts read from the SSD; it picks the same tokens as llama.cpp on the same file at 97.5-99% of
the positions of short greedy answers, 90-91% after a 16K prompt, differing mostly at near-ties
([measured](UNSLOTH_Q4.md#quality-against-llamacpp-on-the-same-file)).
## Before you start
You need **only an NVIDIA driver** (version 580 or newer; update it with the NVIDIA App or from
@@ -383,6 +421,16 @@ print(r.choices[0].message.content)
Without a setting the model uses its own default, **high**. `none` answers at once (fastest); `low` keeps the thinking
short. The levels are instructions the model was trained with, not a hard token limit: on easy questions all three
think briefly, on hard ones `high` thinks longest and is most accurate.
- **A hard thinking budget (opt-in).** `"reasoning_budget_tokens": N` in a request (OpenAI or Anthropic) caps the
thinking at N tokens: when it gets there the server ends it with a short wrap-up line and `</think>`, and the model
answers from there (the engine continues from what it already holds, so nothing is read again). The wrap-up is
part of the thinking the client sees and counts as output tokens. `"reasoning_budget_tokens": N` in
`strata-<model>.json` sets it for every request; a request's own value wins, and `0` means no budget. Off by default;
Anthropic's `"thinking": {"budget_tokens": N}` still only chooses the level, as above.
- **Anthropic requests that don't ask for thinking (opt-in, 0.1.32, #278).** By default a `/v1/messages` request
with no `"thinking"`, effort or budget thinks as the model's template does. `"anthropic_thinking": "on_request"` in
`strata-<model>.json` renders such a request without thinking - Anthropic's own rule, and what Claude Code's short
helper calls (a session title in a few dozen tokens) need; its real turns ask for thinking when it is on there.
- **Streaming.** With `"stream": true` everything arrives as it is made: the thinking, the answer, and tool calls
(the tool's name first, then its arguments piece by piece, like OpenAI and Anthropic do). While the model reads a
long prompt the stream sends keep-alives, so agents do not time out; the server window prints progress every
@@ -396,6 +444,9 @@ print(r.choices[0].message.content)
`max_tokens` would run past the context is refused too (400); agents that always ask for their full output cap
can instead get it shortened to the room left: add `"fit_max_tokens": true` to `strata-<model>.json` (or pass
`--fit-max-tokens` to `serve/server.py`). A prompt that leaves no room at all is still refused.
- **Model aliases** (0.1.32). `"aliases": ["qwen", "local-model"]` in `strata-<model>.json` lists the model under
those names too in `/v1/models` (each with its own `id`, and in the model's `aliases`), like llama-server's
`--alias`; a request naming one is answered under that name. Any other name is still served, as before.
- **From other devices on your network.** The server listens on your PC only (`127.0.0.1`) unless you say otherwise:
run setup with `START-HERE.bat --setup --host 0.0.0.0 --api-key some-long-secret` (or add `"host": "0.0.0.0"` and
`"api_key": "..."` to `strata-<model>.json`). The server window then prints this PC's addresses
@@ -406,7 +457,12 @@ print(r.choices[0].message.content)
- **From the internet.** Put a tunnel in front of it, for example [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/):
`cloudflared tunnel --url http://127.0.0.1:8080`. **Set a key first**, or anyone with the link can use your PC:
add `"api_key": "some-long-secret"` to `strata-<model>.json` (or set the `STRATA_API_KEY` environment variable);
clients then send it as their API key.
clients then send it as their API key. Streamed answers carry `X-Accel-Buffering: no`, so nginx-style proxies pass
each token on at once. The web app's settings and MCP tools only answer Strata's own page: when you open it through
a proxy or tunnel whose address differs, add that address, e.g. `"trusted_origins": ["https://strata.example.com"]`.
- **From web apps in a browser (CORS).** Off by default. `"cors_origins": ["https://chat.example.com"]` lets pages of
those origins call `/v1/*` from the browser (Open WebUI's direct connections, browser extensions); `["*"]` lets any
page do it - only sensible with an API key. It never opens `/settings`, `/unload` or the MCP tools.
**Conversation cache.** A request that continues a chat reads only the part after what the engine already holds: the
live session, or one of the checkpoints it keeps in RAM (up to 6, ~118 MB each, taken at the start of each new
@@ -732,3 +788,56 @@ Strata itself: [MIT](../LICENSE). The model files are not part of it; their lice
`serve/web/fonts/OFL.txt`). Its Monitor tab started from @code-martin's dashboard idea (PR #22).
- The experimental speed projection's vector (`data/experimental-speed-projection/`): Qwen Community License 1.0,
made from the model's activations (see its README).
### Start the text API without occupying the GPU
`serve/server.py --engine strata --config strata-<model>.json --lazy` (or `"lazy_load": true` in that
config) starts the lightweight HTTP API without spawning the native engine. The first generation request
loads it through the existing reload path, including `before_load` and `min_free_vram_mib`. Eager startup
remains the default. This option is text-only: a vision configuration with lazy startup is rejected explicitly.
`POST /v1/load` and `/v1/unload` are JSON control aliases for integrations, accepting `{}` or
`{"model":"<configured model>"}` and returning model status. They require the configured API key,
`application/json`, and no foreign browser Origin. They return **409** while a request is active or queued,
and **404** for an unknown model. Existing `/load` and `/unload` behavior is preserved. `/api/health` aliases
`/health`; `/v1/status` exposes `loaded` and `auto_load`. The unloaded model remains discoverable.
Unloading and shutdown close the native engine's stdin after sending `QUIT`, allowing Windows' detached
stdin reader to see EOF. Cleanup waits for process exit before releasing handles; if forced shutdown still
times out, the server keeps ownership and reports an error rather than claiming the model was unloaded.
### JSON response formats
`POST /v1/chat/completions` accepts `response_format: {"type":"json_object"}` or
`{"type":"json_schema","json_schema":{"name":"answer","strict":true,"schema":{"type":"object","properties":{"answer":{"type":"integer"}},"required":["answer"],"additionalProperties":false}}}`.
The schema must describe an object at its root. Local `#` references work; remote references are refused.
`json_schema` is checked with the Python package `jsonschema` when it is installed (`python -m pip install
"jsonschema>=4.23,<5"`; setup does not add it); without it the answer is only checked to be one JSON object, and the
server says so once.
This is **schema prompting followed by server validation**, not grammar-constrained decoding. One generation
is made per request, with no hidden retry. Successful responses contain a validated JSON object. Malformed JSON,
duplicate keys, non-finite numbers, schema violations and incomplete generations return **502** with
`error.code: structured_output_failed`; invalid request schemas return **400**. JSON formats combined with
tools/MCP are refused explicitly. Without `response_format`, ordinary text and tool behavior stays the same.
Structured SSE buffers the answer while sending keep-alive comments. It emits content only after validation,
then usage/timings and `[DONE]`; failures emit an SSE error and `[DONE]` without invalid content deltas.
`/v1/status.structured_output` advertises the formats, validation method and buffered streaming behavior.
### API request monitor
Off by default, since it keeps prompts and answers in memory: turn it on with `"api_monitor": true` in
`strata-<model>.json` (or `serve/server.py --api-monitor`); otherwise nothing is recorded and the two endpoints below
answer 404.
Open `/api-monitor` to inspect API traffic without opening a chat. It shows the model state, safe
load/unload controls, active/queued requests, original request bodies, output, separate reasoning and
non-stream response bodies. Total wall-clock includes FIFO waits and automatic loading; load, queue,
first-token, prompt/output tokens and engine decode timing are shown separately.
`GET /api/requests` returns compact summaries; `GET /api/requests?id=<id>` returns one retained request.
Both use the existing API-key check. The monitor retains the newest **100 requests in memory** until restart,
with **262,144 characters per input/output/reasoning/response field** and visible truncation flags. The actual API
responses are unaffected. Headers are not recorded, and the monitor key is kept in this tab's session storage.
Treat request history as sensitive input/output when exposing Strata on a network: set an API key as above.
The page uses relative URLs and works through the existing host binding or a reverse proxy.
+21 -4
View File
@@ -44,8 +44,8 @@ now on; the answer is kept.
- a card older than the RTX 20 series (compute capability below 7.5: GTX 10 and older);
- a card with less than 8 GB of VRAM, together with others (each card holds a copy of the dense weights and its
own prompt buffers);
- AMD and Intel GPUs, and a mix of NVIDIA with them. (Two AMD RDNA4 cards run the split from a hand-written
config; see [AMD_HIP.md](AMD_HIP.md#rdna4-gfx1201).)
- Intel GPUs, and a mix of NVIDIA and AMD cards. (AMD cards share a model among themselves: `./setup.sh --backend
hip --gpus 1,0`, see [AMD_HIP.md](AMD_HIP.md).)
Or edit an existing config (`strata-*.json`), then restart:
@@ -54,6 +54,21 @@ Or edit an existing config (`strata-*.json`), then restart:
"layer_split": "auto"
```
**Skip the split when the first card holds everything** (opt-in, 0.1.31): `"split_skip_if_fits": true` in the config
(engine flag `--split-skip-if-fits`, with `--layer-split auto`) runs on the first card alone when it holds every
profiled expert plus the context's KV, the draft layer and the reserve, and says so in the log; otherwise the split
stays. On an R9700 32 GB + RX 9070 XT the R9700 holds all of the Coder's experts: with the flag 4K prompts read at
1,776 tok/s instead of 1,244 (split) and decode runs at ~60 tok/s instead of ~51 (16K prompts ~5% slower than split).
**Short prompts on a split (0.1.32, #340).** 0.1.30 gave each card's prompt path a loan from its own expert cache,
refilled after every request; on cards that hold nearly all their experts that cost short prompts up to a third of
their speed. 0.1.32 refills all cards at once, uses a smaller streaming ring on a split, and lets a card with free
VRAM keep its own prompt buffers - the same output as 0.1.31, measured on an R9700 + RX 9070 XT: 2K prompts 993 ->
1,265 tok/s, 16K 1,852 -> 1,950, decode unchanged. `STRATA_SPLIT_OWN=1` (opt-in) gives every card its own buffers:
2K 1,450 and 16K 2,227 tok/s there, but a full card then keeps a different set of experts resident, so the output
differs from the default's (stable and coherent); `STRATA_SPLIT_OWN=auto` does that only where the buffers are at
most 12% of each card's VRAM.
The engine flags behind it: `--layer-split K1[,K2..]|auto` and `--split-device D1[,D2..]` (the later stages'
devices; default the next visible ones). `--layer-split K --split-device 0` runs both stages on one card sharing
everything - the bit-exact check of the hand-off, not a speed mode.
@@ -95,8 +110,10 @@ into the card that owns the layer.
- The prompt path has its own buffers on every card (1.5 GB each at the default 2048-token chunk; `--prefill 1024`
halves that) instead of borrowing cache slots as one card does. An explicit `--expert-cache` on the first card is
capped to leave room for them.
- On Windows only 8 GiB of the expert arena is pinned (more, mapped into two GPU contexts, leaves WDDM refusing
allocations); the PCIe share covers those layers.
- Under WDDM (Windows, and WSL2) only 8 GiB of the expert arena is pinned (more, mapped into two GPU contexts,
leaves WDDM refusing allocations); the rest streams through the pinned staging ring. A Linux driver has no such
limit, so there the whole arena is pinned (since 0.1.31; the cap cost a 4090 + 3060 split two thirds of its
prompt speed, #253). `STRATA_ARENA_PIN_GIB=N` pins at most N GiB, `0` the whole arena, on any OS.
- Every card needs compute capability 7.5 (RTX 20 or newer). The pre-sm_80 QSA scorer path is fp32 FMAs, so a
Turing card runs the same kernels instead of the tensor-core prompt attention.
+36
View File
@@ -0,0 +1,36 @@
# OrcaRouter Uncensored Q4_K_S (manual setup)
This path uses the three original `orcarouter/Qwen3.8-Flash-Next-Uncensored-GGUF` Q4_K_S shards without rewriting their expert, embedding or PLE table bytes. It is separate from the installer model menu. Keep all three shard filenames together.
The ordinary GGUF quantizes some small projections which Strata reads as BF16. `--compat-bf16` dequantizes and rounds those projections to BF16 in the separate pack; it does not restore their original precision. The Q5_0 PLE table remains in the source GGUF and currently uses the mapped reader (`--ple-io mmap`). The Q4_K gate/up experts and Q5_0/Q5_1 down experts remain in GGUF form, including layers whose three tensors cross shard boundaries (each role is read from its own shard). The GPU expert kernels take Q4_K with Q5_1 (or Q8_0) downs; Q5_0 downs are not among them yet, and the engine refuses to start on a pack with such a layer (it names the layer).
## Build and prepare
Build Strata with CUDA, native experts, `STRATA_ORCA_Q4KS_MMQ=ON` (and `STRATA_BUILD_TESTS=ON` for the two parity programs below). This opt-in compiles the Q5_0 GGML MMQ instance for CUDA or HIP (the Q4_K and Q5_1 instances come with the engine's K-quant MMQ build on CUDA); the usual Q8_0 draft-layer instance remains in both builds. HIP also needs `STRATA_PREFILL_MMQ=ON`. Select your card's compute capability, for example `89` on an L40S. On Windows with Ninja and CUDA 12.6, use the Visual Studio developer environment and `-DCMAKE_CUDA_RUNTIME_LIBRARY=Shared` to keep the CUDA runtime linkage consistent. The default pinned ggml checkout is supported by the project build.
```sh
cmake -S . -B build -G Ninja -DSTRATA_ENABLE_CUDA=ON -DSTRATA_NATIVE_EXPERTS=ON -DSTRATA_ORCA_Q4KS_MMQ=ON -DCMAKE_CUDA_ARCHITECTURES=89 -DCMAKE_CUDA_RUNTIME_LIBRARY=Shared -DCMAKE_BUILD_TYPE=Release
cmake --build build --target strata native_expert_parity ple_q5_parity
python tools/iq_pack.py --gguf /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00001-of-00003.gguf --out packs/orca-q4_k_s --compat-bf16
```
`iq_pack.py` needs NumPy and the `gguf-py` module from the pinned llama.cpp dependency (`STRATA_GGUF_PY` can point to that directory). It writes a roughly 1.43 GiB dense pack and a native-expert manifest. The original 112 GB of model shards are read in place; `experts.bin` is optional and is not written by this command.
Check the changed kernels against the real files before starting the service:
```sh
build/native_expert_parity /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00001-of-00003.gguf /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00002-of-00003.gguf /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00003-of-00003.gguf 0 5 6 20 47
build/ple_q5_parity /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00001-of-00003.gguf
```
## Engine flags
Pass the same first shard to `--native` and `--ple-gguf`; Strata discovers the other two shards by name. For a first text-only run, use 32K context and a modest cache. Once that passes, increase the context and cache with memory measurements on the target machine.
```sh
--pack packs/orca-q4_k_s --native /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00001-of-00003.gguf --ple-gguf /models/Qwen3.8-Flash-Next-Uncensored-Q4_K_S-00001-of-00003.gguf --ple-io mmap --expert-profile data/expert-profile.bin --expert-cache auto --prefill 512 --spec 4 --mtp /path/to/mtp/rt --max-context 32768 --kv int8
```
For two GPUs in persistent server mode, add `--layer-split auto --split-device 1` (with CUDA0 and CUDA1 visible). The usual Strata MTP runtime is built from the original model's draft layer; draft acceptance on the Uncensored fine-tune must be measured. Keep this model's own tokenizer from the pack. Do not combine `--expert-cache-per-layer` with a variable-size native cache: that policy's slot ordering is independent of the pack's per-layer blob sizes.
This port does not claim that Q4_K_S beats llama.cpp on a given computer. Compare the same model bytes, prompt, context, output length and GPU load; report prefill and decode separately.
+3 -2
View File
@@ -34,8 +34,9 @@ compute capacity.
The experiment requires the corresponding visible CUDA devices and a CUDA
enabled build. Each card must keep at least 512 MiB free. Tiers must be enabled
in order. On Windows, CUDA registration of the host expert arena is capped at
8 GiB to leave room for the contexts and MTP on CUDA0. The rest remains
in order. Under WDDM (Windows, WSL2), CUDA registration of the host expert arena is capped at
8 GiB to leave room for the contexts and MTP on CUDA0 (`STRATA_ARENA_PIN_GIB` overrides it; on Linux the whole
arena is registered). The rest remains
available to the CPU pool; the PCIe expert path is available only for the
registered layers. Without secondary GPUs, the original uncapped registration
behavior applies.
+232
View File
@@ -0,0 +1,232 @@
# Unsloth UD-Q4_K_XL (experimental)
**Experimental.** Setup offers it from engine 0.1.32 ([below](#setup)); the manual workflow after that section works
with engine 0.1.31 or newer. Validated on one PC: Windows 10, an RTX 5070 (12 GB), 64 GB of RAM and an AVX-512 CPU,
on 2026-10-01.
The target is Unsloth's 4-bit quantization of the same model the other packs use:
[unsloth/Qwen3.8-Flash-Next-GGUF, `UD-Q4_K_XL`, revision `38bb39e`](https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/tree/38bb39ee97821de2c9009abb7e93950eec396e66/UD-Q4_K_XL).
"UD-Q4_K_XL" is a mix of formats, not Q4_K everywhere: the routed experts are Q4_K (Q5_K in layer 2) for gate/up and
Q5_1 (Q8_0 in layers 2, 4, 30, 46, 47) for down; the token embedding, the output head, the attention and shared-expert
projections and the PLE key are Q8_0; the 28.8 GB PLE table is IQ4_NL. The routed experts are 71.7 GiB, about twice
the 3-bit models'.
## Setup
`START-HERE.bat --setup` (Linux: `./setup.sh --setup`) and choose **Qwen3.8-Flash-Next (Unsloth)**, marked
`[experimental]`; or directly:
```sh
START-HERE.bat --setup --family unsloth --model UD-Q4_K_XL
```
What setup does differently for this model:
- It needs 48 GB of RAM or more and engine 0.1.32 or newer (checked before anything is downloaded), and an NVIDIA
GPU. One GPU only: with `--gpus` it uses the first one and says so. No images (the vision encoder is not wired to
this file yet) and no experimental speed projection (not tested with it).
- It downloads the four shards below from the pinned revision `38bb39e` (resumable, like the other models), then
checks each one's size and SHA-256 against the table below; the check takes a few minutes once and is remembered
in the file's finish mark. A file with the wrong hash is deleted, so the next run downloads it again.
- It packs with `--compat-bf16` and never writes `experts.bin` (`--low-ram` does not apply).
- The RAM budget is the PC's RAM less 24 GB: `--resident-budget-gib 40` on 64 GB, at most all 71 GiB of experts on
96 GB or more. From a 64K context up, where the KV cache moves to RAM, its size comes out of the budget.
- It recommends an 8K context on a GPU under 14 GB (every GB of KV cache is a GB less of cached experts).
## The files
Four shards, 111,334,654,784 bytes (111.3 GB) together. Shard 1 holds only the metadata; layer 11's down projection is
in shard 2 and its gate/up in shard 3, which this engine handles (`native_experts.txt` v4).
| File | Bytes | SHA-256 |
| --- | --- | --- |
| `Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf` | 10,946,624 | `4448186216b3af4cc558bbce2c3213f01608f8f8b2e5267a9767971dd3ec8082` |
| `Qwen3.8-Flash-Next-UD-Q4_K_XL-00002-of-00004.gguf` | 49,859,583,136 | `3f342f1c1580473f1ee94ddd5b28206e8c07a70fa1a366f59d1d6c922919a6c9` |
| `Qwen3.8-Flash-Next-UD-Q4_K_XL-00003-of-00004.gguf` | 49,376,141,504 | `56758f40269cad5cd9b0d3d6fbae0f40f6d5be6de49e4ab392dbe83157d9cbd3` |
| `Qwen3.8-Flash-Next-UD-Q4_K_XL-00004-of-00004.gguf` | 12,087,983,520 | `753bda48b98ba4f1636134a90a967de1b2d3908a236c026e464777342e53510a` |
Keep the four files together in one folder under these names (the engine finds shards 2-4 from shard 1's name; a
missing shard is an error that names it). Setup checks them itself; by hand, check them before packing
(`sha256sum -c`, or `Get-FileHash` on Windows).
Hugging Face snapshot symlinks work if you pass the snapshot's file name, not the hash-named blob it points to.
## What it needs
| | |
| --- | --- |
| Disk | 111.3 GB for the four files, 1.4 GB for the pack, ~6 GB for the MTP draft layer if you have none yet. **No `experts.bin`**: the engine reads the experts from the GGUF files in place. An NVMe SSD matters: the experts that fit neither VRAM nor the RAM budget are read from it for every token. |
| RAM | 64 GB measured. The RAM budget (below) holds the most-used experts; the rest come from the SSD through the OS file cache. |
| GPU | 12 GB measured (RTX 5070): after the weights, the draft layer and the buffers, the expert cache held 1,280 of the 24,576 experts (3.7 GiB) at 4K context. |
## The pack (by hand)
Build Strata (or install 0.1.31+), then, from the repository root, with gguf-py from the pinned llama.cpp
(setup installs it; `STRATA_GGUF_PY` can point to its `gguf-py` folder):
```sh
.venv/bin/python tools/iq_pack.py \
--gguf /path/to/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf \
--out packs/ud-q4_k_xl --compat-bf16
```
About 30 seconds. It writes `index.txt`, `dense.bin` (1.4 GB), `native_experts.txt`, the tokenizer, `conversions.json`
and `compat-bf16.json`. **`--compat-bf16` is required**: this file stores 195 small projections (the hyper-connection
up/down matrices, `output_hc_*` and the PLE value) as Q8_0, while the engine reads them as BF16. Without the flag the
packer refuses and writes nothing; with it, they are dequantized and rounded to BF16 (nearest-even). Do not add
`--experts-bin`: it would write a 77 GB copy of the experts that this mode does not need.
## The numbers: what is native and what is converted
The routed experts, the token embedding, the output head, the attention and shared-expert projections, the PLE key and
the PLE table are used as the GGUF stores them (the engine has GPU kernels and CPU (ggml) paths for Q4_K, Q5_K, Q5_1 and
Q8_0). The small tensors the engine reads as floats are converted, and `conversions.json` lists every one with its
source/destination type, method, whether it is exact, the largest absolute error and the source bytes' SHA-256:
264 F32 tensors (routers, injections, SSM gates) whose values are already BF16's are stored as BF16 exactly; the 195
Q8_0 projections above are rounded to BF16 (largest absolute error 0.0144, in `hc_ffn_up`); the PLE convolution (F32)
is narrowed to F16 when the engine loads it (largest error 3e-8). That is the compatibility Unsloth's file needs; it is
not the original BF16 checkpoint. The output matches llama.cpp's on the same file:
[Quality](#quality-against-llamacpp-on-the-same-file).
## The MTP draft layer
The draft layer is the base model's, the same one the other packs use. If setup installed Strata, you have it
(`mtp/rt` in `Strata-data`). Otherwise build it as [docs/ORCA.md](ORCA.md#preparation) shows (`tools/mtp_fetch.py`,
`tools/mtp_pack.py`, `tools/mtp_rt.py`, then copy `data/draft_vocab.bin` to `mtp/rt/`).
## The server
Save as `strata-ud-q4_k_xl.json` at the repository root (or next to setup's other `strata-*.json`), with `/path/to/`
pointing at **shard 1**. `--ple-gguf` is not needed: the engine finds the shard that holds the PLE table
(`per_layer_token_embd.weight`, shard 2) by name. `--resident-budget-gib` turns on the mapped mode with a RAM budget
(it implies `--mmap-experts`).
```json
{
"exe": "engine/strata.exe",
"args": [
"--pack", "packs/ud-q4_k_xl",
"--native", "/path/to/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf",
"--resident-budget-gib", "40",
"--expert-profile", "data/expert-profile.bin", "--expert-cache", "auto",
"--prefill", "auto", "--spec", "4", "--spec-min-p", "0.5",
"--mtp", "mtp/rt", "--max-context", "8192"
],
"cwd": ".",
"tokenizer": "packs/ud-q4_k_xl/tokenizer",
"model_name": "qwen3.8-flash-next-ud-q4_k_xl",
"log": "strata-ud-q4_k_xl.log",
"host": "127.0.0.1",
"port": 8080
}
```
```sh
.venv/bin/python -m serve.server --engine strata --config strata-ud-q4_k_xl.json --port 8080
```
(`engine/strata.exe` is setup's engine on Windows; a self-built one is `build/strata`.) The expert profile is the base
model's (`data/expert-profile.bin`); it ranks the same 48 x 512 experts and decides which ones the GPU cache and the RAM
budget take first.
**Choosing the RAM budget N:** your RAM minus 20-24 GB (the OS, the engine itself, the 126 MB router copy, and room for
the OS file cache that serves the rest). On 64 GB, 40. The engine clamps a budget larger than the RAM it finds free
(minus 4 GB) and says so. Everything above N comes from the SSD for every token, so N is the setting that matters
most; a bigger budget was faster in every measurement (24 / 32 / 40 GiB). When the driver page-locks the whole budget
(24 GiB did on this PC, 32 and 40 did not), the GPU also computes a share of the misses over PCIe, as in the resident
low-RAM mode; `STRATA_RESIDENT_PIN=0` keeps the budget locked only (the CPU then computes every miss).
**Context:** measured at 4K. The KV cache takes VRAM from the expert cache, so a longer context makes decoding slower;
8K is a reasonable start on 12 GB. `--kv int8` halves the KV cache's VRAM.
## What to expect (RTX 5070 12 GB, 64 GB RAM, Windows, one short greedy prompt)
| RAM budget | Greedy output | Notes |
| --- | --- | --- |
| 24 GiB | 5.1-5.2 tok/s (2 runs, before the routing prefetch below) | 2.2 GB read from the SSD per verify round (~3.5 tokens) |
| 40 GiB | **7-8.5 tok/s** (6 runs: 6.7-8.6, mean 7.9) | 1.1 GB read from the SSD per verify round, ~0.33 GB per token |
- The first answer comes about 60 s after the engine starts (mostly loading: the RAM budget is copied from the GGUF
files at start). A 30-token prompt then took 5-6 s.
- Long prompts (engine 0.1.32): a 16K prompt is read at **160 tokens/s** (15,873 tokens in 99 s; 0.1.31: 57 tokens/s,
273-282 s). Reading a prompt streams every expert once per 4K chunk, and the third of them outside the RAM budget
come from the SSD (~35 GB per chunk), so the prompt path now reads them with 32 threads and up to 128 blobs in
flight when the experts are read from the GGUF in place (`STRATA_STAGER_THREADS` / `STRATA_STAGER_RING` override
it; 4 and 16 before, still the default for every other model). Between the chunks, the 28.8 GB PLE table's rows
take ~5 s per chunk.
- An engine compiled with `-DSTRATA_MMQ_KQUANTS=ON` multiplies the Q4_K / Q5_K / Q5_1 experts of a prompt with
llama.cpp's MMQ kernels (as the other models' formats always are) instead of dequantizing them to FP16: 4x less GPU
time for those products, but on this PC the prompt waits for the SSD either way (29 s per 4K chunk with or
without). Off in the released engine: it loads every kernel at start, and these took 1-3 expert slots of VRAM from
every model.
- The speed varies from run to run (6.7-8.6 tok/s at 40 GiB for the same prompt), with what the OS file cache holds.
- For comparison, IQ3_S (all its experts in RAM) writes ~53 tok/s on the same PC ([the speed tables](DETAILS.md#speed-measured)).
- Where the time goes (`--stats` on the command line): at 40 GiB about 550-750 ms of each verify round (3.5 tokens) is
reading experts from the SSD, ~75 ms the CPU's expert kernels, ~13 ms the GPU.
## Quality: against llama.cpp on the same file
Strata and llama.cpp (the pinned commit `3cf0325`, a CPU build reading the GGUF memory-mapped) were given the same
token sequences, and at every position each wrote its 20 most likely next tokens with their log-probabilities: Strata
through its verify windows (`STRATA_LOGPOS` with `STRATA_LOGPOS_TOPK=20`), llama.cpp from `llama_get_logits_ith` over
one batch. Strata ran with the recommended settings (RAM budget 40 GiB, the MTP draft layer on, greedy,
`--adapt-every 100000` so the expert cache does not move during the run). Per position: whether the most likely token is the same (argmax
agreement), how many of the 5 / 10 most likely tokens both have, the KL divergence (llama.cpp's distribution against
Strata's, over llama.cpp's top 20 plus one bucket for the rest), and the perplexity of the sequence under each.
| Token set | Positions | Argmax agreement | Top-5 / top-10 overlap | KL | Perplexity Strata / llama.cpp |
| --- | ---: | ---: | ---: | ---: | ---: |
| Code: Strata's greedy answer to a coding prompt (an LRU cache in Python, 56-token prompt) | 400 | **99.0%** | 95.6% / 95.3% | 0.0008 | 1.067 / 1.070 |
| Thinking: Strata's greedy answer to a reasoning puzzle (with thinking, 55-token prompt) | 324 | **97.5%** | 96.2% / 96.4% | 0.0016 | 1.107 / 1.106 |
| After a 16K prompt: Strata's greedy continuation (256 tokens) of the 16,384 real-text tokens below | 256 | 90.2% | 88.1% / 89.3% | 0.039 | 1.619 / 1.623 |
| Real text after a 16K prompt: the last 510 tokens of 16,384 tokens of this repository's docs and code | 510 | 91.2% | 88.3% / 89.9% | 0.035 | 4.27 / 4.29 |
| The same 511 positions with only 512 tokens before them | 511 | 89.2% | 86.0% / 86.3% | 0.061 | 8.99 / 8.87 |
For comparison, [eddoursul/Strata](https://github.com/eddoursul/Strata) reported 98.2-99.3% (code), 95.6-95.8%
(thinking) and 97.7% (after a 16K prompt) for the same file against llama.cpp on an RTX 3090.
**Where they differ:** at near-ties. Grouped by llama.cpp's own gap between its two most likely tokens, Strata picks
the same token at every position of the code and thinking answers where that gap is 0.2 or more (695 of 695) and at
every position after the 16K prompt where it is 0.5 or more (144 of 144 in the continuation, 254 of 254 in the real
text; 50 of 54 and 117 of 121 between 0.2 and 0.5). Text after a long document has many more near-ties than a short
answer (58 of the continuation's 256 positions and 135 of the real text's 510 have a gap under 0.2, against 13 of the
code answer's 400), which is why its agreement is lower. It is not the long context itself: the same real-text
positions after only 512 tokens agree a little less (89.2%), and the perplexities match within 3% in every set. For
scale, Strata's own greedy run and its teacher-forced rerun of the continuation pick different tokens at 6% of the
positions (93.8% the same: other window sizes, other experts in VRAM), the same kind of near-tie flips. The 16K
prompts were read by Strata's batched prompt path (15,872 tokens), the rest through the verify windows. These numbers
are the FP16 prompt path's (the released engine's); with the MMQ prompt path (`-DSTRATA_MMQ_KQUANTS=ON`, above) the
continuation after the 16K prompt agrees at 92.2% (KL 0.029, three runs, identical).
To repeat it: Strata's side is `STRATA_LOGPOS=<file>` with `STRATA_LOGPOS_TOPK=20` (engine 0.1.32) on a serve
engine with `--short-read` covering the positions to compare; llama.cpp's side was a short program over
`llama_decode` / `llama_get_logits_ith` writing the same top 20 per position.
## Opt-ins and switches (environment variables)
| | |
| --- | --- |
| `STRATA_LOOKAHEAD=0` | Turns off the routing-aware prefetch (on by default in this mode): while the CPU works on a layer, a thread applies the next layer's router to this layer's input and asks the OS to read the predicted experts' pages. Pages only, the answers are the same. About half of the SSD reads were predicted; mean +14% (6.9 -> 7.9 tok/s). `STRATA_LOOKAHEAD_K` sets the experts per token (default 10). |
| `STRATA_KQ256=1` | Multi-token AVX2 kernels for the Q4_K / Q5_1 / Q8_0 experts. Bit-exact with ggml's, but measured no faster, so off. |
| `STRATA_PARTIAL_PIN=1` | Registers the hottest part of the RAM budget (up to `STRATA_PARTIAL_PIN_GIB`, default 24) with the GPU driver, so the GPU computes a share of the misses over PCIe (`--pcie-frac`). Measured no faster on this PC, and it changes the numerics of those experts (GPU kernels instead of the CPU's), so off. |
| `STRATA_FETCH_THREADS=N` | Threads that read the experts from the GGUF while it answers (default 8; 16 was no faster). The prompt path has its own: `STRATA_STAGER_THREADS` (default 32 here) and `STRATA_STAGER_RING` (128). |
## Scope and validation
- Only UD-Q4_K_XL at revision `38bb39e` is targeted. Other Unsloth quantizations use formats this engine may not
have kernels for; the engine checks every layer's formats at start and refuses an unsupported one by name.
- Tests: the packer's synthetic 4-shard and conversion tests (`.venv/bin/python -m unittest discover -s tools -p
test_iq_pack.py`); CTests `gguf_split_test`, `expert_layout_test`, `native_expert_parity_*` (the three real expert
format pairs against ggml-cpu, the Q5_1 min term, Q8_0 rows), `prefill_mmq_kquant_test` (with `-DSTRATA_MMQ_KQUANTS=ON`: the
prompt path's MMQ products for Q4_K / Q5_K / Q5_1 / Q8_0 against ggml's dequantized weights); the in-place mode against `experts.bin` on the Coder
(identical tokens and logits).
- Real runs: greedy answers to a coding prompt (correct) at every budget and setting above, identical across them;
the same tokens as llama.cpp at 97.5-99% of the positions of short greedy answers and 90-91% after a 16K prompt,
differing mostly at near-ties (above). Not yet: sampled decoding, long conversations. Please report what you see.
## Credits
The split-artifact loader, the expert formats' GPU kernels and the packing of Unsloth's files follow
[eddoursul/Strata](https://github.com/eddoursul/Strata) (PR #245), which ran these files first. The Q8_0 kernels, the
per-role shard column and the PLE convolution's F32 -> F16 fix come from @gopinath87607's PR #255; per-role shard names
were also proposed by @jagsan-cyber in PR #247. The quantization is [Unsloth](https://huggingface.co/unsloth)'s; the
model is Qwen's ([license](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)).
+110
View File
@@ -23,6 +23,8 @@
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <limits>
#include <memory>
#include <string>
#include <vector>
#include <map>
@@ -30,6 +32,8 @@
#include <stdexcept>
#include <algorithm>
#include "strata/artifact/gguf_split.hpp"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#ifndef NOMINMAX
@@ -92,6 +96,8 @@ inline const char* ggml_type_name(uint32_t t) {
return "IQ2_S";
case 23:
return "IQ4_XS";
case 24:
return "I8";
case 30:
return "BF16";
case 34:
@@ -200,6 +206,10 @@ inline bool block_geometry(uint32_t t, int& elems, int& bytes) {
elems = 256;
bytes = 56;
return true;
case 24: // I8: raw bytes (the FP8 PLE table of tools/ple_fp8_pack.py)
elems = 1;
bytes = 1;
return true;
case 42:
elems = 64;
bytes = 18;
@@ -342,6 +352,8 @@ public:
uint32_t version() const { return version_; }
uint64_t data_start() const { return data_start_; }
uint64_t file_size() const { return size_; }
uint64_t alignment() const { return alignment_; }
const std::string& path() const { return path_; }
const TensorInfo* find(const std::string& name) const {
for (const auto& t : tensors_)
@@ -460,6 +472,104 @@ private:
std::map<std::string, MetaValue> meta_;
};
// Bytes of a tensor's payload from its shape and block geometry; 0 when the type is unknown, a row is not whole
// blocks, or the count overflows.
inline uint64_t tensor_payload_bytes(const TensorInfo& t) {
int be = 0, bb = 0;
if (t.shape.empty() || !block_geometry(t.type, be, bb) || t.shape[0] % (uint64_t) be) return 0;
uint64_t elements = 1;
for (uint64_t d : t.shape) {
if (d == 0 || elements > (std::numeric_limits<uint64_t>::max)() / d) return 0;
elements *= d;
}
const uint64_t blocks = elements / (uint64_t) be;
if (blocks > (std::numeric_limits<uint64_t>::max)() / (uint64_t) bb) return 0;
return blocks * (uint64_t) bb;
}
// The shards of one model (strata::gguf_split_paths), opened together; tensors are looked up across all of them.
// From eddoursul/Strata 8029fa9, with the split-key validation of #255 (gopinath87607) made a property of the
// model rather than of one loader: a split GGUF carries the model's metadata (general.architecture and the
// qwen4exp keys) in its FIRST shard only, and the later shards just declare split.count / split.no /
// split.tensors.count. Unsloth's UD-Q4_K_XL is the extreme case: shard 1 holds the metadata and no tensor at
// all, and output.weight, token_embd.weight and the PLE table live in shard 2. So the architecture is checked
// on `meta()` and a tensor is read from the shard that holds it.
//
// Refused at construction: a later shard whose split keys disagree with shard 1's (another model's shard, or a
// shard renamed into the family), a split model whose tensor directories do not add up to split.tensors.count,
// and a tensor name present in two shards (GGUF has no index to say which one is meant).
class GgufModel {
public:
explicit GgufModel(const std::vector<std::string>& paths) {
if (paths.empty()) throw std::runtime_error("GGUF: a model needs at least one shard");
for (const auto& p : paths) shards_.push_back(std::make_unique<GgufFile>(p));
validate_split();
for (size_t i = 0; i < shards_.size(); ++i)
for (const auto& t : shards_[i]->tensors()) {
const auto ins = index_.emplace(t.name, std::make_pair(i, &t));
if (!ins.second)
throw std::runtime_error("GGUF: tensor " + t.name + " is in two shards (" +
shards_[ins.first->second.first]->path() + " and " +
shards_[i]->path() + ")");
}
}
/// Opens every shard of the model that `any_shard` belongs to (throws when one is missing).
static GgufModel open(const std::string& any_shard) { return GgufModel(gguf_split_paths(any_shard)); }
size_t size() const { return shards_.size(); }
const GgufFile& shard(size_t i) const { return *shards_[i]; }
/// The metadata shard: general.architecture and the model's keys.
const GgufFile& meta() const { return *shards_[0]; }
/// The tensor named `name` (its shard index in `*shard`), or nullptr.
const TensorInfo* find(const std::string& name, size_t* shard = nullptr) const {
const auto it = index_.find(name);
if (it == index_.end()) return nullptr;
if (shard) *shard = it->second.first;
return it->second.second;
}
/// Whether `t` (a tensor of shard `s`) has a known byte count that lies inside its file.
bool in_bounds(const TensorInfo& t, size_t s) const {
const GgufFile& g = *shards_[s];
const uint64_t bytes = tensor_payload_bytes(t);
const uint64_t payload = g.file_size() - g.data_start();
return bytes != 0 && t.offset <= payload && bytes <= payload - t.offset;
}
private:
void validate_split() const {
const size_t n = shards_.size();
const MetaValue* count0 = shards_[0]->get("split.count");
if (n == 1) {
if (count0 && count0->u > 1)
throw std::runtime_error("GGUF: " + shards_[0]->path() + " is shard 1 of " + std::to_string(count0->u) +
", but it was opened as a whole model");
return;
}
if (!shards_[0]->get("general.architecture"))
throw std::runtime_error("GGUF: " + shards_[0]->path() + " has no general.architecture; the first shard "
"of a split model carries the metadata");
const MetaValue* total = shards_[0]->get("split.tensors.count");
uint64_t tensors = 0;
for (size_t i = 0; i < n; ++i) {
const GgufFile& g = *shards_[i];
const MetaValue* count = g.get("split.count");
const MetaValue* no = g.get("split.no");
const MetaValue* tc = g.get("split.tensors.count");
if (!count || !no || count->u != n || no->u != i || (total && (!tc || tc->u != total->u)))
throw std::runtime_error("GGUF: " + g.path() + " does not declare itself shard " + std::to_string(i + 1) +
" of " + std::to_string(n) + " of this model (split.count / split.no / "
"split.tensors.count)");
tensors += g.tensors().size();
}
if (total && tensors != total->u)
throw std::runtime_error("GGUF: the " + std::to_string(n) + " shards hold " + std::to_string(tensors) +
" tensors, but split.tensors.count is " + std::to_string(total->u));
}
std::vector<std::unique_ptr<GgufFile>> shards_;
std::map<std::string, std::pair<size_t, const TensorInfo*>> index_;
};
// ---- architecture guard (P1.S2). The engine is specialised to ONE model; anything else must be
// refused with a precise error rather than silently mis-run.
struct Qwen4ExpGuard {
+52
View File
@@ -0,0 +1,52 @@
// include/strata/artifact/gguf_split.hpp - the shards of a split model. Separate from gguf_reader.hpp, which
// includes <windows.h>, so any translation unit can resolve a model's shards.
//
// From eddoursul/Strata 8029fa9 (gguf_split_paths), with one change of contract: upstream's model_shards()
// skipped a shard it could not open and returned the rest, so a download that was still running (or a shard
// deleted by hand) produced a model with some layers missing and an error much later, or none. A missing shard
// is now an error that names it.
#pragma once
#include <cstdio>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace strata {
// Split models: `<name>-00001-of-0000N.gguf` ... `<name>-0000N-of-0000N.gguf`, as llama.cpp's gguf-split names
// them. Given ANY shard's path, the shards in split order (the metadata shard, 00001, first); a file without that
// suffix is a model of one shard. Only the five digits of the shard number are rewritten, so the directory and
// the stem are the caller's own spelling (a symlinked Hugging Face snapshot keeps its split names). Throws when
// a shard is missing.
inline std::vector<std::string> gguf_split_paths(const std::string& any) {
static const char tag[] = "-of-";
const size_t at = any.rfind(tag);
// "...-NNNNN-of-MMMMM.gguf": five digits before the tag, five after it, then the extension
if (at == std::string::npos || at < 6 || any[at - 6] != '-' || any.size() != at + 4 + 5 + 5 ||
any.compare(at + 9, 5, ".gguf") != 0)
return {any};
int no = 0, n = 0;
for (size_t i = 0; i < 5; ++i) {
const char a = any[at - 5 + i], b = any[at + 4 + i];
if (a < '0' || a > '9' || b < '0' || b > '9') return {any};
no = no * 10 + (a - '0');
n = n * 10 + (b - '0');
}
if (n < 1 || no < 1 || no > n) return {any};
std::vector<std::string> out;
for (int i = 1; i <= n; ++i) {
char num[8];
std::snprintf(num, sizeof num, "%05d", i);
std::string p = any;
p.replace(at - 5, 5, num);
if (!std::ifstream(p, std::ios::binary))
throw std::runtime_error("missing model shard " + p + " (shard " + std::to_string(i) + " of " +
std::to_string(n) + "; is the download complete?)");
out.push_back(std::move(p));
}
return out;
}
} // namespace strata
+37 -1
View File
@@ -164,8 +164,44 @@ public:
return true;
}
// #342: drop the parked entries an outgoing conversation (its live tokens and checkpoint chain) supersedes:
// the same conversation a turn back, whose DEEPEST checkpoint the outgoing chain still holds, so all it adds
// is the tail the client rewrote (the reply as it was generated, before the next request re-rendered it) and
// checkpoints older than that one. A subagent's successive turns parked one such copy each, and make_room's
// oldest-first eviction then pushed the parent conversation out after `slots` turns. An entry without
// checkpoints, or whose deepest checkpoint the outgoing chain does not hold (another conversation that only
// shares the system prompt's root with it), is kept. Returns how many were dropped.
size_t drop_superseded(const std::vector<int32_t>& ids, const std::vector<ConversationImageKey>& images,
const std::vector<ConversationCheckpoint>& checkpoints, bool cvec) {
auto held = [&](const ConversationCheckpoint& c) {
if (c.ids == ids && c.imgs == images) return true;
for (const auto& k : checkpoints)
if (k.ids == c.ids && k.imgs == c.imgs) return true;
return false;
};
size_t dropped = 0;
for (size_t i = 0; i < entries_.size();) {
const auto& e = entries_[i];
const ConversationCheckpoint* deepest = nullptr;
for (const auto& c : e.checkpoints)
if (!deepest || c.ids.size() > deepest->ids.size()) deepest = &c;
if (e.cvec == cvec && deepest && !deepest->ids.empty() && held(*deepest)) {
bytes_ -= e.bytes();
entries_.erase(entries_.begin() + (std::ptrdiff_t) i);
++dropped;
continue;
}
++i;
}
superseded_ += dropped;
return dropped;
}
size_t superseded() const { return superseded_; }
bool put(SavedConversation&& image, size_t held = 0) {
const size_t n = image.bytes();
if (!enabled() || held > budget_ || n > budget_ - held) return false; // make_room's refusal, first
drop_superseded(image.live.ids, image.live.imgs, image.checkpoints, image.cvec);
if (!make_room(n, held)) return false;
entries_.push_back(std::move(image));
bytes_ += n;
@@ -173,7 +209,7 @@ public:
}
private:
size_t budget_ = 0, slots_ = 0, bytes_ = 0, evictions_ = 0;
size_t budget_ = 0, slots_ = 0, bytes_ = 0, evictions_ = 0, superseded_ = 0;
std::deque<SavedConversation> entries_; // least recently active first
ConversationKvReuse reuse_;
};
+11 -3
View File
@@ -49,15 +49,23 @@ namespace strata::core {
/// The longest penalty window the coupled drafter mirrors (serve's kPenaltyWindowCap).
inline constexpr int kCoupledHistCap = 4096;
/// STRATA_SPEC_COUPLED=1 (any value but empty or "0"): read once.
inline bool coupled_draft_env() {
static const bool on = [] {
inline bool& coupled_draft_state() {
static bool on = [] {
const char* e = std::getenv("STRATA_SPEC_COUPLED");
return e != nullptr && *e != '\0' && std::strcmp(e, "0") != 0;
}();
return on;
}
/// Whether coupled draft sampling is enabled (via STRATA_SPEC_COUPLED=1 or --coupled-draft CLI flag).
inline bool coupled_draft_env() {
return coupled_draft_state();
}
inline void set_coupled_draft(bool on) {
coupled_draft_state() = on;
}
/// The MTP cell of chain step j after a window at `p` with `a` drafts accepted (draft() runs step j there).
STRATA_COUPLED_HD inline int64_t coupled_draft_cell(int64_t p, int a, int j) { return p + a + j; }
+4
View File
@@ -43,6 +43,10 @@ const char* compiled_gpu_archs();
// this is the matching check at run time (a binary can be carried to a different machine).
DeviceInfo device_info(int ordinal = 0);
/// "" when this build has device code for the current device, else CUDA's error: a build for other GPUs would
/// otherwise fail at its first kernel launch, with nothing that names the cause.
std::string device_code_error();
class CudaError : public std::runtime_error {
public:
CudaError(const std::string& what, int code) : std::runtime_error(what), code_(code) {}
+36
View File
@@ -0,0 +1,36 @@
// strata/core/emulate.hpp - STRATA_EMULATE_CC: another GPU generation's code paths, run on this card (tests only).
//
// A build whose device code is PTX for an older architecture (CMAKE_CUDA_ARCHITECTURES=86-virtual) runs on a newer
// card through the driver's JIT, and every kernel then sees __CUDA_ARCH__ = 860. What the host decides from the
// device must agree with that, or it picks paths and shared-memory sizes the device code was not built for:
// STRATA_EMULATE_CC=75|80|86|89 makes each such query (compute capability, shared memory per block) answer as that
// card would. Speed under it says nothing about the real card; results do - the kernels are the real card's.
#pragma once
#include <cstdlib>
namespace strata {
/// the emulated compute capability as 10 * major + minor, or 0 (off)
inline int emulated_cc() {
static const int cc = [] {
const char* e = std::getenv("STRATA_EMULATE_CC");
const int v = e ? std::atoi(e) : 0;
return v >= 75 && v < 120 ? v : 0;
}();
return cc;
}
inline int cc_major_of(int real_major) { return emulated_cc() ? emulated_cc() / 10 : real_major; }
inline int cc_minor_of(int real_minor) { return emulated_cc() ? emulated_cc() % 10 : real_minor; }
/// cudaDevAttrMaxSharedMemoryPerBlockOptin as the emulated card reports it: 64 KB on Turing, 163 KB on the A100,
/// 99 KB on the other Ampere and Ada cards
inline int smem_optin_of(int real) {
switch (emulated_cc()) {
case 0: return real;
case 75: return 65536;
case 80: return 166912;
default: return real < 101376 ? real : 101376;
}
}
} // namespace strata
+162 -4
View File
@@ -28,13 +28,23 @@
#include <atomic>
#include <cstdint>
#include <cstddef>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_map>
#include <utility>
#include <string>
#include <vector>
namespace strata::kernels::cpu {
struct ExpertLayout;
}
namespace strata::core {
class RemoteExperts;
struct LoadStats;
namespace detail {
@@ -115,6 +125,61 @@ public:
/// checked with `pinned`). The arena answers per layer through its expert 0; the resident RAM mode's compact
/// copy has no expert 0 when the GPU cache holds it, so it answers for the whole copy.
virtual bool pcie_layer(int64_t layer) const { return device_alias(layer, 0) != nullptr; }
/// CS-T: whether `blob(layer, expert)` would be assembled into a short-lived buffer (a native pack read from its
/// GGUF shards in place, where an expert's gate, up and down rows are three separate slices). Such a pointer
/// stays valid for the layer it was asked in and the next one or two; a consumer that keeps a blob longer (the
/// prompt path's stager queues a whole chunk) copies it with `copy_blob` instead.
virtual bool transient(int64_t layer, int64_t expert) const { (void) layer; (void) expert; return false; }
/// The blob's bytes into `dst` (blob_bytes(layer) of them). Safe from several threads for a source whose
/// `transient` can be true.
virtual bool copy_blob(int64_t layer, int64_t expert, uint8_t* dst);
/// The `n` experts of `layer` the CPU is about to ask `blob` for, all at once: a source that reads a file may
/// fetch them in parallel. The bytes `blob` then returns are the same. Default: nothing.
virtual void prefetch(int64_t layer, const int64_t* experts, int64_t n) { (void) layer; (void) experts; (void) n; }
/// CS-T: the experts of `layer` a predictor expects next - a source that reads a file may start reading their
/// pages now, in the background. Only warms: what `blob` returns is unchanged. Default: nothing.
virtual void warm(int64_t layer, const int64_t* experts, int64_t n) { (void) layer; (void) experts; (void) n; }
/// Whether `warm` does anything (the predictor is not run otherwise).
virtual bool warms() const { return false; }
};
/// CS-T, routing-aware prefetch of the file tier: when the CPU pool starts layer `l`, a worker thread applies layer
/// l+1's router (BF16, host copy) to layer l's MoE input - the residual stream changes little from one layer to the
/// next - takes each token's top `k` experts, drops the ones the GPU cache or the RAM copy holds, and asks the
/// source to `warm` the rest, so their pages are on the way while layer l computes. A prediction only warms pages:
/// it never changes which experts are computed or how.
class RouterLookahead {
public:
RouterLookahead() = default;
~RouterLookahead();
RouterLookahead(const RouterLookahead&) = delete;
RouterLookahead& operator=(const RouterLookahead&) = delete;
/// `routers[l]`: layer l's ffn_gate_inp as BF16 bits, n_expert rows of n_embd.
bool start(std::vector<std::vector<uint16_t>> routers, int64_t n_embd, int64_t n_expert, int k, ExpertSource* src,
std::string& err);
/// Layer `layer`'s MoE input for `n_tok` tokens (host floats): predict and warm layer + 1. Never waits: a
/// prediction still running for an earlier layer makes this one skip.
void submit(int64_t layer, const float* x, int64_t n_tok, const int32_t* host_res);
int64_t predicted() const { return predicted_.load(std::memory_order_relaxed); }
int64_t skipped() const { return skipped_.load(std::memory_order_relaxed); }
double busy_ms() const { return (double) busy_us_.load(std::memory_order_relaxed) / 1000.0; }
private:
void run();
std::vector<std::vector<uint16_t>> routers_;
int64_t n_embd_ = 0, n_expert_ = 0;
int k_ = 10;
ExpertSource* src_ = nullptr;
std::thread thread_;
std::mutex mu_;
std::condition_variable cv_;
bool quit_ = false, pending_ = false, busy_ = false;
int64_t layer_ = -1, n_tok_ = 0;
const int32_t* host_res_ = nullptr;
std::vector<float> x_;
std::atomic<int64_t> predicted_{0}, skipped_{0};
std::atomic<uint64_t> busy_us_{0};
};
/// Plan v0.3 P6: what the GPU computes in a verify window's layer, written by the pool (mapped host memory) right
@@ -148,6 +213,7 @@ struct GpuPlanSink {
struct ExpertDispatch {
strata::kernels::cpu::ExpertPool* pool = nullptr;
ExpertSource* src = nullptr;
RouterLookahead* lookahead = nullptr; ///< CS-T: warms the next layer's predicted file-tier experts
RemoteExperts* remote[3] = {}; ///< optional CUDA1..3 tiers for otherwise CPU-served rows
int remote_count = 0;
int64_t n_expert = strata::kernels::cpu::NE;
@@ -329,7 +395,16 @@ public:
///
/// The size check is not a formality: a short file would fault at the END of a long sequence, and an
/// over-long one means the pack is not the one the geometry came from. Refuses with the two numbers.
///
/// CS-T: a native pack WITHOUT experts.bin, after `set_gguf`, maps the model's GGUF shards instead (every file
/// native_experts.txt names, after `check_experts_gguf`), and assembles a blob from its three role slices when
/// it is asked for: the SSD tier, read in place through the OS file cache, with no 30-77 GB experts.bin copy.
/// With experts.bin present nothing changes.
bool open(const std::string& pack_dir, int64_t n_layers, int64_t n_expert, std::string& err);
/// CS-T: the --native shard (native_experts.txt names the other files beside it); see `open`.
void set_gguf(const std::string& native) { gguf_ = native; }
/// Whether the experts are read from the GGUF shards in place (no experts.bin).
bool gguf_mode() const { return !role_ptr_.empty(); }
/// Pin a compact host mirror of experts absent from a fully filled static GPU cache. The mmap remains open
/// as a fallback for later cache reloads. This is opt-in because the complement may still be a large allocation.
///
@@ -342,15 +417,20 @@ public:
/// experts are kept in RAM too, from the last slot down, as far as `available RAM - headroom_bytes` allows
/// (a lent slot's expert is streamed during the prompt and copied back after it).
/// - the rest (the experts no slot holds) must fit that budget, or nothing is allocated and this returns false.
///
/// CS-T, `budget_bytes` > 0 (`--resident-budget-gib`): only as many of those experts as fit `budget_bytes`, taken
/// in `rank` order (the expert profile: the hottest after the GPU cache's), are copied; the rest stay on the
/// mapped files (the SSD tier). No lend region then (a lent slot's expert is read from the files).
bool pin_cache_complement(
const ExpertCache& cache, std::string& err, bool pin = true,
const std::vector<std::pair<int32_t, int32_t>>& additional_gpu_pairs = {}, int64_t lend_from_slot = -1,
uint64_t headroom_bytes = 8ull << 30);
uint64_t headroom_bytes = 8ull << 30, uint64_t budget_bytes = 0,
const std::vector<std::pair<int32_t, int32_t>>* rank = nullptr);
void close();
bool mapped() const { return base_ != nullptr; }
int64_t blobs() const { return blobs_; }
uint64_t pinned_bytes() const { return complement_pinned_ ? complement_bytes_ : 0; }
uint64_t pinned_bytes() const { return complement_pinned_ ? complement_pin_limit_ : 0; }
uint64_t resident_bytes() const { return complement_bytes_; }
bool complement_pinned() const { return complement_pinned_; }
bool complement_ready() const { return complement_ready_; }
@@ -377,11 +457,34 @@ public:
/// With the compact copy ready: blobs read from the mapped file since (what the plain mmap mode may read from
/// the SSD). 0 in a steady resident mode; lend-region experts that did not fit the RAM count here.
int64_t file_reads() const { return file_reads_.load(std::memory_order_relaxed); }
/// CS-T per-tier counters: blobs served from the RAM copy, and the bytes read from the mapped files (the blobs
/// `file_reads` counts, plus the prompt path's copies of them).
int64_t ram_reads() const { return ram_reads_.load(std::memory_order_relaxed); }
uint64_t file_read_bytes() const { return file_read_bytes_.load(std::memory_order_relaxed); }
/// Of those, the bytes `blob` read (decode windows, adaptive swaps; the rest are the prompt path's copies), and
/// the time spent reading the files, summed over threads.
uint64_t file_blob_bytes() const { return file_blob_bytes_.load(std::memory_order_relaxed); }
double file_ms() const { return (double) file_us_.load(std::memory_order_relaxed) / 1000.0; }
/// Threads `prefetch` reads the GGUF with (STRATA_FETCH_THREADS, default 8).
void set_fetch_threads(int n) { fetch_threads_ = n < 1 ? 1 : n; }
const uint8_t* blob(int64_t layer, int64_t expert) override;
bool pinned(int64_t layer, int64_t expert) const override;
const uint8_t* device_alias(int64_t layer, int64_t expert) const override;
bool pcie_layer(int64_t layer) const override;
bool transient(int64_t layer, int64_t expert) const override;
bool copy_blob(int64_t layer, int64_t expert, uint8_t* dst) override;
/// CS-T: advances the assembled blobs' age (see staged_blob).
void begin_layer(int64_t layer, const int32_t* ids, int64_t k) override;
/// CS-T: the GGUF in place assembles the missed experts on `fetch_threads_` threads.
void prefetch(int64_t layer, const int64_t* experts, int64_t n) override;
/// CS-T: the GGUF in place asks the OS for the predicted experts' pages (PrefetchVirtualMemory on Windows,
/// madvise(WILLNEED) elsewhere), skipping the RAM copy's.
void warm(int64_t layer, const int64_t* experts, int64_t n) override;
bool warms() const override { return !role_ptr_.empty(); }
/// Of the blobs the file tier read for the decode, how many had been warmed for their layer beforehand.
int64_t warmed_hits() const { return warm_hits_.load(std::memory_order_relaxed); }
int64_t warmed() const { return warm_count_.load(std::memory_order_relaxed); }
/// Blobs touched, for the driver to report. With `h = 0` this is `48 * k` per token and the number is only
/// interesting once Phase 3 makes it not so.
@@ -389,7 +492,50 @@ public:
private:
const uint8_t* mapped_blob(int64_t layer, int64_t expert) const;
/// The blob's bytes from the mapped file(s) - experts.bin, or the three GGUF role slices - into `dst`.
bool copy_from_files(int64_t layer, int64_t expert, uint8_t* dst) const;
bool open_gguf(std::string& err);
const uint8_t* staged_blob(int64_t layer, int64_t expert);
bool claim_stage(int64_t key, size_t& v, bool& fill);
bool fill_stage(size_t v, int64_t layer, int64_t expert, uint8_t* dst);
static constexpr uint64_t kNoComplement = detail::kNoCacheComplement;
// ---- CS-T: the GGUF shards in place
std::string gguf_;
struct Map {
const uint8_t* base = nullptr;
uint64_t bytes = 0;
#if defined(_WIN32)
void* file = nullptr;
void* mapping = nullptr;
#else
int fd = -1;
#endif
};
std::vector<Map> maps_;
std::vector<const uint8_t*> role_ptr_; ///< 3 x n_layers: gate / up / down of the layer's expert 0
std::vector<uint64_t> role_bytes_; ///< 3 x n_layers: bytes per expert of that role
// the blobs assembled for `blob()`: a small pool of buffers, one per recent (layer, expert). A buffer is
// reused only once `kStageAge` layer changes have passed since its blob was last asked for, so a pointer holds
// through the layer it was asked in and the next ones (the pool computes a layer's misses before the next).
static constexpr uint64_t kStageAge = 3;
std::mutex stage_mu_;
std::vector<std::unique_ptr<uint8_t[]>> stage_buf_;
std::vector<int64_t> stage_key_;
std::vector<uint64_t> stage_epoch_, stage_used_;
std::vector<char> stage_busy_; ///< being filled (outside stage_mu_): never a victim
std::condition_variable stage_cv_;
int fetch_threads_ = 8;
std::atomic<uint64_t> file_blob_bytes_{0}, file_us_{0};
std::unique_ptr<std::atomic<uint32_t>[]> warm_stamp_; ///< per (layer, expert): epoch_ + 1 when warmed
std::atomic<int64_t> warm_hits_{0}, warm_count_{0};
std::unordered_map<int64_t, size_t> stage_of_;
uint64_t stage_blob_ = 0;
uint64_t stage_seq_ = 0;
uint64_t epoch_ = 0;
int64_t last_layer_ = -1;
bool stage_grew_ = false;
std::atomic<int64_t> ram_reads_{0};
std::atomic<uint64_t> file_read_bytes_{0};
const uint8_t* base_ = nullptr;
int64_t blobs_ = 0;
int64_t n_layers_ = 0;
@@ -402,6 +548,9 @@ private:
uint64_t complement_bytes_ = 0;
std::vector<uint64_t> complement_offsets_;
bool complement_pinned_ = false;
bool complement_partial_ = false; ///< CS-T: only the first complement_pin_limit_ bytes are registered
uint64_t complement_pin_limit_ = 0;
uint64_t complement_lock_off_ = 0; ///< the working-set lock covers [lock_off, lock_off + locked)
bool complement_ready_ = false;
uint64_t complement_locked_ = 0; ///< bytes held in the working set (pin refused)
int64_t complement_lent_slots_ = 0;
@@ -450,8 +599,9 @@ public:
/// rate, because those are the two numbers that say whether the arena is the one that was asked for.
bool open(const std::string& pack_dir, int64_t n_layers, int64_t n_expert, int threads, std::string& err,
uint64_t max_pinned_bytes = 0, const std::string& shared_arena_file = {});
/// Plan v0.3 P6: a native pack without experts.bin takes its experts from the model's shard 1.
void set_gguf(const std::string& shard1) { gguf_ = shard1; }
/// Plan v0.3 P6: a native pack without experts.bin takes its experts from the model's GGUF: `native` is the
/// --native shard, and native_experts.txt names the other shards beside it (per layer, or per role in v4).
void set_gguf(const std::string& native) { gguf_ = native; }
void close();
bool mapped() const { return base_ != nullptr; }
@@ -489,4 +639,12 @@ private:
std::string gguf_;
};
/// Plan v0.3 P6: checks native_experts.txt's GGUF spans against the files, before anything is read: each layer's
/// gate/up/down at its recorded (file, offset) must be that tensor (`blk.L.ffn_<role>_exps.weight`), of the
/// layout's type and dimensions, and inside the file. `native` is the --native shard (see set_gguf).
bool check_experts_gguf(const std::string& native, const strata::kernels::cpu::ExpertLayout& lay, std::string& err);
/// Fills `dst` (lay.total bytes, the experts.bin layout) from the GGUF files, one role at a time.
LoadStats load_experts_gguf(const std::string& native, uint8_t* dst, const strata::kernels::cpu::ExpertLayout& lay,
int threads);
} // namespace strata::core
Loaded 100 of 221 files, more files were not shown because too many files have changed in this diff. Show more