PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA

PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA

ASL pseudocode

The complete ASL owner is shown directly below.

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA","surface":"tile","classification":["model","legality","operand-schema"],"depends_on":["PTO-TILE-MODEL-EXECUTION-UNARY","PTO-TILE-MODEL-LEGALITY-ALLOCATION-CAPACITY"]}2
3readonly func TileElementwiseDescriptorLegal(index: TileIndex) => boolean4begin5    let tile = _Tiles[[index]];6    if TileLayoutIsCube(tile.layout) then7        return TileCubeDescriptorLegal(tile);8    end;9    return TileDescriptorLegal(index);10end;11
12readonly func TileElementwiseShapeAndTypeMatch(13    left: TileIndex, right: TileIndex) => boolean14begin15    if !TileElementwiseDescriptorLegal(left) ||16       !TileElementwiseDescriptorLegal(right) then17        return FALSE;18    end;19    return _Tiles[[left]].rows == _Tiles[[right]].rows &&20           _Tiles[[left]].columns == _Tiles[[right]].columns &&21           _Tiles[[left]].valid_rows == _Tiles[[right]].valid_rows &&22           _Tiles[[left]].valid_columns == _Tiles[[right]].valid_columns &&23           _Tiles[[left]].layout == _Tiles[[right]].layout &&24           _Tiles[[left]].storage_kind == _Tiles[[right]].storage_kind &&25           _Tiles[[left]].data_type == _Tiles[[right]].data_type;26end;27
28readonly func TileElementwiseSourceContentsDefined(index: TileIndex)29    => boolean30begin31    return TileElementwiseDescriptorLegal(index) &&32           _Tiles[[index]].contents_defined;33end;34
35readonly func TileElementwiseSourceEncodingsValid(index: TileIndex)36    => boolean37begin38    if !TileElementwiseSourceContentsDefined(index) then return FALSE; end;39    let tile = _Tiles[[index]];40    for row = 0 to tile.valid_rows - 1 looplimit 65536 do41        for column = 0 to tile.valid_columns - 1 looplimit 65536 do42            let element = TileLogicalLinearIndex(tile,43                row as integer {0..65535},44                column as integer {0..65535});45            if !TileNumericEncodingValid(46                   tile.data_type,47                   TileReadLogicalElement(tile, element)) then48                return FALSE;49            end;50        end;51    end;52    return TRUE;53end;54
55readonly func TileOperandsLegal_ExecuteTileBinary(56    op: TileBinaryOperation, destination: TileIndex,57    source_left: TileIndex, source_right: TileIndex) => boolean58begin59    if !TileElementwiseShapeAndTypeMatch(source_left, source_right) ||60       !TileElementwiseShapeAndTypeMatch(destination, source_left) then return FALSE; end;61    if TileBinaryUsesClosedElementwiseContract(op) then62        if !TileElementwiseSourceContentsDefined(source_left) ||63           !TileElementwiseSourceContentsDefined(source_right) ||64           !TileBinaryDataTypeSupported(65               op,66               _Tiles[[source_left]].data_type) ||67           !TileElementwiseLayoutSupported(_Tiles[[source_left]].layout) then68            return FALSE;69        end;70    end;71    if (op == TileBinary_MAX || op == TileBinary_MIN) &&72       TileDataTypeIsFloating(_Tiles[[source_left]].data_type) &&73       (!TileElementwiseSourceEncodingsValid(source_left) ||74        !TileElementwiseSourceEncodingsValid(source_right)) then75        return FALSE;76    end;77    if (op == TileBinary_DIV || op == TileBinary_REM) &&78       TileDataTypeIsInteger(_Tiles[[source_right]].data_type) then79        return TilePayloadNonzero(source_right);80    end;81    return TRUE;82end;83
84readonly func TileOperandsLegal_ExecuteTileFillScalar(85    destination: TileIndex, scalar: Word) => boolean86begin87    return TileDescriptorLegal(destination) &&88           _Tiles[[destination]].storage_kind == TileStorage_Numeric &&89           _Tiles[[destination]].layout == TileLayout_RowMajor &&90           TileFillPadDataTypeSupported(91               _Tiles[[destination]].data_type);92end;93
94readonly func TileOperandsLegal_ExecuteTileUnary(95    op: TileUnaryOperation, destination: TileIndex, source: TileIndex) => boolean96begin97    if !TileElementwiseShapeAndTypeMatch(destination, source) then return FALSE; end;98    if TileUnaryUsesCompleteElementwiseSchema(op) then99        if !TileElementwiseSourceContentsDefined(source) ||100           !TileUnaryDataTypeSupported(op, _Tiles[[source]].data_type) ||101           !TileElementwiseLayoutSupported(_Tiles[[source]].layout) then102            return FALSE;103        end;104        if TileDataTypeIsFloating(_Tiles[[source]].data_type) &&105           !TileElementwiseSourceEncodingsValid(source) then106            return FALSE;107        end;108    end;109    return TRUE;110end;111
112readonly func TileOperandsLegal_ExecuteTileScalar(113    op: TileBinaryOperation, destination: TileIndex,114    source: TileIndex, scalar: Word) => boolean115begin116    let carrier_logical = (op == TileBinary_AND ||117                           op == TileBinary_OR ||118                           op == TileBinary_XOR) &&119                          TileVecScalarIntegerDataTypeSupported(120                              _Tiles[[source]].data_type);121    if !TileElementwiseShapeAndTypeMatch(destination, source) ||122       _Tiles[[source]].storage_kind != TileStorage_Numeric ||123       !TileElementwiseLayoutSupported(_Tiles[[source]].layout) ||124       !TileBinaryDataTypeSupported(op, _Tiles[[source]].data_type) ||125       !TileElementwiseSourceContentsDefined(source) ||126       (!carrier_logical && !TileElementwiseSourceEncodingsValid(source)) then127        return FALSE;128    end;129    let normalized_scalar = TileRawElementValue(130        scalar,131        _Tiles[[source]].data_type);132    if !carrier_logical && !TileNumericEncodingValid(133           _Tiles[[source]].data_type,134           normalized_scalar) then135        return FALSE;136    end;137    if (op == TileBinary_DIV || op == TileBinary_REM) &&138       TileDataTypeIsInteger(_Tiles[[source]].data_type) then139        return !IsZero(TileIntegerOperandValue(140            normalized_scalar,141            _Tiles[[source]].data_type));142    end;143    return TRUE;144end;145
146readonly func TileOperandsLegal_ExecuteTileCompare(147    destination: TileIndex, source_left: TileIndex, source_right: TileIndex,148    comparison: TileComparison) => boolean149begin150    return TileShapeAndTypeMatch(source_left, source_right) &&151           _Tiles[[source_left]].storage_kind == TileStorage_Numeric &&152           _Tiles[[source_left]].layout == TileLayout_RowMajor &&153           TileCompareDataTypeSupported(_Tiles[[source_left]].data_type) &&154           TileSourceContentsDefined(source_left) &&155           TileSourceContentsDefined(source_right) &&156           TileSourceEncodingsValid(source_left) &&157           TileSourceEncodingsValid(source_right) &&158           TileLogicalShapeMatch(destination, source_left) &&159           _Tiles[[destination]].storage_kind == TileStorage_Predicate;160end;161
162readonly func TileOperandsLegal_ExecuteTileCompareScalar(163    destination: TileIndex, source: TileIndex, scalar: Word,164    comparison: TileComparison) => boolean165begin166    let normalized_scalar = TileRawElementValue(167        scalar,168        _Tiles[[source]].data_type);169    return _Tiles[[source]].storage_kind == TileStorage_Numeric &&170           _Tiles[[source]].layout == TileLayout_RowMajor &&171           TileCompareDataTypeSupported(_Tiles[[source]].data_type) &&172           TileSourceContentsDefined(source) &&173           TileSourceEncodingsValid(source) &&174           TileNumericEncodingValid(175               _Tiles[[source]].data_type,176               normalized_scalar) &&177           TileLogicalShapeMatch(destination, source) &&178           _Tiles[[destination]].storage_kind == TileStorage_Predicate;179end;180
181readonly func TileOperandsLegal_ExecuteTileSelect(182    destination: TileIndex, mask: TileIndex,183    source_true: TileIndex, source_false: TileIndex) => boolean184begin185    return TileShapeAndTypeMatch(source_true, source_false) &&186           _Tiles[[source_true]].storage_kind == TileStorage_Numeric &&187           _Tiles[[source_true]].layout == TileLayout_RowMajor &&188           TileSelectDataTypeSupported(_Tiles[[source_true]].data_type) &&189           TileSourceContentsDefined(source_true) &&190           TileSourceContentsDefined(source_false) &&191           TilePredicateValuesLegal(mask) &&192           TileLogicalShapeMatch(mask, source_true) &&193           TileShapeAndTypeMatch(destination, source_true) &&194           _Tiles[[destination]].storage_kind == TileStorage_Numeric;195end;196
197readonly func TileOperandsLegal_ExecuteTileSelectScalar(198    destination: TileIndex, mask: TileIndex,199    source_true: TileIndex, scalar_false: Word) => boolean200begin201    return _Tiles[[source_true]].storage_kind == TileStorage_Numeric &&202           _Tiles[[source_true]].layout == TileLayout_RowMajor &&203           TileSelectDataTypeSupported(_Tiles[[source_true]].data_type) &&204           TileSourceContentsDefined(source_true) &&205           TilePredicateValuesLegal(mask) &&206           TileLogicalShapeMatch(mask, source_true) &&207           TileShapeAndTypeMatch(destination, source_true) &&208           _Tiles[[destination]].storage_kind == TileStorage_Numeric;209end;210
211readonly func TileOperandsLegal_TCI(212    destination: TileIndex, start: Word, descending: boolean) => boolean213begin214    if !TileDescriptorLegal(destination) then return FALSE; end;215    let tile = _Tiles[[destination]];216    return TileTCIDataTypeSupported(tile.data_type) &&217           tile.storage_kind == TileStorage_Numeric &&218           tile.layout == TileLayout_RowMajor &&219           tile.valid_rows == 1 &&220           tile.valid_columns >= 1 &&221           tile.columns >= tile.valid_columns;222end;223
224readonly func TileOperandsLegal_TTRI(225    destination: TileIndex, upper: boolean,226    diagonal: integer {-65535..65535}) => boolean227begin228    if !TileDescriptorLegal(destination) then return FALSE; end;229    let tile = _Tiles[[destination]];230    return TileTTRIDataTypeSupported(tile.data_type) &&231           tile.storage_kind == TileStorage_Numeric &&232           tile.layout == TileLayout_RowMajor &&233           tile.valid_rows >= 1 &&234           tile.valid_columns >= 1 &&235           tile.rows >= tile.valid_rows &&236           tile.columns >= tile.valid_columns;237end;238
239readonly func TileOperandsLegal_TCVT(destination: TileIndex,240                                     source: TileIndex,241                                     control: NumericExecutionControl) => boolean242begin243    if !TileDescriptorLegal(destination) ||244       !TileSourceContentsDefined(source) ||245       !TileSourceEncodingsValid(source) then246        return FALSE;247    end;248    let destination_tile = _Tiles[[destination]];249    let source_tile = _Tiles[[source]];250    if !HardwareTCVTTypePairSupported(251           source_tile.data_type,252           destination_tile.data_type) then253        return FALSE;254    end;255    if destination_tile.rows != source_tile.rows ||256       destination_tile.columns != source_tile.columns ||257       destination_tile.valid_rows != source_tile.valid_rows ||258       destination_tile.valid_columns != source_tile.valid_columns then259        return FALSE;260    end;261    let private_cube_source =262        source_tile.location == TileLocation_Matrix;263    if private_cube_source != CurrentBundleCanonicalize() then264        return FALSE;265    end;266    if private_cube_source then267        return CurrentBundleDataLayout() == TileDataLayout_NORM &&268               source_tile.layout == TileLayout_RowMajor &&269               destination_tile.layout == TileLayout_RowMajor;270    end;271    return source_tile.layout == CurrentBundleTileSourceLayout() &&272           destination_tile.layout == CurrentBundleTileLayout();273end;274
275readonly func TileOperandsLegal_TQUANT(destination: TileIndex,276                                       source: TileIndex, scale: Word,277                                       zero_point: Word,278                                       control: NumericExecutionControl) => boolean279begin280    if !TileDescriptorLegal(destination) ||281       !TileDescriptorLegal(source) ||282       _Tiles[[destination]].storage_kind != TileStorage_Numeric ||283       _Tiles[[source]].storage_kind != TileStorage_Numeric ||284       (_Tiles[[destination]].data_type != TileDataType_S8 &&285        _Tiles[[destination]].data_type != TileDataType_U8) ||286       _Tiles[[source]].data_type != TileDataType_FP32 ||287       _Tiles[[destination]].layout != TileLayout_RowMajor ||288       _Tiles[[source]].layout != TileLayout_RowMajor ||289       _Tiles[[destination]].valid_rows != _Tiles[[source]].valid_rows ||290       _Tiles[[destination]].valid_columns !=291           _Tiles[[source]].valid_columns ||292       _Tiles[[destination]].valid_rows == 0 ||293       _Tiles[[destination]].valid_columns == 0 ||294       !TileSourceContentsDefined(source) ||295       !TileSourceEncodingsValid(source) ||296       !TileQuantizationScaleLegal(scale) then297        return FALSE;298    end;299    return TileQuantizationZeroPointLegal(300        zero_point,301        _Tiles[[destination]].data_type);302end;303
304readonly func TileOperandsLegal_TDEQUANT(destination: TileIndex,305                                         source: TileIndex, scale: Word,306                                         zero_point: Word,307                                         control: NumericExecutionControl) => boolean308begin309    if !TileDescriptorLegal(destination) ||310       !TileDescriptorLegal(source) ||311       _Tiles[[destination]].storage_kind != TileStorage_Numeric ||312       _Tiles[[source]].storage_kind != TileStorage_Numeric ||313       _Tiles[[destination]].data_type != TileDataType_FP32 ||314       (_Tiles[[source]].data_type != TileDataType_S8 &&315        _Tiles[[source]].data_type != TileDataType_U8) ||316       _Tiles[[destination]].layout != TileLayout_RowMajor ||317       _Tiles[[source]].layout != TileLayout_RowMajor ||318       _Tiles[[destination]].valid_rows != _Tiles[[source]].valid_rows ||319       _Tiles[[destination]].valid_columns !=320           _Tiles[[source]].valid_columns ||321       _Tiles[[destination]].valid_rows == 0 ||322       _Tiles[[destination]].valid_columns == 0 ||323       !TileSourceContentsDefined(source) ||324       !TileSourceEncodingsValid(source) ||325       !TileQuantizationScaleLegal(scale) ||326       control.saturating then327        return FALSE;328    end;329    return TileQuantizationZeroPointLegal(330        zero_point,331        _Tiles[[source]].data_type);332end;333
334readonly func TileOperandsLegal_TRESHAPE(destination: TileIndex,335                                         source: TileIndex) => boolean336begin337    return TileDescriptorLegal(destination) && TileDescriptorLegal(source) &&338           _Tiles[[destination]].rows * _Tiles[[destination]].columns ==339               _Tiles[[source]].rows * _Tiles[[source]].columns &&340           _Tiles[[destination]].valid_rows * _Tiles[[destination]].valid_columns ==341               _Tiles[[source]].valid_rows * _Tiles[[source]].valid_columns &&342           _Tiles[[destination]].data_type == _Tiles[[source]].data_type;343end;344
345readonly func TileOperandsLegal_TINTERLEAVE(346    destination: TileIndex, source_even: TileIndex,347    source_odd: TileIndex) => boolean348begin349    if !TileDescriptorLegal(destination) ||350       !TileDescriptorLegal(source_even) ||351       !TileDescriptorLegal(source_odd) then return FALSE; end;352    let extent: integer =353        _Tiles[[source_even]].valid_rows * _Tiles[[source_even]].valid_columns;354    return extent <= PTO_MODEL_TILE_ELEMENTS DIV 2 &&355           extent == _Tiles[[source_odd]].valid_rows *356                     _Tiles[[source_odd]].valid_columns &&357           _Tiles[[destination]].valid_rows *358               _Tiles[[destination]].valid_columns == extent * 2 &&359           _Tiles[[destination]].data_type == _Tiles[[source_even]].data_type &&360           _Tiles[[destination]].data_type == _Tiles[[source_odd]].data_type &&361           _Tiles[[destination]].layout == _Tiles[[source_even]].layout &&362           _Tiles[[destination]].layout == _Tiles[[source_odd]].layout;363end;364
365readonly func TileOperandsLegal_TDEINTERLEAVE(366    destination_even: TileIndex, destination_odd: TileIndex,367    source: TileIndex) => boolean368begin369    if destination_even == destination_odd then return FALSE; end;370    if !TileDescriptorLegal(destination_even) ||371       !TileDescriptorLegal(destination_odd) ||372       !TileDescriptorLegal(source) then return FALSE; end;373    let extent: integer = _Tiles[[destination_even]].valid_rows *374                          _Tiles[[destination_even]].valid_columns;375    return extent <= PTO_MODEL_TILE_ELEMENTS DIV 2 &&376           extent == _Tiles[[destination_odd]].valid_rows *377                     _Tiles[[destination_odd]].valid_columns &&378           _Tiles[[source]].valid_rows * _Tiles[[source]].valid_columns ==379               extent * 2 &&380           _Tiles[[destination_even]].data_type == _Tiles[[source]].data_type &&381           _Tiles[[destination_odd]].data_type == _Tiles[[source]].data_type &&382           _Tiles[[destination_even]].layout == _Tiles[[source]].layout &&383           _Tiles[[destination_odd]].layout == _Tiles[[source]].layout;384end;385

