humanfia-lab/inference-kernels

Inference Kernels

24 FlashInfer Trace operator definitions, with self-contained PyTorch references, open-source baseline solutions, and workloads captured from actual SGLang inference. Model dimensions are constants. Runtime batch sizes, sequence lengths, page sizes, and image grids remain variable.

Every published tensor input references a complete safetensors snapshot. Python scalar arguments use scalar descriptors. There are no random-input descriptors or synthetic activation generators. captures.jsonl joins each workload UUID to its model revision, request, engine operation, input adaptations, actual outputs, and validation results.

1,383 real workloads cover all 24 definitions and pass complete-output replay: 257 Qwen Image, 641 Qwen Flash-Next, 278 DeepSeek, and 207 LTX. The complete dataset is published at humanfia-lab/inference-kernels, including definitions, workloads, capture records, baseline solutions, and tensors. The 6,763 tensor paths contain 6,223 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.

The dataset was regenerated from full pinned checkpoints through SGLang on NVIDIA B300 GPUs. Definitions, reference code, tolerances, and baseline solutions are unchanged.

Kernels

BF16, FP16, FP32, and FP64 mean 16-bit Brain Floating Point, IEEE half precision, 32-bit floating point, and 64-bit floating point. FP8 and FP4 are 8-bit and 4-bit quantized formats. Q, K, and V denote queries, keys, and values.

Family	Model	Fixed dimensions	Definitions	Workloads
Dense matrix multiplication	Qwen Image 2.1 Turbo	(N,K): (4096,4096), (12288,4096), (4096,12288), (4096,64), (64,4096)	5	217
Grouped expert matrix multiplication	DeepSeek V4.1 Flash	384 experts; (N,K): (2304,5120), (4608,5120), (5120,2304); FP8 × FP4	3	156
Mixed-format latent attention	DeepSeek V4.1 Flash	64 heads × 512 dimensions; 128 FP8 window slots and 512 FP4 compressed slots	1	42
Sparse multi-head latent attention (MLA), prefill	DeepSeek V4.1 Flash	64 query heads × 512 dimensions; 1 shared key/value head; BF16; separate 128-slot and 640-slot definitions	2	30
Gated delta recurrence	Qwen 3.8 Flash-Next	16 shared query/key heads, 48 value heads, dimensions 128; prefill and decode	2	257
Noncausal dense attention	LTX-2.5	Video: 32 heads × 128; audio: 32 heads × 64	2	162
Qwen sparse attention	Qwen 3.8 Flash-Next	24 query heads, 2 key/value heads, dimension 256; 512 four-token blocks	1	192
Prefix-cached block-causal attention	Qwen Image 2.1 Turbo	32 heads × 128; empty-prefix and cached-prefix cases	2	40
Sparse index scoring and selection	Qwen 3.8 Flash-Next	4 query heads × 128; Top-512 complete four-token blocks	1	192
Expert router	DeepSeek V4.1 Flash	Hidden dimension 5120, 384 experts, Top-6 selection	1	50
Three-dimensional neighborhood attention	LTX-2.5 diffusion decoder	Dimension 64; (heads, window): (32,3×7×7), (16,3×7×7), (8,3×5×5), (4,11×11×11)	4	45

Shape distribution histograms for all 24 kernels show how the 1,383 workloads are distributed across exact runtime shapes. Each bar counts captured workloads with the same complete combination of variable dimensions; fixed model dimensions are listed above the plot. These counts describe this dataset, not AgentX traffic frequencies. Regenerate the figures with python scripts/plot_shape_distributions.py (requires Matplotlib; no GPU or tensor files needed).

Definitions describe complete logical operators. Captures preserve all model heads and experts; distributed shards must be gathered before publication. Backend padding, layout changes, and page remapping are recorded explicitly. Cache snapshots retain every referenced page, including its unused tail; unreachable allocator pages are omitted. Tensor strides are normalized to contiguous storage without changing values.

