Enum Refusal 

pub enum Refusal {
    StrideOrderOfAStatedLayout,
    GatherOfATiledBinding(Tiling),
    GatherWithLabels,
    GatherRankMismatch {
        mapped: usize,
        rank: usize,
    },
    GatherOfAnUnknownAxis(Axis),
    RankBelowLabels {
        rank: usize,
        block: usize,
    },
    UnlabelledBatchDims {
        dims: usize,
        axes: usize,
    },
    NoCoordinate,
    WidthNotServed {
        width: usize,
        why: LineMisfit,
    },
    UncheckableVectorEdge,
    GatherInnermostNotInLines,
    GatherAxisAddressedTwice(Axis),
    GridNotReadOffLevels {
        units: u32,
        plane: u32,
    },
    CubePastDevice {
        units: u32,
        most: u32,
    },
    PlanesUnavailable,
    ImprecisePlaneDim {
        min: u32,
        max: u32,
    },
    Declined {
        why: &'static str,
    },
    CubeShapePastDevice {
        shape: (u32, u32, u32),
        most: (u32, u32, u32),
    },
    NoUnits,
    NoCubes,
    GridPastDevice {
        count: (u32, u32, u32),
        most: (u32, u32, u32),
    },
    SharedMemoryPastDevice {
        bytes: usize,
        most: usize,
    },
    FillersWithoutBarriers {
        fillers: u32,
    },
    BoxPastDescriptor {
        axis: Axis,
        edge: usize,
        most: usize,
    },
    BoxSplitsStageBlocks {
        axis: Axis,
        rows: usize,
        period: usize,
    },
    RowsNoDescriptorLands {
        why: &'static str,
    },
    PagingOfAStatedLayout,
    PagingOfAnUnlabelledAxis(Axis),
    PagingOfOneDim(Axis),
    PagesAlongALine(Axis),
    PagingOfAnEmptyPool,
    PagingMovedByRuns,
    ScalesOfAPoolUnpaged,
    IndexTableNotU32,
    IndexTableRank {
        keys: usize,
        rank: usize,
    },
    IndexOfAStatedLayout,
    IndexOfAnAxisNotSpanned(Axis),
    IndexAlongALine(Axis),
    IndexKeyedByItsAxis(Axis),
    RunKeyedByMany(usize),
    IndexKeysCutApart(Vec<Axis>),
    IndexedAxisCut(Axis),
    CodebookOfValuesNotIndices,
    CodebookTableNotPlain,
    CodebookTableShort {
        entries: usize,
        bits: usize,
    },
}

Why a launch cannot run as described, or an operand cannot be bound to it.

Variants

StrideOrderOfAStatedLayout

in_stride_order on a gathered or storage-tiled operand.

GatherOfATiledBinding(Tiling)

A gathered mapping over a storage-tiled binding.

GatherWithLabels

gathered combined with axes or batches.

GatherRankMismatch

The mapping addresses mapped dims but the operand has rank.

Fields

mapped: usize

rank: usize

GatherOfAnUnknownAxis(Axis)

The mapping spans an axis the launched space does not have.

RankBelowLabels

The operand’s rank is smaller than its labelled block of dims.

Fields

rank: usize

block: usize

UnlabelledBatchDims

More leading dims than batch axes to label them.

Fields

dims: usize

axes: usize

NoCoordinate

An operand must address at least one coordinate.

WidthNotServed

The buffer cannot be served width wide.

Fields

width: usize

why: LineMisfit

UncheckableVectorEdge

The innermost axis is served in vector lines but is not provably in bounds.

GatherInnermostNotInLines

A gathered mapping read in vector lines whose innermost physical axis does not step by the operand’s last logical axis at coefficient 1.

GatherAxisAddressedTwice(Axis)

A gathered mapping that reads axis off several physical axes: the operand is storage-tiled, or reads one axis from two places.

GridNotReadOffLevels

A grid read off the levels (Grid::FromLevels) needs a units level of one unit or the whole plane; this one holds units.

Fields

units: u32

plane: u32

CubePastDevice

A cube of units units, past the most the device holds.

Fields

units: u32

most: u32

PlanesUnavailable

The kernel works in planes, and the device runs no plane operations.

ImprecisePlaneDim