Architecture behavior

This internal model unit is documented through its normative ASL/NDF owners and validation evidence; it has no reader-guide migration target.

NDF clauses

Bodies come from owning ASL. Dragging or buttons change only this page-session view order.

No NDF clause is attached to this unit.

Evidence index

8 matching entries

Executable evidence2

PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA compiles as an independent normative unit
1. surfaceTILE
2. ownerPTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA
3. categorySTATIC-INVARIANT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-MODEL-LEGALITY-OPERAND-SCHEMA-STATIC-001
Path
tests/asl/tile/model/legality/operand-schema/tile-static-operand-schema-contract-001.asl
Kind / role
static-invariant
Pass condition
the complete model and this unit's static invariant compile
SHA-256
500a0275bfb6116e6613916832311b121e2ccebfa0b19610c0dcd7d4bf354c93
Open exact source ↗ for PTO-AVS-TILE-MODEL-LEGALITY-OPERAND-SCHEMA-STATIC-001
Covers Decoded Tile Legality Faults.
1. surfaceTILE
2. ownerPTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA
3. categoryFAULT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TESTDECODEDTILELEGALITYFAULTS-FAULT-001
Path
tests/asl/tile/model/legality/operand-schema/tile-fault-decoded-legality-faults-001.asl
Kind / role
fault
Pass condition
TestDecodedTileLegalityFaults completes without assertion failure
SHA-256
1930476b3b2de0a7d75aa5921a7c5cfbb0470e78104f9c218e19d4b7fcbbc8b2
Open exact source ↗ for PTO-AVS-TILE-TESTDECODEDTILELEGALITYFAULTS-FAULT-001

