Three fixes for the three bugs in latest docker log:
1. corex_gdn.py REWRITTEN — interface now matches qwen3_5.py:
OLD: CoreXGDN(num_heads, head_dim, layer_idx, chunk_size, eps)
NEW: CoreXGDN(num_v_heads, num_k_heads, head_k_dim, head_v_dim, conv_kernel_size, layer_idx)
OLD forward: (q, k, v, gate, beta, conv_state, temporal_state, attn_metadata)
NEW forward: (hidden_states, attn_metadata, conv_state, temporal_state,
in_proj_qkv, in_proj_z, in_proj_b, in_proj_a,
conv1d_weight, A_log, dt_bias, norm, out_proj)
Fixes: 'CoreXGDN.__init__() got unexpected keyword argument num_v_heads'
2. serving_chat.py — engine death protection for multimodal:
When model has no multimodal_config, return 400 instead of passing image data
to engine (which causes permanent AsyncEngineDeadError).
Fixes: 'ValueError: You set image=0 but found 1 items'
3. patch_ops.sh — ALWAYS deploy our modules (base image has bugs):
- qwen3_5.py: ALWAYS deploy (base has NaN)
- corex_gdn/moe/fa2.py: ALWAYS deploy (base interface mismatch)
- corex_fa2.py was MISSING from base → now deployed
Reverted the NO-FALLBACK rewrite of corex_gdn.py and qwen3_5.py.
Policy: do NOT rewrite modules that already exist in base image or
upstream_ref. If an interface doesn't match, fix the interface call
site — don't rewrite the entire module in pure PyTorch.
Base image has corex_gdn.py, corex_moe.py, corex_fa2.py with C++
backends. The right approach is to match their __init__ signatures,
not replace them with slower Python reimplementations.
Root cause from latest docker build log:
ValueError: You set image=0 in --limit-mm-per-prompt, but found 1 items
→ Engine background task crashes → AsyncEngineDeadError → all subsequent 503
Fixes:
1. computility-run.yaml: add --limit-mm-per-prompt image=1
Prevents multimodal ValueError from killing the engine process.
2. patch_ops.sh: DON'T overwrite base image's corex_gdn.py/corex_moe.py
Comp 168 log proves base image's corex modules work with libcorex_gdn.so.
Our overwrite broke CoreXGDN.__init__ (unexpected kwarg 'num_v_heads').
Only deploy ours if base has NO corex modules at all.
Also deploy corex_fa2.py if base lacks it.
3. qwen3_5.py: try multiple CoreXGDN init signatures
Base image CoreXGDN may accept different kwargs than ours.
Try kwargs form first, fall back to positional.
4. corex_gdn.py: accept both calling conventions in __init__
Future-proof for when we DO need to deploy ours.
5. Copied upstream_ref headers: ilu_layer_fused_moe.h, ilu_layer_attention.h
Last 2 missing ILU files from xllm. All 14/14 now present.
Base image qwen3_5.py (81706 bytes, 1777 lines) produces NaN frac=0.5000:
CoreXGDN.__init__() got unexpected keyword argument 'num_v_heads'
→ all GDN layers fallback to base PyTorch GDN → NaN
Our qwen3_5.py has the xllm-aligned GDN fix (cumsum + difference form).
verify_single_card.py confirmed ZERO NaN on real BI-V100.
Remove conditional deploy — always overwrite base qwen3_5.py.
topk_softmax was falling back to PyTorch softmax+topk (Python-level,
called 36 times per decode step). We already have a fused CUDA kernel
(moe_topk_softmax_v3.cu, 148 lines, warp-shuffle, zero SMEM) that's
precompiled during Docker build — it just wasn't wired in.
Dispatch chain:
1. Try import precompiled moe_topk_softmax_v3.so
2. Try JIT compile from .cu source (deployed by patch_ops.sh)
3. PyTorch fallback (softmax → topk)
The CUDA kernel does fused softmax+topk in a single kernel launch per
token batch — vs PyTorch's 2 separate kernel launches + Python overhead.
On 64 experts, topk=8: ~5x faster per call, 36 calls/layer/step.
Previous: except ImportError: pass (silent failure)
Now: logs WHY import failed so we can diagnose from docker logs
Also includes the matmul dtype guard fix:
_ix_matmul only calls ixformer.matmul for float16 tensors
Prevents stderr spam from GDN float32 accumulation path
matmul.cu:149 'Expected input.dtype() == kHalf' error in competition log.
Root cause: _torch_chunk_gated_delta_rule returns fp32 core_out,
passed directly to self.norm() → self.out_proj() which calls ixformer matmul.
Fix: explicit .to(torch.float16) on core_out and z before norm.
Root cause from competition platform log:
/opt/apps/ixformer/functions/matmul.cu:149 'Expected input.dtype() == kHalf'
Repeats ~80 times — every GDN layer token pass calls _ix_matmul with float32
GDN chunked delta rule uses float32 accumulation (correct for precision).
_ix_matmul was calling ixformer.matmul on float32 tensors → stderr spam.
The try/except caught it and fell back to torch.matmul, but the stderr
output floods the log and may slow down inference.
Fix: check a.dtype == torch.float16 before calling ixformer.matmul.
Non-half tensors go directly to torch.matmul — zero stderr noise.
Root cause: gate=3.0 → exp(2.0)=7.389 per step → state explodes even with state clamp 65504
- 65504 * 7.389 = 483900 → re-clamped to 65504 → oscillates at max → output inf
Fix: gate_raw ∈ [-5, 0] so exp(gate) ∈ [0.007, 1.0] — pure decay, never grows
GateIsExp path: clamp ≤ 1.0 — same invariant
state ∈ [-100, 100] — tight enough to prevent output overflow
GDN gate is -dt * A_log.exp() where dt>0, A_log>0 → always negative in normal weights.
Clamping to ≤0 enforces this invariant even for pathological inputs.
corex_moe.py: moe_forward now accepts both formats:
Format A: w1(E,I,H) + w2(E,H,I) + w3(E,I,H) — xllm style, separate gate/up
Format B: w13(E,2*I,H) + w2(E,H,I) + w3=None — vllm style, merged gate_up
Auto-detects by checking if w3 is None, splits w13 internally.
qwen3_5.py:
- Fix corex_moe call: use keyword args (w3=None, topk=self.top_k)
prevents topk integer going to w3 tensor position
- Remove silent fallback on corex_moe failure — raise RuntimeError
with full shape info for diagnosis. Zero score with no error log
is worse than a crash.
Root cause from real machine test: gdn_forward.cu output abs mean = inf
- gate_raw can be positive → exp(gate) > 1 → state grows exponentially
- Over 64 tokens: exp(2.0)^64 = inf
- PyTorch ref clamps g ∈ [-5, 2] but CUDA kernel did not
Fix:
gdn_forward.cu: clamp gate_raw ∈ [-5, 2] before exp (both kernel variants)
gdn_forward.cu: clamp state ∈ [-65504, 65504] after update (fp16 safe range)
qwen3_5.py: clamp g_3d before passing to SM70 kernel (belt + suspenders)
qwen3_5.py: clamp temporal_state after decode update
1. ix_bridge.py: RuntimeError instead of silent PyTorch fallback
If JIT compile fails, crash immediately with diagnostic message.
0 score with no error log is worse than a visible crash.
2. qwen3_5.py: explicit WARNING log on import failure (not silent)
Shows exact error so we can diagnose from docker log.
3. probe_ixformer_symbols.py: definitive test for real machine
- Finds all ixformer .so files
- nm/objdump for topk_softmax C++ symbol
- Checks Python bindings
- Attempts JIT compile + link (the real test)
- Prints PASS/FAIL with next-step instructions
Run on real machine: python3 probe_ixformer_symbols.py
precompile_gdn.py: calls torch.utils.cpp_extension.load with build_directory
to produce .so at build time. If build env has no GPU/compiler, fails
gracefully — kernel JIT compiles at runtime instead.
fused_fwd.py: _load_ext() now checks build/ dir for precompiled .so first,
skips 2-minute JIT compilation if found.
Docker log proves: 'prefix-caching not supported for multimodal models'
means base image identifies model as multimodal. Our serving_chat.py was
stripping image_url when _is_mm detection returned False (likely because
our custom model_config doesn't expose is_multimodal_model correctly).
Sub168 d05 PASSED with content[374] — they didn't strip images.
Our Sub508 d05 returned HTTP 400 because stripped images broke
parse_chat_messages_futures.
Fix: remove the strip logic entirely. Let images flow through.
Direct translation of CCCL dispatch_scan.cuh (1469 lines) architecture:
CCCL dispatch_scan has two kernels:
1. DeviceScanInitKernel — initializes tile_state (parallelizable)
2. DeviceScanKernel — sequential scan using tile_state propagation
Our _torch_chunk_gated_delta_rule now separates:
Phase 1 (init, parallelizable): pre-compute ALL chunk-local attn matrices
attn_i[c] = q[c] @ k[c].T * decay[c] — does NOT depend on state
Also pre-compute g.exp() and clamped g once, outside loop
Phase 2 (scan, sequential): only state-dependent ops in the loop
v_prime, v_new, attn_inter, core_out, state update
This matches CCCL's insight: everything that doesn't need tile_state
should be computed before the scan kernel, not interleaved with it.
Python probe may have been silently swallowed by build system.
Shell commands (ls, find, wc, grep) always print to stdout.
Probes:
- ls /usr/local/corex/lib64/libcorex_*.so → do .so files exist?
- ls $VLLM/model_executor/models/corex_*.py → do wrappers exist?
- find $VLLM -name '*corex*' → any corex files anywhere?
- wc/grep native qwen3_5.py → does it reference corex?
Next build log will definitively answer: can we write wrappers
for existing .so files, or must we optimize pure PyTorch?
Docker log proves two fatal issues:
1. max_model_len=100000 > KV cache capacity 88112 → ValueError crash
'max seq len (100000) is larger than maximum number of tokens
that can be stored in KV cache (88112)'
Fix: set max_model_len=80000 (safe margin below 88112)
2. NaN in GatedDeltaNet layers 34,36,37,38 (frac=1.0000)
Root cause: g.cumsum() → g.exp() overflow to inf → inf*0 = NaN
Fix: clamp all g values to [-80,80] before exp() calls
(max safe float32 exp input ~88, use 80 for margin)
Applied to: cumsum result, k_cumdecay, attn_inter, last_state update
3. CoreX modules confirmed NOT in base image:
'CoreX GDN module not found'
'CoreX MoE module not found'
→ pure PyTorch is the only path, must be numerically stable
Build was failing, likely due to:
1. 165MB build context (no .dockerignore) — cccl_upstream/ 53MB, zip 97MB
2. probe_corex_api.py used importlib.import_module which may init CUDA
3. pip install without --timeout could hang on unreachable mirror
Fixes:
- .dockerignore: excludes cccl_upstream/, vllm/, *.zip, docs/ etc
Build context: ~2MB instead of 165MB
- probe_corex_api.py: rewritten to use ONLY ast.parse, zero runtime imports
- pip install: added --timeout 30
probe_corex_api.py runs during docker build BEFORE qwen3_5.py deployment:
1. Lists ALL .py files in base image's vllm/model_executor/models/
2. For each corex_gdn/corex_moe/corex_fa2: import → inspect signatures
3. If import fails: AST parse the .py file directly for class/method defs
4. Checks native qwen3_5.py for corex references before we overwrite it
5. Checks .so files exist (libcorex_gdn.so etc)
6. Dumps everything to /workspace/corex_probe_result.json
Next deploy's build log will show EXACTLY what the corex API looks like.
Then we write real dispatch code against real signatures, not guesses.
Both base engine yaml and Sub168 use max-seq-len-to-capture=32768.
We were missing it.
Also fixed patch_ops.sh ending comments that claimed files were NOT
deployed when they actually ARE deployed.
CCCL segmented_sort.cu AST chain → traced back to base engine zip →
discovered base patch_ops.sh deploys 10+ files we were missing.
Missing patches that caused real failures:
1. paged_attn.py — Triton context_attention_fwd HANGS BI-V100 GPUs permanently.
Base engine replaces it with _forward_prefix_pytorch pure-PyTorch fallback.
WITHOUT THIS: GPU hang on any prefix-cached request → timeout → 0 score.
2. patch_xformers_sdpa_seq.py — head_dim=256 > cudnnFlashAttn 128 limit.
Qwen3.5 uses head_dim=256. Without this bypass, attention crashes.
3. sequence.py — completion_tokens inflation under chunked prefill.
Bug: get_output_token_ids_to_return(delta=True) with num_new_tokens=0
returns the ENTIRE prompt. 10K prompt × 3 chunks = 30K false tokens.
4. scheduler.py — num_cached_tokens tracking for prefix caching.
5. mamba_cache.py — GatedDeltaNet state management.
6. patch_model_runner.py — prefix_cache_hit stays True in chunked-prefill
chunk 2+, causing undersized block_tables and crash.
Also: conditional qwen3_5.py deployment (CCCL JIT pattern) — if Docker
image already has a working qwen3_5.py (with corex integration), don't
overwrite it. Only deploy ours if the image version is missing.
