CCCL single_pass_scan_operators.cuh (line ~180) reveals:
if (gridDim.x < GridThreshold) { __threadfence_block(); }
else { __nanosleep(Delay); }
GridThreshold=500. BI-V100 has 16 SMs → ~32 max CTAs → always < 500.
So ALL delay strategies (no_delay, fixed_delay, exponential_backoff, etc.)
collapse to the same instruction: __threadfence_block(). This means:
1. Inter-CTA synchronization is effectively free on BI-V100
2. The dominant per-decode-step overhead is Python scheduler dispatch
3. Batching more steps per dispatch is pure win
num-scheduler-steps: 8 → 16 doubles the batch size per Python call.
Each call amortizes ~100μs of Python overhead over 16 token generations
instead of 8. For Output TPS (83% of competition weight), this is
the highest-leverage single-parameter change available.
Also includes prefix_prefill.py changes from previous commit.
Source: cccl_upstream/cub/cub/agent/single_pass_scan_operators.cuh
cccl_upstream/cub/cub/block/specializations/block_reduce_warp_reductions.cuh
256 concurrent seqs risks OOM: worst case with long prompts in queue
can exhaust KV cache + activation memory. 32K batched-tokens prefill
activation ≈ 20GB competes with KV cache. 0.95 mem-util leaves only
5% headroom for spikes.
Conservative start: max-num-seqs=8 (8× improvement over baseline=1).
8 seqs × 2048 avg context × 80KB/token = 1.3GB KV cache, safe.
gpu-memory-utilization and max-num-batched-tokens restored to proven
baseline values.
Optimal max-num-seqs needs real-hardware sweep: 4→8→16→32→64→128.
The value where Output TPS plateaus (KV cache saturated) is the
answer. Can't determine this without Phanthy Cloud access.
computility-run.yaml:
max-num-seqs 1→256: benchmark sweeps [128,256] concurrent seqs,
current config processes 1 while 127 queue. KV cache budget:
256 seqs × 2048 tokens × 80KB/token = 41.9GB < 45GB available.
max-num-batched-tokens 8192→32768: support 256 concurrent prefills.
gpu-memory-utilization 0.9→0.95: provide KV cache headroom.
Dockerfile:
Deploy paged_attention_v2_triton.py to vllm package path so
try-triton-first logic in _custom_ops.py can find it. Falls back
to PyTorch V2 automatically if Triton V2 fails (SMEM/runtime).
muh/tuning/common.cuh:
scale_mem_bound max_smem now a parameter (default 48KB). Allows
policy_selectors to pass hw.max_shared_memory_per_block if actual
SMEM differs from CCCL 48KB assumption.
muh/tuning/tuning_transform.cuh:
bytes_in_flight 16KB→32KB. Old derivation used 900/50=18 GB/s/SM
(wrong, SM=16 confirmed). Actual per-SM BW = 56 GB/s.
32KB is estimate pending benchmark sweep.
SM count 50→16 corrections across all affected files.
Analysis:
CUDA graph eliminates kernel launch overhead (~10-20% for decode).
At 32768, sequences >32K skip graph capture.
At 65536, most competition workload sequences get graph acceleration.
Memory: CUDA graph capture allocates one copy of all intermediate tensors
at the max captured batch size. With max-num-seqs=1, this is one sequence's
worth of tensors — small relative to model weights.
Combined with V2 enabled for seq>8192 and threshold raised to 65536,
the decode path is now:
seq <= 8192: V1 compiled kernel (fastest)
8192 < seq <= 65536: V2 pytorch (single-bmm, good)
seq > 65536: PyTorch fallback (rare at competition workload)
After reading the full baseline (enginex-vllm-bi100-qwen36-main.zip):
KEY DISCOVERY: The competition optimization surface is Python/Triton,
not C++ CUDA. There is no csrc/ directory. All CUDA kernels are
precompiled in vllm._C and ixformer .so files. The muh C++ headers
have no injection point in this competition framework.
What CAN be optimized:
1. Triton kernel parameters (prefix_prefill.py):
- BLOCK: stays at 64 (correct — BLOCK_N=128 overflows 48KB SMEM
at head_dim=128: 128×128×2×2=64KB > 48KB)
- NUM_WARPS: 8 → 4 (derived from occupancy analysis:
at 8 warps + 32KB SMEM/block, only 1 block fits per SM;
at 4 warps, potentially 2 blocks per SM = 2× occupancy;
BI-V100 is bandwidth-limited (900GB/s), so more blocks
hiding bandwidth latency matters more than more warps
hiding instruction latency)
2. computility-run.yaml:
- max-num-batched-tokens: 8192 → 16384 (larger prefill chunks
reduce kernel launch overhead; with max-num-seqs=1, SMEM
pressure is determined by BLOCK, not batch token count)
- gpu-memory-utilization: 0.9 → 0.95 (model uses ~17.5GB/GPU,
KV cache for 100K tokens ≈ 1.38GB, plenty of headroom)
3. Added Dockerfile with patch_triton_tuning.py step.
4. Analysis document in optimizations/prefix_prefill_patch.py
with full SMEM/register/occupancy derivation.
