COMMUNITY SOURCE INDEX · Source-backed · Free accessAbout the index ↗
Run AI Here Source ledger ↗

EVIDENCE EXPLAINED / A13

Qwen Flash-Next: Concurrency Has a Latency Cost

Read Qwen Spark concurrency, per-request delay and cold-context evidence, keeping checkpoints, releases, cache settings and memory failures distinct.

THE PRACTICAL ANSWER

Higher aggregate output can coexist with slower individual streams. Read the single-Spark ShareGPT sweep and the separate TP2 task/cold-prefix arms with their own versions, cache policy and repetitions; slot counts do not prove simultaneous long windows.

Qwen3.8-Flash-Next can serve more requests while each user waits longer. The useful question is which request mix was actually tested. A single-Spark SGLang study publishes a ShareGPT concurrency sweep; a separate two-Spark vLLM/b12x study publishes task throughput and cold-prefix latency. Their different checkpoints, cache policies and hardware prevent a controlled engine ranking. A third operator's memory failure explains why a configured window and a scheduler limit are insufficient capacity evidence.

Two distinct Spark benchmark cohorts with different request shapes, cache settings and repeat counts.

Single Spark: read latency beside aggregate throughput

The nabe2030 recipe uses senfu/Qwen3.8-Flash-Next-NVFP4 at 5d37b3b3711d8406174b96ff950c0aa16324b266, SGLang commit 4fb9b5b5bad41ac7de5586ec812c421fe3aa2b8b, and NVMe file-backed PLE. Experts and the LM head use NVFP4; the dense path uses FP8. Those details distinguish it from the other Flash-Next conversions on this site.

Its aggregated result table uses vllm bench serve with 200 ShareGPT prompts, thinking off, MTP off and radix caching disabled. One warmup request is discarded. The C1 summary is the median of three trials; the higher-concurrency points are single trials. All selected senfu cases completed 200 requests without errors. Individual prompt/output distributions, temperature and per-request cache history are not supplied.

Concurrent requests Aggregate output, tokens/s Median first token, ms Median time per output token, ms
1 26.97 221.23 36.14
8 67.68 526.78 113.46
16 77.48 686.27 198.00
32 89.35 1,017.98 343.57

Single-Spark median TTFT increases from 221.23 ms at C1 to 1017.98 ms at C32.

For a shared endpoint, more total output does not preserve the interactive experience. Keep first-token wait and token spacing beside aggregate throughput when deciding how many users to admit. Do not estimate an individual stream's speed by dividing aggregate tokens/s by concurrency: the timing definitions and request completion patterns need not match. Single higher-load trials also provide no run-to-run error bar. These results are useful measurements of this workload, rather than a latency guarantee for a different team.

Two Sparks: preserve the older concurrency cohort

The TP2 repository contains several generations of measurements. The selected k76 concurrency series belongs to recipe v2.0.0 on October 10, using two directly connected Sparks and llama-benchy 0.4.1.dev4+g0d4de4271. It requests 2,048 input and 512 output tokens, temperature 1.0, top-p 0.95, top-k 20 and thinking on, with prefix caching enabled. It reports three runs within one boot.

The version ledger binds v2.0.0 to GDN-MSE checkpoint 16c9bd54788d12390838a65ce4a4ecda97fa5f1d. The later v2.1.0/v2.2.0 checkpoint ends in ...85406 and includes a different MTP drafter. Keeping the old checkpoint identity prevents newer recipe defaults from silently rewriting historical results. The ledger's release-image digest is retained separately from the unreported digest of the exact executed test container.

Concurrency Aggregate output, mean ± run SD Per-request decode, mean ± run SD
1 88.697 ± 2.562 88.697 ± 2.562
4 156.645 ± 4.558 48.631 ± 1.533
8 172.213 ± 16.348 33.236 ± 0.977
16 231.294 ± 4.910 22.142 ± 0.362

Both columns use tokens/s. The machine-readable source CSV retains the exact values and original run paths. Aggregate throughput divides all output by elapsed wall time including prompt processing. Per-request decode describes one stream after its first token. Their denominators differ; neither column can be reconstructed by simply multiplying or dividing the other by the number of users.

Dual-Spark per-request decode falls from 88.697 to 22.142 tokens per second across C1 to C16.

The larger C8 aggregate SD remains visible. It describes dispersion in those three runs; it does not identify a cause, quantify between-boot variation or establish a confidence interval. Reporting mean and SD does not itself require a normally distributed population. A scheduling explanation would need more evidence than the summary cells provide.

Long-context latency comes from a separate release

The v2.2.0 cold-prefix arm uses the later checkpoint, C1, temperature zero and one requested output token. It averages four boots with three cold prompts per boot. SD is between boot means. The method and build notes separate this prefill work from the older concurrency campaign.

Actual input tokens First-token latency, mean ± boot SD Prefill, mean ± boot SD, tokens/s
16,384 5.487 ± 0.045 s 2,986.0 ± 24.6
65,536 24.041 ± 0.057 s 2,726.1 ± 6.4
131,072 54.037 ± 0.256 s 2,425.6 ± 11.5