Gated delta prefill receives the engine's normalized BF16 Q/K, with each shared head repeated three times. Decode receives raw Q/K and gate inputs because the engine performs normalization and gating inside the kernel using FP32 arithmetic. Both interfaces use state layout [batch, head, key_dimension, value_dimension].

Quantized byte carriers use int8 because the trace schema lacks unsigned-byte and exponent-only scale types. The byte patterns remain unchanged. Grouped matrix multiplication uses logical scale layouts with one scale per 32 K elements. Mixed attention preserves the engine's physical pages: each page stores all payload rows followed by all scale rows. Both cache formats share the softmax denominator, including the zero-value attention sink.

Engine inputs

Text: Qwen Flash-Next and DeepSeek

The engine receives sequences of token IDs. Their lengths and shared prefixes come from selected requests in the public AgentX trace: 98,827 requests across 393 sessions. The selected records are in agentx_shapes.json, pinned to trace revision 23f152f6f0f9399a85901b89a6458def0ef16729.

Text content. The original prompts are not public. We use one short, authored coding conversation about fixing a Python cache and writing tests. The served model's tokenizer converts it to tokens. The trace describes prompts in anonymous 64-token blocks; each session/block ID selects a repeatable 64-token span from the replacement text. Joining those spans produces the recorded input length.

If two requests start with the same blocks, they receive the same initial tokens. For example, three shared blocks give them a shared 192-token prefix. Because the replacement text is short, different block IDs can also select identical spans. The input therefore repeats a small amount of coding text; it does not reproduce the original vocabulary, topics, or token frequencies. Lengths follow the trace's block counts, not a retokenization of the unavailable original prompts.

Lengths. Cases cover short requests, long contexts, reused prefixes, full-prefix reuse, and long responses:

Model	Input tokens	Generated output tokens
Qwen Flash-Next	Selected short-to-long requests, up to 249,088	Recorded lengths, including a 7,948-token response
DeepSeek, serial requests	128 / 2,944 / 142,016 / 549,504 / 989,824	Respectively 107 / 1,813 / 90 / 6,765 / 1,204
DeepSeek, three concurrent requests	35,008 / 35,392 / 35,456	Respectively 120 / 108 / 126

The engine uses temperature 0 and is instructed to generate the recorded output length, ignoring an early end-of-sequence signal. Thus output length is controlled by the replay. All eight DeepSeek requests completed on four GPUs, producing 10,333 tokens in total without the earlier extra 128-token cap.

Cache reuse. A cache hit lets the engine reuse work for an identical beginning of a request. Before each serial case, we clear the cache. For a case with a shared prefix, we first submit its recorded predecessor, generate one token to populate the cache, and then send the target request. For a cold case, we send the target directly. This exercises reuse through actual requests rather than assigning a cache-hit percentage.

For example, the 549,504-token DeepSeek request reused 541,952 tokens, leaving 7,552 prompt tokens to process. The actual hit can differ from the trace's shared-prefix length because of engine cache boundaries and the replacement text. This procedure does not replay the entire conversation or its cache-eviction history.

Concurrency. Qwen includes groups of 3, 9, and 23 requests that overlapped in the source trace; DeepSeek includes a group of 3. Each group starts with a cleared cache and is submitted together. The engine schedules the requests itself. Original arrival times are not reproduced.

Frequency distribution. Requests are chosen to cover different situations, without frequency weights. For example, the full trace's median input is 142,016 tokens, its 90th percentile is 549,504, and its maximum is 989,824; DeepSeek includes those lengths as coverage points. Their inclusion does not mean these requests are replayed in their original proportions. The input/output length histogram, overall cache-hit rate, role proportions, and token frequencies do not match AgentX traffic.

Images: Qwen Image

The engine receives four authored prompts, independent of AgentX:

Request	Input content	Requested output size
Text to image	A red ceramic teapot on a wooden table	1024 × 1024
Landscape	A lakeside village at sunrise	1536 × 1024
Image editing	The generated teapot image, with an instruction to make it blue	1024 × 1024
Transparent background	An orange cat on a transparent background	1024 × 1024

