PTO-BLOCK-MODEL-DISPATCH-TILE-SCHEMA

1// PTO-UNIT: {"id":"PTO-BLOCK-MODEL-DISPATCH-TILE-SCHEMA","surface":"block","classification":["model","dispatch","tile-schema"],"depends_on":["PTO-BLOCK-MODEL-DISPATCH-SCALAR-SCHEMA","PTO-BLOCK-MODEL-OPERANDS-SUBVIEW-DESCRIPTOR","PTO-TILE-MODEL-EXECUTION-UNARY"]}2func BundleTileInstructionOperands(3    operation: integer {0..PTO_TILE_OPERATION_COUNT-1})4    => TileInstructionOperands5begin6    var operands = DefaultTileInstructionOperands();7    var destination_count: integer = 0;8    var source_count: integer = 0;9    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do10        if _BundleTileBindings[[binding]].valid then11            if _BundleTileBindings[[binding]].destination_valid then12                if destination_count == 0 then13                    operands.destination0 =14                        _BundleTileBindings[[binding]].destination;15                elsif destination_count == 1 then16                    operands.destination1 =17                        _BundleTileBindings[[binding]].destination;18                elsif destination_count == 2 then19                    operands.destination2 =20                        _BundleTileBindings[[binding]].destination;21                else22                    SetFault(Fault_TileLegality, ReadTPC());23                    return operands;24                end;25                destination_count = destination_count + 1;26            end;27            if _BundleTileBindings[[binding]].source0_valid then28                case source_count of29                    when 0 => operands.source0 =30                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);31                    when 1 => operands.source1 =32                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);33                    when 2 => operands.source2 =34                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);35                    when 3 => operands.source3 =36                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);37                    when 4 => operands.source4 =38                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);39                    when 5 => operands.source5 =40                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);41                    when 6 => operands.source6 =42                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);43                    when 7 => operands.source7 =44                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);45                    when 8 => operands.source8 =46                        BundleTileSourceIndex(binding as BundleTileBindingIndex, FALSE);47                    otherwise => unreachable;48                end;49                source_count = source_count + 1;50            end;51            if _BundleTileBindings[[binding]].source1_valid then52                case source_count of53                    when 0 => operands.source0 =54                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);55                    when 1 => operands.source1 =56                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);57                    when 2 => operands.source2 =58                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);59                    when 3 => operands.source3 =60                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);61                    when 4 => operands.source4 =62                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);63                    when 5 => operands.source5 =64                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);65                    when 6 => operands.source6 =66                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);67                    when 7 => operands.source7 =68                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);69                    when 8 => operands.source8 =70                        BundleTileSourceIndex(binding as BundleTileBindingIndex, TRUE);71                    otherwise => unreachable;72                end;73                source_count = source_count + 1;74            end;75        end;76    end;77    // B.IOR inputs are resolved in one architectural order so that optional78    // fields pack densely into RegSrc0..RegSrc2.  TLOAD/TSTORE retain their79    // omission-only dense-row stride default.80    if TileOperandPresent(operation, TileOperand_address) then81        if _BundleScalarBindings[[0]].valid then82            operands.address = ReadScalarRegisterOperand(83                BundleOperationGPRInputSelector(84                    BundleOperationGPRInputSlot(85                        operation, TileOperand_address) as integer {0..2}));86        end;87    end;88    if TileOperandPresent(operation, TileOperand_scalar0) then89        if _BundleScalarBindings[[0]].valid then90            operands.scalar0 = ReadScalarRegisterOperand(91                BundleOperationGPRInputSelector(92                    BundleOperationGPRInputSlot(93                        operation, TileOperand_scalar0) as integer {0..2}));94        elsif TileOperationOfIndex(operation) == TileOperation_TQUANT ||95              TileOperationOfIndex(operation) == TileOperation_TDEQUANT then96            operands.scalar0 = Zeros{PTO_XLEN} + 0x3f800000;97        elsif TileOperationOfIndex(operation) == TileOperation_TLOAD ||98              TileOperationOfIndex(operation) == TileOperation_TSTORE then99            // Regular TLSU omission derives a byte pitch from the resolved100            // physical column count and transfer data type. TPREFETCH retains101            // its separately owned logical-element stride contract.102            let tstore = TileOperationOfIndex(operation) ==103                TileOperation_TSTORE;104            let columns = BundleDestinationPhysicalColumns(105                tstore, operands.source0);106            operands.scalar0 = TileDenseRowStrideBytes(107                columns,108                TileDataTypeFromEncoding(109                    CurrentBundleTileOperationDataTypeCode()110                        as TileDataTypeEncoding));111        elsif TileOperandPresent(operation, TileOperand_address) then112            operands.scalar0 = _BundleDimensions[[2]];113        end;114    end;115    if TileOperandPresent(operation, TileOperand_scalar1) &&116       _BundleScalarBindings[[0]].valid then117        operands.scalar1 = ReadScalarRegisterOperand(118            BundleOperationGPRInputSelector(119                BundleOperationGPRInputSlot(120                    operation, TileOperand_scalar1) as integer {0..2}));121    end;122    if TileOperandPresent(operation, TileOperand_diagonal) then123        if _BundleScalarBindings[[0]].valid then124            let raw = ReadScalarRegisterOperand(125                BundleOperationGPRInputSelector(126                    BundleOperationGPRInputSlot(127                        operation, TileOperand_diagonal) as integer {0..2}));128            // Raw conversion is performed only after the complete-bundle129            // preflight has proved the signed value lies in the ASL domain.130            operands.diagonal = SInt(raw) as integer {-65535..65535};131        end;132    end;133    if TileOperandPresent(operation, TileOperand_flag0) then134        if _BundleScalarBindings[[0]].valid then135            let raw = ReadScalarRegisterOperand(136                BundleOperationGPRInputSelector(137                    BundleOperationGPRInputSlot(138                        operation, TileOperand_flag0) as integer {0..2}));139            // Raw booleans accept exactly zero and one; legality is checked140            // before this constrained assignment during bundle commit.141            operands.flag0 = UInt(raw) == 1;142        end;143    end;144    // Matrix post-processing scalar descriptors consume the next dense B.IOR145    // slots after any mathematical scalar controls.  Matrix operations do not146    // currently have scalar0/scalar1 controls, so these are RegSrc0/RegSrc1.147    if _BundleOperation.valid &&148       _BundleOperation.operation_class == BundleOperation_TileMatrix &&149       _BundleFixedPointAttributes.valid &&150       _BundleScalarBindings[[0]].valid then151        var post_slot: integer {0..2} = 0;152        if BundleFPATRModeUsesScalarParameter(153               _BundleFixedPointAttributes.pre_quant_mode) then154            operands.post_quant_param = ReadScalarRegisterOperand(155                BundleOperationGPRInputSelector(post_slot));156            post_slot = (post_slot + 1) as integer {0..2};157        end;158        if BundleFPATRReluModeUsesScalarParameter(159               _BundleFixedPointAttributes.relu_mode) then160            operands.post_lrelu_param = ReadScalarRegisterOperand(161                BundleOperationGPRInputSelector(post_slot));162        end;163    end;164    let dimension0 = UInt(_BundleDimensions[[0]]);165    let dimension1 = UInt(_BundleDimensions[[1]]);166    let dimension2 = UInt(_BundleDimensions[[2]]);167    if dimension0 <= 65535 then168        operands.natural0 = dimension0 as integer {0..65535};169        if dimension0 != 0 then170            operands.positive0 = dimension0 as integer {1..65535};171        end;172    end;173    if dimension1 <= 65535 then174        operands.natural1 = dimension1 as integer {0..65535};175        if dimension1 != 0 then176            operands.positive1 = dimension1 as integer {1..65535};177        end;178    end;179    if dimension2 >= 1 && dimension2 <= 65535 then180        operands.positive2 = dimension2 as integer {1..65535};181    end;182    if dimension0 <= 262144 then183        operands.byte_count = dimension0 as integer {0..262144};184    end;185    if dimension0 >= 1 && dimension0 <= 64 then186        operands.sort_width = dimension0 as integer {1..64};187    end;188    operands.selected_byte = UInt(_BundleDataAttributes.pad_value)189        as integer {0..3};190    case UInt(_BundleDataAttributes.comparison_mode) of191        when 0 => operands.comparison = TileComparison_EQ;192        when 1 => operands.comparison = TileComparison_NE;193        when 2 => operands.comparison = TileComparison_LT;194        when 3 => operands.comparison = TileComparison_GT;195        when 4 => operands.comparison = TileComparison_LE;196        when 5 => operands.comparison = TileComparison_GE;197        otherwise => operands.comparison = TileComparison_EQ;198    end;199    // Generic boolean operands are operation controls, not aliases of the200    // numeric saturation bit. Numeric consumers receive the separate typed201    // control below; other bundle operations retain their operation default.202    operands.numeric_control = DecodeBundleRoundingSelection(203        _BundleDataAttributes.rounding_mode);204    operands.numeric_control.saturating = _BundleDataAttributes.saturating;205    return operands;206end;207
208func SelectedBundleTileDataAttributesLegal(209    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean210begin211    // Inherited/default values are operation inputs, not explicitly encoded212    // nonzero B.DATR fields.  Applicability therefore examines field values213    // only when the optional command was present.214    let explicit_c_mode = if _BundleDataAttributesPresent then215        _BundleDataAttributes.comparison_mode else Zeros{3};216    let explicit_pad = if _BundleDataAttributesPresent then217        _BundleDataAttributes.pad_value else Zeros{2};218    let explicit_saturating = _BundleDataAttributesPresent &&219        _BundleDataAttributes.saturating;220    let explicit_canonicalize = _BundleDataAttributesPresent &&221        _BundleDataAttributes.canonicalize;222    let explicit_data_type = if _BundleDataAttributesPresent then223        _BundleDataAttributes.data_type else Zeros{5};224    let explicit_rounding = if _BundleDataAttributesPresent then225        _BundleDataAttributes.rounding_mode else Zeros{3};226    let explicit_layout = if _BundleDataAttributesPresent then227        _BundleDataAttributes.data_layout else Zeros{5};228    if !TileOperationDATRFieldsLegal(229        operation, explicit_c_mode, explicit_pad, explicit_saturating,230        explicit_canonicalize, explicit_data_type, explicit_rounding,231        explicit_layout) then232        SetFault(Fault_TileLegality, ReadTPC());233        return FALSE;234    end;235    let matrix = _BundleOperation.valid &&236        _BundleOperation.operation_class == BundleOperation_TileMatrix;237    let datr_legal = if matrix then238        _BundleFixedPointAttributes.valid &&239        BundleFPATRDATRFieldsLegal(240            _BundleFixedPointAttributes.pre_quant_mode,241            _BundleDataAttributes.rounding_mode,242            _BundleDataAttributes.saturating)243    else244        TileOperationDATRFieldsLegal(245            operation,246            explicit_c_mode,247            explicit_pad,248            explicit_saturating,249            explicit_canonicalize,250            explicit_data_type,251            explicit_rounding,252            explicit_layout);253    if !datr_legal then254        SetFault(Fault_TileLegality, ReadTPC());255        return FALSE;256    end;257    let decoded_operation = TileOperationOfIndex(operation);258    if (decoded_operation == TileOperation_TLOAD ||259        decoded_operation == TileOperation_TSTORE) &&260       !TileDataLayoutIsCubeConversion(explicit_layout) &&261       explicit_pad != Zeros{2} then262        // PadValue is assigned to the explicit Local CUBE conversion form.263        // Ordinary and Shared TLOAD/TSTORE retain their zero-only union rule.264        SetFault(Fault_TileLegality, ReadTPC());265        return FALSE;266    end;267    if _BundleDataAttributesPresent &&268       _BundleDataAttributes.pad_value != Zeros{2} &&269       TileOperationDATRPadUnion(operation) ==270           TileDATRPadUnion_MustZero then271        SetFault(Fault_TileLegality, ReadTPC());272        return FALSE;273    end;274    return TRUE;275end;276
277readonly func SelectedBundleTileMasksLegal() => boolean278begin279    var first_mask = Zeros{4};280    var first_mask_seen = FALSE;281    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do282        if _BundleTileBindings[[binding]].valid then283            let mask = _BundleTileBindings[[binding]].pe_mask;284            if first_mask_seen && mask != first_mask then return FALSE; end;285            first_mask = mask;286            first_mask_seen = TRUE;287        end;288    end;289    return TRUE;290end;291
292readonly func SelectedBundleTileMaskIsZero() => boolean293begin294    var seen = FALSE;295    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do296        if _BundleTileBindings[[binding]].valid then297            seen = TRUE;298            if _BundleTileBindings[[binding]].pe_mask != Zeros{4} then299                return FALSE;300            end;301        end;302    end;303    return seen || (_BundleZeroParticipationSeen &&304        BundleTileBindingCount() == 0 && BundleSharedBindingCount() == 0);305end;306
307readonly func BundleTileBindingCount() => integer {0..16}308begin309    var count: integer {0..16} = 0;310    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do311        if _BundleTileBindings[[binding]].valid then312            count = (count + 1) as integer {0..16};313        end;314    end;315    return count;316end;317
318pure func TileOperationUsesClosedBinarySchema(319    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean320begin321    let decoded = TileOperationOfIndex(operation);322    return decoded == TileOperation_TADD ||323           decoded == TileOperation_TSUB ||324           decoded == TileOperation_TMUL ||325           decoded == TileOperation_TDIV ||326           decoded == TileOperation_TREM ||327           decoded == TileOperation_TMAX ||328           decoded == TileOperation_TMIN;329end;330
331readonly func SelectedBundleClosedBinarySchemaLegal(332    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean333begin334    if !TileOperationUsesClosedBinarySchema(operation) then return TRUE; end;335    if BundleTileBindingCount() != 1 || BundleSharedBindingCount() != 0 then336        return FALSE;337    end;338    if !_BundleTileBindings[[0]].destination_valid ||339       _BundleTileBindings[[0]].destination_allocated_by_bundle ||340       !BundleTileDestinationSizeLegal(0) ||341       !_BundleTileBindings[[0]].source0_valid ||342       !_BundleTileBindings[[0]].source1_valid ||343       !_BundleTileBindings[[0]].last then return FALSE; end;344    if !_BundleDimensionPresent[[0]] ||345       UInt(_BundleDimensions[[0]]) < 1 ||346       UInt(_BundleDimensions[[0]]) > 65535 then return FALSE; end;347    for dimension = 1 to 2 looplimit 2 do348        if _BundleDimensionPresent[[dimension]] &&349           (UInt(_BundleDimensions[[dimension]]) < 1 ||350            UInt(_BundleDimensions[[dimension]]) > 65535) then351            return FALSE;352        end;353    end;354    let data_type = TileDataTypeFromEncoding(355        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);356    return TileVecArithmeticDataTypeSupported(data_type) &&357           TileElementwiseLayoutSupported(CurrentBundleTileLayout());358end;359
360pure func TileOperationUsesClosedUnarySchema(361    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean362begin363    let decoded = TileOperationOfIndex(operation);364    return decoded == TileOperation_TABS ||365           decoded == TileOperation_TNOT ||366           decoded == TileOperation_TNEG ||367           decoded == TileOperation_TRELU;368end;369
370readonly func SelectedBundleClosedUnarySchemaLegal(371    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean372begin373    if !TileOperationUsesClosedUnarySchema(operation) then return TRUE; end;374    if BundleTileBindingCount() != 1 || BundleSharedBindingCount() != 0 then375        return FALSE;376    end;377    let binding = _BundleTileBindings[[0]];378    if !binding.destination_valid || binding.destination_allocated_by_bundle ||379       !BundleTileDestinationSizeLegal(0) ||380       !binding.source0_valid || binding.source1_valid || !binding.last then381        return FALSE;382    end;383    if !_BundleDimensionPresent[[0]] ||384       UInt(_BundleDimensions[[0]]) < 1 ||385       UInt(_BundleDimensions[[0]]) > 65535 then386        return FALSE;387    end;388    for dimension = 1 to 2 looplimit 2 do389        if _BundleDimensionPresent[[dimension]] &&390           (UInt(_BundleDimensions[[dimension]]) < 1 ||391            UInt(_BundleDimensions[[dimension]]) > 65535) then392            return FALSE;393        end;394    end;395    let decoded = TileOperationOfIndex(operation);396    let unary = if decoded == TileOperation_TABS then TileUnary_ABS397                else if decoded == TileOperation_TNOT then TileUnary_NOT398                else if decoded == TileOperation_TNEG then TileUnary_NEG399                else TileUnary_RELU;400    let data_type = TileDataTypeFromEncoding(401        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);402    return TileUnaryDataTypeSupported(unary, data_type) &&403           TileElementwiseLayoutSupported(CurrentBundleTileLayout());404end;405
406pure func TileOperationUsesClosedTFMASchema(407    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean408begin409    return TileOperationOfIndex(operation) == TileOperation_TFMA;410end;411
412readonly func SelectedBundleClosedTFMASchemaLegal(413    operation: integer {0..PTO_TILE_OPERATION_COUNT-1}) => boolean414begin415    if !TileOperationUsesClosedTFMASchema(operation) then return TRUE; end;416    if BundleTileBindingCount() != 2 ||417       BundleSharedBindingCount() != 0 ||418       _BundleScalarBindings[[0]].valid then419        return FALSE;420    end;421
422    let multiplicands = _BundleTileBindings[[0]];423    let result = _BundleTileBindings[[1]];424    if multiplicands.destination_valid ||425       !multiplicands.source0_valid ||426       !multiplicands.source1_valid ||427       multiplicands.last then428        return FALSE;429    end;430    if !result.destination_valid ||431       result.destination_allocated_by_bundle ||432       !BundleTileDestinationSizeLegal(1) ||433       !result.source0_valid ||434       result.source1_valid ||435       !result.last then436        return FALSE;437    end;438    if !_BundleDimensionPresent[[0]] ||439       UInt(_BundleDimensions[[0]]) < 1 ||440       UInt(_BundleDimensions[[0]]) > 65535 then441        return FALSE;442    end;443    for dimension = 1 to 2 looplimit 2 do444        if _BundleDimensionPresent[[dimension]] &&445           (UInt(_BundleDimensions[[dimension]]) < 1 ||446            UInt(_BundleDimensions[[dimension]]) > 65535) then447            return FALSE;448        end;449    end;450
451    let data_type = TileDataTypeFromEncoding(452        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);453    return TileFusedMultiplyAddDataTypeSupported(data_type) &&454           TileElementwiseLayoutSupported(CurrentBundleTileLayout());455end;456
457
458readonly func BundleLocalTileSourceCount() => integer {0..32}459begin460    var count: integer {0..32} = 0;461    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do462        if _BundleTileBindings[[binding]].valid then463            if _BundleTileBindings[[binding]].source0_valid then464                count = (count + 1) as integer {0..32};465            end;466            if _BundleTileBindings[[binding]].source1_valid then467                count = (count + 1) as integer {0..32};468            end;469        end;470    end;471    return count;472end;473
474readonly func BundleLocalTileDestinationCount() => integer {0..16}475begin476    var count: integer {0..16} = 0;477    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do478        if _BundleTileBindings[[binding]].valid &&479           _BundleTileBindings[[binding]].destination_valid then480            count = (count + 1) as integer {0..16};481        end;482    end;483    return count;484end;485
486readonly func BundleTileBindingStreamTerminated() => boolean487begin488    var binding_count: integer {0..16} = 0;489    var seen_last = FALSE;490    for binding = 0 to PTO_BUNDLE_TILE_BINDING_COUNT - 1 do491        if _BundleTileBindings[[binding]].valid then492            if seen_last then return FALSE; end;493            binding_count = (binding_count + 1) as integer {0..16};494            if _BundleTileBindings[[binding]].last then495                seen_last = TRUE;496            end;497        end;498    end;499    return binding_count > 0 && seen_last;500end;501