MatmulTileScenario

Optimization scenarios · Implementation: mlsysim/engine/scenario_definitions/optimization.py.

Construct this scenario with keyword inputs. The fields below show the types and defaults declared by this class.

C = A B with A m x k and B k x n, computed one tile_m x tile_n output tile at a time, stepping through the reduction tile_k elements per step.

Operands are operand_bytes each and the accumulator accumulator_bytes. The on-chip store holds one A tile and one B tile (two of each when double buffered) and the accumulator tile. Traffic counts element moves between memory and the on-chip store: A is loaded once per output-tile column, B once per output-tile row, and C written once. The single-cell loop orders (no tile) count one held value per cell: the other operands stream once per MAC, and a partial sum that is not held is read and written once per MAC.

Notes

Equation: The calculation members below define macs, flops, tiles_m, tiles_n, tiles_k, output_tiles, tile_products, tile_product_flops, tile_product_bytes, tile_intensity, unblocked_intensity, compulsory_intensity, buffer_copies, a_tile_bytes, b_tile_bytes, accumulator_tile_bytes, operand_tile_bytes, live_bytes, fits, a_bytes, a_elements, b_elements, c_elements, a_moves, b_moves, tiled_moves, global_loads_per_mac, partial_sum_moves, a_stationary_moves, output_stationary_moves, b_stationary_moves, row_b_reads.

Assumptions: Dense multiplication uses two FLOPs per MAC and fixed-width operands/accumulators; full-tile work counts padded edges.

Excludes: Bank conflicts, cache effects, scheduling overhead, and precision-dependent arithmetic throughput.

References

Derivation: C = A B with A m x k and B k x n, computed one tile_m x tile_n output tile at a time, stepping through the reduction tile_k elements per step. Each member records the corresponding algebra or named physics function.

Examples

Evaluate the named configuration and display a modeled result.

>>> from mlsysim import Scenarios
>>> case = Scenarios.Matmul4096Fp16Tile128
>>> value = case.tile_intensity
>>> print(f"{value:.3g}")
64

Attributes

Name	Description
a_bytes	Full A-matrix storage in bytes at operand precision.
a_elements	Number of elements in the M-by-K input matrix A.
a_moves	A-element reads when A is reloaded for every output tile column.
a_stationary_moves	Element transfers when each cell retains A while B and partial sums stream.
a_tile_bytes	Live A-tile operand buffers in bytes, including double buffering if enabled.
accumulator_bytes
accumulator_tile_bytes	Output-tile accumulator storage in bytes at accumulator precision.
b_elements	Number of elements in the K-by-N input matrix B.
b_moves	B-element reads when B is reloaded for every output tile row.
b_stationary_moves	Element transfers when each cell retains B while A and partial sums stream.
b_tile_bytes	Live B-tile operand buffers in bytes, including double buffering if enabled.
buffer_copies	Operand buffer-copy count: two for double buffering, otherwise one.
c_elements	Number of elements in the M-by-N output matrix C.
compulsory_intensity	FLOP/byte if each A, B, and C element moves exactly once at operand precision.
double_buffered
flops	Dense multiplication work in FLOPs, two operations per MAC.
global_loads_per_mac	Operand loads per MAC for a full tile, reciprocal tile dimensions summed.
k
live_bytes	Combined operand and accumulator bytes simultaneously resident.
m
macs	Multiply-accumulate count for dense M-by-K times K-by-N multiplication.
n
operand_bytes
operand_tile_bytes	Combined A and B operand-buffer bytes, excluding accumulators.
output_stationary_moves	Element transfers when output sums remain local and both operands stream.
output_tiles	Number of output tiles, tile rows times tile columns.
partial_sum_moves	Partial-sum transfers if each MAC reads and writes its sum.
tile_intensity	FLOP per operand byte loaded for a full tile, excluding output traffic.
tile_k
tile_m
tile_n
tile_product_bytes	Operand bytes loaded for one full A-tile/B-tile product.
tile_product_flops	FLOPs for one full tile product; edge padding is counted as full work.
tile_products	Tile products required, one per output tile and reduction slice.
tiled_moves	Total element transfers: tiled A and B reads plus one output write.
tiles_k	Reduction tile count, rounding K up to a multiple of reduction width.
tiles_m	Output tile-row count, rounding M up to a multiple of tile height.
tiles_n	Output tile-column count, rounding N up to a multiple of tile width.
unblocked_intensity	FLOP/byte when every MAC loads both operands without reuse.

Methods

Name	Description
fits	Whether live bytes fit the supplied capacity quantity; equality is feasible.
row_b_reads	B-element reads after reuse along `cells` cells; integer division requires complete sharing groups.

fits

engine.scenario_types.MatmulTileScenario.fits(capacity)

Whether live bytes fit the supplied capacity quantity; equality is feasible.

Equation: bool(live_bytes <= capacity).

row_b_reads

engine.scenario_types.MatmulTileScenario.row_b_reads(cells)

B-element reads after reuse along cells cells; integer division requires complete sharing groups.

B reads when each B value passes along a row of cells cells holding A values.

Equation: macs // cells.