KohakuBlueleaf_KohakuTPU/docs/projects/kohakutpu/tinygrad.md

metadata

title: The tinygrad frontend
summary: >-
  tinygrad as an optional tensor frontend that dispatches into the same kernel
  library — where the seam is, what is switched off, and the ops where this path
  is worse than calling the library.
tags:
  - kohakutpu
  - compiler
  - software

Tinygrad as the tensor frontend

Kind: Yours throughout. An optional tensor frontend, where its seam falls and what it switches off are this project's software choices. The framework has no frontend and no opinion about one.

ktpugrad makes Tensor(x, device="KTPU") work by matching tinygrad's lowered loop nest against this project's kernel library and dispatching the library kernel. It is an optional frontend, not a replacement for L5 — the reason is §3.

1. The seam

On tinygrad 0.13 the ast is already a lowered loop nest by the time a backend sees it: Ops.PARAM / INDEX / RANGE / REDUCE / RECIPROCAL, with no ShapeTracker and strides as affine coefficients. There is no Tensor.schedule and no realize.get_runner; the ast exists only where to_program is called, which is therefore the seam. ktpugrad.capture() records asts through the installed seam rather than rebuilding one, and _PATTERNS is captured at import: rebuilding the pattern matcher from an already-rebound matcher re-snapshots a stale dict and the seam silently stops firing.

ktpugrad touches nothing outside its own directory. The device takes its machine from kohakutpu.api.device(), so the whole path is gradeable without a card.

2. What is switched off, and why

On the Renderer:

flag	set to	why
has_local	False	there is no thread and no program_id; a unit is programmed, not commanded
has_shared	False	no inter-unit barrier inside a kernel, so no shared scratch to put behind one
shared_max	0	follows
local_max	(1,1,1)	one program per unit
tensor_cores	[]	WMMA is a warp of threads cooperating on a fragment; our GEMM is a whole-tile instruction with gm/gn/nk as fields, not a warp op
supports_float4	False	vector width is a codegen concern; our fills are entry-granular, 4 lanes x 32 K

By environment:

• NOOPT=1 — skips apply_tensor_cores and hand_coded_optimizations, i.e. every OptOps: UPCAST, UNROLL, LOCAL, GROUP, GROUPTOP, NOLOCALS, PADTO, SWAP. All are loop transforms over generated code. We generate no loops — the equivalent decision here is gm/gn/nk, which Compiled.compile already chooses per shape.
• BEAM=0 — beam search times candidate kernels by RUNNING them. Over JTAG at 100 MHz that is not a search, it is a hang.

3. Where the mapping fails

1. Our multi-stage fused kernels lose. softmax is FOUR tinygrad kernels and ONE of ours; rmsnorm, layernorm, group_norm_silu and flash_attention are the same shape of loss. The scheduler has already cut them apart before we see them, so matching them back means re-fusing across kernel boundaries — which is a scheduler of our own, i.e. the thing adopting tinygrad was meant to avoid. Adopting it wholesale would make attention and the norms slower than the library we already ship.
2. Reduces map only along a row. REDUCE_AXIS over the LAST axis is row_sum/row_max. Any other axis has no mapping; the vector core reduces ALONG a row and nothing transposes.
3. dtype. tinygrad defaults to float32; this machine is fp16 in, MXFP7 operands, FP22 accumulator. The frontend is pinned to dtypes.float16, and the accumulator's extra range is invisible to tinygrad's cost model. The product itself must be fp16 to match: an fp32 matmul over fp16 buffers has its casts exactly where the accumulator's are, so a matcher that only unwraps casts will match it and dispatch the wrong kernel.
4. Tensor.rand costs 7 threefry kernels of pure elementwise integer work. None of it maps; use Tensor(numpy_array).

A fused elementwise chain was on this list and came off it: x*2+1 is one tinygrad kernel and two library entries, but lang/vector.py already turns an expression tree into a vector chain, so the job was UOp-tree → L4 chain at the level built for it — a translation rather than new machinery.

4. What generates

Matmul, epilogues, elementwise chains, and — via the chain generator — softmax and the norms. Two readings carry more weight than their size suggests:

• rsqrt, not sqrt, is what unlocked the norms. tinygrad spells rsqrt(z) as RECIP(SQRT(z)), read as the PAIR onto OpKind.RSQRT, which lowers to a correct VRSQRT. Nothing maps OpKind.SQRT, so a bare x.sqrt() still refuses.
• min and max arrive as selects. WHERE(CMPLT(a, b), b, a) is max(a, b) and WHERE(CMPLT(a, b), a, b) is min(a, b); x.clip(lo, hi) is two of them nested. Those are the only two select shapes read as arithmetic, because every other one is a real predicate.

5. The ceiling, and it is the one that matters for a DiT

A row must be a multiple of 16 and at most VLMAX = 128. So a DiT's attention softmax at L=1024 REFUSES, and so does a layernorm over a 1024-wide model dimension. This is pre-existing — RowReduceKernel carries the identical check — but it means "softmax and the norms generate" is true at 64-wide rows and false at DiT rows.

And the escape hatch does not lift it. Measured at 256 and 1024: ktpugrad.softmax, K.softmax, K.layernorm, K.rmsnorm, K.group_norm and K.row_sum all raise the same refusal, so the message names that rather than sending the reader to a door that is also shut. The hierarchical form exists only as kernels.groupnorm.group_stats — verified past 128, unexported, and wired into no row-wise kernel.

scaled_dot_product_attention still needs the hatch: its score is a batched contraction the matcher declines, and a rank-3 reduce is refused rather than guessed at — reading [2][32][64] as rows=2 would be the wrong row count, so the refusal is at rank and does not lean on a downstream span check.

Also refused, each by name: a fold down a column, a fold over two axes, a MUL reduce, and a row where VRED cannot fold.

6. The shape of the answer

tinygrad as an OPTIONAL frontend that dispatches into the same kernel library, with our own multi-stage kernels kept and reachable, and a documented list of the ops where the tinygrad path is slower than calling the library directly.

The refusals are asserted as tightly as the matches. A matcher that quietly widened would dispatch a wrong kernel and report success — which is why every refusal above is a test, and why the escape hatch is held to the same line: a refused ast still raises rather than falling through to something that computes a different thing.