Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

vllm-exl3 v0.3.0 is LIVE with custom native CUDA kernels for 2-bit EXL3 on NVIDIA DGX Spark GB10. GLM-5.3-Flash-EXL3-K2 jumped from 16.9 → 24.6 tok/s average single-stream decode, a +45.6% gain. Coding hit 27.6 tok/s, +85.6%. 🚀 The previous ExLlamaV3-backed path inside vLLM was leaving a lot of GB10 bandwidth...

21,784 görüntüleme • 2 ay önce •via X (Twitter)

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

Qwen3.8-Flash-Next now reaches ~43 tok/s after a 122,902-token prompt on ONE DGX Spark. ⚡🚀 MTP k=2 won my draft-depth sweep, with +42.5% mean decode over no draft. The PLE table stays fully on-device. I promised the deeper MTP tests. Here are the results, and now you can explore them in an interactive benchmark page too. 𝗧𝗪𝗢 𝗗𝗥𝗔𝗙𝗧 𝗧𝗢𝗞𝗘𝗡𝗦 𝗪𝗢𝗡 Mean single-request decode with 32K context configured: MTP k=2: 39.21 tok/s MTP k=3: 36.42 tok/s MTP k=1: 35.18 tok/s No draft: 27.51 tok/s k=2 also produced the fastest individual sweep run: 41.34 tok/s. Four runs each for no draft, k=1 and k=2. Seven for k=3. Decode excludes time to first token. Here, k means speculative draft depth, not quantization bits. k=3 produced more tokens per step, but the extra drafting work did not pay off in throughput. k=2 is my current pick for this setup. 𝗧𝗛𝗘 𝟭𝟮𝟯𝗞-𝗧𝗢𝗞𝗘𝗡 𝗣𝗥𝗢𝗠𝗣𝗧 𝗧𝗘𝗦𝗧 I then ran a separate long-prompt comparison: Actual input: 122,902 tokens Configured context: 262,144 Requested output: 128 tokens One request at a time MTP k=2: ~43 tok/s No draft: 26.2 tok/s Time to first token: 110.6 seconds with MTP 107.0 seconds without it The win here is generation speed, not faster prefill. To keep the scope clear: 256K was the configured limit. This was a real ~123K input, not a completely filled 256K window or a full k sweep at that depth. 𝗣𝗟𝗘 𝗦𝗧𝗔𝗬𝗦 𝗢𝗡 𝗧𝗛𝗘 𝗦𝗣𝗔𝗥𝗞 Whole model on-device: 78.57 GiB Packed 5-bit PLE table: 30.4 GiB, included in that total No NVMe PLE offload in this build. This is still turboderp’s 3.05bpw_h5_ng5 EXL3 pack, served through my vllm-exl3 integration. My work here is the serving integration and testing. These are preliminary performance measurements, not a quality evaluation or a claim of bit-exact full-output parity. 𝗘𝗫𝗣𝗟𝗢𝗥𝗘 𝗧𝗛𝗘 𝗥𝗘𝗦𝗨𝗟𝗧𝗦 The benchmark page has the individual sweep values, long-prompt comparison, and measurement scope. You can play the animation, export the charts, or download the HTML and data to render them yourself. No Spark needed to view the results. Credit to turboderp / ExLlamaV3 for the pack and kernels, vLLM for the serving engine, and Qwen Qwen Developers for the model. Recipe + reproduction: Interactive benchmark:

Cruz

12,258 görüntüleme • 2 ay önce

