PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS

PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS

ASL pseudocode

The complete ASL owner is shown directly below.

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS","surface":"tile","classification":["model","definedness","elements"],"depends_on":["PTO-ARCH-DATA-TYPES-TILE-DATA-TYPES","PTO-TILE-MODEL-STATE-ALLOCATION","PTO-TILE-MODEL-DEFINEDNESS-PACKED-BOUNDARY"]}2pure func TileFractalInnerElements(3    data_type: TileDataType) => integer {4,8,16,32,64}4begin5    // PTO fractals contain 16 rows by 32 bytes.  Packed X2 formats therefore6    // carry 64 independently addressed logical nibbles in each fractal row.7    return (256 DIV TileElementBits(data_type))8        as integer {4,8,16,32,64};9end;10readonly func TileLayoutShapeLegal(tile: TileInfo) => boolean11begin12    if tile.layout == TileLayout_ImplementationDefined then return FALSE; end;13    if tile.layout == TileLayout_RowMajor ||14       tile.layout == TileLayout_ColumnMajor then15        return TRUE;16    end;17    let inner_elements = TileFractalInnerElements(tile.data_type);18    return tile.rows MOD 16 == 0 &&19           tile.columns MOD inner_elements == 0;20end;21readonly func TileGenericIndexingPermitted(tile: TileInfo) => boolean22begin23    return !TileLayoutIsCube(tile.layout) && TileLayoutShapeLegal(tile);24end;25readonly func TileLinearIndex(tile: TileInfo, row: integer {0..65535},26                     column: integer {0..65535}) => ModelTileElementIndex27begin28    assert row < tile.rows;29    assert column < tile.columns;30    assert TileGenericIndexingPermitted(tile);31    var index: integer = 0;32    if tile.layout == TileLayout_RowMajor then33        index = row * tile.columns + column;34    elsif tile.layout == TileLayout_ColumnMajor then35        index = column * tile.rows + row;36    else37        let inner_elements = TileFractalInnerElements(tile.data_type);38        let block_rows: integer {0..65535} =39            (tile.rows DIVRM 16) as integer {0..65535};40        let block_columns: integer {0..65535} =41            (tile.columns DIVRM inner_elements) as integer {0..65535};42        let block_row: integer {0..65535} =43            (row DIVRM 16) as integer {0..65535};44        let block_column: integer {0..65535} =45            (column DIVRM inner_elements) as integer {0..65535};46        let inner_row: integer {0..15} =47            (row MOD 16) as integer {0..15};48        let inner_column: integer {0..63} =49            (column MOD inner_elements) as integer {0..63};50        let block_elements: integer {64..1024} =51            (16 * inner_elements) as integer {64..1024};52        if tile.layout == TileLayout_ZN then53            index = (block_row * block_columns + block_column) *54                    block_elements + inner_column * 16 + inner_row;55        else56            assert tile.layout == TileLayout_NZ;57            index = (block_column * block_rows + block_row) *58                    block_elements + inner_row * inner_elements +59                    inner_column;60        end;61    end;62    assert index < PTO_MODEL_TILE_ELEMENTS;63    return index as ModelTileElementIndex;64end;65readonly func TileStorageIndex(tile: TileInfo,66                               row: integer {0..65535},67                               column: integer {0..65535})68    => ModelTileElementIndex69begin70    if !TileLayoutIsCube(tile.layout) then71        return TileLinearIndex(tile, row, column);72    end;73    assert TileCubeDescriptorShapeLegal(tile.capacity_bytes,74        tile.valid_rows, tile.valid_columns, tile.data_type, tile.layout);75    assert tile.rows == TileCubeStorageRows(76        tile.layout, tile.valid_rows, tile.data_type);77    assert tile.columns == TileCubeStorageColumns(78        tile.layout, tile.valid_columns, tile.data_type);79    assert tile.cube_k_repeat == TileCubeKRepeat(tile.layout,80        tile.valid_rows, tile.valid_columns, tile.data_type);81    assert tile.cube_n_repeat == TileCubeNRepeat(tile.layout,82        tile.valid_rows, tile.valid_columns, tile.data_type);83    assert tile.cube_cell_count == TileCubeCellCount(tile.layout,84        tile.valid_rows, tile.valid_columns, tile.data_type);85    assert tile.cube_storage_bytes == TileCubeRequiredBytes(tile.layout,86        tile.valid_rows, tile.valid_columns, tile.data_type);87    return TileCubePayloadIndex(tile, row, column);88end;89
90readonly func TileLogicalLinearIndex(tile: TileInfo,91                                     row: integer {0..65535},92                                     column: integer {0..65535})93                                     => PackedTileElementIndex94begin95    if TileUsesPackedCarrierRepresentation(tile) then96        return TilePackedLinearIndex(tile, row, column);97    end;98    return TileStorageIndex(tile, row, column) as PackedTileElementIndex;99end;100pure func TileElementBytes(data_type: TileDataType) => integer {1,2,4,8}101begin102    case data_type of103        when TileDataType_S8, TileDataType_U8, TileDataType_HiF8,104             TileDataType_E4M3, TileDataType_E5M2, TileDataType_E3M2,105             TileDataType_E2M3, TileDataType_E2M1X2,106             TileDataType_E1M2X2, TileDataType_E8M0,107             TileDataType_HiF4X2, TileDataType_S4X2,108             TileDataType_U4X2 => return 1;109        when TileDataType_S16, TileDataType_U16,110             TileDataType_FP16, TileDataType_BF16 => return 2;111        when TileDataType_S32, TileDataType_U32, TileDataType_FP32,112             TileDataType_TF32, TileDataType_HF32 => return 4;113        when TileDataType_S64, TileDataType_U64,114             TileDataType_FP64 => return 8;115    end;116end;117pure func TileDataTypeIsSigned(data_type: TileDataType) => boolean118begin119    return data_type == TileDataType_S8 || data_type == TileDataType_S16 ||120           data_type == TileDataType_S32 || data_type == TileDataType_S64 ||121           data_type == TileDataType_S4X2;122end;123pure func TileDataTypeIsUnsignedInteger(data_type: TileDataType) => boolean124begin125    return data_type == TileDataType_U8 || data_type == TileDataType_U16 ||126           data_type == TileDataType_U32 || data_type == TileDataType_U64 ||127           data_type == TileDataType_U4X2;128end;129pure func TileDataTypeIsInteger(data_type: TileDataType) => boolean130begin131    return TileDataTypeIsSigned(data_type) ||132           TileDataTypeIsUnsignedInteger(data_type);133end;134pure func IndexedTLSUTransferDataTypeLegal(135    data_type: TileDataType) => boolean136begin137    // Indexed TLSU addresses are byte displacements. A packed four-bit138    // transfer would additionally need a low/high-nibble selector, which the139    // block schema does not encode. IndexTile legality is governed separately140    // by IndexedTLSUIndexDataTypeLegal.141    return !TileDataTypeIsFourBit(data_type);142end;143pure func IndexedTLSUIndexDataTypeLegal(144    data_type: TileDataType) => boolean145begin146    return TileDataTypeIsInteger(data_type);147end;148pure func TileDataTypeIsFloating(data_type: TileDataType) => boolean149begin150    return data_type == TileDataType_FP64 ||151           data_type == TileDataType_FP32 || data_type == TileDataType_TF32 ||152           data_type == TileDataType_HF32 || data_type == TileDataType_FP16 ||153           data_type == TileDataType_BF16 || data_type == TileDataType_HiF8 ||154           data_type == TileDataType_E4M3 || data_type == TileDataType_E5M2 ||155           data_type == TileDataType_E3M2 || data_type == TileDataType_E2M3 ||156           data_type == TileDataType_E2M1X2 ||157           data_type == TileDataType_E1M2X2 ||158           data_type == TileDataType_E8M0 ||159           data_type == TileDataType_HiF4X2;160end;161pure func TileMatrixAccumulatorDataType(data_type: TileDataType) => TileDataType162begin163    if TileDataTypeIsSigned(data_type) then return TileDataType_S32; end;164    if TileDataTypeIsUnsignedInteger(data_type) then165        return TileDataType_U32;166    end;167    return TileDataType_FP32;168end;169pure func TilePadValueForDataType(pad_value: TilePadValue,170                                  data_type: TileDataType) => Word171begin172    if pad_value == TilePad_Zero || pad_value == TilePad_Null then173        return Zeros{PTO_XLEN};174    end;175    if pad_value == TilePad_Max then176        case data_type of177            when TileDataType_FP64 =>178                return Zeros{PTO_XLEN} + 0x7fefffffffffffff;179            when TileDataType_FP32 =>180                return Zeros{PTO_XLEN} + 0x7f7fffff;181            when TileDataType_TF32 =>182                return Zeros{PTO_XLEN} + 0x7f7fe000;183            when TileDataType_HF32 =>184                return Zeros{PTO_XLEN} + 0x7f7ff000;185            when TileDataType_FP16 =>186                return Zeros{PTO_XLEN} + 0x7bff;187            when TileDataType_BF16 =>188                return Zeros{PTO_XLEN} + 0x7f7f;189            when TileDataType_E4M3 =>190                return Zeros{PTO_XLEN} + 0x7e;191            when TileDataType_E5M2 =>192                return Zeros{PTO_XLEN} + 0x7b;193            when TileDataType_U8 => return Zeros{PTO_XLEN} + 0xff;194            when TileDataType_U16 => return Zeros{PTO_XLEN} + 0xffff;195            when TileDataType_U32 => return Zeros{PTO_XLEN} + 0xffffffff;196            when TileDataType_U64 => return Ones{PTO_XLEN};197            when TileDataType_S8 => return Zeros{PTO_XLEN} + 0x7f;198            when TileDataType_S16 => return Zeros{PTO_XLEN} + 0x7fff;199            when TileDataType_S32 => return Zeros{PTO_XLEN} + 0x7fffffff;200            when TileDataType_S64 =>201                return Zeros{PTO_XLEN} + 0x7fffffffffffffff;202            otherwise => return Ones{PTO_XLEN};203        end;204    end;205    case data_type of206        when TileDataType_FP64 =>207            return Zeros{PTO_XLEN} + 0xffefffffffffffff;208        when TileDataType_FP32 =>209            return Zeros{PTO_XLEN} + 0xff7fffff;210        when TileDataType_TF32 =>211            return Zeros{PTO_XLEN} + 0xff7fe000;212        when TileDataType_HF32 =>213            return Zeros{PTO_XLEN} + 0xff7ff000;214        when TileDataType_FP16 =>215            return Zeros{PTO_XLEN} + 0xfbff;216        when TileDataType_BF16 =>217            return Zeros{PTO_XLEN} + 0xff7f;218        when TileDataType_E4M3 =>219            return Zeros{PTO_XLEN} + 0xfe;220        when TileDataType_E5M2 =>221            return Zeros{PTO_XLEN} + 0xfb;222        when TileDataType_U8, TileDataType_U16, TileDataType_U32,223             TileDataType_U64, TileDataType_U4X2 => return Zeros{PTO_XLEN};224        when TileDataType_S8 => return Zeros{PTO_XLEN} + 0x80;225        when TileDataType_S16 => return Zeros{PTO_XLEN} + 0x8000;226        when TileDataType_S32 => return Zeros{PTO_XLEN} + 0x80000000;227        when TileDataType_S64 => return Zeros{PTO_XLEN} + 0x8000000000000000;228        otherwise => return Zeros{PTO_XLEN} + 0x8000000000000000;229    end;230end;231
232readonly func ReadTileElement(index: TileIndex, row: integer {0..65535},233                     column: integer {0..65535}) => Word234begin235    let tile = _Tiles[[index]];236    let element = TileLogicalLinearIndex(tile, row, column);237    assert TileLogicalElementDefined(tile, element);238    return TileReadLogicalElement(tile, element);239end;240
241readonly func TileElementDefined(index: TileIndex,242                                 row: integer {0..65535},243                                 column: integer {0..65535}) => boolean244begin245    let tile = _Tiles[[index]];246    let element = TileLogicalLinearIndex(tile, row, column);247    return TileLogicalElementDefined(tile, element);248end;249
250readonly func TilePredicateValuesLegal(index: TileIndex) => boolean251begin252    return TileSourceContentsDefined(index) &&253           _Tiles[[index]].storage_kind == TileStorage_Predicate;254end;255
256readonly func TilePredicateLogicalIndex(257    tile: TileInfo,258    row: integer {0..65535},259    column: integer {0..65535}) => integer {0..16383}260begin261    assert tile.storage_kind == TileStorage_Predicate;262    assert row < tile.rows && column < tile.columns;263    return (row * tile.columns + column) as integer {0..16383};264end;265
266pure func TilePredicateByteIndex(267    logical_index: integer {0..16383}) => integer {0..2047}268begin269    return (logical_index DIVRM 8) as integer {0..2047};270end;271
272pure func TilePredicateBitIndex(273    logical_index: integer {0..16383}) => integer {0..7}274begin275    return (logical_index MOD 8) as integer {0..7};276end;277
278readonly func TilePredicateBitFromInfo(279    tile: TileInfo,280    row: integer {0..65535},281    column: integer {0..65535}) => boolean282begin283    let logical = TilePredicateLogicalIndex(tile, row, column);284    let byte_index = TilePredicateByteIndex(logical);285    let bit_index = TilePredicateBitIndex(logical);286    return tile.payload[[byte_index]][bit_index] == '1';287end;288
289func TileInfoWithPredicateBit(290    tile: TileInfo,291    row: integer {0..65535},292    column: integer {0..65535},293    value: boolean) => TileInfo294begin295    var result = tile;296    let logical = TilePredicateLogicalIndex(result, row, column);297    let byte_index = TilePredicateByteIndex(logical);298    let bit_index = TilePredicateBitIndex(logical);299    result.payload[[byte_index]][bit_index] = if value then '1' else '0';300    if result.defined_elements[logical] == '0' then301        result.defined_elements[logical] = '1';302        result.defined_valid_elements =303            (result.defined_valid_elements + 1) as integer {0..524288};304    end;305    result.contents_defined = result.defined_valid_elements ==306        result.valid_rows * result.valid_columns;307    return result;308end;309
310func WriteTilePredicateBit(311    index: TileIndex,312    row: integer {0..65535},313    column: integer {0..65535},314    value: boolean)315begin316    assert row < _Tiles[[index]].valid_rows;317    assert column < _Tiles[[index]].valid_columns;318    _Tiles[[index]] = TileInfoWithPredicateBit(319        _Tiles[[index]], row, column, value);320end;321
322readonly func TilePredicateBitDefined(323    index: TileIndex,324    row: integer {0..65535},325    column: integer {0..65535}) => boolean326begin327    let logical = TilePredicateLogicalIndex(_Tiles[[index]], row, column);328    return _Tiles[[index]].defined_elements[logical] == '1';329end;330
331readonly func ReadTilePredicateBit(332    index: TileIndex,333    row: integer {0..65535},334    column: integer {0..65535}) => boolean335begin336    assert TilePredicateBitDefined(index, row, column);337    return TilePredicateBitFromInfo(_Tiles[[index]], row, column);338end;339
340readonly func ReadTilePredicateByte(341    index: TileIndex,342    byte_index: integer {0..2047}) => bits(8)343begin344    assert _Tiles[[index]].storage_kind == TileStorage_Predicate;345    return _Tiles[[index]].payload[[byte_index]][7:0];346end;347
348func PredicateTileWithPadding(349    tile: TileInfo,350    pad_value: TilePadValue) => TileInfo351begin352    var result = tile;353    assert result.storage_kind == TileStorage_Predicate;354    let padding_defined = pad_value != TilePad_Null;355    let padding_value = pad_value == TilePad_Max;356    for row = 0 to result.rows - 1 looplimit 65536 do357        for column = 0 to result.columns - 1 looplimit 65536 do358            if row >= result.valid_rows || column >= result.valid_columns then359                let logical = TilePredicateLogicalIndex(360                    result,361                    row as integer {0..65535},362                    column as integer {0..65535});363                let byte_index = TilePredicateByteIndex(logical);364                let bit_index = TilePredicateBitIndex(logical);365                result.payload[[byte_index]][bit_index] =366                    if padding_value then '1' else '0';367                result.defined_elements[logical] =368                    if padding_defined then '1' else '0';369            end;370        end;371    end;372    return result;373end;374
375func ApplyPredicateTilePadding(index: TileIndex, pad_value: TilePadValue)376begin377    _Tiles[[index]] = PredicateTileWithPadding(378        _Tiles[[index]], pad_value);379end;380
381readonly func TileSourceEncodingsValid(index: TileIndex) => boolean382begin383    if !TileSourceContentsDefined(index) ||384       !TileGenericIndexingPermitted(_Tiles[[index]]) then385        return FALSE;386    end;387
388    let tile = _Tiles[[index]];389    let payload = tile.payload;390    for row = 0 to tile.valid_rows - 1 looplimit 65536 do391        for column = 0 to tile.valid_columns - 1 looplimit 65536 do392            let element = TileLogicalLinearIndex(393                tile, row as integer {0..65535},394                column as integer {0..65535});395            if !TileNumericEncodingValid(396                tile.data_type,397                TileReadLogicalElement(tile, element)) then398                return FALSE;399            end;400        end;401    end;402    return TRUE;403end;404
405func WriteTileElement(index: TileIndex, row: integer {0..65535},406                      column: integer {0..65535}, value: Word)407begin408    let tile = _Tiles[[index]];409    let element = TileLogicalLinearIndex(tile, row, column);410    let was_defined = TileLogicalElementDefined(tile, element);411    _Tiles[[index]] = TileInfoWithLogicalElement(tile, element, value);412    if !was_defined then413        if row < _Tiles[[index]].valid_rows &&414           column < _Tiles[[index]].valid_columns then415            assert _Tiles[[index]].defined_valid_elements < 524288;416            _Tiles[[index]].defined_valid_elements =417                (_Tiles[[index]].defined_valid_elements + 1)418                    as integer {0..524288};419        end;420    end;421    _Tiles[[index]].contents_defined =422        _Tiles[[index]].defined_valid_elements ==423            _Tiles[[index]].valid_rows * _Tiles[[index]].valid_columns;424end;425
426func TileWithValidRegionDefined(tile: TileInfo) => TileInfo427begin428    var result = tile;429    for row = 0 to result.valid_rows - 1 looplimit 524288 do430        for column = 0 to result.valid_columns - 1 looplimit 65536 do431            let element = TileLogicalLinearIndex(432                result, row as integer {0..65535},433                column as integer {0..65535});434            result = TileInfoWithLogicalElement(result, element,435                TileReadLogicalElement(result, element));436        end;437    end;438    result.defined_valid_elements =439        (result.valid_rows * result.valid_columns)440            as integer {0..524288};441    result.contents_defined = TRUE;442    return result;443end;444
445func MarkTileValidRegionDefined(index: TileIndex)446begin447    _Tiles[[index]] = TileWithValidRegionDefined(_Tiles[[index]]);448end;449
450func TileWithPadding(tile: TileInfo, pad_value: TilePadValue) => TileInfo451begin452    var result = tile;453    let padding_defined = pad_value != TilePad_Null;454    let padding = TilePadValueForDataType(pad_value, result.data_type);455    for row = 0 to result.rows - 1 looplimit 65536 do456        for column = 0 to result.columns - 1 looplimit 65536 do457            if row >= result.valid_rows || column >= result.valid_columns then458                let element = TileLogicalLinearIndex(459                    result, row as integer {0..65535},460                    column as integer {0..65535});461                result = TileInfoWithLogicalElementAndDefined(462                    result, element, padding, padding_defined);463            end;464        end;465    end;466    return result;467end;468
469func ApplyTilePadding(index: TileIndex, pad_value: TilePadValue)470begin471    _Tiles[[index]] = TileWithPadding(_Tiles[[index]], pad_value);472end;473
474func MarkTilePhysicalRegionDefined(index: TileIndex)475begin476    let tile = _Tiles[[index]];477    for row = 0 to tile.rows - 1 looplimit 65536 do478        for column = 0 to tile.columns - 1 looplimit 65536 do479            let element = TileLogicalLinearIndex(480                tile, row as integer {0..65535},481                column as integer {0..65535});482            _Tiles[[index]] = TileInfoWithLogicalElement(483                _Tiles[[index]], element,484                TileReadLogicalElement(tile, element));485        end;486    end;487    _Tiles[[index]].defined_valid_elements =488        (tile.valid_rows * tile.valid_columns)489                as integer {0..524288};490    _Tiles[[index]].contents_defined = TRUE;491end;492readonly func TileShapesMatch(left: TileInfo, right: TileInfo) => boolean493begin494    return left.rows == right.rows &&495           left.columns == right.columns &&496           left.valid_rows == right.valid_rows &&497           left.valid_columns == right.valid_columns &&498           left.storage_kind == right.storage_kind &&499           left.data_type == right.data_type;500end;501

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

