Glossary#

Terms#

batch#

One independent reduction in cuda.coop.cutlass.reduce_batched(). Each lane contributes the value in the same local payload slot: slot j contributes to batch j. A batch spans the selected warp, and its result belongs to the lane and slot selected by the output layout. See batched reduction.

bin#

A counter indexed by an input sample in cuda.coop.cutlass.histogram(). A sample with value b increments bin b. Every sample must satisfy 0 <= b < bins. Returned bins use striped ownership. See Histogram.

blocked#

A layout in which each thread owns consecutive elements of a tile. With K items per thread, thread t owns tile positions t * K through t * K + K - 1. See blocked versus striped.

compiler integration#

The machinery that recognizes cuda.coop.cutlass calls while CuTe traces a kernel, generates CUB provider functions, and links them into device code. See the Developer Guide.

decoded window#

The output interval returned by one cuda.coop.cutlass.run_length_decode() call. Its start is an offset in the expanded sequence, and its capacity is block_threads * decoded_items_per_thread. Positions beyond the sequence contain zero. See decoding windows and scratch.

family#

A group of related primitives that share semantics and implementation. For example, the Scan family includes scan, exclusive_scan, inclusive_scan, exclusive_sum, and inclusive_sum. Families organize implementation modules; a thread group describes the threads executing a primitive. See the implementation discussion in the Developer Guide.

head flag#

An integer flag marking the start of a sequence according to Discontinuity’s comparison predicate. With the default inequality predicate, it is one where an item differs from its predecessor. Without an explicit tile predecessor, the first item is a head. See Discontinuity.

key-value pair#

A key used for ordering or selection and an associated value, such as its original array index. Pair operations move the two together. Key and value payloads have the same number of items per thread but may have different dtypes. See Merge Sort.

payload#

The values contributed or received by one thread. ThreadData(K) describes a fixed-size payload of K items. Some operations also accept scalars or CuTe register tensors. See thread data.

phi#

A compiler intermediate representation (IR) operation that selects a value according to the control-flow path taken into a block. For example, after an if statement assigns different values to a variable, a phi selects the value from the branch that ran. At a loop header, it can select the initial value or the value from the previous iteration. Comments refer to these alternatives as phi inputs.

primitive#

A cooperative operation provided by cuda.coop.cutlass, such as load, reduce, or exclusive_sum. Each primitive defines which threads participate, how it uses their data, and where its results are available. See participation and synchronization.

radix digit#

A fixed-width interval of key bits used in one ranking or sorting step. radix_rank_keys assigns ranks according to one such digit; radix_sort_keys and radix_sort_pairs order keys over the requested bit interval. See radix sorting and ranks.

relative run offset#

A decoded element’s position within its own run. For runs [7, 9] with lengths [3, 2], the full sequence has relative offsets [0, 1, 2, 0, 1]. This differs from its absolute decoded position or its position within a requested window.

run#

A consecutive sequence represented by one value and its repetition count, such as value 7 and length 3 representing 7, 7, 7. Run Length Decode expands these pairs. Its run-length payload uses positive lengths followed by optional zero-length padding. See Run Length Decode.

stable sort#

A sort that preserves the input order of elements with equal keys. A function’s contract must promise stability before a program relies on it. Radix Sort in cuda.coop.cutlass is stable; Merge Sort does not promise equal-key order. See radix sorting.

striped#

A layout in which consecutive threads own consecutive tile elements at each per-thread item position. For G threads, thread t owns tile positions t, t + G, t + 2 * G, and so on. See blocked versus striped.

tail flag#

An integer flag marking the end of a sequence according to Discontinuity’s comparison predicate. With the default inequality predicate, it is one where an item differs from its successor. Without an explicit tile successor, the last item is a tail.

temporary storage#

Shared-memory scratch used internally by a primitive. The compiler allocates it automatically when needed. An explicit TempStorage descriptor can control allocation sharing and synchronization for supported operations. A reservation returns a typed shared view for application data; its lifetime and synchronization remain the caller’s responsibility. See the temporary-storage FAQ.

thread group#

The threads participating in a primitive, such as a block, a physical warp, or a logical group within a warp. A thread’s rank identifies its position within that group. See groups.

tile#

The sequence of values processed by one group in an operation. With G threads and K items per thread, a full tile has G * K values. valid_items in Load and Store selects a prefix of that sequence. It counts tile elements, not elements per thread.

tile boundary#

The edge between one group’s tile and the neighboring data. Adjacent Difference and Discontinuity can consume an explicit predecessor or successor value to compare across this edge. Without one, their endpoint rules apply to the local tile. See Adjacent Difference and Discontinuity.

top-k#

Selection of up to k smallest or largest keys, optionally with associated values. cuda.coop.cutlass TopK returns an unordered selection; only its selected prefix is defined. See TopK.

Blocked versus striped#

Both layouts distribute the same tile across threads. They differ in which thread owns each position. For four illustrative threads and two items per thread, a tile of positions 0 through 7 is distributed as follows:

Thread rank

Blocked: items[0], items[1]

Striped: items[0], items[1]

0

0, 1

0, 4

1

2, 3

1, 5

2

4, 5

2, 6

3

6, 7

3, 7

For group size G, items per thread K, thread rank t, and local item slot i:

Layout

Tile position owned by items[i] in thread t

Owner of tile position p

Blocked

t * K + i

Thread p // K, slot p % K

Striped

t + i * G

Thread p % G, slot p // G

The four-thread table illustrates ownership, not a supported physical CUDA warp size. A physical warp has 32 threads.

Layout describes the values a caller sees. The memory-access algorithm may use a different intermediate layout. For example, load(..., algorithm="transpose") reads striped values, then rearranges them into blocked payloads. algorithm="striped" leaves the payloads striped.

Store expects the layout selected by its algorithm. Combining a striped Load with a direct Store without conversion changes the output order. ThreadData does not carry a layout tag that corrects this mismatch.

Follow the values in the Load and Store visualizations. Exchange converts between layouts; the shared layout discussion explains how layout affects Scan.

Run positions, windows, and scratch#

Run Length Decode first prepares a table of run values and starting positions in shared scratch. A window offset then selects where to read from the expanded sequence. For values [7, 9] and lengths [3, 2]:

Absolute decoded position

Value

0

7

1

7

2

7

3

9

4

9

A window starting at position two begins with values [7, 9, 9]. The total decoded size remains five. Each independent window call prepares its table again; passing the same TempStorage descriptor reuses memory, not a prepared decoder.

cuda.coop.cutlass.run_length_decode_into() keeps that table alive while it loops over windows within one call. The table’s lifetime ends when the call returns. Neither form exposes a parent decoder object or a mutable decode cursor. See the RLD lifecycle FAQ.