Commit-scoped evidence5

spec/evidence/release-traceability-readiness.json · closedPTO-EVIDENCE-RELEASE-TRACEABILITY
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-TRACEABILITY
Path
spec/evidence/release-traceability-readiness.json
Kind / role
ASL/NDF/documentation/AVS traceability
SHA-256
c7327021d39dc67ac5564bc55073b3870a397d79ac8d9648284d56e33bc14a3e
Open exact source ↗ for PTO-EVIDENCE-RELEASE-TRACEABILITY
spec/evidence/instruction-contract-closure.json · closedPTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
Sources and references
Complete stable ID
PTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
Path
spec/evidence/instruction-contract-closure.json
Kind / role
mnemonic and encoding contract closure
SHA-256
3ef2bb62421c79dff8fa77a1c7983923b523244b8090812883ef81286ca8106a
Open exact source ↗ for PTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
spec/evidence/architecture-readiness.json · openPTO-EVIDENCE-ARCHITECTURE-READINESS
Sources and references
Complete stable ID
PTO-EVIDENCE-ARCHITECTURE-READINESS
Path
spec/evidence/architecture-readiness.json
Kind / role
architecture maturity and blockers
SHA-256
4b0b85199101251bea744e0f3591cc31906909dc80d5ab651c417a936036a004
Open exact source ↗ for PTO-EVIDENCE-ARCHITECTURE-READINESS
spec/evidence/release-gate-readiness.json · ready-for-exact-head-verificationPTO-EVIDENCE-RELEASE-GATE-READINESS
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-GATE-READINESS
Path
spec/evidence/release-gate-readiness.json
Kind / role
exact-head gate readiness
SHA-256
a0f4d2b6920c08981ea55fd8ef820708a40d4feb5402c5150e8e9ab532d84ce0
Open exact source ↗ for PTO-EVIDENCE-RELEASE-GATE-READINESS
spec/release-manifest.json · draftPTO-EVIDENCE-RELEASE-MANIFEST
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-MANIFEST
Path
spec/release-manifest.json
Kind / role
release content and encoding fingerprints
SHA-256
1a64c109ed7a90351c41e2a418b3c0ebaf8ad975838986d2101385186b85c0d8
Open exact source ↗ for PTO-EVIDENCE-RELEASE-MANIFEST