9 matching entries

Executable evidence3

CUBE physical positions outside the valid region receive PadValue without becoming valid elements
1. surfaceTILE
2. ownerPTO-TILE-MODEL-DEFINEDNESS-ELEMENTS
3. categorySTATE-TRANSITION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-CUBE-PADDING-001
Path
tests/asl/tile/model/definedness/elements/tile-state-cube-padding-001.asl
Kind / role
state-transition
Requirements
PTO-CUBE-CELL-STATE-001
Pass condition
K-tail N-tail and final physical positions contain FP16 Max and are physically defined while valid elements remain undefined
SHA-256
711adcf263934fb9acae9141b472b637c6c8a64e219ff0463e66f1ae04b3d8d6
Open exact source ↗ for PTO-AVS-TILE-CUBE-PADDING-001
PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS compiles as an independent normative unit
1. surfaceTILE
2. ownerPTO-TILE-MODEL-DEFINEDNESS-ELEMENTS
3. categorySTATIC-INVARIANT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-MODEL-DEFINEDNESS-ELEMENTS-STATIC-001
Path
tests/asl/tile/model/definedness/elements/tile-static-elements-contract-001.asl
Kind / role
static-invariant
Pass condition
the complete model and this unit's static invariant compile
SHA-256
177fec07698dadcbfac822e7c25a29a2c63427e0e972c8a32ba3a22ca3f20d6f
Open exact source ↗ for PTO-AVS-TILE-MODEL-DEFINEDNESS-ELEMENTS-STATIC-001
Covers Tile Element Definedness.
1. surfaceTILE
2. ownerPTO-TILE-MODEL-DEFINEDNESS-ELEMENTS
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TESTTILEELEMENTDEFINEDNESS-EXECUTION-001
Path
tests/asl/tile/model/definedness/elements/tile-exec-element-definedness-001.asl
Kind / role
execution
Pass condition
TestTileElementDefinedness completes without assertion failure
SHA-256
10ba62d77e2ad13dc604cae88667c34f53a75e71203c6e3008dd0efb48e84e73
Open exact source ↗ for PTO-AVS-TILE-TESTTILEELEMENTDEFINEDNESS-EXECUTION-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

