PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE

PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE

ASL pseudocode

The complete ASL owner is shown directly below.

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE","surface":"tile","classification":["model","legality","matrix-shape"],"depends_on":["PTO-TILE-MODEL-LEGALITY-MATRIX-FUNCTIONS","PTO-TILE-MODEL-LEGALITY-MATRIX-INFO-DESCRIPTOR","PTO-TILE-MODEL-LEGALITY-MEMORY-SCHEMA"]}2readonly func TileMatrixShapeLegal(left: TileIndex,3                                   right: TileIndex) => boolean4begin5    return BundleTileOperationSelected() &&6           TileMatrixCubeInfosMatchDimensions(7               _Tiles[[left]], _Tiles[[right]],8               _Tiles[[left]].valid_rows,9               _Tiles[[right]].valid_columns,10               _Tiles[[left]].valid_columns) &&11           _Tiles[[left]].valid_rows * _Tiles[[right]].valid_columns <=12               PTO_MODEL_TILE_ELEMENTS;13end;14
15pure func TileOrdinaryMatrixInputTypeSupported(16    data_type: TileDataType) => boolean17begin18    return data_type == TileDataType_FP32 ||19           data_type == TileDataType_TF32 ||20           data_type == TileDataType_HF32 ||21           data_type == TileDataType_FP16 ||22           data_type == TileDataType_BF16 ||23           data_type == TileDataType_HiF8 ||24           data_type == TileDataType_E4M3 ||25           data_type == TileDataType_E5M2 ||26           data_type == TileDataType_E3M2 ||27           data_type == TileDataType_E2M3 ||28           data_type == TileDataType_E2M1X2 ||29           data_type == TileDataType_E1M2X2 ||30           data_type == TileDataType_S16 ||31           data_type == TileDataType_S8 ||32           data_type == TileDataType_S4X2 ||33           data_type == TileDataType_U16 ||34           data_type == TileDataType_U8 ||35           data_type == TileDataType_U4X2;36end;37
38pure func TileOrdinaryMatrixInputTypesSameClass(39    left_type: TileDataType, right_type: TileDataType) => boolean40begin41    if !TileOrdinaryMatrixInputTypeSupported(left_type) ||42       !TileOrdinaryMatrixInputTypeSupported(right_type) then43        return FALSE;44    end;45    return (TileDataTypeIsFloating(left_type) &&46            TileDataTypeIsFloating(right_type)) ||47           (TileDataTypeIsSigned(left_type) &&48            TileDataTypeIsSigned(right_type)) ||49           (TileDataTypeIsUnsignedInteger(left_type) &&50            TileDataTypeIsUnsignedInteger(right_type));51end;52
53pure func TileOrdinaryMatrixAccumulatorType(54    left_type: TileDataType, right_type: TileDataType) => TileDataType55begin56    assert TileOrdinaryMatrixInputTypesSameClass(left_type, right_type);57    return TileMatrixAccumulatorDataType(left_type);58end;59
60readonly func BundleCubeDimensionValue(61    dimension: BundleDimensionRegister) => integer {0..65535}62begin63    let index = BundleDimensionIndexOfRegister(dimension);64    if !_BundleDimensionPresent[[index]] then return 1; end;65    let raw = UInt(_BundleDimensions[[index]]);66    if raw <= 65535 then return raw as integer {0..65535}; end;67    return 0;68end;69
70readonly func BundleTMATMULDimensionsLegal(71    shared_count: integer {0..4}) => boolean72begin73    let m = BundleCubeDimensionValue(BundleDimension_LB0);74    let n = BundleCubeDimensionValue(BundleDimension_LB1);75    let k = BundleCubeDimensionValue(BundleDimension_LB2);76    if shared_count == 0 then77        return m != 0 && n != 0 && k != 0;78    end;79    return m >= 1 && m <= 128 && IsNonzeroPowerOfTwo(n) &&80           IsNonzeroPowerOfTwo(k);81end;82
83readonly func TileMatrixInfosMatchDimensions(84    left: TileInfo, right: TileInfo,85    m: integer {1..65535}, n: integer {1..65535},86    k: integer {1..65535}) => boolean87begin88    return TileInfoDescriptorLegal(left) && TileInfoDescriptorLegal(right) &&89           IsNonzeroPowerOfTwo(left.rows) &&90           IsNonzeroPowerOfTwo(left.columns) &&91           IsNonzeroPowerOfTwo(right.rows) &&92           IsNonzeroPowerOfTwo(right.columns) &&93           left.valid_rows == m && left.valid_columns == k &&94           right.valid_rows == k && right.valid_columns == n;95end;96
97readonly func TileMatrixInfoShapeLegal(left: TileInfo,98                                       right: TileInfo) => boolean99begin100    return BundleTileOperationSelected() &&101           TileInfoDescriptorLegal(left) && TileInfoDescriptorLegal(right) &&102           IsNonzeroPowerOfTwo(left.valid_rows) &&103           IsNonzeroPowerOfTwo(left.valid_columns) &&104           IsNonzeroPowerOfTwo(right.valid_rows) &&105           IsNonzeroPowerOfTwo(right.valid_columns) &&106           left.valid_columns == right.valid_rows &&107           left.valid_rows * right.valid_columns <= PTO_MODEL_TILE_ELEMENTS;108end;109
110readonly func TileOrdinaryMatrixInfosLegal(left: TileInfo,111                                           right: TileInfo) => boolean112begin113    if !TileMatrixInfoShapeLegal(left, right) then return FALSE; end;114    let left_type = TileDataTypeFromEncoding(115        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);116    let right_type = if _BundleDataAttributesPresent then117        TileDataTypeFromEncoding(118            _BundleDataAttributes.data_type as TileDataTypeEncoding)119        else left_type;120    return left.data_type == left_type && right.data_type == right_type &&121           TileOrdinaryMatrixInputTypesSameClass(left_type, right_type);122end;123
124readonly func TileMatrixInfoDestinationLegal(destination: TileIndex,125                                              left: TileInfo,126                                              right: TileInfo) => boolean127begin128    if !TileDescriptorLegal(destination) ||129       !TileMatrixInfoShapeLegal(left, right) then return FALSE; end;130    let left_type = TileDataTypeFromEncoding(131        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);132    let right_type = if _BundleDataAttributesPresent then133        TileDataTypeFromEncoding(134            _BundleDataAttributes.data_type as TileDataTypeEncoding)135        else left_type;136    if !TileOrdinaryMatrixInputTypesSameClass(left_type, right_type) then137        return FALSE;138    end;139    let accumulator_type = TileOrdinaryMatrixAccumulatorType(140        left_type, right_type);141    let expected_destination_type = if _BundleFixedPointAttributes.valid &&142        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0 then143        BundleFPATROutputType(_BundleFixedPointAttributes.pre_quant_mode)144    else accumulator_type;145    return _Tiles[[destination]].valid_rows == left.valid_rows &&146           _Tiles[[destination]].valid_columns == right.valid_columns &&147           _Tiles[[destination]].data_type == expected_destination_type;148end;149
150readonly func TileMatrixInfoBiasLegal(left: TileInfo, right: TileInfo,151                                      bias: TileIndex,152                                      mx: boolean) => boolean153begin154    if !TileSourceContentsDefined(bias) ||155       _Tiles[[bias]].valid_rows != 1 ||156       _Tiles[[bias]].valid_columns != right.valid_columns ||157       _Tiles[[bias]].layout != TileLayout_RowMajor then158        return FALSE;159    end;160    let left_type = TileDataTypeFromEncoding(161        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);162    let right_type = if _BundleDataAttributesPresent then163        TileDataTypeFromEncoding(164            _BundleDataAttributes.data_type as TileDataTypeEncoding)165        else left_type;166    let result_type = if mx then TileDataType_FP32 else167        TileOrdinaryMatrixAccumulatorType(left_type, right_type);168    return _Tiles[[bias]].data_type == result_type;169end;170
171readonly func TileMatrixInfoAccumulatorLegal(destination: TileIndex,172                                               accumulator: TileIndex,173                                               left: TileInfo,174                                               right: TileInfo) => boolean175begin176    let output_converted = _BundleFixedPointAttributes.valid &&177        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0;178    let accumulator_type = TileOrdinaryMatrixAccumulatorType(179        left.data_type, right.data_type);180    return TileSourceContentsDefined(accumulator) &&181           TileDescriptorLegal(accumulator) &&182           TileMatrixInfoShapeLegal(left, right) &&183           _Tiles[[accumulator]].valid_rows == left.valid_rows &&184           _Tiles[[accumulator]].valid_columns == right.valid_columns &&185           _Tiles[[accumulator]].data_type == accumulator_type &&186           _Tiles[[accumulator]].layout == _Tiles[[destination]].layout &&187           (output_converted ||188            _Tiles[[accumulator]].capacity_bytes ==189                _Tiles[[destination]].capacity_bytes);190end;191
192readonly func TileMatrixInfoOptionalScalesLegal(193    left: TileInfo, left_scale: TileInfo, left_scale_present: boolean,194    right: TileInfo, right_scale: TileInfo, right_scale_present: boolean)195    => boolean196begin197    let primary_shape_legal = TileMatrixInfoShapeLegal(left, right) ||198        TileMatrixCubeInfosMatchDimensions(199            left, right, left.valid_rows,200            right.valid_columns, left.valid_columns) ||201        TileMatrixMixedInfosMatchDimensions(202            left, right, left.valid_rows,203            right.valid_columns, left.valid_columns);204    if !primary_shape_legal then return FALSE; end;205    let left_type = TileDataTypeFromEncoding(206        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);207    let right_type = if _BundleDataAttributesPresent then208        TileDataTypeFromEncoding(209            _BundleDataAttributes.data_type as TileDataTypeEncoding)210        else left_type;211    if left.data_type != left_type || right.data_type != right_type ||212       !TileMXOperandPairLegal(left_type, right_type) then213        return FALSE;214    end;215    let left_scale_required = TileMXInputTypeNeedsScale(left_type);216    let right_scale_required = TileMXInputTypeNeedsScale(right_type);217    if left_scale_present != left_scale_required ||218       right_scale_present != right_scale_required then219        return FALSE;220    end;221    let left_groups = if left_scale_present then TileMXScaleGroupCount(222        left.valid_columns as integer {1..65535}, left_type) else 1;223    let right_groups = if right_scale_present then TileMXScaleGroupCount(224        left.valid_columns as integer {1..65535}, right_type) else 1;225    let left_scale_legal = !left_scale_present ||226        (((left_scale.layout == TileLayout_CUBE_M32 && TileCubeDescriptorLegal(left_scale)) ||227          (left_scale.layout == TileLayout_RowMajor &&228           left_scale.location == TileLocation_Any &&229           TileInfoDescriptorLegal(left_scale))) &&230         left_scale.data_type == TileMXScaleCarrierType(left_type) &&231         left_scale.valid_rows == left.valid_rows &&232         left_scale.valid_columns == left_groups);233    let right_scale_legal = !right_scale_present ||234        (((right_scale.layout == TileLayout_CUBE_M32 && TileCubeDescriptorLegal(right_scale) &&235           right_scale.valid_rows == right.valid_columns &&236           right_scale.valid_columns == right_groups) ||237          (right_scale.layout == TileLayout_RowMajor &&238           right_scale.location == TileLocation_Any &&239           TileInfoDescriptorLegal(right_scale) &&240           right_scale.valid_rows == right_groups &&241           right_scale.valid_columns == right.valid_columns)) &&242         right_scale.data_type == TileMXScaleCarrierType(right_type));243    return left_scale_legal && right_scale_legal;244end;245
246readonly func TileMatrixInfoScalesLegal(left: TileInfo,247                                         left_scale: TileInfo,248                                         right: TileInfo,249                                         right_scale: TileInfo) => boolean250begin251    return TileMatrixInfoOptionalScalesLegal(252        left, left_scale, TRUE, right, right_scale, TRUE);253end;254
255readonly func TileOrdinaryMatrixOperandsLegal(left: TileIndex,256                                              right: TileIndex) => boolean257begin258    if !TileMatrixShapeLegal(left, right) then return FALSE; end;259    let left_type = TileDataTypeFromEncoding(260        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);261    let right_type = if _BundleDataAttributesPresent then262        TileDataTypeFromEncoding(263            _BundleDataAttributes.data_type as TileDataTypeEncoding)264        else left_type;265    return _Tiles[[left]].data_type == left_type &&266           _Tiles[[right]].data_type == right_type &&267           TileOrdinaryMatrixInputTypesSameClass(left_type, right_type);268end;269
270readonly func TileMXMatrixOperandsLegal(left: TileIndex,271                                        right: TileIndex) => boolean272begin273    if !TileMatrixShapeLegal(left, right) then return FALSE; end;274    let left_type = TileDataTypeFromEncoding(275        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);276    let right_type = if _BundleDataAttributesPresent then277        TileDataTypeFromEncoding(278            _BundleDataAttributes.data_type as TileDataTypeEncoding)279        else left_type;280    return _Tiles[[left]].data_type == left_type &&281           _Tiles[[right]].data_type == right_type &&282           TileMXOperandPairLegal(left_type, right_type);283end;284
285readonly func TileMatrixBiasShapeLegal(left: TileIndex, right: TileIndex,286                                       bias: TileIndex) => boolean287begin288    return TileSourceContentsDefined(bias) &&289           _Tiles[[bias]].valid_rows == 1 &&290           _Tiles[[bias]].valid_columns == _Tiles[[right]].valid_columns &&291           _Tiles[[bias]].layout == TileLayout_RowMajor;292end;293
294readonly func TileOrdinaryMatrixBiasLegal(left: TileIndex, right: TileIndex,295                                          bias: TileIndex) => boolean296begin297    let left_type = TileDataTypeFromEncoding(298        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);299    let right_type = if _BundleDataAttributesPresent then300        TileDataTypeFromEncoding(301            _BundleDataAttributes.data_type as TileDataTypeEncoding)302        else left_type;303    return TileOrdinaryMatrixOperandsLegal(left, right) &&304           TileMatrixBiasShapeLegal(left, right, bias) &&305           _Tiles[[bias]].data_type == TileOrdinaryMatrixAccumulatorType(306               left_type, right_type);307end;308
309readonly func TileMXMatrixBiasLegal(left: TileIndex, right: TileIndex,310                                    bias: TileIndex) => boolean311begin312    return TileMXMatrixOperandsLegal(left, right) &&313           TileMatrixBiasShapeLegal(left, right, bias) &&314           _Tiles[[bias]].data_type == TileDataType_FP32;315end;316
317readonly func TileMatrixScaleLegal(left: TileIndex, right: TileIndex,318                                   left_scale: TileIndex,319                                   right_scale: TileIndex) => boolean320begin321    if !TileMXMatrixOperandsLegal(left, right) then return FALSE; end;322    let left_scale_present =323        TileMXInputTypeNeedsScale(_Tiles[[left]].data_type);324    let right_scale_present =325        TileMXInputTypeNeedsScale(_Tiles[[right]].data_type);326    return TileMatrixInfoOptionalScalesLegal(327        _Tiles[[left]], _Tiles[[left_scale]], left_scale_present,328        _Tiles[[right]], _Tiles[[right_scale]], right_scale_present);329end;330
331readonly func TileMatrixDestinationLegal(destination: TileIndex,332                                         left: TileIndex,333                                         right: TileIndex) => boolean334begin335    if !TileCubeDescriptorLegal(_Tiles[[destination]]) ||336       !TileMatrixShapeLegal(left, right) then return FALSE; end;337    let left_type = TileDataTypeFromEncoding(338        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);339    let right_type = if _BundleDataAttributesPresent then340        TileDataTypeFromEncoding(341            _BundleDataAttributes.data_type as TileDataTypeEncoding)342        else left_type;343    if !TileOrdinaryMatrixInputTypesSameClass(left_type, right_type) then344        return FALSE;345    end;346    let accumulator_type = TileOrdinaryMatrixAccumulatorType(347        left_type, right_type);348    let expected_destination_type = if _BundleFixedPointAttributes.valid &&349        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0 then350        BundleFPATROutputType(_BundleFixedPointAttributes.pre_quant_mode)351    else accumulator_type;352    return _Tiles[[destination]].valid_rows == _Tiles[[left]].valid_rows &&353           _Tiles[[destination]].valid_columns == _Tiles[[right]].valid_columns &&354           _Tiles[[destination]].data_type == expected_destination_type &&355           _Tiles[[destination]].layout == _Tiles[[left]].layout;356end;357
358readonly func TileMatrixAccumulatorDestinationLegal(destination: TileIndex,359                                                     left: TileIndex,360                                                     right: TileIndex) => boolean361begin362    if !TileCubeDescriptorLegal(_Tiles[[destination]]) ||363       !TileMatrixShapeLegal(left, right) then return FALSE; end;364    let accumulator_type = TileOrdinaryMatrixAccumulatorType(365        _Tiles[[left]].data_type, _Tiles[[right]].data_type);366    return _Tiles[[destination]].valid_rows == _Tiles[[left]].valid_rows &&367           _Tiles[[destination]].valid_columns == _Tiles[[right]].valid_columns &&368           _Tiles[[destination]].data_type == accumulator_type &&369           _Tiles[[destination]].layout == _Tiles[[left]].layout;370end;371
372readonly func TileOperandsLegal_TMATMUL(373    destination: TileIndex, left: TileIndex, right: TileIndex) => boolean374begin375    return TileOrdinaryMatrixOperandsLegal(left, right) &&376           TileMatrixDestinationLegal(destination, left, right);377end;378
379readonly func TileOperandsLegal_TMATMUL_BIAS(380    destination: TileIndex, left: TileIndex, right: TileIndex,381    bias: TileIndex) => boolean382begin383    return TileOperandsLegal_TMATMUL(destination, left, right) &&384           TileOrdinaryMatrixBiasLegal(left, right, bias);385end;386
387readonly func TileOperandsLegal_TMATMUL_ACC(388    destination: TileIndex, accumulator: TileIndex,389    left: TileIndex, right: TileIndex) => boolean390begin391    let output_converted = _BundleFixedPointAttributes.valid &&392        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0;393    return destination != accumulator &&394           TileOperandsLegal_TMATMUL(destination, left, right) &&395           TileCubeDescriptorLegal(_Tiles[[accumulator]]) &&396           _Tiles[[accumulator]].contents_defined &&397           TileMatrixAccumulatorDestinationLegal(accumulator, left, right) &&398           _Tiles[[accumulator]].layout == _Tiles[[destination]].layout &&399           (output_converted ||400            _Tiles[[accumulator]].capacity_bytes ==401                _Tiles[[destination]].capacity_bytes);402end;403
404readonly func TileOperandsLegal_TMATMUL_MX(405    destination: TileIndex, left: TileIndex, left_scale: TileIndex,406    right: TileIndex, right_scale: TileIndex) => boolean407begin408    return TileMatrixScaleLegal(left, right, left_scale, right_scale) &&409           TileMatrixDestinationLegal(destination, left, right);410end;411
412readonly func TileOperandsLegal_TMATMUL_MX_BIAS(413    destination: TileIndex, left: TileIndex, left_scale: TileIndex,414    right: TileIndex, right_scale: TileIndex,415    bias: TileIndex) => boolean416begin417    return TileOperandsLegal_TMATMUL_MX(418               destination, left, left_scale, right, right_scale) &&419           TileMXMatrixBiasLegal(left, right, bias);420end;421
422readonly func TileOperandsLegal_TMATMUL_MX_ACC(423    destination: TileIndex, accumulator: TileIndex,424    left: TileIndex, left_scale: TileIndex,425    right: TileIndex, right_scale: TileIndex) => boolean426begin427    let output_converted = _BundleFixedPointAttributes.valid &&428        UInt(_BundleFixedPointAttributes.pre_quant_mode) != 0;429    return destination != accumulator &&430           TileOperandsLegal_TMATMUL_MX(431               destination, left, left_scale, right, right_scale) &&432           TileCubeDescriptorLegal(_Tiles[[accumulator]]) &&433           _Tiles[[accumulator]].contents_defined &&434           TileMatrixAccumulatorDestinationLegal(accumulator, left, right) &&435           _Tiles[[accumulator]].layout == _Tiles[[destination]].layout &&436           (output_converted ||437            _Tiles[[accumulator]].capacity_bytes ==438                _Tiles[[destination]].capacity_bytes);439end;440
441readonly func TileOperandsLegal_TGEMV(442    destination: TileIndex, left_vector: TileIndex,443    right_matrix: TileIndex) => boolean444begin445    return TileOperandsLegal_TMATMUL(446               destination, left_vector, right_matrix) &&447           _Tiles[[left_vector]].valid_rows == 1;448end;449
450readonly func TileOperandsLegal_TGEMV_BIAS(451    destination: TileIndex, left_vector: TileIndex,452    right_matrix: TileIndex,453    bias: TileIndex) => boolean454begin455    return TileOperandsLegal_TGEMV(456               destination, left_vector, right_matrix) &&457           TileOrdinaryMatrixBiasLegal(left_vector, right_matrix, bias);458end;459
460readonly func TileOperandsLegal_TGEMV_ACC(461    destination: TileIndex, accumulator: TileIndex,462    left_vector: TileIndex, right_matrix: TileIndex) => boolean463begin464    return TileOperandsLegal_TMATMUL_ACC(465               destination, accumulator, left_vector, right_matrix) &&466           _Tiles[[left_vector]].valid_rows == 1;467end;468
469readonly func TileOperandsLegal_TGEMV_MX(470    destination: TileIndex, left_vector: TileIndex,471    left_scale: TileIndex, right_matrix: TileIndex,472    right_scale: TileIndex) => boolean473begin474    return TileOperandsLegal_TMATMUL_MX(475               destination, left_vector, left_scale,476               right_matrix, right_scale) &&477           _Tiles[[left_vector]].valid_rows == 1;478end;479
480readonly func TileOperandsLegal_TGEMV_MX_BIAS(481    destination: TileIndex, left_vector: TileIndex,482    left_scale: TileIndex, right_matrix: TileIndex,483    right_scale: TileIndex,484    bias: TileIndex) => boolean485begin486    return TileOperandsLegal_TGEMV_MX(487               destination, left_vector, left_scale,488               right_matrix, right_scale) &&489           TileMXMatrixBiasLegal(left_vector, right_matrix, bias);490end;491
492readonly func TileOperandsLegal_TGEMV_MX_ACC(493    destination: TileIndex, accumulator: TileIndex,494    left_vector: TileIndex, left_scale: TileIndex,495    right_matrix: TileIndex, right_scale: TileIndex) => boolean496begin497    return TileOperandsLegal_TMATMUL_MX_ACC(destination, accumulator,498               left_vector, left_scale, right_matrix, right_scale) &&499           _Tiles[[left_vector]].valid_rows == 1;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