Dual-Spark cold-prefix TTFT is 5.487, 24.041 and 54.037 seconds at the three measured input lengths.

A cold prefix means there was no matching prefix-cache hit. It does not establish cold weight pages, cold compilation caches or a cold operating-system page cache. One requested output token measures the route to the first answer token, rather than long-answer generation. These points cannot prove that sixteen simultaneous 128K prompts fit or retain the same latency. Read the earlier memory/context explanation for the distinction between a shared KV pool and a request ceiling.

Memory failure is useful evidence too

In a separate first-person dual-GB10 operator report, jcagle describes vLLM 0.30.0 with MiaAI overlays, FP8 KV, three MTP drafts, 16 sequence slots and capped GPU clocks. This is a third configuration, rather than another repetition of k76. The report is post version 3, updated October 13; its public URL is mutable, so a dated snapshot hash is retained in the case export instead of claiming an immutable commit URL.

The operator reports an eight-request deep-prefill burst that reached 2.4 GiB head-node MemAvailable at GMU 0.80 before earlyoom killed the engine. With GMU 0.78, the reported eight-by-64K-class load completed at 2,510 combined prefill tokens/s and 117 seconds TTFT, with 3.8 GiB available on the head. Exact individual token counts, output lengths, sampling and repeated-run dispersion are missing. These observations demonstrate the operator's outcome; they do not make 0.78 a universal safe setting or isolate GMU as the only causal variable.

The single-Spark SGLang recipe separately lists a 49,152-token per-request window, 393,216 total tokens and eight slots for one configuration. That configuration is not evidence that every slot was simultaneously filled. Its 3.04 GB KV figure at 128K is a source-labelled allocation, with byte convention unverified, rather than whole-model peak RAM. The KV and speculation guide explains why those distinctions matter.

A practical reading order

Choose the source matching your checkpoint, runtime and hardware. Next, compare the tested prompt/output mix with your actual workload. Then inspect aggregate output, per-request decode, first-token delay and host memory together. Finally, mark configured capacities that the source did not actually fill. This is an editorial method for choosing what to verify, not a request to reproduce these benchmarks automatically.

Does C32 throughput prove C32 long-context serving?

No. The single-Spark C32 ShareGPT mix does not publish a simultaneous full-window fill. Its prompt distribution is also absent.

Can the two Spark articles rank SGLang against vLLM?

No controlled engine comparison is available here. Checkpoints, nodes, cache behavior, MTP and request shapes differ.

Which missing fields should an AI retain?

Keep null execution digests, unknown request lengths, trial counts and memory scope. Use the For AI filters to retrieve complete reports and their conditions rather than a speed-only fragment.

Continue with the source material

Original sources and evidence boundary

Checked 2026-10-18. Source declarations and community measurements retain their own conditions. No independent model benchmark was run by Run AI Here.

  1. nabe2030 · README.md Document revision: 8a161f2bee2e2d85b689a2d457ae68bead3929a4
    Document checksum and matching source record

    SHA-256 8a27445102511702ff42fa60cfcc469583de37c4c0bd031c43cd40db7c0db9f4

    Read source conditions →
  2. ursuciprian · README.md Document revision: b384f4a0e3ff0d563980befe52eb3e6964a5b6b1
    Document checksum and matching source record

    SHA-256 f3bd45cb1f01c287ef00f97b98e0d5c5d66576d5be34baaefce5c108242ad1cf

    Read source conditions →
  3. nabe2030 · results/speed_senfu_vs_radixark.md Document revision: 8a161f2bee2e2d85b689a2d457ae68bead3929a4
    Document checksum and matching source record

    SHA-256 cf77f1feb1a37ab7fcdd8073ca0ff3b5fe78b8c47cf261fd917ae69fcb018297

    Read source conditions →
  4. ursuciprian · docs/data/capability.csv Document revision: b384f4a0e3ff0d563980befe52eb3e6964a5b6b1
    Document checksum and matching source record

    SHA-256 a82bffe4f0e33f4243db9549c02fb8e9379e5faa62825a35a7b087cd30b4996e

    Read source conditions →
  5. ursuciprian · docs/BENCHMARKS.md Document revision: b384f4a0e3ff0d563980befe52eb3e6964a5b6b1
    Document checksum and matching source record

    SHA-256 5645ff4e129b3e2766672e092c65333b073b5550ad89aa6374cbd81ce1da7776

    Read source conditions →
  6. ursuciprian · VERSIONS.md Document revision: b384f4a0e3ff0d563980befe52eb3e6964a5b6b1
    Document checksum and matching source record

    SHA-256 eb9ec6435802430a1be7302b445c67ceb48da9cf5e1ba32e939b5f7aaf9b100e

    Read source conditions →
  7. jcagle · post-1 Document revision: 3
    Document checksum and matching source record

    SHA-256 95ae1019d350e10f941b22110e09c3d65372413fa3139ae2b676b7eb244267a0

    Read source conditions →

AI-assisted draft, reviewed and edited by Run AI Here. A cohort map, not a speed ranking. The single-Spark request mix and the dual-Spark task/cold-prefix arms must retain their own conditions. Original authors retain attribution. Corrections should identify the source revision and affected statement.