---
license: apache-2.0
tags:
  - benchmark
  - llm-inference
  - mixture-of-experts
  - tensor-parallelism
  - consumer-gpu
  - freetoken
  - qwen
pretty_name: FreeToken Qwen3.6-35B-A3B Dual RTX 3090 Benchmarks
---

# FreeToken Qwen3.6-35B-A3B — Dual RTX 3090 Consumer Benchmarks

Measured inference performance of **Qwen3.6-35B-A3B** (FP8 / NVFP4 / BF16 checkpoints) served by
[FreeToken](https://github.com/FlashML-org/FreeToken) on a **consumer dual-GPU workstation**
(2x RTX 3090 24 GB, 62 GB RAM), across quantization formats, tensor-parallel configurations,
MoE backends, RAM bandwidth regimes, and three engine revisions — including validation of two
upstream fixes that landed during testing.

This is, to our knowledge, the **first published set of consumer dual-GPU numbers for this stack**.
All figures were measured on real hardware; methodology and provenance below.

## Hardware / software environment

| Component | Value |
|---|---|
| GPU | 2x NVIDIA RTX 3090 24 GB (Ampere, sm_86), PCIe |
| CPU | Intel Core i9-10980XE, 18c/36t (X299 platform) |
| RAM | 62 GB DDR4, tested at 2000 MT/s (JEDEC) and 3600 MT/s (XMP) |
| OS | Ubuntu 24.04 |
| Driver / CUDA | 580.173.02 / CUDA 13.0 (official toolkit — see reproduction notes) |
| NCCL | 2.31.2 (`libnccl2` + `libnccl-dev`) |
| Engine | FreeToken v0.1.2 (PyPI) + `freetoken_kernel_cache` 0.1.2+cu130; later PR #104 head `3c8b281` + stacked branch (`f1ff8e2`, then `c23ec78`) |
| Models | `nvidia/Qwen3.6-35B-A3B-FP8` (35 GB), `nvidia/Qwen3.6-35B-A3B-NVFP4` (22 GB), BF16 (~70 GB, OOM on this host) |

## Headline findings

### 1. Config ladder (decode throughput, tok/s)

| Config | Engine revision | Decode tok/s | Verdict |
|---|---|---|---|
| FP8, TP=1, offload | v0.1.2 | **93.9** | Speed champion on 2x 3090 |
| NVFP4, TP=1, hybrid | v0.1.2 | 61.0 → **~79** (RAM 3600 MT/s) | CPU/RAM-bound |
| NVFP4, TP=2, hybrid | PR #104 @ `f1ff8e2` | 2.2 | Broken: CPU executor core collision |
| NVFP4, TP=2, hybrid + `--moe-cpu-threads 8` | PR #104 @ `f1ff8e2` | 9.5 | Workaround (4.3x) |
| NVFP4, TP=2, offload | PR #104 @ `f1ff8e2` | 3.1 | PCIe + host all-reduce serialization |
| **NVFP4, TP=2, hybrid** | **PR #104 @ `c23ec78`** | **32.7 wall / 59.3 engine-instantaneous** | Affinity fix verified: **14.9x vs broken** |
| FP8, TP=2 | PR #104 @ `f1ff8e2` | — | OOM at load (62 GB RAM < ~35 GB banks + runtime) |
| BF16, TP=2 | PR #104 | — | OOM (67 GB model > 62 GB RAM) |

### 2. KV-cache capacity is the real TP=2 prize

| TP | Usable KV tokens |
|---|---|
| 1 | 262,144 |
| 2 | **524,288** (2.4x claim confirmed) |

### 3. RAM bandwidth scaling (2000 → 3600 MT/s)

| Metric | 2000 MT/s | 3600 MT/s | Change |
|---|---|---|---|
| CPU STREAM read | 54.1 GB/s | 80.8 GB/s | +49% |
| PCIe H2D | 8.6 GB/s | 8.5 GB/s | flat |
| CPU-MoE NVFP4 | 28.1 GB/s | 46.7 GB/s | +66% |
| CPU-MoE BF16 | 41.5 GB/s | 71.3 GB/s | +72% |
| Serving: NVFP4 hybrid decode | 60.1–63.8 tok/s | 76.0–80.9 tok/s | **+29–31%** |
| Serving: FP8 offload decode | ~90–106 tok/s | ~86–106 tok/s | **flat** (PCIe-bound) |

**Lesson:** RAM overclocking only pays off on CPU-compute (hybrid) MoE paths; pure offload is PCIe-bound.

### 4. Engine findings reported upstream (PR #104)

1. **CPU executor core collision (fixed in `c23ec78`)**: both TP ranks' hybrid executors pinned to the same
   physical cores. Per-rank disjoint core partitioning recovered 13.5–14.9x across three independent machines
   (this dataset's host + two author machines).
2. **Offload + `--disable-pynccl` serialization**: in offload mode, per-token PCIe expert streams and the
   host-staged all-reduce contend on the same bus. Machine-dependent: hybrid wins on bare metal, offload can
   win in VMs.
3. **Fused MoE gate** (`freetoken/engine/engine.py`, `applied_nv`/`applied_fp` guards): `--moe-backend fused`
   refuses NVFP4/FP8 ("bf16-only for now"). At TP=2 the sharded NVFP4 experts (~11 GB/rank) would fit in
   24 GB of VRAM — lifting this gate would likely beat every row in this dataset.

Also verified: the `lm_head` vocab-sharding fix (`f1ff8e2`) — both FP8 and NVFP4 now load past the previous
crash point at TP=2.

## Data

`benchmarks.jsonl` — one row per measurement. Schema:

| Column | Type | Meaning |
|---|---|---|
| `date` | string | Measurement date (UTC) |
| `engine` | string | FreeToken version / commit |
| `model` | string | Checkpoint served |
| `quant` | string | `fp8` / `nvfp4` / `bf16` |
| `tp_size` | int | Tensor-parallel size |
| `moe_backend` | string | `offload` / `hybrid` / n/a |
| `attention_backend` | string | e.g. `hybrid_linear`, `triton` |
| `extra_flags` | string | Non-default serve flags |
| `ram_mts` | int | DDR4 transfer rate during run |
| `category` | string | `serving` / `bandwidth` / `capacity` / `load_test` |
| `metric` | string | `decode_tok_s`, `ttft_s`, `bandwidth_gbs`, `kv_usable_tokens`, `load_status` |
| `target` | string | For bandwidth rows: the subsystem measured |
| `value` | number/string | Measured value (or status string) |
| `value_max` | number | Upper bound when the run produced a range |
| `unit` | string | Unit of `value` |
| `notes` | string | Context, caveats, cross-references |

## Methodology

- Serving numbers: OpenAI-compatible endpoint (`127.0.0.1`, local), scripted client, representative prompt
  batches (up to 399 output tokens); decode throughput = generated tokens / decode-phase wall time unless
  noted (`engine-instantaneous` = the server's own logged per-batch gen throughput).
- "Warm" = after first request; "cold" includes FlashInfer JIT compilation.
- Bandwidth rows: `ft bench bw` calibration output.
- Every TP=2 row was run on an otherwise idle host; a contaminated first offload measurement (a stale server
  holding both GPUs) was discarded and re-run clean — the discarded number is not in this dataset.

## Reproduction notes (the parts the docs understate)

1. **Do not use pip-installed CUDA packages with FreeToken.** FlashInfer JIT-compiles kernels lazily
   (including at first inference), so a partial toolkit fails *after* the server reports ready. Install the
   official toolkit: `cuda-nvcc-13-0 cuda-cudart-dev-13-0 libcurand-dev-13-0`, `CUDA_HOME=/usr/local/cuda-13.0`.
2. Multi-GPU needs NCCL dev libs: `sudo apt-get install libnccl2 libnccl-dev` (upstream docs PR #90).
3. After killing `ft serve`, orphaned multiprocessing workers can hold VRAM and port 1920;
   `pkill -9 -f "multiprocessing.spawn"` cleans them.
4. DDR4-3600 stability on X299 quad-channel may need VCCSA/VCCIO raised (1.2 V / 1.15 V worked here) —
   vdimm alone at 1.35–1.41 V was not sufficient.
5. `bench_decode_moe.py` (upstream) hangs spawning its own server in this environment; direct `ft serve` +
   scripted client was used instead.

## Provenance

- Engine: [FlashML-org/FreeToken](https://github.com/FlashML-org/FreeToken)
- TP support work: [PR #104](https://github.com/FlashML-org/FreeToken/pull/104) (+ stacked branch by CraigStone-Dev)
- Tracking issues: [#29](https://github.com/FlashML-org/FreeToken/issues/29) (Qwen3.5/3.6 MoE TP=1 gate), [#15](https://github.com/FlashML-org/FreeToken/issues/15) (multi-GPU roadmap)
- Benchmarks and fix validation on this hardware: [Alogotron](https://huggingface.co/Alogotron)

## Limitations

- Single hardware sample (Ampere consumer); NVFP4 carries a software-dequant penalty here — Blackwell cards
  should shift the hybrid/offload balance.
- Decode figures are single-client, moderate batch; no concurrency sweep.
- BF16 rows are load-test only (host RAM bound).

## Citation

```bibtex
@misc{freetoken_qwen36_dual3090_benchmarks,
  title  = {FreeToken Qwen3.6-35B-A3B — Dual RTX 3090 Consumer Benchmarks},
  author = {Alogotron},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Alogotron/freetoken-qwen36-dual3090-benchmarks}
}
```