Operations

arange(shape; dtype=Int32, start=1, step=1) -> Tile{dtype, shape}
arange(n; dtype=Int32, start=1, step=1) -> Tile{dtype, Tuple{n}}

Create a 1D tile with values [1, 2, 3, ..., n] (1-indexed).

Example

indices = ct.arange(16)              # Int32 [1, 2, ..., 16]
indices = ct.arange(16; dtype=Int64) # Int64 [1, 2, ..., 16]
odd = ct.arange(16; start=1, step=2) # Int32 [1, 3, ..., 31]

cat(tiles::Tuple{Tile, Tile}, axis::Int) -> Tile

Concatenate two tiles along the specified axis (1-indexed). Supports negative axis (e.g., -1 for last dimension).

Example

tile_a = ct.load(arr_a, (1,), (4, 8))  # Shape (4, 8)
tile_b = ct.load(arr_b, (1,), (4, 8))  # Shape (4, 8)
# Concatenate along axis 1: (4, 8) + (4, 8) -> (8, 8)
combined = ct.cat((tile_a, tile_b), 1)
# Concatenate along axis -1 (last): (4, 8) + (4, 8) -> (4, 16)
combined_last = ct.cat((tile_a, tile_b), -1)

broadcast_to(tile::Tile{T, S}, shape::NTuple{N, Int}) -> Tile{T, shape}

Explicitly broadcast a tile to a target shape.

Example

row = ct.load(arr, (1, 1), (1, 128))  # Shape (1, 128)
expanded = ct.broadcast_to(row, (64, 128))  # Shape (64, 128)

extract(tile::Tile{T, S}, index::NTuple{N, Int}, shape::NTuple{N, Int}) -> Tile{T, shape}

Extract a sub-tile from a tile at the given slice indices.

IMPORTANT: The index parameter specifies SLICE INDICES, not element offsets!

For each dimension, the source tile is divided into S[i] ÷ shape[i] non-overlapping slices. The index[i] selects which slice to extract (1-indexed).

Example: Extracting quadrants from an 8×8 tile

tile = ct.load(arr, (1, 1), (8, 8))
# 8÷4 = 2 slices per dimension, so valid indices are {1, 2} × {1, 2}
tl = ct.extract(tile, (1, 1), (4, 4))  # Top-left (rows 1-4, cols 1-4)
bl = ct.extract(tile, (2, 1), (4, 4))  # Bottom-left (rows 5-8, cols 1-4)
tr = ct.extract(tile, (1, 2), (4, 4))  # Top-right (rows 1-4, cols 5-8)
br = ct.extract(tile, (2, 2), (4, 4))  # Bottom-right (rows 5-8, cols 5-8)

insert(tile::Tile, index, value::Tile) -> Tile

Return a copy of tile with the non-overlapping subtile at the 1-indexed slice index replaced by value. This is the inverse of extract and requires Tile IR v13.4 or newer.

Base.reinterpret(::Type{T}, x::Tile) -> Tile{T}

Reinterpret the whole tile x as a tile of element type T, like reinterpret(T, ::AbstractArray): the underlying bits are viewed as a contiguous (column-major) block and the leading dimension is rescaled by the ratio of element widths. Lowers to cuda_tile.bitcast for equal widths and to cuda_tile.pack/unpack (via reshape to rank-1) when widths differ.

This is how sub-byte formats move through global memory: a Tile{UInt8,Tuple{N}} reinterprets to a Tile{Float4_E2M1FN,Tuple{2N}} and back, so FP4 data can be stored in a UInt8 array. The total bit-width is preserved, so it must divide evenly.

Note reinterpret.(T, x) (with a dot) is the unrelated element-wise broadcast, which keeps the shape and requires T to be the same width as eltype(x).

bytes = ct.load(a, pid, (8,))                 # Tile{UInt8,Tuple{8}}
fp4   = reinterpret(Float4_E2M1FN, bytes)     # Tile{Float4_E2M1FN,Tuple{16}}
vals  = convert(ct.Tile{Float32}, fp4)        # widen for compute

Base.reinterpret(reshape, ::Type{T}, x::Tile) -> Tile{T}

The reshape-form whole-tile reinterpret, mirroring reinterpret(reshape, T, ::AbstractArray): instead of rescaling the leading dimension it removes it when widening (the leading dim must equal bitwidth(T) ÷ bitwidth(eltype(x))) and prepends one when narrowing.

divmod(x, y) -> (q, r)

Floored quotient and remainder, i.e. (fld(x, y), mod(x, y)). Accepts integer scalars or integer tiles of matching shape, and follows Julia's sign conventions: the remainder takes the sign of the divisor.

rsqrt(x)

Reciprocal square root, 1 / sqrt(x), computed as a single Tile IR operation rather than a division followed by a square root. Broadcast it (rsqrt.(tile)) to apply it element-wise over a tile.

muladd(a::Tile, b::Tile, acc::Tile; fast_acc::Bool=false) -> Tile

Matrix multiply-accumulate a * b + acc over tiles, lowering to cuda_tile.mmaf (float) or cuda_tile.mmai (i8 × i8 → i32).

a/b are 2-D matrices (M, K) × (K, N) → (M, N); a 1-D operand is promoted (vec-mat / mat-vec) and any trailing dimensions (≥3-D) are treated as broadcast batch dims, lifting Base.muladd's shape rules to tiles. acc carries the result dtype, which must be one tileiras allows for the input dtype (f16/f32 for f16 and f8; f32 for bf16/tf32; f64 for f64; i32 for i8).

fast_acc enables fast accumulation (lower accumulator precision for throughput); it is valid only for FP8 inputs and requires Tile IR v13.3+.

muladd_scaled(a, a_scale, b, b_scale, acc) -> Tile

Block-scaled matrix multiply-accumulate (a ⊙ a_scale) * (b ⊙ b_scale) + acc, lowering to cuda_tile.mmaf_scaled (Tile IR v13.3+, Blackwell). Each scale element multiplies a contiguous block of B = K ÷ K_s elements along the K dimension of its operand, so a_scale/b_scale match a/b in every dimension except K, where they have K_s ≤ K entries.

a/b are low-precision floats (f8e4m3fn, f8e5m2, or f4e2m1fn), a_scale/b_scale are f8e8m0fnu or f8e4m3fn, and acc is f32. Shapes follow muladd: 2-D (M, K) × (K, N), mat-vec, and trailing batch dims; vec-mat is unsupported (it would collapse K, leaving nothing to scale).