---
license: cc-by-4.0
pretty_name: Qwen3.8-Flash-Next Mixed INT2 AutoRound Benchmark on RTX 5090
language:
- en
tags:
- qwen3.8-flash-next
- autoround
- sglang
- rtx-5090
- blackwell
- int2
- long-context
- 256k-context
- moe
- moe-autotuning
- kv-cache
- cpu-offload
- local-llm
- single-gpu
- inference-benchmark
size_categories:
- n<1K
---

# Qwen3.8-Flash-Next Mixed INT2 AutoRound on a Single RTX 5090

This benchmark and reproducibility artifact documents SGLang inference for the mixed-INT2 AutoRound Qwen3.8-Flash-Next checkpoint on one NVIDIA RTX 5090 Blackwell GPU. It covers a validated **256K / 262,144-token long context**, MoE autotuning, tiered KV cache, CPU offload, and the device-local evidence showing why another Blackwell GPU's tuning configuration should not be copied blindly.

![Single-GPU runtime and evidence map](assets/qwen38-rtx5090-evidence.svg)

## Headline inference benchmark

| Measurement | Result |
|---|---:|
| Maximum validated context | 262,144 tokens |
| 247,296-token needle retrieval | 5/5 |
| 247,296-token prefill / decode | 1,127.77 / 36.42 tok/s |
| 257,519-token pressure prefill / decode | 1,489.46 / 41.90 tok/s |
| Short decode, three-run median | 60.78 tok/s end-to-end |
| Short decode range | 59.58–62.14 tok/s |
| Synthetic regression smoke gate | 8/8 |
| Cross-device MoE seed | **rejected**, −29.43% throughput |

The 8/8 result is a deterministic integration gate, not a broad model-quality score.

## Hardware under test

| Component | Hardware / current host snapshot |
|---|---|
| CPU | AMD Ryzen 9 9950X3D · 16 cores / 32 logical processors |
| GPU | NVIDIA GeForce RTX 5090 · 32,607 MiB reported by `nvidia-smi` (~31.8 GiB; marketed as 32 GB) |
| System memory | 64 GB installed class · 61.3 GiB visible to the operating system |
| Host OS | Microsoft Windows 11 Enterprise · version 10.0.26200 · build 26200 |
| NVIDIA driver | 616.64, observed on the current host on 2026-09-20 |
| GPU compute capability | 12.0, captured by the Qwen runtime device snapshot |

This table records the hardware and current host state; the currently observed driver must not be assumed to be the driver used for every historical measurement. For the benchmark software snapshot and pinned revisions, treat [`environment/runtime.json`](environment/runtime.json) and the files under `results/` as authoritative.

**Search terms:** Qwen3.8 Flash Next / Qwen3.8-Flash-Next, mixed INT2 AutoRound, SGLang 256K long-context inference, RTX 5090 Blackwell, single-GPU local LLM, MoE autotuning, tiered KV cache, CPU offload, and bounded RAG, tool-calling, and agent regression evaluation.

## What this dataset gives you

- Sanitized performance, retrieval, quality-gate, and autotune summaries.
- A path-neutral 256K SGLang launch template.
- Endpoint-level decode and deterministic regression runners with no third-party Python dependencies.
- Pinned runtime and checkpoint revisions.
- A documented negative result: a same-generation GPU configuration removed warnings yet made the matched workload slower.

It does **not** contain model weights, runtime patches, credentials, chat history, private prompts, client data, or machine logs.

## Download this research package

```bash
hf download Jerrybro/qwen38-flash-next-rtx5090-research \
  --repo-type dataset \
  --local-dir qwen38-flash-next-rtx5090-research
```

Download the checkpoint from its publisher; this dataset never redistributes it:

```bash
hf download HaberstrohSystems/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang \
  --revision 1199caf239e61da9230b5ba7ba88d29304c9a309 \
  --local-dir Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang
```