Each prompt is submitted with 1, 2, and 4 requested outputs. Multiple outputs share the prompt and use independent seeds starting at 42. All requests use the checkpoint's original eight-step Turbo schedule and guidance scale 1. These four prompts cover generation modes and image sizes; they are not sampled from a production prompt distribution.

Video and audio: LTX

The engine receives three authored requests, also independent of AgentX:

Request	Input content	Requested width × height × frames
Text to video	A camera moving toward a steaming teapot	768 × 448 × 49
Image to video	The Qwen-generated teapot image, with a camera-motion instruction	512 × 320 × 49
Longer video	A boat crossing a lake at sunrise	512 × 320 × 121

Each is submitted with 1, 2, and 4 requested outputs, at 24 frames per second. Multiple outputs share the prompt and use independent seeds starting at 42. All requests use the original eight-step schedule, guidance scale 1, and the full decoder; generated videos include audio. These cases cover two resolutions, two durations, and text/image conditioning. They do not represent production frequencies of video sizes or content. All nine requests are included; audio and video transformer attention use the math SDPA policy described below.

Baseline solutions

solutions/ contains native FlashInfer Trace Solution JSON files, with embedded source code, entry points, and pinned dependencies. Each solution accepts the definition's complete inputs and returns its complete outputs. GPU layout conversions, padding, sparse gathers, and output reordering are included in the solution call.

The existing baseline implementations and B200 measurements come from the original 768-workload dataset. They are retained unchanged. The regenerated 1,383-workload dataset has passed complete engine-output replay against the independent references; baseline solutions have not been rebenchmarked on this new dataset.

Kernels	Open-source implementation
Dense and grouped matrix multiplication	DeepGEMM; selected small dense shapes use FlashInfer 0.7.2 CuTe DSL
Sparse MLA prefill and mixed-format MLA decode	FlashMLA
Dense, block-causal, and sparse grouped-query attention	FlashAttention-4 4.0.0b35, with runtime masks or sparse-input adapters
Gated delta recurrence	FlashInfer 0.7.2 prefill; adapted SGLang fused Triton decode
Sparse index scoring and selection	SGLang TileLang scoring, exact-threshold Top-512, and Triton compaction that preserves lower-ID ties
Expert router	FlashInfer CUTLASS FP32-output projection and compiled PyTorch scoring/selection
Three-dimensional neighborhood attention	NATTEN 0.21.7 Blackwell fused neighborhood attention

Local B200 comparisons covered 45 dense GEMM shapes across 147 backend/shape pairs, nine grouped GEMM shapes with five implementations/configurations each, and all 19 sparse-index workloads. Dense dispatch selects the fastest tested backend per captured shape; DeepGEMM won all nine grouped comparisons. The index adapter was 1.21–2.58× faster than full stable sorting while returning exactly the same IDs. These measurements describe the tested B200 configurations.

The audio-attention solution uses FP16 computation and converts the output back to BF16 to reduce attention-probability rounding error. In the original B200 validation, all 96 audio workloads passed the unchanged reference tolerances, and their inputs remained finite after conversion with maximum conversion error below 3e-8. These measurements refer to the original tensors.

Install the dependencies listed in each solution's spec before running it. The historical B200 baseline environment used PyTorch 2.11.0, CUDA 13.2, Triton 3.6.0, CUTLASS DSL 4.7.1, Quack 0.6.5, TileLang 0.1.15, and TVM FFI 0.1.12. NATTEN and FlashMLA were built from their pinned sources for Blackwell. FlashMLA's CUDA 13.2 build required its upstream FLASH_MLA_SKIP_REG_SPILL_CHECK=1 option; timings include that build.

python scripts/benchmark_solutions.py \
  --gpu GPU-UUID --lock-directory /path/to/kernel-locks \
  --report results/baselines/local.jsonl

The runner uses the native Trace builder, validates every output element against the unchanged definition reference, then measures GPU time with CUDA events over CUDA Graph replays. Compilation and input loading occur before timing. --solution NAME selects a solution and --validation-only skips timing. --compare-to capture explicitly compares against saved engine outputs instead; two approximate implementations can differ beyond tolerance even when both pass against the independent reference.