8GB RTX 4060 Laptop. ~16GB Ornith IQ3_S GGUF. 44.5 tok/s streaming locally. FreeToken didn’t have the qwen35moe GGUF path needed for this model, so I implemented it and submitted PR #131 upstream. 👀 I also exposed the K/I GGUF quant types its CUDA kernels already supported through the Python loader. This is the result. Setup: Ornith-1.5-35B-A3B 35B MoE / ~3B active IQ3_S GGUF · ~16GB RTX 4060 Laptop · 8GB VRAM FreeToken · FlashInfer MoE backend: offload On the attached full-prompt run, I measured ~44.5 tok/s streaming on screen. In the same runs, FreeToken’s server decode counter reported 46.7 → 50.1 tok/s. VRAM stayed at 6,879 / 8,188 MiB, with 20GB host RAM and 98% GPU utilization during generation. Load time: 65s. My llama.cpp CPU reference on the same model was 11.1 tok/s. The interesting part isn’t just “35B on an 8GB GPU.” The code path itself was missing. FreeToken’s CUDA side already supported more GGUF quant types than its Python loader exposed, including the K/I quants needed for this IQ3_S model. And qwen35moe models like Ornith needed their own GGUF architecture/loading path. I implemented both pieces in my fork and opened them upstream in PR #131. Once loaded, FreeToken can use GPU + CPU + host RAM as an elastic MoE inference system instead of requiring the entire checkpoint to live in VRAM. That fits Ornith well because only a subset of its experts are active per token. Important caveat: PR #131 is still open. This is not merged upstream yet. I’m not calling this official Ornith support. I’m showing a working implementation, the code is public, and the attached terminal video is the actual run. PR #131: My fork: Next I’m going to test where this path holds up across more quants, longer context and real agent workloads.

Cruz

12,257 görüntüleme • 2 ay önce

Qwen 3.8 Flash decisively crushes the M5 Ultra with this new recipe by vr8vr8 . I think I found the fastest dual DGX Spark recipe for Qwen3.8-Flash-Next. 138 tok/s structured, 133 code, 383 structured aggregate at four streams, and now it talks to Hermes. It feels like a cloud API, running on your desk. This should torch any current M5 run right now. This is part two. Same pair of Sparks, vr8vr8's recipe, his new v4.1, plus a patch of mine that's now an open PR against his repo. WHAT INITIALLY BROKE Through Hermes, the recipe answered in garbled mixed Chinese, then looped on "function86 to90 turn91" until it hit the token cap. Most people would blame the quant. The quant is fine. Three things in the serving stack were stacking up: Hermes doesn't send a temperature for this model. When a request omits it, vLLM 0.30 applies the checkpoint's own generation config: temperature 1.0, top_p 0.95, top_k 20, sampling on. The documented opt-out flag still leaves the server default at 1.0. Every Hermes turn was sampling hot. Hermes sends reasoning as a top-level reasoning object. vLLM 0.30 only maps a field called reasoning_effort onto thinking. So "thinking off" never arrived. Thinking is on by default in the chat template, and with no effort set it defaults to xhigh. A request for no thinking became the longest think the model can do, at temperature 1.0. This is why benchmarks alone do not tell you if a recipe is ready. A real harness that leaves temperature out and names the reasoning field differently gets a different model. Mia's older image never applied the generation config and drafts with argmax, so omitted temperature never sampled hot there. This recipe samples the draft. THE PATCH Two changes to vLLM's chat protocol, applied on both ranks by The Hermes reasoning object now sets thinking. none turns it off. low, medium and xhigh pass through to the template. An explicit enable_thinking still wins. If a request omits temperature, the chat path uses 0. An explicit temperature still passes through. Receipts: three table requests with no temperature and thinking off came back in English. A medium request closed its think and answered in English. The PR is open, not merged. Until it lands, a stock Hermes custom provider still samples at 1.0. HIS V4.1 vr8vr8 shipped recipe v4.1 in the meantime, same v6 image: FlashInfer GDN prefill. His card claims about +5% prefill with decode unchanged. On my depth ladder, prefill came in +6 to +7% from 128k to 900k. Claim holds. THE SECOND GRID Same pair, same protocols, thinking off, temperature 0. My runners already send temperature 0, so this is v4.1 against part one, not a test of the patch. Prose 600: 81.6 tok/s (part one 78.4) Structured count 200: 138.3 (131.8) Code clamp: 133.2 (126.4) JSON catalog: 118.6 (111.8) That's up 4 to 6% across the board, which is run-to-run band. I'm not crediting FlashInfer for it. At four streams: structured 383.1 aggregate, code 330.5, JSON 290.4, prose 200.5. Single-stream structured costs 0.52 J per token of GPU power across both boxes. Tool-call smoke test clean, finish_reason tool_calls, no XML in content. DEPTH Needle retrieval 18/18, from 8k out to the 900k rung (880k server-measured). Decode after fill holds between 65 and 77 tok/s the whole way, 70.6 at the top. Prefill runs 3,245 tok/s at 128k and still 2,577 at 880k. AGENT TURNS The OMP agent lane now runs a full 2,048-token write_file turn at 35k context, replacing part one's 35-token window: 107.4 tok/s decode. The Hermes research turn, two web_search calls at 35k context: 81.0 tok/s, up from 74.7. STILL NOT LIKE-FOR-LIKE Against Mia's d2f54b7 recipe on this same pair: prose 1.6x, structured 2.0x, code 2.0x, JSON 1.9x, Hermes turn 2.2x. Different quant, K=5 vs K=3 drafting, bf16 KV vs fp8. My own version is also my own customized recipe, but it felt better to just serve a PR to the creator, since I didn't invent anything new. The biggest single lever is his output head: 1.18 GiB down to 0.33 GiB, read about 5.4 times every decode step, worth +30% engine steps on its own. SUMMARY Every clean lane faster than the mainstream recipe on this rig: checked. Retrieval 18/18 to 900k: checked. Decode holds to 900k: checked. Agent lane measured over a full 2,048-token window: checked. Hermes out of the box: PR open, work in progress. The speed was always the hard part, and vr8vr8 had it in part one. Sources , Benchmarks and Recipe in Reply 👇