Decision history1

PTO ISA 0.58.4.1 to 0.58.5 compatibility boundary · accepted
1. decision recordADR
2. case0108
Decision record
Loading ADR-0108…
Sources and references
Complete stable ID
ADR-0108
Path
docs/status/decisions/0108-0584-1-to-0585-compatibility.md
Affected units
PTO-ARCH-FEATURES-TILE-ALLOCATION, PTO-ARCH-MEMORY-MODEL-GLOBAL-MEMORY-ACCESS, PTO-ARCH-OVERVIEW-ENCODING-OWNERSHIP, PTO-BLOCK-B-IOS, PTO-BLOCK-B-IOT, PTO-BLOCK-BSTART-TLOAD, PTO-BLOCK-BSTART-TMATMUL, PTO-BLOCK-BSTART-TMATMUL-ACC, PTO-BLOCK-BSTART-TMATMUL-BIAS, PTO-BLOCK-BSTART-TMATMULMX, PTO-BLOCK-BSTART-TMATMULMX-ACC, PTO-BLOCK-BSTART-TMATMULMX-BIAS, PTO-BLOCK-BSTART-TMOV, PTO-BLOCK-BSTART-TSTORE, PTO-BLOCK-MODEL-DISPATCH-CELL-REARRANGEMENT-SCHEMA, PTO-BLOCK-MODEL-DISPATCH-COMMANDS, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-DISPATCH-DESCRIPTOR-LEGALITY, PTO-BLOCK-MODEL-DISPATCH-DESTINATION-SHAPE, PTO-BLOCK-MODEL-DISPATCH-PARTIAL-SCHEMA, PTO-BLOCK-MODEL-DISPATCH-SHARED-CUBE-MATRIX, PTO-BLOCK-MODEL-DISPATCH-SHARED-TLSU, PTO-BLOCK-MODEL-DISPATCH-TILE-EXECUTION, PTO-BLOCK-MODEL-DISPATCH-TILE-SCALAR-SCHEMA, PTO-BLOCK-MODEL-DISPATCH-TILE-SCHEMA, PTO-BLOCK-MODEL-DISPATCH-TLSU-LAYOUT-CONVERSION, PTO-BLOCK-MODEL-OPERANDS-PORTABLE-CARRIERS, PTO-BLOCK-MODEL-OPERANDS-SHARED-GENERATION, PTO-TILE-GMOV, PTO-TILE-MGATHER, PTO-TILE-MGATHER-CAS, PTO-TILE-MGATHER-MASK, PTO-TILE-MSCATTER, PTO-TILE-MSCATTER-MASK, PTO-TILE-TCI, PTO-TILE-TCONCAT, PTO-TILE-TDEQUANT, PTO-TILE-TEXTRACT, PTO-TILE-TFILLPAD, PTO-TILE-TGATHER, PTO-TILE-TGEMV, PTO-TILE-TGEMV-ACC, PTO-TILE-TGEMV-BIAS, PTO-TILE-TGEMV-MX, PTO-TILE-TGEMV-MX-ACC, PTO-TILE-TGEMV-MX-BIAS, PTO-TILE-THISTOGRAM, PTO-TILE-TINSERT, PTO-TILE-TLOAD, PTO-TILE-TMATMUL, PTO-TILE-TMATMUL-ACC, PTO-TILE-TMATMUL-BIAS, PTO-TILE-TMATMUL-MX, PTO-TILE-TMATMUL-MX-ACC, PTO-TILE-TMATMUL-MX-BIAS, PTO-TILE-TMOV, PTO-TILE-TMRGSORT, PTO-TILE-TPACK, PTO-TILE-TPARTADD, PTO-TILE-TPARTMAX, PTO-TILE-TPARTMIN, PTO-TILE-TPARTMUL, PTO-TILE-TPERMUTE, PTO-TILE-TPREFETCH, PTO-TILE-TQUANT, PTO-TILE-TSCATTER, PTO-TILE-TSHUF, PTO-TILE-TSORT, PTO-TILE-TSTORE, PTO-TILE-TTRANS, PTO-TILE-TTRI, PTO-TILE-TUNPACK, PTO-TILE-MODEL-DISPATCH-IRREGULAR-AND-COMPLEX, PTO-TILE-MODEL-DISPATCH-LAYOUT-AND-REARRANGEMENT, PTO-TILE-MODEL-EXECUTION-COMPLEX, PTO-TILE-MODEL-EXECUTION-GENERATION, PTO-TILE-MODEL-EXECUTION-REARRANGEMENT, PTO-TILE-MODEL-LEGALITY-ALLOCATION-CAPACITY, PTO-TILE-MODEL-LEGALITY-DTYPE-LAYOUT, PTO-TILE-MODEL-LEGALITY-INDEXED-LAYOUT, PTO-TILE-MODEL-LEGALITY-LAYOUT-REARRANGEMENT, PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA, PTO-TILE-MODEL-MEMORY-SHARED-MOVEMENT, PTO-TILE-MODEL-STATE-DESCRIPTORS, PTO-TILE-MODEL-STATE-SHARED-REGISTERS, PTO-TILE-MODEL-STATE-TYPES
Affected NDF
PTO-ARCH-GM-ACCESS-001, PTO-B-IOS-SHARED-STATE-001, PTO-B-IOT-STREAM-001, PTO-B-SHARED-WHOLE-PARENT-READY-001, PTO-B-SUBVIEW-SHARED-PER-PE-001, PTO-BSTART-TLOAD-MEMORY-001, PTO-BSTART-TMOV-SHARED-001, PTO-BSTART-TSTORE-MEMORY-001, PTO-INST-BLOCK-B-IOS, PTO-INST-BLOCK-B-IOT, PTO-INST-BLOCK-BSTART-TLOAD, PTO-INST-BLOCK-BSTART-TMATMUL, PTO-INST-BLOCK-BSTART-TMATMUL-ACC, PTO-INST-BLOCK-BSTART-TMATMUL-BIAS, PTO-INST-BLOCK-BSTART-TMATMULMX, PTO-INST-BLOCK-BSTART-TMATMULMX-ACC, PTO-INST-BLOCK-BSTART-TMATMULMX-BIAS, PTO-INST-BLOCK-BSTART-TMOV, PTO-INST-BLOCK-BSTART-TSTORE, PTO-INST-TILE-GMOV, PTO-INST-TILE-MGATHER, PTO-INST-TILE-MGATHER-CAS, PTO-INST-TILE-MGATHER-MASK, PTO-INST-TILE-MSCATTER, PTO-INST-TILE-MSCATTER-MASK, PTO-INST-TILE-TCI, PTO-INST-TILE-TCONCAT, PTO-INST-TILE-TDEQUANT, PTO-INST-TILE-TEXTRACT, PTO-INST-TILE-TFILLPAD, PTO-INST-TILE-TGATHER, PTO-INST-TILE-TGEMV, PTO-INST-TILE-TGEMV-ACC, PTO-INST-TILE-TGEMV-BIAS, PTO-INST-TILE-TGEMV-MX, PTO-INST-TILE-TGEMV-MX-ACC, PTO-INST-TILE-TGEMV-MX-BIAS, PTO-INST-TILE-THISTOGRAM, PTO-INST-TILE-TINSERT, PTO-INST-TILE-TLOAD, PTO-INST-TILE-TMATMUL, PTO-INST-TILE-TMATMUL-ACC, PTO-INST-TILE-TMATMUL-BIAS, PTO-INST-TILE-TMATMUL-MX, PTO-INST-TILE-TMATMUL-MX-ACC, PTO-INST-TILE-TMATMUL-MX-BIAS, PTO-INST-TILE-TMOV, PTO-INST-TILE-TMRGSORT, PTO-INST-TILE-TPACK, PTO-INST-TILE-TPARTADD, PTO-INST-TILE-TPARTMAX, PTO-INST-TILE-TPARTMIN, PTO-INST-TILE-TPARTMUL, PTO-INST-TILE-TPERMUTE, PTO-INST-TILE-TPREFETCH, PTO-INST-TILE-TQUANT, PTO-INST-TILE-TSCATTER, PTO-INST-TILE-TSHUF, PTO-INST-TILE-TSORT, PTO-INST-TILE-TSTORE, PTO-INST-TILE-TTRANS, PTO-INST-TILE-TTRI, PTO-INST-TILE-TUNPACK, PTO-ISA-LEGACY-SHARED-MOVEMENT-001, PTO-TFILLPAD-CONTRACT-001, PTO-TLOAD-MEMORY-001, PTO-TMATMUL-ACC-CONTRACT-001, PTO-TMATMUL-BIAS-CONTRACT-001, PTO-TMATMUL-CONTRACT-001, PTO-TMATMUL-MX-ACC-CONTRACT-001, PTO-TMATMUL-MX-BIAS-CONTRACT-001, PTO-TMATMUL-MX-CONTRACT-001, PTO-TPACK-CONTRACT-001, PTO-TPARTADD-CONTRACT-001, PTO-TPARTMAX-CONTRACT-001, PTO-TPARTMIN-CONTRACT-001, PTO-TPARTMUL-CONTRACT-001, PTO-TPERMUTE-CONTRACT-001, PTO-TSHUF-CONTRACT-001, PTO-TSTORE-MEMORY-001, PTO-TTRANS-CONTRACT-001, PTO-TUNPACK-CONTRACT-001
SHA-256
5689fa78a7291b6ae88d55197205e4cf79e9719ee5ba18ebf186f5c6871c350d
Open exact decision source ↗ for ADR-0108