Upstream checkpoint: [HaberstrohSystems/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang](https://huggingface.co/HaberstrohSystems/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang).

## Package map

| Path | Purpose |
|---|---|
| `results/benchmark-summary.json` | Long-context, needle, pressure, and short-decode measurements |
| `results/autotune-summary.json` | Accepted device-local tune and rejected cross-device seed |
| `results/quality-summary.json` | Scope and outcome of the eight-case regression gate |
| `environment/runtime.json` | Device and pinned software revisions |
| `config/serve-256k-reference.sh` | Path-neutral launch template |
| `scripts/benchmark_decode.py` | Repeated endpoint-level decode measurement |
| `scripts/run_quality_suite.py` | Deterministic JSONL regression runner |
| `data/cos_domain_v1.jsonl` | Eight synthetic, non-client regression cases |

## Reproduce the measured launch profile

### 1. Match the software snapshot

The captured environment was Python 3.12.14, PyTorch 2.13.0+cu130, CUDA runtime 13.0, Triton 3.7.1, Transformers 5.12.1, and SGLang commit [`73a2552`](https://github.com/sgl-project/sglang/commit/73a255206f916366c8d26d4022f82ddfb0ab558d). The runtime also used patch revision `1f73e9c8b6a572582292bd4717b3fa6616bf2cf2`.

The INT4 ring-KV and lazy-backing switches in the reference template are not guaranteed to exist in stock SGLang. If that patch revision is unavailable, you can inspect the method and configuration here, but you cannot claim a bit-for-bit reproduction of the published run.

### 2. Launch the server

```bash
cd qwen38-flash-next-rtx5090-research
export MODEL_PATH=/path/to/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang
export SERVED_MODEL_NAME=qwen38-flash-next-int2
export PORT=19080

# Optional: only use configurations generated and measured on the target GPU.
export MOE_CONFIG_DIR=/path/to/rtx5090-device-local-moe-configs

bash config/serve-256k-reference.sh
```

The template binds to loopback, allows one running request, uses 19 GB CPU weight offload, 1,024-token chunked prefill, a 32,768-token prefill ceiling, breakable decode CUDA Graphs, and `int8ring_int4` tiered KV with lazy backing.

### 3. Measure short decode

Set `OPENAI_BASE_URL` to the OpenAI-compatible `/v1` endpoint exposed by your runtime, then run:

```bash
python scripts/benchmark_decode.py \
  --endpoint "$OPENAI_BASE_URL" \
  --model qwen38-flash-next-int2 \
  --max-tokens 256 \
  --warmup 1 \
  --repeats 3 \
  --output reproduced/decode.json
```

### 4. Run the bounded quality gate

```bash
python scripts/run_quality_suite.py \
  --endpoint "$OPENAI_BASE_URL" \
  --model qwen38-flash-next-int2 \
  --suite data/cos_domain_v1.jsonl \
  --output reproduced/quality.json
```

The runner returns a non-zero exit code if any case fails. Do not reinterpret this small, synthetic suite as a leaderboard result.

## RTX 5090 optimization method

The reference profile combines four practical constraints:

1. **Fit the mixed-INT2 MoE weights** with 19 GB CPU offload while keeping the serving path single-request and deterministic.
2. **Bound prefill pressure** with 1,024-token chunks and a 32,768-token maximum prefill batch.
3. **Reduce long-context KV cost** with `int8ring_int4`, lazy backing for 262,144 tokens, and an 8,192-token hot tier.
4. **Tune MoE kernels on the target device.** The accepted RTX 5090 run observed 290 unique expert shapes across expert counts 57–480 and generated coverage for 1–512. It completed the 8/8 gate with zero default-config warnings and zero runtime errors.

### Negative cross-GPU result

A seed derived from an RTX PRO 4000 Blackwell configuration was tested against the same eight-case gate. Both arms remained 8/8, but effective completion throughput fell from 17.87 to 12.61 tok/s, a **29.43% regression**. The seed was rejected and removed.

This is the central portability finding: **the launch policy is a reference; the MoE tune is device-local evidence, not a portable configuration artifact.** Re-run measurement after any GPU, driver, Triton, SGLang, checkpoint, or batch-shape change.

## Recommended settings

| Setting | Published value | Why |
|---|---:|---|
| Context / total tokens | 262,144 | Validated upper runtime setting |
| Running requests | 1 | Keeps the single-user memory envelope predictable |
| CPU weight offload | 19 GB | Fits the mixed-INT2 checkpoint on 32 GB VRAM |
| Chunked prefill | 1,024 tokens | Controls transient prefill pressure |
| Maximum prefill batch | 32,768 tokens | Bounds large-input scheduling |
| KV cache | `int8ring_int4` | Reduces long-context KV footprint |
| Lazy KV tokens | 262,144 | Backs the full configured context |
| Lazy KV hot tier | 8,192 tokens | Keeps a recent working set resident |
| Decode CUDA Graph | breakable | Matches the measured runtime profile |

Treat these as a tested RTX 5090 starting point, not a universal optimum.

## Measurement boundaries

- Needle retrieval, pressure, and decode rates are descriptive measurements from one host and one software snapshot.
- The short-decode number is end-to-end completion tokens divided by wall time, with one warmup and three measured runs.
- The 8-case suite tests formatting, retrieval, coding, simple reasoning, language handling, and unknown-data behavior. It is not a general intelligence, safety, or contamination-resistant benchmark.
- Thermal state and background GPU activity were not controlled as laboratory variables.
- No claim is made for other GPUs, drivers, checkpoint revisions, concurrency levels, or unpatched SGLang.

## Companion research

For the separate PQ2/Q4-KV/Fable comparison on the same GPU class, see [Jerrybro/bonsai2-27b-pq2-vs-fable-rtx5090](https://huggingface.co/datasets/Jerrybro/bonsai2-27b-pq2-vs-fable-rtx5090).

## Licensing and attribution

- Dataset documentation, aggregate results, and original visual: [CC BY 4.0](LICENSE-DATA.md).
- Original scripts and launch template: [Apache License 2.0](LICENSE-CODE).
- The checkpoint, SGLang, PyTorch, Triton, Transformers, CUDA, and any runtime patches remain under their upstream licenses. Nothing here relicenses them.

## Citation

Use [CITATION.cff](CITATION.cff), and cite the upstream checkpoint and runtime when reporting reproduced results.

## Author

**Jerry Sheen** · Hugging Face: [Jerrybro](https://huggingface.co/Jerrybro)