Yume_X

21,745 görüntüleme • 1 ay önce

Day 12/90 of Inference Engineering What is chunked prefill within vLLM? In continuation of yesterday's post on the high level architecture of vLLM, I want to dive deeper into vLLM core engine starting with the mechanics of chunked prefill. In this post, I will closely follow the original blog on the anatomy of vLLM. To start, let's define chunked prefill. It's a runtime inference optimization technique that splits a long input request so that it doesn’t monopolize the whole GPU. Keep in mind this is all within the context of vLLM. And since vLLM is an inference engine that's meant to serve a model to multiple concurrent users, having a GPU that’s fully monopolized on a single user's request means other users' requests would be in queue waiting to be processed. It isn’t too good to have the whole GPU occupied on a single request when the GPU is meant to be shared! So the key idea behind chunked prefill is to break the long request into smaller chunks, so that each chunk along with other users' requests gets processed and written into the KV cache together. Suppose we split up the long request into chunks and each chunk has 8 tokens. Now each memory block can hold 4 tokens. Therefore, 8 tokens can fit into 2 blocks of memory. After the first forward pass, 2 blocks are occupied, and after the second forward pass, 4 blocks of memory are occupied and so forth. Each forward pass handles a small chunk of the long request so that there's room in the same pass to keep serving other users' requests. Here's a small animation that I made today to fully visualize the idea behind chunked prefill when learning this topic~

max fu

29,585 görüntüleme • 4 ay önce

Qwen3.8-Flash-Next is starting to feel like the local model Opus fans have been waiting for. Someone ran the NVFP4 176B-class Flash-Next on 2× DGX Sparks, and the results are wild. Real measured scaling → C1: 44.2 tok/s → C2: 64.6 tok/s → C4: 86.8 tok/s aggregate The per-stream speed drops with concurrency, but total throughput keeps climbing. Long-context behavior was even more impressive: → 5K: needle retrieved → 21K: needle retrieved → 84K: needle retrieved → 167K: needle retrieved → 262K: prefill succeeded, but the window was saturated That 167K retrieval test is the one I care about. Long agent runs are where models usually start losing the plot. Flash-Next didn’t. It also held up surprisingly well on physics-heavy reasoning, artifact generation, research workflows, evidence checking, and long-horizon planning. The personality is interesting too. DeepSeek V4 Flash feels like the dependable workhorse. GLM-5.2 feels like the problem-solving machine. Qwen3.8-Flash-Next feels more insightful. It has that rare ability to understand what you’re actually asking rather than just following the surface pattern. The main weakness I’ve noticed is instruction following. It can occasionally drift between prose turns where DeepSeek and GLM stay tighter. And this is why the 256GB M5 Ultra conversation gets interesting. If Apple can pair that huge unified-memory pool with enough bandwidth, this model class becomes genuinely practical for long-running local agents. We’re talking about frontier-class reasoning on hardware sitting on a desk.

FHILY👑

20,253 görüntüleme • 2 ay önce