12 matching entries

Executable evidence3

PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE compiles as an independent normative unit
1. surfaceTILE
2. ownerPTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE
3. categorySTATIC-INVARIANT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-MODEL-LEGALITY-MATRIX-SHAPE-STATIC-001
Path
tests/asl/tile/model/legality/matrix-shape/tile-static-matrix-shape-contract-001.asl
Kind / role
static-invariant
Pass condition
the complete model and this unit's static invariant compile
SHA-256
8b8b0332ed905744f10b06a47279ddf399f49d4c55e6aa29cbae9dced9d3b0de
Open exact source ↗ for PTO-AVS-TILE-MODEL-LEGALITY-MATRIX-SHAPE-STATIC-001
Covers Matrix Numeric Contract Legality.
1. surfaceTILE
2. ownerPTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE
3. categoryBOUNDARY
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TESTMATRIXNUMERICCONTRACTLEGALITY-BOUNDARY-001
Path
tests/asl/tile/model/legality/matrix-shape/tile-bound-numeric-contract-legality-001.asl
Kind / role
boundary
Pass condition
TestMatrixNumericContractLegality completes without assertion failure
SHA-256
d4d9b5031c8aa7a489d4f27b32048beeb7373fac00f8e51de2eb6393e52fb4c8
Open exact source ↗ for PTO-AVS-TILE-TESTMATRIXNUMERICCONTRACTLEGALITY-BOUNDARY-001
Covers Matrix Physical Accumulator Classes.
1. surfaceTILE
2. ownerPTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-TILE-TESTMATRIXPHYSICALACCUMULATORCLASSES-EXECUTION-001
Path
tests/asl/tile/model/legality/matrix-shape/tile-exec-physical-accumulator-classes-001.asl
Kind / role
execution
Pass condition
TestMatrixPhysicalAccumulatorClasses completes without assertion failure
SHA-256
df3babc5baee2dd58ee1d77ac539a64c852ae0e9c1c8eb885735b0a7d53f11d4
Open exact source ↗ for PTO-AVS-TILE-TESTMATRIXPHYSICALACCUMULATORCLASSES-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 history4