Re-encode B.IOT and B.IOS size and PE mode fields · accepted
1. decision recordADR
2. case0096
Decision record
Loading ADR-0096…
Sources and references
Complete stable ID
ADR-0096
Path
docs/status/decisions/0096-b-iot-b-ios-sizecode-pemode.md
Affected units
PTO-ARCH-DATA-TYPES-INTEGER, PTO-ARCH-FEATURES-TILE-ALLOCATION, PTO-ARCH-MEMORY-MODEL-GLOBAL-MEMORY-ACCESS, PTO-ARCH-PROFILE-RESET, PTO-ARCH-PROGRAMMING-MODEL-CORE-PE-TOPOLOGY, PTO-BLOCK-B-IOS, PTO-BLOCK-B-IOT, PTO-BLOCK-MODEL-DISPATCH-COMMANDS, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-DISPATCH-DESTINATION-SHAPE, PTO-BLOCK-MODEL-DISPATCH-SHARED-CUBE-MATRIX, PTO-BLOCK-MODEL-DISPATCH-SHARED-TLSU, PTO-BLOCK-MODEL-OPERANDS-SHARED-BINDINGS, PTO-BLOCK-MODEL-OPERANDS-TILE-BINDINGS, PTO-BLOCK-MODEL-SCHEMA-PROFILE-ENCODING, PTO-BLOCK-MODEL-STATE-TYPES, PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS, PTO-TILE-MODEL-DEFINEDNESS-PACKED-BOUNDARY, PTO-TILE-MODEL-EXECUTION-COMPARISON, PTO-TILE-MODEL-EXECUTION-COMPLEX, PTO-TILE-MODEL-EXECUTION-CUBE, PTO-TILE-MODEL-EXECUTION-ELEMENTWISE, PTO-TILE-MODEL-EXECUTION-EXPANSION, PTO-TILE-MODEL-EXECUTION-FUSED-MULTIPLY-ADD, PTO-TILE-MODEL-EXECUTION-GENERATION, PTO-TILE-MODEL-EXECUTION-IMAGE-TO-COLUMN, PTO-TILE-MODEL-EXECUTION-INDEXED-REARRANGEMENT, PTO-TILE-MODEL-EXECUTION-REARRANGEMENT, PTO-TILE-MODEL-EXECUTION-REDUCTION, PTO-TILE-MODEL-EXECUTION-SORTING, PTO-TILE-MODEL-EXECUTION-UNARY, PTO-TILE-MODEL-LEGALITY-ALLOCATION-CAPACITY, PTO-TILE-MODEL-LEGALITY-DESCRIPTOR-SHAPE, PTO-TILE-MODEL-LEGALITY-IMAGE-TO-COLUMN, PTO-TILE-MODEL-LEGALITY-INDEXED-REARRANGEMENT, PTO-TILE-MODEL-LEGALITY-MATRIX-INFO-DESCRIPTOR, PTO-TILE-MODEL-LEGALITY-MATRIX-POSTPROCESS, PTO-TILE-MODEL-LEGALITY-PE-MASK, PTO-TILE-MODEL-MEMORY-LOAD-STORE, PTO-TILE-MODEL-MEMORY-SHARED-MOVEMENT, PTO-TILE-MODEL-NUMERIC-FORMATS, PTO-TILE-MODEL-ORDERING-SORTING, PTO-TILE-MODEL-SHAPE-VALID-REGION, PTO-TILE-MODEL-STATE-ALLOCATION, PTO-TILE-MODEL-STATE-DESCRIPTORS, PTO-TILE-MODEL-STATE-FEATURE-MAP-DESCRIPTORS, PTO-TILE-MODEL-STATE-SHARED-REGISTERS, PTO-TILE-MODEL-STATE-TYPES, PTO-TILE-TLOAD
Affected NDF
PTO-ARCH-GM-ACCESS-001, PTO-B-IOS-SHARED-STATE-001, PTO-B-IOT-STREAM-001, PTO-CUBE-ACCUMULATOR-OUTPUT-001, PTO-TLOAD-CUBE-001, PTO-TLOAD-MEMORY-001
SHA-256
c4b4fb7bc17878f710015207dc19ddaf22a0cf6989d185b16844714c71e23f62
Open exact decision source ↗ for ADR-0096

