PTO-ARCH-PROFILE-REFERENCE-QUANTIZATION

1// PTO-UNIT: {"id":"PTO-ARCH-PROFILE-REFERENCE-QUANTIZATION","surface":"arch","classification":["profile","reference-quantization"],"depends_on":["PTO-ARCH-PROFILE-REFERENCE-PROFILE","PTO-TILE-MODEL-NUMERIC-FORMATS"]}2pure func ReferencePowerOfTwo(exponent: integer {-149..127}) => real3begin4    var result: real = 1.0;5    if exponent > 0 then6        for step = 1 to exponent looplimit 127 do7            result = result * 2.0;8        end;9    elsif exponent < 0 then10        for step = 1 to -exponent looplimit 149 do11            result = result / 2.0;12        end;13    end;14    return result;15end;16
17pure func ReferenceFP32FiniteValue(value: bits(32)) => real18begin19    let exponent = UInt(value[30:23]);20    let fraction = UInt(value[22:0]);21    assert exponent != 255;22    var magnitude: real = 0.0;23    if exponent == 0 then24        magnitude = Real(fraction) * ReferencePowerOfTwo(-149);25    else26        let significand = Real(0x800000 + fraction) / Real(0x800000);27        magnitude = significand * ReferencePowerOfTwo(28            (exponent - 127) as integer {-126..127});29    end;30    if value[31] == '1' then return -magnitude; end;31    return magnitude;32end;33
34pure func ReferenceIntegerValue(value: Word,35                                data_type: TileDataType) => integer36begin37    let normalized = NormalizeTileInteger(value, data_type);38    if TileDataTypeIsSigned(data_type) then return SInt(normalized); end;39    return UInt(normalized);40end;41
42func ReferenceFP32FiniteEncoding(43    value: real,44    rounding_mode: NumericRoundingMode) => (Word, bits(5))45begin46    if value == 0.0 then return (Zeros{PTO_XLEN}, Zeros{5}); end;47    let negative = value < 0.0;48    var normalized = if negative then -value else value;49    var exponent: integer {-149..128} = 0;50    for step = 1 to 128 looplimit 128 do51        if normalized >= 2.0 && exponent < 128 then52            normalized = normalized / 2.0;53            exponent = (exponent + 1) as integer {-149..128};54        end;55    end;56    for step = 1 to 149 looplimit 149 do57        if normalized < 1.0 && exponent > -149 then58            normalized = normalized * 2.0;59            exponent = (exponent - 1) as integer {-149..128};60        end;61    end;62
63    let sign = if negative then 0x80000000 else 0;64    if exponent > 127 then65        return (66            Zeros{PTO_XLEN} + sign + 0x7f800000,67            Zeros{5} + 0x14);68    end;69
70    if exponent < -126 then71        let scaled = value / ReferencePowerOfTwo(-149);72        let rounded = FloatingToInteger(scaled, rounding_mode);73        let magnitude = if rounded < 0 then -rounded else rounded;74        if magnitude == 0 then75            return (Zeros{PTO_XLEN} + sign, Zeros{5} + 0x18);76        end;77        return (78            Zeros{PTO_XLEN} + sign + magnitude,79            if Real(rounded) == scaled then Zeros{5}80            else Zeros{5} + 0x18);81    end;82
83    let scaled = if negative then84        -(normalized * Real(0x800000))85        else normalized * Real(0x800000);86    let rounded = FloatingToInteger(scaled, rounding_mode);87    var magnitude = if rounded < 0 then -rounded else rounded;88    var encoded_exponent = exponent + 127;89    if magnitude == 0x1000000 then90        magnitude = 0x800000;91        encoded_exponent =92            (encoded_exponent + 1) as integer {-22..255};93    end;94    if encoded_exponent >= 255 then95        return (96            Zeros{PTO_XLEN} + sign + 0x7f800000,97            Zeros{5} + 0x14);98    end;99    let fraction = magnitude - 0x800000;100    return (101        Zeros{PTO_XLEN} + sign + encoded_exponent * 0x800000 + fraction,102        if Real(rounded) == scaled then Zeros{5} else Zeros{5} + 0x10);103end;104
105implementation func TileProfileQuantize(value: Word, scale: Word,106                                         zero_point: Word,107                                         source_type: TileDataType,108                                         destination_type: TileDataType,109                                         control: NumericExecutionControl)110                                         => (Word, bits(5))111begin112    assert source_type == TileDataType_FP32;113    assert destination_type == TileDataType_S8 ||114           destination_type == TileDataType_U8;115    let source_class = TileNumericValueClass(source_type, value);116    let scale_class = TileNumericValueClass(TileDataType_FP32, scale);117    assert !NumericValueClassIsNaN(scale_class);118    assert !NumericValueClassIsInfinity(scale_class);119    assert !NumericValueClassIsZero(scale_class);120    let minimum = ReferenceIntegerValue(121        TileIntegerMinimum(destination_type), destination_type);122    let maximum = ReferenceIntegerValue(123        TileIntegerMaximum(destination_type), destination_type);124    if NumericValueClassIsNaN(source_class) then125        return (Zeros{PTO_XLEN}, Zeros{5} + 1);126    elsif NumericValueClassIsInfinity(source_class) then127        let saturated = if value[31] == '1' then minimum else maximum;128        return (129            NormalizeTileInteger(130                Zeros{PTO_XLEN} + saturated,131                destination_type),132            Zeros{5} + 0x14);133    end;134    let affine = ReferenceFP32FiniteValue(value[31:0]) *135        ReferenceFP32FiniteValue(scale[31:0]) +136        Real(ReferenceIntegerValue(zero_point, destination_type));137    let rounded = FloatingToInteger(affine, control.rounding_mode);138    var selected = rounded;139    let flags = if Real(rounded) == affine then Zeros{5}140        else Zeros{5} + 0x10;141    if control.saturating then142        if selected < minimum then selected = minimum;143        elsif selected > maximum then selected = maximum;144        end;145    end;146    return (147        NormalizeTileInteger(Zeros{PTO_XLEN} + selected, destination_type),148        flags);149end;150
151implementation func TileProfileDequantize(value: Word, scale: Word,152                                           zero_point: Word,153                                           source_type: TileDataType,154                                           destination_type: TileDataType,155                                           control: NumericExecutionControl)156                                           => (Word, bits(5))157begin158    assert source_type == TileDataType_S8 ||159           source_type == TileDataType_U8;160    assert destination_type == TileDataType_FP32;161    let scale_class = TileNumericValueClass(TileDataType_FP32, scale);162    assert !NumericValueClassIsNaN(scale_class);163    assert !NumericValueClassIsInfinity(scale_class);164    assert !NumericValueClassIsZero(scale_class);165    let source_value = ReferenceIntegerValue(value, source_type);166    let zero_value = ReferenceIntegerValue(zero_point, source_type);167    let dequantized = Real(source_value - zero_value) *168        ReferenceFP32FiniteValue(scale[31:0]);169    return ReferenceFP32FiniteEncoding(170        dequantized,171        control.rounding_mode);172end;173