Qwen3.6-27B AWQ INT4 on DGX Spark (GB10) — only 1.8-4.9 tok/s decode with 285k token prompt, how to improve?

Has someone ideas, why it is so extremely slow?..

=== SYSTEM ===

Hardware: NVIDIA DGX Spark (ASUS Ascent GX10)

GPU: NVIDIA GB10 (Blackwell, 128GB unified memory)

CPU: ARM64 (aarch64)

RAM: 128 GiB unified

OS: Ubuntu 24.04.4 LTS

CUDA: 13.2

Driver: 580.159.03

=== MODEL ===

Model: Qwen3.6-27B-AWQ-BF16-INT4

Quantization: AWQ INT4 (MarlinLinearKernel)

Parameters: 27B

=== VLLM CONFIG ===

Version: 0.21.0 (V1 Engine)

Attention: FlashInfer

KV Cache dtype: fp8_e4m3

KV Cache Size: 521,274 tokens

max-model-len: 262,144

max-batched-tokens: 262,144

max-num-seqs: 5

gpu-memory-util: 0.80

chunked-prefill: enabled

prefix-caching: enabled

=== LIVE PERFORMANCE (single request) ===

Prompt Size: 285,749 tokens

Requests: 2

Prefill Speed: ~44 tok/s

Decode Speed: ~1.8 - 4.9 tok/s

KV Cache Usage: 35.1%

Prefix Cache Hit: 39.1%

Couple of things:

  • Intel Autoround W4A16 should outperform AWQ
  • You need the specific Marlin atomic add environment variable to reach optimal performance on Marlin with Int4 variants
  • VLLM hard quits at the specified max model length, so I have no idea how you’re getting any response at all from a 285k prompt when your max model length is 256K.

Before chasing a config fix, let’s separate the two issues:

your 285K prompt exceeds max-model-len (262k), and that’s is causing your performance variation from 1.8 to 4.9 because of 2 request’s decode steps are nterleaved with “contaminated” request’s prefill due to your max-batched-tokens configuration. I would reduce it to 32k or 64k, but would not expect huge improvements, but that’s one first test.

To get a clean, comparable baseline, run a known-good NVFP4 recipe (good prefill and output quality) from Spark Arena and check the depth profile matches your regime first (like rdtand/Qwen3.6-27B-PrismaSCOUT-Blackwell-NVFP4-BF16-vllm - Spark Arena Benchmark):

run it with: sparkrun show @spark-arena/440ad5de-83c3-4ac4-b07b-dbdd395fb7dc

then run a benchmark: sparkrun benchmark @spark-arena/440ad5de-83c3-4ac4-b07b-dbdd395fb7dc -b depth=0,4096,262144 -b tg=128 --tp 1

Let me know what you see. If I were you I would see if KV-side TurboQuant path helps.

You can also test Qwen 3.6 35B PrismaQuant rdtand/Qwen3.6-35B-A3B-PrismaQuant-4.75bit-vllm - Spark Arena Benchmark just to have another comparison.

But I really feel the best scenario is going multi-node, because two Sparks over the ConnectX-7 link give you ~546 GB/s aggregate bandwidth and double the KV capacity, which is the only change that meaningfully scales both the context and the decode rate at that length. Dense models scale really well on Spark clusters.

I use it for coding with open code (I try to use it…) this is the reason why I have 262k context… But I heard often I should put it lower around 100k… ClaudeCode has the context 200k…

Yea the same one from Spark Arena I saw it couple minutes ago and try to run it right now.

Thank you very much.

I am using this anf ~30 tok/s

services:

vllm-intel:

image: vllm/vllm-openai:latest

container_name: ${VLLM_CONTAINER_NAME:-vllm-intel}

restart: unless-stopped

gpus: all

ipc: host

ports:

  • “${VLLM_PORT:-8000}:8000”

command:

  • –model

  • ${MODEL_REPO:-Intel/Qwen3.6-35B-A3B-int4-mixed-AutoRound}

  • –host

  • ${VLLM_HOST:-0.0.0.0}

  • –port

  • “8000”

  • –language-model-only

  • –max-model-len

  • “${MODEL_MAX_LEN:-131072}”

  • –max-num-batched-tokens

  • “${MODEL_MAX_BATCHED_TOKENS:-32768}”

  • –max-num-seqs

  • “${MODEL_MAX_SEQS:-4}”

  • –gpu-memory-utilization

  • “${MODEL_GPU_UTIL:-0.8}”

  • –load-format

  • fastsafetensors

  • –attention-backend

  • flash_attn

  • –enable-prefix-caching

  • –enable-chunked-prefill

  • –trust-remote-code

  • –quantization

  • gptq

  • –reasoning-parser

  • qwen3

  • –enable-auto-tool-choice

  • –tool-call-parser

  • qwen3_coder

  • –default-chat-template-kwargs

  • ‘{“enable_thinking”: false}’

  • –speculative-config

  • ‘{“method”:“dflash”,“model”:“z-lab/Qwen3.6-35B-A3B-DFlash”,“num_speculative_tokens”:${NUM_SPECULATIVE_TOKENS:-8}}’

  • –served-model-name

  • ${VLLM_SERVED_MODEL:-local-travel}

  • –api-key

  • ${VLLM_API_KEY:-dummy-key}