Unit metadata

Open 4 generated metadata fields

id: PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS
surface: tile
classification: [ "model", "definedness", "elements" ]
depends_on: [ "PTO-ARCH-DATA-TYPES-TILE-DATA-TYPES", "PTO-TILE-MODEL-STATE-ALLOCATION", "PTO-TILE-MODEL-DEFINEDNESS-PACKED-BOUNDARY" ]

Open generated traceability record

{
  "classification": [
    "model",
    "definedness",
    "elements"
  ],
  "documentation": "docs/tile/model/definedness/elements.md",
  "id": "PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS",
  "mnemonic": null,
  "readiness_subjects": [
    "ADR-0096"
  ],
  "semantic_tests": [
    "PTO-AVS-TILE-CUBE-PADDING-001",
    "PTO-AVS-TILE-TESTTILEELEMENTDEFINEDNESS-EXECUTION-001"
  ],
  "source": "asl/tile/model/definedness/elements.asl",
  "surface": "tile",
  "tests": [
    "PTO-AVS-TILE-CUBE-PADDING-001",
    "PTO-AVS-TILE-MODEL-DEFINEDNESS-ELEMENTS-STATIC-001",
    "PTO-AVS-TILE-TESTTILEELEMENTDEFINEDNESS-EXECUTION-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/definedness/elements.asl
ASL SHA-256: c01757fba2b8b32ccf3a4df8e2a2a111d83950d4af08488c3a8cfb5bc51447e6
Generated documentation: docs/tile/model/definedness/elements.md · embedded in this page
Documentation SHA-256: 20de2b500f31882e1f48f068a036c0f8afa801a6889927c1eb20126a4d0ba490

Exact owners

ASL PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS asl/tile/model/definedness/elements.asl

Architecture behavior

Evidence index

Decision record

Unit metadata

Sources and release identity

Exact owners