API reference

Gives one point of access to the Level 1, 2 and 3 BLAS routines.

Holds one scalar argument of a BLAS call as a complex double, on the host.

Holds one double parameter as a value of each real and integer element type.

Holds a GEMM epilogue functor together with the regions it reads and writes.

Holds an element functor with its N scalar parameters narrowed to T; this is what a kernel captures.

Holds an element functor with N scalar parameters not yet narrowed; it stays on the host.

Records element-wise arithmetic and mathematical operations on contiguous tensors.

Owns one task graph with its scratch pool, recorder, tensor factory and random stream, and runs the graph.

Builds the TaskMetadata of one BLAS task: scalars first, then flags.

Runs an operation's reference or SYCL kernel under the mode fixed at record time.

Holds one reference to each distinct Storage a recorded task must keep allocated.

Input/Output operations for Tensors.

Holds the running sum of a reference kernel: in double for HALF, FLOAT32 and COMPLEX32, compensated for FLOAT64 and COMPLEX64.

Holds the solved elements of a substitution in Accumulator<T> between steps.

Records the Level 1 BLAS routines.

Records the Level 2 BLAS routines.

Records the Level 3 BLAS routines.

Records comparisons, boolean combinations and truth tests of tensors.

Records activation functions and their backward passes on contiguous tensors.

Collects the tensors one task touches: their regions and the storage they live in.

Records random fills of tensors, drawing from one random stream.

Holds a complex running sum as two CompensatedSum, one per component.

Holds a running sum that carries Neumaier's correction term.

Holds a running sum over a type whose addition is exact.

Holds the running (value, index) maximum under the iamax reference kernel's NaN rule.

Holds a running maximum in the shape the folding seams accumulate in.

Holds a running product, folded in the same fixed order as CompensatedSum.

Holds a running Euclidean norm that cannot overflow or underflow on the way.

Records reductions of a tensor into a scalar result tensor or along an axis.

Holds one counter-based random stream: a seed and an offset counter under one lock.

Leases one device scratch block; the block returns to its pool when the last copy dies.

Owns the shelf of device scratch blocks that ScratchBuffer leases come from.

Sparse matrix operations.

Records windowed gathers, windowed reductions and channel-wise broadcasts.

A class to manage memory for tensors.

Identifies one task a TaskRecorder recorded, or no task.

Records tasks on one TaskGraph under one execution mode.

Allocates dense tensors of one default layout from one runtime context.

Detects whether a type is a std::complex specialization.

Specialization matching any std::complex<T>.

Holds the launch geometry of a one-dimensional grid-stride kernel.

Holds what a kernel that stages a tile in work-group local memory needs from a device.

Holds the device properties a kernel is allowed to dispatch on.

Carries one element type to a with_element_type arm as a value.

Holds the batch count, matrix size, leading dimension and layout of one operand.

The finalizer a reduction with nothing to finalize passes.

The transform a reduction with nothing to transform passes.

Holds a device buffer a reduction may stage per-work-group partials in.

Holds the element count and the distance between consecutive elements of a vector.

Names the type a sum of T is accumulated in: T itself for every type but HALF.

Accumulates HALF in FLOAT32.

Adds a per-channel bias to each GEMM output element, in either layout.

Conjugates: the policy of dotc, gerc, hemv, her, her2 and herk.

Stores the computed GEMM element unchanged.

Holds the row step, the column step and the conjugation of one operand's op(X).

Names the real component type of T: T itself for a real type.

Names R as the real component type of std::complex<R>.

Names the type a reference kernel sums a real T in: double.

Sums a complex element in std::complex<double>.

Leaves every element as it is: the policy of an unconjugated or symmetric routine.

How one per-element kernel walks its elements.

The launch geometry of one segmented reduction.

Holds where one segmented reduction's inputs and outputs live, in element counts.

Pairs a value with the index it was read from.

Holds the launch geometry of one reduction.

Holds the seed and first offset one random task draws from.

Holds how an im2col matrix is addressed: a row stride and an element stride.

Holds a 2-D sliding window: its size, step, spacing and origin.

Holds where one spatial operation's input and output live, in element counts.

A structure that represents a multi-dimensional array of data.