Cooperative Shared CUBE Inputs and Transpose · accepted
1. decision recordADR
2. case0072
Decision record
Loading ADR-0072…
Sources and references
Complete stable ID
ADR-0072
Path
docs/status/decisions/0072-cooperative-shared-cube-transpose.md
Affected units
PTO-ARCH-PROFILE-RESET, PTO-BLOCK-B-FPATR, PTO-BLOCK-BSTART-TGEMV-ACC, PTO-BLOCK-BSTART-TGEMV-BIAS, PTO-BLOCK-BSTART-TGEMV, PTO-BLOCK-BSTART-TGEMVMX-ACC, PTO-BLOCK-BSTART-TGEMVMX-BIAS, PTO-BLOCK-BSTART-TGEMVMX, PTO-BLOCK-BSTART-TMATMUL-ACC, PTO-BLOCK-BSTART-TMATMUL-BIAS, PTO-BLOCK-BSTART-TMATMUL, PTO-BLOCK-BSTART-TMATMULMX-ACC, PTO-BLOCK-BSTART-TMATMULMX-BIAS, PTO-BLOCK-BSTART-TMATMULMX, PTO-BLOCK-MODEL-DISPATCH-COMMANDS, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-DISPATCH-SHARED-CUBE-MATRIX, PTO-BLOCK-MODEL-LIFECYCLE-RESET, PTO-BLOCK-MODEL-SCHEMA-ATTRIBUTES, PTO-BLOCK-MODEL-STATE-DESCRIPTOR-STATE, PTO-BLOCK-MODEL-STATE-TYPES, 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-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-MODEL-LEGALITY-MATRIX-INFO-DESCRIPTOR, PTO-TILE-MODEL-LEGALITY-MATRIX-OPERANDS, PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE, PTO-TILE-MODEL-STATE-SHARED-REGISTERS
Affected NDF
PTO-B-FPATR-MATRIX-POSTPROCESS-001, PTO-CUBE-SHARED-TRANSPOSE-001, PTO-BSTART-TGEMV-ACC-CONTRACT-001, PTO-BSTART-TGEMV-BIAS-CONTRACT-001, PTO-BSTART-TGEMV-CONTRACT-001, PTO-BSTART-TGEMVMX-ACC-CONTRACT-001, PTO-BSTART-TGEMVMX-BIAS-CONTRACT-001, PTO-BSTART-TGEMVMX-CONTRACT-001, PTO-BSTART-TMATMUL-ACC-CONTRACT-001, PTO-BSTART-TMATMUL-BIAS-CONTRACT-001, PTO-BSTART-TMATMUL-CONTRACT-001, PTO-BSTART-TMATMULMX-ACC-CONTRACT-001, PTO-BSTART-TMATMULMX-BIAS-CONTRACT-001, PTO-BSTART-TMATMULMX-CONTRACT-001, PTO-TGEMV-CONTRACT-001, PTO-TGEMV-ACC-CONTRACT-001, PTO-TGEMV-BIAS-CONTRACT-001, PTO-TGEMV-MX-CONTRACT-001, PTO-TGEMV-MX-ACC-CONTRACT-001, PTO-TGEMV-MX-BIAS-CONTRACT-001, PTO-TMATMUL-CONTRACT-001, PTO-TMATMUL-ACC-CONTRACT-001, PTO-TMATMUL-BIAS-CONTRACT-001, PTO-TMATMUL-MX-CONTRACT-001, PTO-TMATMUL-MX-ACC-CONTRACT-001, PTO-TMATMUL-MX-BIAS-CONTRACT-001
SHA-256
9bc7340fea777ee543d4b9393f8f6002b55106833e55ff6d388f8beac504dd09
Open exact decision source ↗ for ADR-0072
CUBE Accumulator and Atomic Output Contract · accepted
1. decision recordADR
2. case0073
Decision record
Loading ADR-0073…
Sources and references
Complete stable ID
ADR-0073
Path
docs/status/decisions/0073-cube-accumulator-atomic-output.md
Affected units
PTO-BLOCK-BSTART-TGEMV-ACC, PTO-BLOCK-BSTART-TGEMVMX-ACC, PTO-BLOCK-BSTART-TMATMUL-ACC, PTO-BLOCK-BSTART-TMATMULMX-ACC, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-OPERANDS-TILE-BINDINGS, PTO-TILE-TMATMUL-ACC, PTO-TILE-TMATMUL-MX-ACC, PTO-TILE-TGEMV-ACC, PTO-TILE-TGEMV-MX-ACC, PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE
Affected NDF
PTO-CUBE-ACCUMULATOR-OUTPUT-001, PTO-BSTART-TGEMV-ACC-CONTRACT-001, PTO-BSTART-TGEMVMX-ACC-CONTRACT-001, PTO-BSTART-TMATMUL-ACC-CONTRACT-001, PTO-BSTART-TMATMULMX-ACC-CONTRACT-001, PTO-TGEMV-ACC-CONTRACT-001, PTO-TGEMV-MX-ACC-CONTRACT-001, PTO-TMATMUL-ACC-CONTRACT-001, PTO-TMATMUL-MX-ACC-CONTRACT-001
SHA-256
d63ba89014fe901b5055fc38bbd5578aa1b571c1038321a903f20cc6e9756fef
Open exact decision source ↗ for ADR-0073
Cooperative Group-M Distribution and Inactive PE Semantics · accepted
1. decision recordADR
2. case0100
Decision record
Loading ADR-0100…
Sources and references
Complete stable ID
ADR-0100
Path
docs/status/decisions/0100-cooperative-group-m-distribution.md
Affected units
PTO-BLOCK-MODEL-DISPATCH-CUBE-DESTINATION, PTO-BLOCK-MODEL-DISPATCH-CUBE-TMATMUL, PTO-BLOCK-MODEL-DISPATCH-SHARED-CUBE-MATRIX, PTO-BLOCK-MODEL-DISPATCH-TILE-EXECUTION, PTO-BLOCK-MODEL-OPERANDS-LOCAL-GENERATION, PTO-BLOCK-MODEL-OPERANDS-PORTABLE-CARRIERS, PTO-BLOCK-MODEL-OPERANDS-SUBVIEW-DESCRIPTOR, PTO-TILE-MODEL-LEGALITY-MATRIX-OPERANDS, PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE
Affected NDF
PTO-CUBE-GROUP-M-DISTRIBUTION-001, PTO-B-ASSEMBLE-CONSUMER-READINESS-001
SHA-256
adcfcca401a69fb4e7635fbe4d65d33b36fb2744b3fbedf6d7862cadbc8e7232
Open exact decision source ↗ for ADR-0100
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-LEGALITY-MATRIX-SHAPE
surface: tile
classification: [ "model", "legality", "matrix-shape" ]
depends_on: [ "PTO-TILE-MODEL-LEGALITY-MATRIX-FUNCTIONS", "PTO-TILE-MODEL-LEGALITY-MATRIX-INFO-DESCRIPTOR", "PTO-TILE-MODEL-LEGALITY-MEMORY-SCHEMA" ]