The kernel needs one plane width, and the device’s varies between min and max.

Fields

min: u32

max: u32

Declined

A routine declines a problem it does not serve, for the reason why.

Fields

why: &'static str

CubeShapePastDevice

A cube shaped shape along x, y and z, past the most the device spawns along one of them: a cube legal in units can still be too long on an axis.

Fields

shape: (u32, u32, u32)

most: (u32, u32, u32)

NoUnits

A cube with a zero axis, which spawns no units.

NoCubes

A grid with a zero axis, which spawns no cubes: the runtime returns without dispatching anything, and the outputs keep whatever they held.

GridPastDevice

A grid of count cubes along x, y and z, past the most the device launches along one of them.

Fields

count: (u32, u32, u32)

most: (u32, u32, u32)

SharedMemoryPastDevice

A cube holding bytes of shared memory, past the most the device gives one.

Fields

bytes: usize

most: usize

FillersWithoutBarriers

fillers planes are set aside to fill a walk’s stages, and the device has no barrier type for the two roles to meet on.

Fields

fillers: u32

BoxPastDescriptor

A TMA box edge past the descriptor’s per-axis limit most.

Fields

axis: Axis

edge: usize

most: usize

BoxSplitsStageBlocks

A TMA box lands its rows whole, one after the other, and the stage’s blocks split the rows along axis, the innermost, or stack rows of them where the swizzle repeats every period.

Fields

axis: Axis

rows: usize

period: usize

RowsNoDescriptorLands

A TMA box lands its rows dense, at most swizzled within one span, and the stage keeps them as why says.

Fields

why: &'static str

PagingOfAStatedLayout

indexed over a pool of pages on a gathered or storage-tiled operand: a page is resolved coordinate by coordinate over a plain buffer’s labelled dims.

PagingOfAnUnlabelledAxis(Axis)

indexed over a pool of pages naming an axis no dim of the operand is labelled with.

PagingOfOneDim(Axis)

indexed over a pool of pages naming one dim for both the pages and their positions.

PagesAlongALine(Axis)

indexed over a pool of pages with the pages along the innermost dim, this axis’s: a line runs along it, so one line would span pages.

PagingOfAnEmptyPool

indexed over a pool of pages on a pool of no pages, or of pages of no positions: there is no page for a table entry to read.

PagingMovedByRuns

indexed over a pool of pages on an operand moved by runs (a bulk copy, a tensor map): the table resolves one line at a time.

ScalesOfAPoolUnpaged

indexed over a pool of pages whose scales span its pages or positions unplaced: they are a pool of their own, placed by the same table before they are stated.

IndexTableNotU32

indexed with a table that is not plain u32 entries, one a line: an entry is a coordinate.

IndexTableRank

indexed with a table of rank dims keyed by keys axes: a table holds one dim per key.

Fields

keys: usize

rank: usize

IndexOfAStatedLayout

indexed on a tensor map, or on a gathered, storage-tiled or paged operand: an entry moves a window of a plain buffer’s labelled dims.

IndexOfAnAxisNotSpanned(Axis)

indexed placing an axis the operand does not span.

IndexAlongALine(Axis)

indexed placing the innermost axis, this one, which the operand reads more than one value a line along: an entry is an element, and a line would straddle two of them.

IndexKeyedByItsAxis(Axis)

indexed with no key, or keyed by the axis it places.

RunKeyedByMany(usize)

Indexing::Run keyed by this many axes: a run’s end is the next entry along its one key.

IndexKeysCutApart(Vec<Axis>)

An indexed operand under a nest whose first level cutting one of these keys does not cut them all: the table is read at one step.

IndexedAxisCut(Axis)

An indexed operand under a nest that cuts the axis its entry places: a coordinate is the table’s to state, and a run is placed whole before any level cuts it.

CodebookOfValuesNotIndices

codebook on values not stored as indices (Field::Index).

CodebookTableNotPlain

codebook with a table that is not a plain one-dim buffer read one value a line.

CodebookTableShort

codebook with a table of entries, fewer than the 2^bits the indices name.

Fields

entries: usize

bits: usize

Trait Implementations

impl Clone for Refusal

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Refusal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Refusal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Refusal

impl Error for Refusal

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for Refusal

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Refusal