PTO-TILE-MODEL-DEFINEDNESS-PACKED-BOUNDARY

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-DEFINEDNESS-PACKED-BOUNDARY","surface":"tile","classification":["model","definedness","packed-boundary"],"depends_on":["PTO-TILE-MODEL-STATE-TYPES"]}2// Large logical Tiles use the existing 32768 Word payload slots as complete3// carriers. One carrier holds 16, 8, 4, 2, or 1 logical elements according to4// element width. The companion definedness map is total, so every accepted5// 256 KiB descriptor is representable without a 524288-Word TileInfo.6pure func PackedTileDataTypeIsFourBit(data_type: TileDataType) => boolean7begin8    return data_type == TileDataType_E2M1X2 ||9           data_type == TileDataType_E1M2X2 ||10           data_type == TileDataType_HiF4X2 ||11           data_type == TileDataType_S4X2 ||12           data_type == TileDataType_U4X2;13end;14
15pure func PackedTileElementBits(data_type: TileDataType) => integer {4,8,16,32,64}16begin17    return TileElementBits(data_type);18end;19
20pure func PackedTileElementsPerCarrier(21    data_type: TileDataType) => integer {1,2,4,8,16}22begin23    return (64 DIVRM PackedTileElementBits(data_type))24        as integer {1,2,4,8,16};25end;26
27readonly func PackedTileLogicalCapacity(capacity_bytes: integer {0..262144},28                                        data_type: TileDataType)29                                        => integer {1..524288}30begin31    assert capacity_bytes > 0;32    return ((capacity_bytes * 8) DIVRM PackedTileElementBits(data_type))33        as integer {1..524288};34end;35
36readonly func TilePackedCarrierIndex(data_type: TileDataType,37                                     element: PackedTileElementIndex)38    => PackedTileCarrierIndex39begin40    var carrier: integer = 0;41    carrier = element DIVRM PackedTileElementsPerCarrier(data_type);42    assert carrier < PTO_MODEL_TILE_ELEMENTS;43    return carrier as PackedTileCarrierIndex;44end;45
46readonly func TilePackedLaneIndex(data_type: TileDataType,47                                  element: PackedTileElementIndex)48    => PackedTileLaneIndex49begin50    var lane: integer = 0;51    lane = element MOD PackedTileElementsPerCarrier(data_type);52    assert lane <= 15;53    return lane as PackedTileLaneIndex;54end;55
56pure func PackedTileNibbleFromWord(word: Word,57                                  nibble: PackedTileLaneIndex) => bits(4)58begin59    case nibble of60        when 0 => return word[3:0];61        when 1 => return word[7:4];62        when 2 => return word[11:8];63        when 3 => return word[15:12];64        when 4 => return word[19:16];65        when 5 => return word[23:20];66        when 6 => return word[27:24];67        when 7 => return word[31:28];68        when 8 => return word[35:32];69        when 9 => return word[39:36];70        when 10 => return word[43:40];71        when 11 => return word[47:44];72        when 12 => return word[51:48];73        when 13 => return word[55:52];74        when 14 => return word[59:56];75        when 15 => return word[63:60];76    end;77end;78
79pure func PackedTileWordWithNibble(word: Word,80                                  nibble: PackedTileLaneIndex,81                                  value: Word) => Word82begin83    var result = word;84    case nibble of85        when 0 => result[3:0] = value[3:0];86        when 1 => result[7:4] = value[3:0];87        when 2 => result[11:8] = value[3:0];88        when 3 => result[15:12] = value[3:0];89        when 4 => result[19:16] = value[3:0];90        when 5 => result[23:20] = value[3:0];91        when 6 => result[27:24] = value[3:0];92        when 7 => result[31:28] = value[3:0];93        when 8 => result[35:32] = value[3:0];94        when 9 => result[39:36] = value[3:0];95        when 10 => result[43:40] = value[3:0];96        when 11 => result[47:44] = value[3:0];97        when 12 => result[51:48] = value[3:0];98        when 13 => result[55:52] = value[3:0];99        when 14 => result[59:56] = value[3:0];100        when 15 => result[63:60] = value[3:0];101    end;102    return result;103end;104
105pure func PackedTileElementFromWord(word: Word,106                                    lane: PackedTileLaneIndex,107                                    data_type: TileDataType) => Word108begin109    let element_bits = PackedTileElementBits(data_type);110    if element_bits == 4 then111        return ZeroExtend{PTO_XLEN}(PackedTileNibbleFromWord(word, lane));112    elsif element_bits == 8 then113        assert lane <= 7;114        if lane == 0 then return ZeroExtend{PTO_XLEN}(word[7:0]);115        elsif lane == 1 then return ZeroExtend{PTO_XLEN}(word[15:8]);116        elsif lane == 2 then return ZeroExtend{PTO_XLEN}(word[23:16]);117        elsif lane == 3 then return ZeroExtend{PTO_XLEN}(word[31:24]);118        elsif lane == 4 then return ZeroExtend{PTO_XLEN}(word[39:32]);119        elsif lane == 5 then return ZeroExtend{PTO_XLEN}(word[47:40]);120        elsif lane == 6 then return ZeroExtend{PTO_XLEN}(word[55:48]);121        else return ZeroExtend{PTO_XLEN}(word[63:56]);122        end;123    elsif element_bits == 16 then124        assert lane <= 3;125        if lane == 0 then return ZeroExtend{PTO_XLEN}(word[15:0]);126        elsif lane == 1 then return ZeroExtend{PTO_XLEN}(word[31:16]);127        elsif lane == 2 then return ZeroExtend{PTO_XLEN}(word[47:32]);128        else return ZeroExtend{PTO_XLEN}(word[63:48]);129        end;130    elsif element_bits == 32 then131        assert lane <= 1;132        if lane == 0 then return ZeroExtend{PTO_XLEN}(word[31:0]);133        else return ZeroExtend{PTO_XLEN}(word[63:32]);134        end;135    end;136    assert element_bits == 64 && lane == 0;137    return word;138end;139
140pure func PackedTileWordWithElement(word: Word,141                                    lane: PackedTileLaneIndex,142                                    data_type: TileDataType,143                                    value: Word) => Word144begin145    let element_bits = PackedTileElementBits(data_type);146    if element_bits == 4 then147        return PackedTileWordWithNibble(word, lane, value);148    end;149    var result = word;150    if element_bits == 8 then151        assert lane <= 7;152        if lane == 0 then result[7:0] = value[7:0];153        elsif lane == 1 then result[15:8] = value[7:0];154        elsif lane == 2 then result[23:16] = value[7:0];155        elsif lane == 3 then result[31:24] = value[7:0];156        elsif lane == 4 then result[39:32] = value[7:0];157        elsif lane == 5 then result[47:40] = value[7:0];158        elsif lane == 6 then result[55:48] = value[7:0];159        else result[63:56] = value[7:0];160        end;161    elsif element_bits == 16 then162        assert lane <= 3;163        if lane == 0 then result[15:0] = value[15:0];164        elsif lane == 1 then result[31:16] = value[15:0];165        elsif lane == 2 then result[47:32] = value[15:0];166        else result[63:48] = value[15:0];167        end;168    elsif element_bits == 32 then169        assert lane <= 1;170        if lane == 0 then result[31:0] = value[31:0];171        else result[63:32] = value[31:0];172        end;173    else174        assert element_bits == 64 && lane == 0;175        result = value;176    end;177    return result;178end;179
180readonly func ZeroPackedTileDefinedElements() => PackedTileDefinedElements181begin182    return Zeros{524288};183end;184
185readonly func TilePackedLinearIndex(tile: TileInfo,186                                    row: integer {0..65535},187                                    column: integer {0..65535})188                                    => PackedTileElementIndex189begin190    assert !TileLayoutIsCube(tile.layout);191    assert row < tile.rows && column < tile.columns;192    var index: integer = 0;193    if tile.layout == TileLayout_RowMajor then194        index = row * tile.columns + column;195    elsif tile.layout == TileLayout_ColumnMajor then196        index = column * tile.rows + row;197    else198        let inner_elements = (256 DIV PackedTileElementBits(tile.data_type))199            as integer {4,8,16,32,64};200        let block_rows: integer = tile.rows DIVRM 16;201        let block_columns: integer = tile.columns DIVRM inner_elements;202        let block_row: integer = row DIVRM 16;203        let block_column: integer = column DIVRM inner_elements;204        let inner_row: integer = row MOD 16;205        let inner_column: integer = column MOD inner_elements;206        let block_elements: integer = 16 * inner_elements;207        if tile.layout == TileLayout_ZN then208            index = (block_row * block_columns + block_column) *209                    block_elements + inner_column * 16 + inner_row;210        else211            assert tile.layout == TileLayout_NZ;212            index = (block_column * block_rows + block_row) *213                    block_elements + inner_row * inner_elements +214                    inner_column;215        end;216    end;217    assert index < PackedTileLogicalCapacity(tile.capacity_bytes,218                                              tile.data_type);219    return index as PackedTileElementIndex;220end;221
222readonly func TileUsesPackedCarrierRepresentation(tile: TileInfo) => boolean223begin224    return !TileLayoutIsCube(tile.layout) &&225           (PackedTileDataTypeIsFourBit(tile.data_type) ||226            tile.rows * tile.columns > PTO_MODEL_TILE_ELEMENTS);227end;228
229readonly func TileLogicalElementDefined(tile: TileInfo,230                                        element: PackedTileElementIndex)231                                        => boolean232begin233    if TileUsesPackedCarrierRepresentation(tile) then234        return tile.packed_defined_elements[element] == '1';235    end;236    return tile.defined_elements[element as ModelTileElementIndex] == '1';237end;238
239readonly func TileReadLogicalElement(tile: TileInfo,240                                     element: PackedTileElementIndex) => Word241begin242    if TileUsesPackedCarrierRepresentation(tile) then243        let carrier = TilePackedCarrierIndex(tile.data_type, element);244        let lane = TilePackedLaneIndex(tile.data_type, element);245        return PackedTileElementFromWord(246            tile.payload[[carrier]], lane, tile.data_type);247    end;248    return tile.payload[[element as ModelTileElementIndex]];249end;250
251// A newly allocated decoded TLOAD destination may have a complete physical252// packed shape while every selected GM byte is zero.  This helper preserves253// the ordinary TLOAD result (zero payload, full valid-region definedness) in254// one carrier-state update; it is used only by the executable model's255// zero-stride fast path, never as an architectural alternate representation.256func TileWithPackedZeroValidRegionDefined(tile: TileInfo) => TileInfo257begin258    assert PackedTileDataTypeIsFourBit(tile.data_type);259    assert tile.valid_rows == tile.rows && tile.valid_columns == tile.columns;260    assert tile.rows * tile.columns ==261        PackedTileLogicalCapacity(tile.capacity_bytes, tile.data_type);262    var result = tile;263    result.packed_defined_elements = Ones{524288};264    result.defined_valid_elements =265        (tile.valid_rows * tile.valid_columns) as integer {0..524288};266    result.contents_defined = TRUE;267    return result;268end;269
270func TileWithPackedZeroSelectedMaxRegionDefined(tile: TileInfo,271                                                pe_mask: bits(4)) => TileInfo272begin273    assert PackedTileDataTypeIsFourBit(tile.data_type);274    assert tile.capacity_bytes == 262144;275    assert tile.valid_rows == tile.rows && tile.valid_columns == tile.columns;276    assert tile.rows * tile.columns ==277        PackedTileLogicalCapacity(tile.capacity_bytes, tile.data_type);278    var result = tile;279    result.packed_defined_elements = Zeros{524288};280    if pe_mask[PTOPEMaskBitOfPEIdentity(0)] == '1' then281        result.packed_defined_elements[0 +: 131072] = Ones{131072};282    end;283    if pe_mask[PTOPEMaskBitOfPEIdentity(1)] == '1' then284        result.packed_defined_elements[131072 +: 131072] = Ones{131072};285    end;286    if pe_mask[PTOPEMaskBitOfPEIdentity(2)] == '1' then287        result.packed_defined_elements[262144 +: 131072] = Ones{131072};288    end;289    if pe_mask[PTOPEMaskBitOfPEIdentity(3)] == '1' then290        result.packed_defined_elements[393216 +: 131072] = Ones{131072};291    end;292    result.defined_valid_elements =293        (tile.valid_rows * tile.valid_columns) as integer {0..524288};294    result.contents_defined = pe_mask == '1111';295    return result;296end;297
298readonly func TileInfoWithLogicalElementAndDefined(tile: TileInfo,299                                                   element: PackedTileElementIndex,300                                                   value: Word,301                                                   defined: boolean) => TileInfo302begin303    var result = tile;304    if TileUsesPackedCarrierRepresentation(tile) then305        let carrier = TilePackedCarrierIndex(tile.data_type, element);306        let lane = TilePackedLaneIndex(tile.data_type, element);307        result.payload[[carrier]] = PackedTileWordWithElement(308            tile.payload[[carrier]], lane, tile.data_type, value);309        result.packed_defined_elements[element] =310            if defined then '1' else '0';311    else312        result.payload[[element as ModelTileElementIndex]] = value;313        result.defined_elements[element as ModelTileElementIndex] =314            if defined then '1' else '0';315    end;316    return result;317end;318
319readonly func TileInfoWithLogicalElement(tile: TileInfo,320                                         element: PackedTileElementIndex,321                                         value: Word) => TileInfo322begin323    return TileInfoWithLogicalElementAndDefined(tile, element, value, TRUE);324end;325
326func WriteTileLogicalElement(index: TileIndex,327                             element: PackedTileElementIndex,328                             value: Word)329begin330    _Tiles[[index]] = TileInfoWithLogicalElement(331        _Tiles[[index]], element, value);332end;333
334readonly func ReadTileLogicalElement(index: TileIndex,335                                     element: PackedTileElementIndex) => Word336begin337    let tile = _Tiles[[index]];338    assert TileLogicalElementDefined(tile, element);339    return TileReadLogicalElement(tile, element);340end;341