PTO-TILE-MODEL-EXECUTION-CUBE

PTO-TILE-MODEL-EXECUTION-CUBE

ASL pseudocode

The complete ASL owner is shown directly below.

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-EXECUTION-CUBE","surface":"tile","classification":["model","execution","cube"],"depends_on":["PTO-TILE-MODEL-MEMORY-RESTART","PTO-TILE-MODEL-EXECUTION-COMPLEX","PTO-TILE-MODEL-EXECUTION-MATRIX-SCALE"]}2// PTO-REQ-CUBE-001: profile-defined matrix arithmetic with portable integer3// defaults. CUBE operations name their Local destination D explicitly. ACC4// forms also name their Local accumulator input C explicitly;5// C is snapshotted before D is written so D == C has read-old/write-new6// behavior.7
8impdef func TileProfileMatrixAccumulate(accumulator: Word, left: Word, right: Word,9                                         destination_type: TileDataType,10                                         left_type: TileDataType,11                                         right_type: TileDataType,12                                         control: NumericExecutionControl)13                                         => Word14begin15    return accumulator + MultiplyWord(left, right);16end;17
18impdef func TileProfileMatrixBias(value: Word, bias: Word,19                                  destination_type: TileDataType,20                                  bias_type: TileDataType) => Word21begin22    return value + bias;23end;24
25impdef func TileProfileMatrixScaledAccumulate(26    accumulator: Word, left: Word, right: Word,27    left_scale: Word, right_scale: Word,28    left_scale_present: boolean, right_scale_present: boolean,29    destination_type: TileDataType, left_type: TileDataType,30    right_type: TileDataType, left_scale_type: TileDataType,31    right_scale_type: TileDataType) => Word32begin33    let scaled_left = if left_scale_present then34        MultiplyWord(left, left_scale)35    else36        left;37    let scaled_right = if right_scale_present then38        MultiplyWord(right, right_scale)39    else40        right;41    return accumulator + MultiplyWord(scaled_left, scaled_right);42end;43
44func MarkLocalTileValidRegionDefined(tile: TileInfo) => TileInfo45begin46    var result = tile;47    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};48    result.packed_defined_elements = ZeroPackedTileDefinedElements();49    for row = 0 to result.valid_rows - 1 looplimit 65536 do50        for column = 0 to result.valid_columns - 1 looplimit 65536 do51            let element = TileStorageIndex(result,52                row as integer {0..65535}, column as integer {0..65535});53            result.defined_elements[element] = '1';54        end;55    end;56    result.defined_valid_elements =57        (result.valid_rows * result.valid_columns) as integer {0..524288};58    result.contents_defined = TRUE;59    return result;60end;61
62func MatrixProductResultFromTiles(destination: TileIndex,63                                  accumulator: TileIndex,64                                  left_tile: TileInfo,65                                  right_tile: TileInfo,66                                  accumulate: boolean,67                                  c_scale: TileIndex,68                                  c_scale_present: boolean) => TileInfo69begin70    let destination_tile = _Tiles[[destination]];71    let accumulator_tile = _Tiles[[accumulator]];72    let selected_data_type = TileDataTypeFromEncoding(73        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);74    let accumulator_data_type =75        TileMatrixAccumulatorDataType(selected_data_type);76    let expected_destination_type = if _BundleFixedPointAttributes.valid &&77        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0 then78        BundleFPATROutputType(_BundleFixedPointAttributes.pre_quant_mode)79    else accumulator_data_type;80    let output_converted = _BundleFixedPointAttributes.valid &&81        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0;82    assert left_tile.allocated && left_tile.contents_defined;83    assert right_tile.allocated && right_tile.contents_defined;84    assert left_tile.valid_columns == right_tile.valid_rows;85    assert destination_tile.allocated;86    assert destination_tile.valid_rows == left_tile.valid_rows;87    assert destination_tile.valid_columns == right_tile.valid_columns;88    assert destination_tile.data_type == expected_destination_type;89    if accumulate then90        assert accumulator_tile.allocated && accumulator_tile.contents_defined;91        assert accumulator_tile.valid_rows == left_tile.valid_rows;92        assert accumulator_tile.valid_columns == right_tile.valid_columns;93        assert accumulator_tile.data_type == accumulator_data_type;94        assert accumulator_tile.layout == destination_tile.layout;95        assert output_converted ||96               accumulator_tile.capacity_bytes == destination_tile.capacity_bytes;97    end;98    if c_scale_present then99        assert accumulate &&100               TileMatrixLocalCScaleSchemaLegal(101                   c_scale,102                   left_tile.valid_rows as integer {1..65535});103    end;104
105    let left_payload = left_tile.payload;106    let right_payload = right_tile.payload;107    var result: TileInfo = destination_tile;108    result.contents_defined = FALSE;109    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};110    result.defined_valid_elements = 0;111    result.packed_defined_elements = ZeroPackedTileDefinedElements();112    result.location = TileLocation_Matrix;113    var result_payload: TilePayload = destination_tile.payload;114    let control = NumericExecutionControl {115        rounding_mode = DecodeBundleRoundingSelection(116            _BundleDataAttributes.rounding_mode).rounding_mode,117        saturating = _BundleDataAttributes.saturating118    };119    for row = 0 to left_tile.valid_rows - 1 looplimit 65536 do120        for column = 0 to right_tile.valid_columns - 1 looplimit 65536 do121            let result_element = TileStorageIndex(result,122                row as integer {0..65535}, column as integer {0..65535});123            var sum: Word = MatrixInitialAccumulatorValue(124                accumulator_tile, accumulate,125                row as integer {0..65535},126                column as integer {0..65535},127                c_scale, c_scale_present);128            for inner = 0 to left_tile.valid_columns - 1 looplimit 65536 do129                let left_element = TileStorageIndex(left_tile,130                    row as integer {0..65535}, inner as integer {0..65535});131                let right_element = TileStorageIndex(right_tile,132                    inner as integer {0..65535}, column as integer {0..65535});133                sum = TileProfileMatrixAccumulate(sum,134                    left_payload[[left_element]], right_payload[[right_element]],135                    accumulator_data_type, left_tile.data_type,136                    right_tile.data_type, control);137            end;138            result_payload[[result_element]] = sum;139        end;140    end;141    result.payload = result_payload;142    return MarkLocalTileValidRegionDefined(result);143end;144
145func MatrixProductResult(destination: TileIndex, accumulator: TileIndex,146                         left: TileIndex, right: TileIndex,147                         accumulate: boolean) => TileInfo148begin149    return MatrixProductResultFromTiles(destination, accumulator,150        _Tiles[[left]], _Tiles[[right]], accumulate, 0, FALSE);151end;152
153func MatrixBiasResult(input: TileInfo, bias: TileIndex,154                      intermediate_type: TileDataType) => TileInfo155begin156    let bias_tile = _Tiles[[bias]];157    let bias_payload = bias_tile.payload;158    assert bias_tile.allocated && bias_tile.contents_defined;159    assert bias_tile.valid_rows == 1;160    assert bias_tile.valid_columns == input.valid_columns;161    assert bias_tile.layout == TileLayout_RowMajor;162    var result = input;163    var result_payload = input.payload;164    for row = 0 to input.valid_rows - 1 looplimit 65536 do165        for column = 0 to input.valid_columns - 1 looplimit 65536 do166            let result_element = TileStorageIndex(input,167                row as integer {0..65535}, column as integer {0..65535});168            let bias_element = TileStorageIndex(bias_tile,169                0, column as integer {0..65535});170            result_payload[[result_element]] = TileProfileMatrixBias(171                input.payload[[result_element]], bias_payload[[bias_element]],172                intermediate_type, bias_tile.data_type);173        end;174    end;175    result.payload = result_payload;176    return result;177end;178
179func MatrixMXProductResultFromTiles(destination: TileIndex,180                                    accumulator: TileIndex,181                                    left_tile: TileInfo,182                                    left_scale_tile: TileInfo,183                                    left_scale_present: boolean,184                                    right_tile: TileInfo,185                                    right_scale_tile: TileInfo,186                                    right_scale_present: boolean,187                                    accumulate: boolean,188                                    c_scale: TileIndex,189                                    c_scale_present: boolean) => TileInfo190begin191    let destination_tile = _Tiles[[destination]];192    let accumulator_tile = _Tiles[[accumulator]];193    let selected_data_type = TileDataTypeFromEncoding(194        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);195    let accumulator_data_type =196        TileMatrixAccumulatorDataType(selected_data_type);197    let expected_destination_type = if _BundleFixedPointAttributes.valid &&198        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0 then199        BundleFPATROutputType(_BundleFixedPointAttributes.pre_quant_mode)200    else accumulator_data_type;201    let output_converted = _BundleFixedPointAttributes.valid &&202        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0;203    assert left_tile.allocated && left_tile.contents_defined;204    assert right_tile.allocated && right_tile.contents_defined;205    assert !left_scale_present ||206           (left_scale_tile.allocated && left_scale_tile.contents_defined);207    assert !right_scale_present ||208           (right_scale_tile.allocated && right_scale_tile.contents_defined);209    assert left_tile.valid_columns == right_tile.valid_rows;210    assert destination_tile.allocated;211    assert destination_tile.valid_rows == left_tile.valid_rows;212    assert destination_tile.valid_columns == right_tile.valid_columns;213    assert destination_tile.data_type == expected_destination_type;214    if accumulate then215        assert accumulator_tile.allocated && accumulator_tile.contents_defined;216        assert accumulator_tile.valid_rows == left_tile.valid_rows;217        assert accumulator_tile.valid_columns == right_tile.valid_columns;218        assert accumulator_tile.data_type == accumulator_data_type;219        assert accumulator_tile.layout == destination_tile.layout;220        assert output_converted ||221               accumulator_tile.capacity_bytes == destination_tile.capacity_bytes;222    end;223    if c_scale_present then224        assert accumulate &&225               TileMatrixLocalCScaleSchemaLegal(226                   c_scale,227                   left_tile.valid_rows as integer {1..65535});228    end;229
230    let left_payload = left_tile.payload;231    let right_payload = right_tile.payload;232    let left_scale_payload = left_scale_tile.payload;233    let right_scale_payload = right_scale_tile.payload;234    var result: TileInfo = destination_tile;235    result.contents_defined = FALSE;236    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};237    result.defined_valid_elements = 0;238    result.packed_defined_elements = ZeroPackedTileDefinedElements();239    result.location = TileLocation_Matrix;240    var result_payload = destination_tile.payload;241    for row = 0 to left_tile.valid_rows - 1 looplimit 65536 do242        for column = 0 to right_tile.valid_columns - 1 looplimit 65536 do243            let result_element = TileStorageIndex(result,244                row as integer {0..65535}, column as integer {0..65535});245            var sum: Word = MatrixInitialAccumulatorValue(246                accumulator_tile, accumulate,247                row as integer {0..65535},248                column as integer {0..65535},249                c_scale, c_scale_present);250            for inner = 0 to left_tile.valid_columns - 1 looplimit 65536 do251                let left_element = TileStorageIndex(left_tile,252                    row as integer {0..65535}, inner as integer {0..65535});253                let right_element = TileStorageIndex(right_tile,254                    inner as integer {0..65535}, column as integer {0..65535});255                let left_scale_element = if left_scale_present then256                    MatrixLeftScaleElement(257                        left_scale_tile, left_tile.data_type,258                        row as integer {0..65535},259                        inner as integer {0..65535})260                else261                    0;262                let right_scale_element = if right_scale_present then263                    MatrixRightScaleElement(264                        right_scale_tile, right_tile.data_type,265                        column as integer {0..65535},266                        inner as integer {0..65535})267                else268                    0;269                let left_scale_value = if left_scale_present then270                    left_scale_payload[[left_scale_element]]271                else272                    Zeros{PTO_XLEN};273                let right_scale_value = if right_scale_present then274                    right_scale_payload[[right_scale_element]]275                else276                    Zeros{PTO_XLEN};277                sum = TileProfileMatrixScaledAccumulate(278                    sum, left_payload[[left_element]],279                    right_payload[[right_element]],280                    left_scale_value, right_scale_value,281                    left_scale_present, right_scale_present,282                    accumulator_data_type, left_tile.data_type,283                    right_tile.data_type, left_scale_tile.data_type,284                    right_scale_tile.data_type);285            end;286            result_payload[[result_element]] = sum;287        end;288    end;289    result.payload = result_payload;290    return MarkLocalTileValidRegionDefined(result);291end;292
293func MatrixMXProductResult(destination: TileIndex, accumulator: TileIndex,294                           left: TileIndex, left_scale: TileIndex,295                           right: TileIndex, right_scale: TileIndex,296                           accumulate: boolean) => TileInfo297begin298    let left_scale_present =299        TileMXInputTypeNeedsScale(_Tiles[[left]].data_type);300    let right_scale_present =301        TileMXInputTypeNeedsScale(_Tiles[[right]].data_type);302    return MatrixMXProductResultFromTiles(303        destination, accumulator,304        _Tiles[[left]], _Tiles[[left_scale]], left_scale_present,305        _Tiles[[right]], _Tiles[[right_scale]], right_scale_present,306        accumulate, 0, FALSE);307end;308
309func MatrixMXProductResultWithOptionalScales(310    destination: TileIndex, accumulator: TileIndex,311    left: TileInfo, left_scale: TileInfo, left_scale_present: boolean,312    right: TileInfo, right_scale: TileInfo, right_scale_present: boolean,313    accumulate: boolean,314    c_scale: TileIndex, c_scale_present: boolean) => TileInfo315begin316    return MatrixMXProductResultFromTiles(destination, accumulator,317        left, left_scale, left_scale_present, right, right_scale,318        right_scale_present, accumulate, c_scale, c_scale_present);319end;320
321func TMATMULShared(destination: TileIndex, accumulator: TileIndex,322                   left: TileInfo, right: TileInfo,323                   bias: TileIndex, use_bias: boolean,324                   accumulate: boolean,325                   c_scale: TileIndex, c_scale_present: boolean)326begin327    let intermediate_type = TileOrdinaryMatrixAccumulatorType(328        left.data_type, right.data_type);329    let product = MatrixProductResultFromTiles(destination, accumulator,330        left, right, accumulate, c_scale, c_scale_present);331    let result = if use_bias then332        MatrixBiasResult(product, bias, intermediate_type)333        else product;334    CommitMatrixResult(destination, result, intermediate_type);335end;336
337func TMATMULMXShared(destination: TileIndex, accumulator: TileIndex,338                     left: TileInfo, left_scale: TileInfo,339                     right: TileInfo, right_scale: TileInfo,340                     bias: TileIndex, use_bias: boolean,341                     accumulate: boolean)342begin343    let intermediate_type = TileDataType_FP32;344    let product = MatrixMXProductResultFromTiles(destination, accumulator,345        left, left_scale, TRUE, right, right_scale, TRUE,346        accumulate, 0, FALSE);347    let result = if use_bias then348        MatrixBiasResult(product, bias, intermediate_type)349        else product;350    CommitMatrixResult(destination, result, intermediate_type);351end;352
353func TMATMULMXSharedWithOptionalScales(354    destination: TileIndex, accumulator: TileIndex,355    left: TileInfo, left_scale: TileInfo, left_scale_present: boolean,356    right: TileInfo, right_scale: TileInfo, right_scale_present: boolean,357    bias: TileIndex, use_bias: boolean, accumulate: boolean,358    c_scale: TileIndex, c_scale_present: boolean)359begin360    let intermediate_type = TileDataType_FP32;361    let product = MatrixMXProductResultWithOptionalScales(362        destination, accumulator,363        left, left_scale, left_scale_present,364        right, right_scale, right_scale_present,365        accumulate, c_scale, c_scale_present);366    let result = if use_bias then367        MatrixBiasResult(product, bias, intermediate_type)368        else product;369    CommitMatrixResult(destination, result, intermediate_type);370end;371
372func TMATMUL(destination: TileIndex, left: TileIndex, right: TileIndex)373begin374    let result = MatrixProductResult(destination, destination,375        left, right, FALSE);376    CommitMatrixResult(destination, result,377        TileOrdinaryMatrixAccumulatorType(378            _Tiles[[left]].data_type, _Tiles[[right]].data_type));379end;380
381func TMATMUL_BIAS(destination: TileIndex, left: TileIndex, right: TileIndex,382                  bias: TileIndex)383begin384    let intermediate_type = TileOrdinaryMatrixAccumulatorType(385        _Tiles[[left]].data_type, _Tiles[[right]].data_type);386    let product = MatrixProductResult(destination, destination,387        left, right, FALSE);388    let result = MatrixBiasResult(product, bias, intermediate_type);389    CommitMatrixResult(destination, result, intermediate_type);390end;391
392func TMATMUL_ACC(destination: TileIndex, accumulator: TileIndex,393                 left: TileIndex, right: TileIndex)394begin395    let result = MatrixProductResult(destination, accumulator,396        left, right, TRUE);397    CommitMatrixResult(destination, result,398        TileOrdinaryMatrixAccumulatorType(399            _Tiles[[left]].data_type, _Tiles[[right]].data_type));400end;401
402func TMATMUL_MX(destination: TileIndex, left: TileIndex,403                left_scale: TileIndex, right: TileIndex,404                right_scale: TileIndex)405begin406    let result = MatrixMXProductResult(destination, destination,407        left, left_scale, right, right_scale, FALSE);408    CommitMatrixResult(destination, result, TileDataType_FP32);409end;410
411func TMATMUL_MX_BIAS(destination: TileIndex, left: TileIndex,412                     left_scale: TileIndex, right: TileIndex,413                     right_scale: TileIndex,414                     bias: TileIndex)415begin416    let product = MatrixMXProductResult(destination, destination,417        left, left_scale, right, right_scale, FALSE);418    let result = MatrixBiasResult(product, bias, TileDataType_FP32);419    CommitMatrixResult(destination, result, TileDataType_FP32);420end;421
422func TMATMUL_MX_ACC(destination: TileIndex, accumulator: TileIndex,423                    left: TileIndex, left_scale: TileIndex,424                    right: TileIndex, right_scale: TileIndex)425begin426    let result = MatrixMXProductResult(destination, accumulator,427        left, left_scale, right, right_scale, TRUE);428    CommitMatrixResult(destination, result, TileDataType_FP32);429end;430
431func TGEMV(destination: TileIndex, left_vector: TileIndex,432           right_matrix: TileIndex)433begin434    assert _Tiles[[left_vector]].valid_rows == 1;435    let result = MatrixProductResult(destination, destination,436        left_vector, right_matrix, FALSE);437    CommitMatrixResult(destination, result,438        TileOrdinaryMatrixAccumulatorType(439            _Tiles[[left_vector]].data_type,440            _Tiles[[right_matrix]].data_type));441end;442
443func TGEMV_BIAS(destination: TileIndex, left_vector: TileIndex,444                right_matrix: TileIndex, bias: TileIndex)445begin446    let intermediate_type = TileOrdinaryMatrixAccumulatorType(447        _Tiles[[left_vector]].data_type,448        _Tiles[[right_matrix]].data_type);449    assert _Tiles[[left_vector]].valid_rows == 1;450    let product = MatrixProductResult(destination, destination,451        left_vector, right_matrix, FALSE);452    let result = MatrixBiasResult(product, bias, intermediate_type);453    CommitMatrixResult(destination, result, intermediate_type);454end;455
456func TGEMV_ACC(destination: TileIndex, accumulator: TileIndex,457               left_vector: TileIndex, right_matrix: TileIndex)458begin459    assert _Tiles[[left_vector]].valid_rows == 1;460    let result = MatrixProductResult(destination, accumulator,461        left_vector, right_matrix, TRUE);462    CommitMatrixResult(destination, result,463        TileOrdinaryMatrixAccumulatorType(464            _Tiles[[left_vector]].data_type,465            _Tiles[[right_matrix]].data_type));466end;467
468func TGEMV_MX(destination: TileIndex, left_vector: TileIndex,469              left_scale: TileIndex, right_matrix: TileIndex,470              right_scale: TileIndex)471begin472    assert _Tiles[[left_vector]].valid_rows == 1;473    let result = MatrixMXProductResult(destination, destination,474        left_vector, left_scale, right_matrix, right_scale, FALSE);475    CommitMatrixResult(destination, result, TileDataType_FP32);476end;477
478func TGEMV_MX_BIAS(destination: TileIndex, left_vector: TileIndex,479                   left_scale: TileIndex, right_matrix: TileIndex,480                   right_scale: TileIndex,481                   bias: TileIndex)482begin483    assert _Tiles[[left_vector]].valid_rows == 1;484    let product = MatrixMXProductResult(destination, destination,485        left_vector, left_scale, right_matrix, right_scale, FALSE);486    let result = MatrixBiasResult(product, bias, TileDataType_FP32);487    CommitMatrixResult(destination, result, TileDataType_FP32);488end;489
490func TGEMV_MX_ACC(destination: TileIndex, accumulator: TileIndex,491                  left_vector: TileIndex, left_scale: TileIndex,492                  right_matrix: TileIndex, right_scale: TileIndex)493begin494    assert _Tiles[[left_vector]].valid_rows == 1;495    let result = MatrixMXProductResult(destination, accumulator,496        left_vector, left_scale, right_matrix, right_scale, TRUE);497    CommitMatrixResult(destination, result, TileDataType_FP32);498end;499

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