Unit metadata

Open 4 generated metadata fields

id: PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA
surface: tile
classification: [ "model", "legality", "operand-schema" ]
depends_on: [ "PTO-TILE-MODEL-EXECUTION-UNARY", "PTO-TILE-MODEL-LEGALITY-ALLOCATION-CAPACITY" ]

Open generated traceability record

{
  "classification": [
    "model",
    "legality",
    "operand-schema"
  ],
  "documentation": "docs/tile/model/legality/operand-schema.md",
  "id": "PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA",
  "mnemonic": null,
  "readiness_subjects": [
    "ADR-0108"
  ],
  "semantic_tests": [
    "PTO-AVS-TILE-TESTDECODEDTILELEGALITYFAULTS-FAULT-001"
  ],
  "source": "asl/tile/model/legality/operand-schema.asl",
  "surface": "tile",
  "tests": [
    "PTO-AVS-TILE-MODEL-LEGALITY-OPERAND-SCHEMA-STATIC-001",
    "PTO-AVS-TILE-TESTDECODEDTILELEGALITYFAULTS-FAULT-001"
  ]
}

Sources and release identity

Show commit, paths, hashes, version, and canonical owners

Release: 0.58.5 · Release candidate
Commit: 7dc8b7e5b121d2b2499a2273bebff29e2cd86812
Original ASL: asl/tile/model/legality/operand-schema.asl
ASL SHA-256: 4a24d709a60466acbf81c8428c7cf234b9be5c01f2a9e0dab1b54059ad3376f8
Generated documentation: docs/tile/model/legality/operand-schema.md · embedded in this page
Documentation SHA-256: 369dfcb7cae287327a6331831c8ee7316a9ac7968069924a806498a14c7b62a8

Exact owners

ASL PTO-TILE-MODEL-LEGALITY-OPERAND-SCHEMA asl/tile/model/legality/operand-schema.asl

Architecture behavior

Evidence index

Decision record

Unit metadata

Sources and release identity

Exact owners