PTO-TILE-MODEL-EXECUTION-REARRANGEMENT

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-EXECUTION-REARRANGEMENT","surface":"tile","classification":["model","execution","rearrangement"],"depends_on":["PTO-TILE-MODEL-NUMERIC-EXCEPTIONS","PTO-TILE-MODEL-LEGALITY-LAYOUT-REARRANGEMENT"]}2// PTO-REQ-TEPL-REARRANGE-001: direct tile layout and indexing operations.3
4func TEXTRACT(destination: TileIndex, source: TileIndex,5              row_offset: integer {0..65535}, column_offset: integer {0..65535})6begin7    let destination_tile = _Tiles[[destination]];8    let source_tile = _Tiles[[source]];9    assert TileOperandsLegal_TEXTRACT(10        destination,11        source,12        row_offset,13        column_offset);14    var result = destination_tile;15    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do16        for column = 0 to destination_tile.valid_columns - 1 looplimit 65536 do17            let source_element = TileLogicalLinearIndex(source_tile,18                (row + row_offset) as integer {0..65535},19                (column + column_offset) as integer {0..65535});20            let destination_element = TileLogicalLinearIndex(21                result,22                row as integer {0..65535},23                column as integer {0..65535});24            result = TileInfoWithLogicalElement(result, destination_element,25                TileReadLogicalElement(source_tile, source_element));26        end;27    end;28    result = TileWithValidRegionDefined(result);29    result = TileWithPadding(result, CurrentBundlePadValue());30    _Tiles[[destination]] = result;31end;32
33func TINSERT(destination: TileIndex,34             old_destination: TileIndex,35             source: TileIndex,36             row_offset: integer {0..65535}, column_offset: integer {0..65535})37begin38    let destination_tile = _Tiles[[destination]];39    let old_tile = _Tiles[[old_destination]];40    let source_tile = _Tiles[[source]];41    assert TileOperandsLegal_TINSERT(42        destination,43        old_destination,44        source,45        row_offset,46        column_offset);47    let old_payload = old_tile.payload;48    var result = destination_tile;49    result.payload = old_payload;50    result.defined_elements = old_tile.defined_elements;51    result.packed_defined_elements = old_tile.packed_defined_elements;52    result.defined_valid_elements = old_tile.defined_valid_elements;53    result.contents_defined = old_tile.contents_defined;54    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do55        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do56            let source_element = TileLogicalLinearIndex(source_tile,57                row as integer {0..65535}, column as integer {0..65535});58            let destination_element = TileLogicalLinearIndex(59                result,60                (row + row_offset) as integer {0..65535},61                (column + column_offset) as integer {0..65535});62            result = TileInfoWithLogicalElement(result, destination_element,63                TileReadLogicalElement(source_tile, source_element));64        end;65    end;66    result = TileWithValidRegionDefined(result);67    _Tiles[[destination]] = result;68end;69
70func TCONCAT(destination: TileIndex, source_left: TileIndex,71             source_right: TileIndex)72begin73    let destination_tile = _Tiles[[destination]];74    let left_tile = _Tiles[[source_left]];75    let right_tile = _Tiles[[source_right]];76    assert TileOperandsLegal_TCONCAT(77        destination,78        source_left,79        source_right);80    var result = destination_tile;81    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do82        for column = 0 to destination_tile.valid_columns - 1 looplimit 65536 do83            let destination_element = TileLogicalLinearIndex(84                result,85                row as integer {0..65535},86                column as integer {0..65535});87            if column < left_tile.valid_columns then88                let element = TileLogicalLinearIndex(left_tile,89                    row as integer {0..65535}, column as integer {0..65535});90                result = TileInfoWithLogicalElement(result, destination_element,91                    TileReadLogicalElement(left_tile, element));92            else93                let element = TileLogicalLinearIndex(right_tile,94                    row as integer {0..65535},95                    (column - left_tile.valid_columns)96                        as integer {0..65535});97                result = TileInfoWithLogicalElement(result, destination_element,98                    TileReadLogicalElement(right_tile, element));99            end;100        end;101    end;102    result = TileWithValidRegionDefined(result);103    result = TileWithPadding(result, TilePad_Null);104    _Tiles[[destination]] = result;105end;106
107readonly func TileInfoWithCellByte(tile: TileInfo,108                                   row: integer {0..65535},109                                   byte_index: integer {0..262143},110                                   value: Byte) => TileInfo111begin112    let element_bits = TileElementBits(tile.data_type);113    if element_bits == 4 then114        assert byte_index <= 32767;115        let first_byte_index = byte_index as integer {0..32767};116        let first_nibble = (first_byte_index * 2) as integer {0..65535};117        let first_element = TileLogicalLinearIndex(tile, row,118            first_nibble as integer {0..65535});119        var first_word = TileReadLogicalElement(tile, first_element);120        first_word[3:0] = value[3:0];121        var result = TileInfoWithLogicalElement(tile, first_element,122            first_word);123        if first_nibble + 1 < tile.valid_columns then124            let second_element = TileLogicalLinearIndex(tile, row,125                (first_nibble + 1) as integer {0..65535});126            var second_word = TileReadLogicalElement(result, second_element);127            second_word[3:0] = value[7:4];128            result = TileInfoWithLogicalElement(result, second_element,129                second_word);130        end;131        return result;132    end;133    let element_bytes = TileElementBytes(tile.data_type);134    let element_column = (byte_index DIVRM element_bytes)135        as integer {0..65535};136    let byte_in_element = (byte_index MOD element_bytes) as integer {0..7};137    let element = TileLogicalLinearIndex(tile, row, element_column);138    var word = TileReadLogicalElement(tile, element);139    word[(byte_in_element * 8) +: 8] = value;140    return TileInfoWithLogicalElement(tile, element, word);141end;142
143readonly func TileReadCellWord(tile: TileInfo,144                               row: integer {0..65535},145                               word_index: integer {0..65535}) => Word146begin147    let valid_bytes = TileCellRearrangementValidBytes(tile);148    let byte_base = (word_index * 4) as integer {0..262143};149    var result = Zeros{PTO_XLEN};150    for byte_index = 0 to 3 looplimit 4 do151        if byte_base + byte_index < valid_bytes then152            result[(byte_index * 8) +: 8] = TileReadCellByte(tile, row,153                (byte_base + byte_index) as integer {0..262143});154        end;155    end;156    return result;157end;158
159readonly func TileInfoWithCellWord(tile: TileInfo,160                                   row: integer {0..65535},161                                   word_index: integer {0..65535},162                                   value: Word) => TileInfo163begin164    let valid_bytes = TileCellRearrangementValidBytes(tile);165    let byte_base = (word_index * 4) as integer {0..262143};166    var result = tile;167    for byte_index = 0 to 3 looplimit 4 do168        if byte_base + byte_index < valid_bytes then169            result = TileInfoWithCellByte(result, row,170                (byte_base + byte_index) as integer {0..262143},171                value[(byte_index * 8) +: 8]);172        end;173    end;174    return result;175end;176
177func TPERMUTE(destination: TileIndex, source0: TileIndex,178              source1: TileIndex, indices: TileIndex)179begin180    let destination_tile = _Tiles[[destination]];181    let source0_tile = _Tiles[[source0]];182    let source1_tile = _Tiles[[source1]];183    let index_tile = _Tiles[[indices]];184    assert TileOperandsLegal_TPERMUTE(185        destination, source0, source1, indices);186    let row_bytes = TileCellRearrangementRowBytes(destination_tile.layout);187    let valid_bytes = TileCellRearrangementValidBytes(destination_tile);188    var result = destination_tile;189    // Validate all indices before the first destination write.190    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do191        for byte_index = 0 to valid_bytes - 1 looplimit 65536 do192            let index_value = UInt(TileReadCellByte(193                index_tile, row as integer {0..65535}, byte_index));194            assert index_value < row_bytes * 2;195        end;196    end;197    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do198        for byte_index = 0 to valid_bytes - 1 looplimit 65536 do199            let index_value = UInt(TileReadCellByte(200                index_tile, row as integer {0..65535}, byte_index));201            let selected_source = if index_value < row_bytes then202                source0_tile else source1_tile;203            let cell_base = (byte_index DIVRM row_bytes) * row_bytes;204            let selected_byte = if index_value < row_bytes then205                index_value else index_value - row_bytes;206            result = TileInfoWithCellByte(207                result,208                row as integer {0..65535},209                byte_index,210                TileReadCellByte(211                    selected_source,212                    row as integer {0..65535},213                    (cell_base + selected_byte)214                        as integer {0..262143}));215        end;216    end;217    result = TileWithValidRegionDefined(result);218    result = TileWithPadding(result, TilePad_Null);219    _Tiles[[destination]] = result;220end;221
222func TSHUF(destination: TileIndex, source: TileIndex,223           controls: TileIndex, control: Word)224begin225    let destination_tile = _Tiles[[destination]];226    let source_tile = _Tiles[[source]];227    let controls_tile = _Tiles[[controls]];228    assert TileOperandsLegal_TSHUF(destination, source, controls, control);229    let mode = UInt(control[7:0]);230    let segment_code = UInt(control[15:8]);231    let boundary = UInt(control[23:16]);232    let segment_width = if segment_code == 0 then 2233        else if segment_code == 1 then 4234        else if segment_code == 2 then 8235        else if segment_code == 3 then 16236        else 32;237    let cell_rows = if destination_tile.layout == TileLayout_CUBE_M32 then 32238        else 16;239    var result = destination_tile;240    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do241        let lane = (row MOD cell_rows) as integer {0..31};242        let segment_base = ((lane DIVRM segment_width) * segment_width)243            as integer {0..31};244        let local_lane = (lane - segment_base) as integer {0..31};245        let word_count = TileCellRearrangementWordsPerRow(source_tile);246        for word_index = 0 to word_count - 1 looplimit 65536 do247            let source_word = TileReadCellWord(source_tile,248                row as integer {0..65535},249                word_index as integer {0..65535});250            let control_word = TileReadCellWord(controls_tile,251                row as integer {0..65535},252                word_index as integer {0..65535});253            let b = UInt(control_word[4:0]);254            var candidate_valid = TRUE;255            var candidate_lane: integer {0..31} = lane as integer {0..31};256            if mode == 0 then257                if b > lane - segment_base then candidate_valid = FALSE;258                else candidate_lane = (lane - b) as integer {0..31};259                end;260            elsif mode == 1 then261                if (lane - segment_base) + b >= segment_width then262                    candidate_valid = FALSE;263                else candidate_lane = (lane + b) as integer {0..31};264                end;265            elsif mode == 2 then266                candidate_lane = (segment_base +267                    UInt(((Zeros{5} + local_lane) as bits(5)) XOR268                         ((Zeros{5} + b) as bits(5))))269                    as integer {0..31};270                if candidate_lane >= segment_base + segment_width then271                    candidate_valid = FALSE;272                end;273            else274                candidate_lane = (segment_base +275                    (b MOD segment_width)) as integer {0..31};276            end;277            let candidate_row = (row - lane) + candidate_lane;278            var value = Zeros{PTO_XLEN};279            if candidate_valid && candidate_row < source_tile.valid_rows then280                value = TileReadCellWord(source_tile,281                    candidate_row as integer {0..65535},282                    word_index as integer {0..65535});283            elsif boundary == 0 then284                value = source_word;285            end;286            result = TileInfoWithCellWord(result,287                row as integer {0..65535},288                word_index as integer {0..65535}, value);289        end;290    end;291    result = TileWithValidRegionDefined(result);292    result = TileWithPadding(result, TilePad_Null);293    _Tiles[[destination]] = result;294end;295
296func TPACK(destination: TileIndex, source0: TileIndex,297           source1: TileIndex, control: Word)298begin299    let destination_tile = _Tiles[[destination]];300    let source0_tile = _Tiles[[source0]];301    let source1_tile = _Tiles[[source1]];302    assert TileOperandsLegal_TPACK(destination, source0, source1, control);303    let source0_bytes = UInt(control[7:0]);304    let source1_bytes = UInt(control[15:8]);305    var result = destination_tile;306    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do307        for word_index = 0 to destination_tile.valid_columns - 1 looplimit 65536 do308            let left_element = TileLogicalLinearIndex(source0_tile,309                row as integer {0..65535}, word_index as integer {0..65535});310            let right_element = TileLogicalLinearIndex(source1_tile,311                row as integer {0..65535}, word_index as integer {0..65535});312            let left_word = TileReadLogicalElement(source0_tile, left_element);313            let right_word = TileReadLogicalElement(source1_tile, right_element);314            var packed = Zeros{PTO_XLEN};315            for byte_index = 0 to source0_bytes - 1 looplimit 3 do316                packed[(byte_index * 8) +: 8] = left_word[(byte_index * 8) +: 8];317            end;318            for byte_index = 0 to source1_bytes - 1 looplimit 3 do319                packed[((source0_bytes + byte_index) * 8) +: 8] =320                    right_word[(byte_index * 8) +: 8];321            end;322            let destination_element = TileLogicalLinearIndex(result,323                row as integer {0..65535}, word_index as integer {0..65535});324            result = TileInfoWithLogicalElement(result, destination_element, packed);325        end;326    end;327    result = TileWithValidRegionDefined(result);328    result = TileWithPadding(result, TilePad_Null);329    _Tiles[[destination]] = result;330end;331
332func TUNPACK(destination: TileIndex, source: TileIndex, control: Word)333begin334    let destination_tile = _Tiles[[destination]];335    let source_tile = _Tiles[[source]];336    assert TileOperandsLegal_TUNPACK(destination, source, control);337    let byte_offset = UInt(control[7:0]);338    let byte_count = UInt(control[15:8]);339    var result = destination_tile;340    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do341        for word_index = 0 to destination_tile.valid_columns - 1 looplimit 65536 do342            let source_element = TileLogicalLinearIndex(source_tile,343                row as integer {0..65535}, word_index as integer {0..65535});344            let source_word = TileReadLogicalElement(source_tile, source_element);345            var unpacked = Zeros{PTO_XLEN};346            for byte_index = 0 to byte_count - 1 looplimit 4 do347                unpacked[(byte_index * 8) +: 8] =348                    source_word[((byte_offset + byte_index) * 8) +: 8];349            end;350            let destination_element = TileLogicalLinearIndex(result,351                row as integer {0..65535}, word_index as integer {0..65535});352            result = TileInfoWithLogicalElement(result, destination_element, unpacked);353        end;354    end;355    result = TileWithValidRegionDefined(result);356    result = TileWithPadding(result, TilePad_Null);357    _Tiles[[destination]] = result;358end;359