Week 5 · Lesson 6

The week 5 lab

Lift the rank limit. Your type checker learns shapes of any rank and the four movement ops, run evaluates them, and your rangeify pass turns each one into index arithmetic. You're done when every week 5 test passes, weeks 1 to 4 still pass, and you've written 10 new tests of your own.

python tools/test.py --compiler "C:/path/to/your.exe" --week 5
python tools/test.py --compiler "C:/path/to/your.exe" --week 5 -k render -v   # the render tests, with details
python tools/test.py --compiler "C:/path/to/your.exe" --week 4
python tools/test.py --compiler "C:/path/to/your.exe" --week 3
python tools/test.py --compiler "C:/path/to/your.exe" --week 2
python tools/test.py --compiler "C:/path/to/your.exe" --week 1

python tools/test.py --check-tests path/to/your-repo/tests/week5

A build order that works

1. Shapes of any rank

   Lift the rank limit everywhere except memory and params. ALU ops, where, cast and assert take one shared shape of any rank. stack takes items of one shape and adds a leading axis, and index pops one leading axis per index.

   Checkpoint: every week 1 to 4 test still passes.

2. Type the movement ops

   reshape (same element count), permute (a permutation), pad (two numbers per axis), value shrink (one provable offset per axis, using your week 1 bounds), expand (scalar, or size-1 axes only), reduce pop=m.

   Checkpoint: every file in tests/week5/run/ parses or is rejected with exit 2.

3. Evaluate them

   In run, represent a value as a shape and a flat row-major array. Each movement op is a function from output index to input index. Tabulate it over the output shape.

   Checkpoint: every week 5 run test passes.

4. Index tuples in rangeify

   Change "your element at index i" to take one index per axis. Write flatten and unflatten once, as helpers that build mul, add, div and mod nodes.

   Checkpoint: a reshape round trip renders to one loop that passes. Its index math (a flatten, an unflatten and a leftover % n) needn't be simplified to a plain copy. Correct is enough this week.

5. Each op as index arithmetic

   Permute reorders the tuple, shrink adds offsets, expand reads size-1 axes at 0, and pad clamps the index and masks the value with where.

   Checkpoint: the pad and transpose render tests pass bit for bit.

6. Reduce over several axes

   Use one accumulator, seeded with the first element, and one loop over a flat counter covering the other T - 1 combinations of the leading axes (T is the product of the popped axis sizes), unflattened in row-major order.

   Checkpoint: the movement GEMM tests pass, including the large one.

7. Clean up the index math

   Optional but worthwhile: run your week 1 simplifier on the lowered index arithmetic. Constant folding and bounds-based mod elimination remove most of what flatten and unflatten leave behind.

   Checkpoint: your rendered GEMM has no % c on a value already known to be below c.

8. Your 10 tests

   Write them, check them with --check-tests, and use them to break your compiler before the suite does.

Checklist

• Values of any rank type check, and memory and params stay rank 0 or 1
• reshape, permute, pad and value shrink parse, type check and reject bad attributes
• expand grows only size-1 axes, and stack and index work at any rank
• run evaluates every movement op, and reduce pop=m folds in row-major order
• Rangeify asks for elements by index tuple, with flatten and unflatten helpers
• Padded reads clamp their index and mask the value
• The movement GEMM renders to loops and passes bit for bit
• python tools/test.py --compiler ... --week 5 passes everything
• Weeks 1 to 4 still pass everything
• 10 week 5 tests of my own, passing --check-tests

Check yourself