PTO-TILE-MODEL-NUMERIC-FORMATS

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-NUMERIC-FORMATS","surface":"tile","classification":["model","numeric","formats"],"depends_on":["PTO-TILE-MODEL-EXECUTION-GENERATION","PTO-ARCH-DATA-TYPES-NUMERIC-CLASSIFICATION","PTO-ARCH-FEATURES-MX-FORMATS","PTO-ARCH-STATE-NUMERIC-STATUS"]}2// PTO-REQ-TEPL-CONVERT-001: conversion, quantization, and dequantization.3
4pure func NormalizeTileInteger(value: Word, data_type: TileDataType) => Word5begin6    case data_type of7        when TileDataType_S4X2 => return SignExtend{PTO_XLEN}(value[3:0]);8        when TileDataType_U4X2 => return ZeroExtend{PTO_XLEN}(value[3:0]);9        when TileDataType_S8 => return SignExtend{PTO_XLEN}(value[7:0]);10        when TileDataType_U8 => return ZeroExtend{PTO_XLEN}(value[7:0]);11        when TileDataType_S16 => return SignExtend{PTO_XLEN}(value[15:0]);12        when TileDataType_U16 => return ZeroExtend{PTO_XLEN}(value[15:0]);13        when TileDataType_S32 => return SignExtend{PTO_XLEN}(value[31:0]);14        when TileDataType_U32 => return ZeroExtend{PTO_XLEN}(value[31:0]);15        when TileDataType_S64, TileDataType_U64 => return value;16        otherwise => return value;17    end;18end;19
20pure func TileIntegerMinimum(data_type: TileDataType) => Word21begin22    assert TileDataTypeIsInteger(data_type);23    case data_type of24        when TileDataType_S4X2 =>25            return SignExtend{PTO_XLEN}('1000');26        when TileDataType_S8 =>27            return SignExtend{PTO_XLEN}('10000000');28        when TileDataType_S16 =>29            return SignExtend{PTO_XLEN}('1000000000000000');30        when TileDataType_S32 =>31            return Zeros{PTO_XLEN} + 0xffffffff80000000;32        when TileDataType_S64 =>33            return Zeros{PTO_XLEN} + 0x8000000000000000;34        otherwise => return Zeros{PTO_XLEN};35    end;36end;37
38pure func TileIntegerMaximum(data_type: TileDataType) => Word39begin40    assert TileDataTypeIsInteger(data_type);41    case data_type of42        when TileDataType_S4X2 => return Zeros{PTO_XLEN} + 0x7;43        when TileDataType_U4X2 => return Zeros{PTO_XLEN} + 0xf;44        when TileDataType_S8 => return Zeros{PTO_XLEN} + 0x7f;45        when TileDataType_U8 => return Zeros{PTO_XLEN} + 0xff;46        when TileDataType_S16 => return Zeros{PTO_XLEN} + 0x7fff;47        when TileDataType_U16 => return Zeros{PTO_XLEN} + 0xffff;48        when TileDataType_S32 => return Zeros{PTO_XLEN} + 0x7fffffff;49        when TileDataType_U32 => return Zeros{PTO_XLEN} + 0xffffffff;50        when TileDataType_S64 =>51            return Zeros{PTO_XLEN} + 0x7fffffffffffffff;52        when TileDataType_U64 => return Ones{PTO_XLEN};53        otherwise => unreachable;54    end;55end;56
57pure func TileQuantizationScaleLegal(scale: Word) => boolean58begin59    if !TileNumericEncodingValid(TileDataType_FP32, scale) ||60       scale[31] == '1' then61        return FALSE;62    end;63    let value_class = TileNumericValueClass(TileDataType_FP32, scale);64    return !NumericValueClassIsNaN(value_class) &&65           !NumericValueClassIsInfinity(value_class) &&66           !NumericValueClassIsZero(value_class);67end;68
69pure func TileQuantizationZeroPointLegal(70    zero_point: Word,71    data_type: TileDataType) => boolean72begin73    if data_type != TileDataType_S8 && data_type != TileDataType_U8 then74        return FALSE;75    end;76    return NormalizeTileInteger(zero_point, data_type) == zero_point;77end;78
79pure func TileConvertIntegerSaturating(80    value: Word,81    source_type: TileDataType,82    destination_type: TileDataType) => Word83begin84    assert TileDataTypeIsInteger(source_type);85    assert TileDataTypeIsInteger(destination_type);86    let source = NormalizeTileInteger(value, source_type);87    let minimum = TileIntegerMinimum(destination_type);88    let maximum = TileIntegerMaximum(destination_type);89    if TileDataTypeIsSigned(source_type) then90        if !TileDataTypeIsSigned(destination_type) && SInt(source) < 0 then91            return minimum;92        end;93        if TileDataTypeIsSigned(destination_type) then94            if SInt(source) < SInt(minimum) then return minimum; end;95            if SInt(source) > SInt(maximum) then return maximum; end;96        elsif UInt(source) > UInt(maximum) then97            return maximum;98        end;99    elsif UInt(source) > UInt(maximum) then100        return maximum;101    end;102    return NormalizeTileInteger(source, destination_type);103end;104
105pure func TileConvertIntegerValue(106    value: Word,107    source_type: TileDataType,108    destination_type: TileDataType,109    saturating: boolean) => Word110begin111    if saturating then112        return TileConvertIntegerSaturating(113            value, source_type, destination_type);114    end;115    return NormalizeTileInteger(116        NormalizeTileInteger(value, source_type), destination_type);117end;118
119impdef func TileProfileConvert(value: Word, source_type: TileDataType,120                               destination_type: TileDataType,121                               control: NumericExecutionControl)122                               => (Word, bits(5))123begin124    // Profiles replace this raw-encoding rule for floating conversions.125    return (value, Zeros{5});126end;127
128func TileConvertValue(value: Word, source_type: TileDataType,129                      destination_type: TileDataType,130                      control: NumericExecutionControl)131                      => (Word, bits(5))132begin133    if TileDataTypeIsFloating(source_type) || TileDataTypeIsFloating(destination_type) then134        return TileProfileConvert(value, source_type, destination_type, control);135    else136        // Integer conversion first interprets the source width/signedness,137        // then truncates or extends into the destination representation.138        return (TileConvertIntegerValue(139            value, source_type, destination_type, control.saturating),140            Zeros{5});141    end;142end;143
144func TileCommitConversionResult(destination: TileIndex,145                                result: TileInfo,146                                flags: bits(5))147begin148    // All conversion and padding work is complete before this non-faulting149    // architectural publish boundary is entered.150    RecordNumericStatusFlags(flags);151    _Tiles[[destination]] = result;152end;153
154func TCVT(destination: TileIndex, source: TileIndex,155          control: NumericExecutionControl)156begin157    var result = _Tiles[[destination]];158    let source_tile = _Tiles[[source]];159    assert result.rows == source_tile.rows;160    assert result.columns == source_tile.columns;161    assert result.valid_rows == source_tile.valid_rows;162    assert result.valid_columns == source_tile.valid_columns;163    var conversion_flags = Zeros{5};164    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};165    result.defined_valid_elements = 0;166    result.packed_defined_elements = ZeroPackedTileDefinedElements();167    result.contents_defined = FALSE;168    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do169        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do170            let source_element = TileLogicalLinearIndex(source_tile,171                row as integer {0..65535}, column as integer {0..65535});172            let destination_element = TileLogicalLinearIndex(result,173                row as integer {0..65535}, column as integer {0..65535});174            let (converted, flags) = TileConvertValue(175                TileReadLogicalElement(source_tile, source_element),176                source_tile.data_type,177                result.data_type, control);178            result = TileInfoWithLogicalElement(result, destination_element,179                converted);180            conversion_flags = conversion_flags OR flags;181        end;182    end;183    result = TileWithValidRegionDefined(result);184    result = TileWithPadding(result, CurrentBundlePadValue());185    result.location = TileLocation_Any;186    TileCommitConversionResult(destination, result, conversion_flags);187end;188
189impdef func TileProfileQuantize(value: Word, scale: Word, zero_point: Word,190                                source_type: TileDataType,191                                destination_type: TileDataType,192                                control: NumericExecutionControl)193                                => (Word, bits(5))194begin195    assert !IsZero(scale);196    return (197        NormalizeTileInteger(value + zero_point, destination_type),198        Zeros{5});199end;200
201impdef func TileProfileDequantize(value: Word, scale: Word, zero_point: Word,202                                  source_type: TileDataType,203                                  destination_type: TileDataType,204                                  control: NumericExecutionControl)205                                  => (Word, bits(5))206begin207    return (value - zero_point, Zeros{5});208end;209
210func TQUANT(destination: TileIndex, source: TileIndex, scale: Word,211            zero_point: Word, control: NumericExecutionControl)212begin213    var result = _Tiles[[destination]];214    let source_tile = _Tiles[[source]];215    assert result.valid_rows == source_tile.valid_rows;216    assert result.valid_columns == source_tile.valid_columns;217    var conversion_flags = Zeros{5};218    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};219    result.defined_valid_elements = 0;220    result.packed_defined_elements = ZeroPackedTileDefinedElements();221    result.contents_defined = FALSE;222    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do223        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do224            let source_element = TileLogicalLinearIndex(source_tile,225                row as integer {0..65535}, column as integer {0..65535});226            let destination_element = TileLogicalLinearIndex(result,227                row as integer {0..65535}, column as integer {0..65535});228            let (converted, flags) = TileProfileQuantize(229                TileReadLogicalElement(source_tile, source_element),230                scale,231                zero_point,232                source_tile.data_type,233                result.data_type,234                control);235            result = TileInfoWithLogicalElement(result, destination_element,236                converted);237            conversion_flags = conversion_flags OR flags;238        end;239    end;240    result = TileWithValidRegionDefined(result);241    result = TileWithPadding(result, TilePad_Null);242    result.location = TileLocation_Any;243    TileCommitConversionResult(destination, result, conversion_flags);244end;245
246func TDEQUANT(destination: TileIndex, source: TileIndex, scale: Word,247              zero_point: Word, control: NumericExecutionControl)248begin249    var result = _Tiles[[destination]];250    let source_tile = _Tiles[[source]];251    assert result.valid_rows == source_tile.valid_rows;252    assert result.valid_columns == source_tile.valid_columns;253    var conversion_flags = Zeros{5};254    result.defined_elements = Zeros{PTO_MODEL_TILE_ELEMENTS};255    result.defined_valid_elements = 0;256    result.packed_defined_elements = ZeroPackedTileDefinedElements();257    result.contents_defined = FALSE;258    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do259        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do260            let source_element = TileLogicalLinearIndex(source_tile,261                row as integer {0..65535}, column as integer {0..65535});262            let destination_element = TileLogicalLinearIndex(result,263                row as integer {0..65535}, column as integer {0..65535});264            let (converted, flags) = TileProfileDequantize(265                TileReadLogicalElement(source_tile, source_element),266                scale,267                zero_point,268                source_tile.data_type,269                result.data_type,270                control);271            result = TileInfoWithLogicalElement(result, destination_element,272                converted);273            conversion_flags = conversion_flags OR flags;274        end;275    end;276    result = TileWithValidRegionDefined(result);277    result = TileWithPadding(result, TilePad_Null);278    result.location = TileLocation_Any;279    TileCommitConversionResult(destination, result, conversion_flags);280end;281