Open generated traceability record

{
  "classification": [
    "model",
    "legality",
    "matrix-shape"
  ],
  "documentation": "docs/tile/model/legality/matrix-shape.md",
  "id": "PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE",
  "mnemonic": null,
  "readiness_subjects": [
    "ADR-0072",
    "ADR-0073",
    "ADR-0100",
    "ADR-0101"
  ],
  "semantic_tests": [
    "PTO-AVS-TILE-TESTMATRIXNUMERICCONTRACTLEGALITY-BOUNDARY-001",
    "PTO-AVS-TILE-TESTMATRIXPHYSICALACCUMULATORCLASSES-EXECUTION-001"
  ],
  "source": "asl/tile/model/legality/matrix-shape.asl",
  "surface": "tile",
  "tests": [
    "PTO-AVS-TILE-MODEL-LEGALITY-MATRIX-SHAPE-STATIC-001",
    "PTO-AVS-TILE-TESTMATRIXNUMERICCONTRACTLEGALITY-BOUNDARY-001",
    "PTO-AVS-TILE-TESTMATRIXPHYSICALACCUMULATORCLASSES-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/legality/matrix-shape.asl
ASL SHA-256: de080a69a6b193f3748d33f3a4b989ce2b724fe69864cbc21957b8864b1e4c2e
Generated documentation: docs/tile/model/legality/matrix-shape.md · embedded in this page
Documentation SHA-256: 6aab9e2c122ddf23dd374d600a23878d5134d95643fbcd96099fa7ae11d96ae2

Exact owners

ASL PTO-TILE-MODEL-LEGALITY-MATRIX-SHAPE asl/tile/model/legality/matrix-shape.asl

Architecture behavior

Evidence index

Decision record

Decision record

Decision record

Decision record

Unit metadata

Sources and release identity

Exact owners