12 matching entries

Executable evidence5

CUBE aliases, composite preflight, and MX rejection are effect safe
1. surfaceTILE
2. ownerPTO-TILE-MODEL-EXECUTION-CUBE
3. categoryBOUNDARY
4. case002
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-CUBE-PREFLIGHT-BOUND-002
Path
tests/asl/tile/model/execution/cube/tile-bound-preflight-002.asl
Kind / role
boundary
Pass condition
alias, preflight, and applicability rejection assertions hold
SHA-256
8a25302eef50a31015691493f464bf8c3d80657dbf3d88dcdd0f6432cc9ee593
Open exact source ↗ for PTO-AVS-TILE-CUBE-PREFLIGHT-BOUND-002
CUBE selectors and raw carrier types enforce assigned legality
1. surfaceTILE
2. ownerPTO-TILE-MODEL-EXECUTION-CUBE
3. categoryBOUNDARY
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-CUBE-SELECTORS-BOUND-001
Path
tests/asl/tile/model/execution/cube/tile-bound-totality-001.asl
Kind / role
boundary
Pass condition
selector, type, and placement assertions hold
SHA-256
06adeaf18564ef4a525cffdaf68b38354462ed86033e874dc6c53ab74687e381
Open exact source ↗ for PTO-AVS-TILE-CUBE-SELECTORS-BOUND-001
PTO-TILE-MODEL-EXECUTION-CUBE compiles as an independent normative unit
1. surfaceTILE
2. ownerPTO-TILE-MODEL-EXECUTION-CUBE
3. categorySTATIC-INVARIANT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-MODEL-EXECUTION-CUBE-STATIC-001
Path
tests/asl/tile/model/execution/cube/tile-static-cube-contract-001.asl
Kind / role
static-invariant
Pass condition
the complete model and this unit's static invariant compile
SHA-256
fd9dd8102a0da44356e571839ef289abbac473221d6c4ed4459f4d0009594085
Open exact source ↗ for PTO-AVS-TILE-MODEL-EXECUTION-CUBE-STATIC-001
Covers Tile Matmul.
1. surfaceTILE
2. ownerPTO-TILE-MODEL-EXECUTION-CUBE
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TESTTILEMATMUL-EXECUTION-001
Path
tests/asl/tile/model/execution/cube/tile-exec-matmul-001.asl
Kind / role
execution
Pass condition
TestTileMatmul completes without assertion failure
SHA-256
3f8e34e66c7f62dbe1c0ae34e3eb1e13ceb7ae588f5230be84ee44fba1c44303
Open exact source ↗ for PTO-AVS-TILE-TESTTILEMATMUL-EXECUTION-001
TMATMUL reads and writes logical coordinates through persistent CUBE storage mappings
1. surfaceTILE
2. ownerPTO-TILE-MODEL-EXECUTION-CUBE
3. categoryEXECUTION
4. case003
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TMATMUL-CUBE-STORAGE-003
Path
tests/asl/tile/model/execution/cube/tile-exec-tmatmul-cube-storage-003.asl
Kind / role
execution
Requirements
PTO-CUBE-LOCAL-MATRIX-001
Pass condition
M16 A N8 B and M16 D produce the exact 2 by 2 product while preserving their non-row-major physical payload order
SHA-256
e3436bee5f86cc292fb819824a31c1152c964f79b02bd45a9ada96285d2d976f
Open exact source ↗ for PTO-AVS-TILE-TMATMUL-CUBE-STORAGE-003

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 history2

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
Matrix Scale Cell Layouts, HiF4 Scale Words, and CScale · accepted
1. decision recordADR
2. case0101
Decision record
Loading ADR-0101…
Sources and references
Complete stable ID
ADR-0101
Path
docs/status/decisions/0101-matrix-scale-and-cscale.md
Affected units
PTO-ARCH-DATA-TYPES-FORMAT-HIF4-SCALE, PTO-ARCH-PROFILE-MATRIX-POSTPROCESS, PTO-BLOCK-B-FPATR, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-DISPATCH-MATRIX-SCALE, PTO-BLOCK-MODEL-DISPATCH-SHARED-CUBE-MATRIX, PTO-BLOCK-MODEL-SCHEMA-ATTRIBUTES, PTO-BLOCK-MODEL-STATE-TYPES, PTO-TILE-MODEL-EXECUTION-CUBE, PTO-TILE-MODEL-EXECUTION-MATRIX-SCALE, PTO-TILE-MODEL-LEGALITY-MATRIX-FUNCTIONS, PTO-TILE-MODEL-LEGALITY-MATRIX-OPERANDS, PTO-TILE-MODEL-LEGALITY-MATRIX-POSTPROCESS, PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE, PTO-TILE-MODEL-SHAPE-CUBE-CELL
Affected NDF
PTO-B-FPATR-MATRIX-POSTPROCESS-001, PTO-CUBE-CSCALE-001, PTO-CUBE-HIF4-SCALE-001, PTO-CUBE-MATRIX-SCALE-001, PTO-CUBE-MATRIX-SCALE-CELL-001, PTO-CUBE-SHARED-TRANSPOSE-001
SHA-256
a5c962437636c0d3f4f3585d3b529fcc9821d4b00c540243c2351978196e9be0
Open exact decision source ↗ for ADR-0101