Reproduce

The capture engine image is lmsysorg/sglang:nightly-dev-cu13-20261014-684fea8a, verified as lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8. It contains PyTorch 2.14.1+cu130 and SGLang build 684fea8af3b11a5b51ec9966c02959a32ad3421c. The native dataset checker was run with FlashInfer-Bench commit 15618a67e8d7b7f49ca61b5ba3b9f26a876d0bee. The Modal runner defaults to its cached image in the current workspace; --image accepts another prepared Modal image ID. Install the Modal client locally and authenticate it before using the runner. Model downloads use a CPU worker and the task's persistent volume.

For LTX, pass --audio-sdpa-backend math --video-sdpa-backend math. These options select standard PyTorch math SDPA for every transformer audio/video attention call, retaining BF16 inputs/outputs and FP32 intermediates. This avoids the default BF16 backend's observed tolerance failures and includes all nine LTX requests without changing references or tolerances.

# Use a GPU lock directory appropriate for your environment.
python scripts/run_modal_capture.py --name image-model --kind image \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name image --kind image \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name qwen-model --kind qwen-next \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name qwen-agentx --kind qwen-next \
  --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name qwen-overlap --kind qwen-next \
  --case overlap_p50 --case overlap_p95 --case overlap_p100 \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name deepseek-model --kind deepseek41 \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name deepseek-agentx --kind deepseek41 \
  --case short_request --case cold_main --case full_context_p50 \
  --case full_context_p90 --case full_context_max --case overlap_p50 \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name ltx-model --kind ltx25 \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name ltx --kind ltx25 \
  --audio-sdpa-backend math --video-sdpa-backend math \
  --reference-image /task/data/captures/image/results/square.png \
  --lock-directory /path/to/kernel-locks

The runner takes exclusive GPU locks, uploads the capture hooks and definitions, starts the serving engine, sends requests, validates captured outputs, releases the GPUs, and retrieves dumped tensors. Runs are stored under results/capture/<name>/dataset/. --retrieve-only resumes file retrieval using the saved inventory. --case selects a request; --max-output-tokens explicitly caps output for instrumentation checks. For image/video capture, --num-outputs 2 or --num-outputs 4 requests native multi-output generation; use a distinct --name for each run. --reference-image can reuse the original single-image capture for both editing and video conditioning. Every returned image/video is saved and its count checked.

With the pinned engine image and an existing checkpoint, DeepSeek can also run directly on four local GPUs. Acquire their device locks before running the following command. Container caches must be writable; set SGLANG_CACHE_DIR to a writable task directory when the container filesystem is read-only.

CUDA_VISIBLE_DEVICES=0,1,2,3 python scripts/capture_llm.py \
  --kind deepseek41 --model-path /path/to/DeepSeek-V4.1-Flash \
  --output-root results/capture/deepseek-host/dataset \
  --case short_request --case cold_main --case full_context_p50 \
  --case full_context_p90 --case full_context_max --case overlap_p50

To reproduce each validated LTX batch, use --audio-sdpa-backend math --video-sdpa-backend math, and run all three request types with --num-outputs 1, 2, and 4 under distinct run names. Keep the same reference image for image editing and image-conditioned video.

The published dataset keeps every passing workload from the nine canonical runs: images 101 + 78 + 78; Qwen 193 serial + 448 concurrent; DeepSeek 278 of 279; LTX 69 + 69 + 69. The optional Modal retrieval filters (--batch-sizes and --context-endpoints) were not used for this publication. DeepSeek retains 52 workloads per grouped matrix definition, 50 router calls, 42 mixed-attention calls, and 30 sparse-prefill calls. Each grouped definition covers actual row counts 6/12/18/768/2688/11904/14592/17664/20736/24192/24576. Decode captures include early, middle, and final steps and actual concurrent batches 1/2/3.