environment:

NVIDIA_VISIBLE_DEVICES: all

NVIDIA_DRIVER_CAPABILITIES: compute,utility

VLLM_MARLIN_USE_ATOMIC_ADD: “${VLLM_MARLIN_USE_ATOMIC_ADD:-1}”

HF_HUB_OFFLINE: “${HF_HUB_OFFLINE:-1}”

HF_TOKEN: “${HF_TOKEN:-}”

volumes:

  • hf-cache:/root/.cache/huggingface

healthcheck:

test: [“CMD-SHELL”, “curl -fsS -H ‘Authorization: Bearer ${VLLM_API_KEY:-dummy-key}’ http://127.0.0.1:8000/v1/models || exit 1”]

interval: 30s

timeout: 10s

retries: 20

start_period: 180s

networks:

llm-net:

aliases:

  • ${VLLM_NETWORK_ALIAS:-vllm}

networks:

llm-net:

name: ${VLLM_SHARED_NETWORK:-shared-vllm-net}

driver: bridge

volumes:

hf-cache:

And the moel config:
MODEL_REPO=Qwen/Qwen3-30B-A3B

VLLM_SERVED_MODEL=local-travel

MODEL_MAX_LEN=32768

MODEL_GPU_UTIL=0.90

MODEL_MAX_BATCHED_TOKENS=4096

OPENAI_MODEL=local-travel

VLLM_MODEL=local-travel

VLLM_API_KEY=dummy-key

I tried hardest to get anything useful out of 27b. In theory it’s great but I feel it is incredibly benchmaxxed by Qwen first, and way too slow and has verbose thinking second. There is a reason we are getting almost all new models as MoE (except perhaps Mistral 3.5 128b which is so slow it’s totally irrelevant). For coding I would say Nemotron Cascade 2 is amazing as a build model. 60 tps tg, very fast and 1m tokens window, similar to Super speed does not degrade with context. And you can have 5m tokens cache on one spark to run fleet of subagents. Only like 12gb per 1m q8 tokens. I would use it this way: setup a cloud model like deepseek V4 flash or pro as your planning and review model, you need big brains, and setup you cascade as your builder and subagents model. Tool calling is tge most of the expense and totally can be done by local model. If you want to stay purely local I would so for Nemotron 3 Super. Again 1m tokens window, hybrid mamba attention guarantee stable speed on context large and small, small tokens let you have 2m+ total cache on spark even after 75gb weights, meaning you can hot cache you codebade and docs in karpathi wiki once and all next requests hit prefix cache and are very fast. Hard to do with 256k models. I am using 1m models exclusively. Lotsa code and documentation. Stuff a massive prompt, let is warm the cache, slow start fast ride. Lol.

Speed wise: best I could get out of 27 b on production ready setup (not nightly builds that can produce one benchmark out of 5 it’s crashes vllm) is about 21-23 tg tok/s at small prompt. Super is around 22-23 tg t/s with my maxxed optimization recipe. But once context and cache grows 27 drops to 15, then sub 10. Super stays at 22 and when prefix cache hits above 75% it goes to 25-27 quite often. It does not slow down. At 120b A12b I would argue any day it’s better than 27b dense.

And if you review the argument that not everybody needs a lot of context… Let me ask then why on earth you wasted 4k on spark? Just use cloud. Small context = small expense. No tinkering. Yuo want spark to have a lot of ram, be able to fine tune, stuff vast corpus of data, stay sovereign. If you need it for concurrency and many small requests - wrong choice, it’s too slow. Rent freaking gh200 for 2$ an hour and get 10x speed for your team, private docker, encrypted data, ssl/ssh tunnel, nobody peeks on your precious.

That’s solvable with Yarn, I used to run 27b up to 500k tokens and it does not lose its mind thanks to 27b dense core unlike 35b cousin, but it’s still becomes so slow I just ctrl-c it and switch to cloud out of frustration. Hence I have abandoned it.