Unit metadata

Open 4 generated metadata fields

id: PTO-TILE-MODEL-EXECUTION-CUBE
surface: tile
classification: [ "model", "execution", "cube" ]
depends_on: [ "PTO-TILE-MODEL-MEMORY-RESTART", "PTO-TILE-MODEL-EXECUTION-COMPLEX", "PTO-TILE-MODEL-EXECUTION-MATRIX-SCALE" ]

Open generated traceability record

{
  "classification": [
    "model",
    "execution",
    "cube"
  ],
  "documentation": "docs/tile/model/execution/cube.md",
  "id": "PTO-TILE-MODEL-EXECUTION-CUBE",
  "mnemonic": null,
  "readiness_subjects": [
    "ADR-0096",
    "ADR-0101"
  ],
  "semantic_tests": [
    "PTO-AVS-TILE-CUBE-PREFLIGHT-BOUND-002",
    "PTO-AVS-TILE-CUBE-SELECTORS-BOUND-001",
    "PTO-AVS-TILE-TESTTILEMATMUL-EXECUTION-001",
    "PTO-AVS-TILE-TMATMUL-CUBE-STORAGE-003"
  ],
  "source": "asl/tile/model/execution/cube.asl",
  "surface": "tile",
  "tests": [
    "PTO-AVS-TILE-CUBE-PREFLIGHT-BOUND-002",
    "PTO-AVS-TILE-CUBE-SELECTORS-BOUND-001",
    "PTO-AVS-TILE-MODEL-EXECUTION-CUBE-STATIC-001",
    "PTO-AVS-TILE-TESTTILEMATMUL-EXECUTION-001",
    "PTO-AVS-TILE-TMATMUL-CUBE-STORAGE-003"
  ]
}

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/execution/cube.asl
ASL SHA-256: c3b6207cabb062ee8e16ccb458d99514f856b5e36ecd7c5203797ccf9a6005a9
Generated documentation: docs/tile/model/execution/cube.md · embedded in this page
Documentation SHA-256: 43207ffaf6e5267eee3361d1b41b96f05d6420ac4a8e8dbbcf7f151796ec7255

Exact owners