All 768 original request/operator/step locations remain represented. New UUIDs and tensor hashes identify the regenerated values. Images, Qwen, and LTX retain every original exact runtime shape. DeepSeek mixed attention keeps the actual reachable physical pages selected by the new full-model execution: 14 calls differ in their N4/N8 page counts, leaving 12 original exact storage shapes absent. These content-dependent cache footprints are not padded to imitate earlier allocations.

Pinned checkpoints are Qwen Image 2.1 Turbo, NVIDIA Qwen 3.8 Flash-Next NVFP4, and DeepSeek V4.1 Flash. Qwen uses the full NVIDIA quantized export with its original architecture, not a smaller model. Its large embedding table is offloaded to CPU.

All regenerated DeepSeek samples use exactly four B300 GPUs with tensor parallelism 4, expert parallelism 4, and data parallelism 1. Tensor and expert parallelism use the same four GPUs. The local run retains the full architecture and shared CPU Engram tables. Prefill chunks contain at most 4,096 tokens; CUDA Graph and overlap scheduling are disabled for capture. The capture hook gathers all expert shards and query heads into complete logical operators. It also corrects the pinned engine's FP4-expert scale recipe to use the dispatcher's actual activation-group metadata; quantized tensor bytes are unchanged. Mixed-attention runs explicitly select the V4.1 cache layout, because the pinned engine otherwise defaults to the older layout. These settings are recorded with each request.

LTX uses the licensed public original-weight distribution and a pinned convolutional VAE distribution. prepare_ltx.py verifies file hashes, retains license notices, extracts the embedded Gemma tokenizer, and invokes the official Diffusers converter at commit efe46a5b177af67c64b3666da8ddddac7ee12163. All components load strictly, including all text/transformer layers and vision/audio embeddings. The original optional decoder keyframe tag is retained; these requests use the ordinary decoder path without an auxiliary keyframe stream.

Import and validate

Only completely validated captures can be imported:

python scripts/capture_inputs.py --import-capture results/capture/image/dataset --output-root .
python scripts/check_workload_inputs.py
python scripts/capture_inputs.py --replay-root . --device cuda

Input checking requires PyTorch, safetensors, and FlashInfer-Bench. It verifies native schemas, every tensor's shape/dtype/content hash, complete input mappings, and provenance coverage. Missing model captures are listed separately. Output replay runs the embedded reference at each complete captured shape and compares all output elements with the saved serving output. No output sampling is used.

BF16 comparisons use rtol=0.016, atol=0.005; FP32 uses rtol=1e-4, atol=2e-5; integer outputs must match exactly. Gated delta prefill state has a separate finite-precision comparison because the engine's chunk algorithm rounds intermediate matrix operands to BF16 despite storing state in FP32: relative root-mean-square error ≤1%, maximum absolute error relative to the largest state value ≤1.5%, and per-head relative root-mean-square error ≤2%. Every measured error and criterion is saved with its workload. Qwen block IDs and DeepSeek expert IDs are serialized in increasing ID order without changing selected membership; router weights follow their IDs. Original engine IDs/weights are also saved. Comparisons preserve exact selected-set equality; this ordering does not relax selection accuracy.

One complete router workload is excluded from the 279 DeepSeek raw captures: at two rows of a 4,096-row call, FP32 ranking ties produce different expert selections. The original FP32 reference and exact selected-set requirement remain unchanged. This call was also absent from the original dataset. No rows are removed from published tensors. All nine LTX requests pass and are included.

Tensor files are published directly as blob/workloads/<definition>/<hash>.safetensors through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 6,763 paths contain 6,223 unique snapshots totaling 168.49 GB (169.51 GB when materialized at every path).

git clone https://huggingface.co/datasets/humanfia-lab/inference-kernels
cd inference-kernels
git lfs install --local
git lfs pull
python scripts/check_workload_inputs.py

Checkpoint tensors retain their upstream license terms; required license text and notices are in licenses/. The NVIDIA export's model card links the NVIDIA Open Model License and Qwen Community License.

results/ holds local run logs, generated images, and validation reports. record.md stays outside this repository and is never committed. The new capture runs do not support serving-performance claims because tracing and comparison add substantial overhead; baseline measurements above are historical.