PTO-TILE-MODEL-EXECUTION-ELEMENTWISE

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-EXECUTION-ELEMENTWISE","surface":"tile","classification":["model","execution","elementwise"],"depends_on":["PTO-TILE-MODEL-DEFINEDNESS-ELEMENTS","PTO-TILE-MODEL-EXECUTION-MINMAX","PTO-SCALAR-MODEL-FSU-PROFILE"]}2// PTO-REQ-TEPL-001: direct, read-before-write TEPL semantics.3
4impdef func TileSquareRoot(value: Word) => Word5begin6    // A numeric profile replaces this stable raw-encoding default.7    return value;8end;9
10impdef func TileLogarithm(value: Word) => Word11begin12    return value;13end;14
15impdef func TileReciprocal(value: Word) => Word16begin17    // The typed SFU special-value path handles representable signed18    // infinities and status before this finite-profile hook is called.19    return DivideWordUnsigned(Ones{PTO_XLEN}, value);20end;21
22impdef func TileReciprocalSquareRoot(value: Word) => Word23begin24    // One profile operation; this is not two architecturally rounded steps.25    return value;26end;27
28impdef func TileExponential(value: Word) => Word29begin30    return value;31end;32
33pure func TileBinaryValue(op: TileBinaryOperation, left: Word, right: Word) => Word34begin35    case op of36        when TileBinary_ADD => return left + right;37        when TileBinary_SUB => return left - right;38        when TileBinary_MUL => return MultiplyWord(left, right);39        when TileBinary_MAX =>40            if SInt(left) > SInt(right) then return left; else return right; end;41        when TileBinary_MIN =>42            if SInt(left) < SInt(right) then return left; else return right; end;43        when TileBinary_AND => return left AND right;44        when TileBinary_OR  => return left OR right;45        when TileBinary_XOR => return left XOR right;46        when TileBinary_SHL => return LSL(left, UInt(right[5:0]));47        when TileBinary_SHR => return LSR(left, UInt(right[5:0]));48        when TileBinary_DIV => return DivideWordUnsigned(left, right);49        when TileBinary_REM => return left - MultiplyWord(DivideWordUnsigned(left, right), right);50    end;51end;52
53pure func TileIntegerOperandValue(value: Word,54                                  data_type: TileDataType) => Word55begin56    case data_type of57        when TileDataType_S8 => return SignExtend{PTO_XLEN}(value[7:0]);58        when TileDataType_S16 => return SignExtend{PTO_XLEN}(value[15:0]);59        when TileDataType_S32 => return SignExtend{PTO_XLEN}(value[31:0]);60        when TileDataType_S64 => return value;61        when TileDataType_U8 => return ZeroExtend{PTO_XLEN}(value[7:0]);62        when TileDataType_U16 => return ZeroExtend{PTO_XLEN}(value[15:0]);63        when TileDataType_U32 => return ZeroExtend{PTO_XLEN}(value[31:0]);64        when TileDataType_U64 => return value;65        otherwise => unreachable;66    end;67end;68
69// A scalar bound through B.IOR is one raw Tile element carried in an XLEN70// GPR.  Bits above the architectural element width never participate in the71// Tile operation.  Keep this normalization separate from signed integer72// interpretation: a later operation decides whether the retained bits are a73// floating encoding, a signed integer, or an unsigned integer.74pure func TileRawElementValue(75    value: Word,76    data_type: TileDataType) => Word77begin78    case TileElementBits(data_type) of79        when 8 =>80            return ZeroExtend{PTO_XLEN}(value[7:0]);81        when 16 =>82            return ZeroExtend{PTO_XLEN}(value[15:0]);83        when 32 =>84            return ZeroExtend{PTO_XLEN}(value[31:0]);85        when 64 =>86            return value;87        otherwise =>88            // Packed four-bit types do not belong to the closed scalar-VEC89            // type sets.  Retaining the low nibble makes this helper total90            // without granting those types operation legality.91            return ZeroExtend{PTO_XLEN}(value[3:0]);92    end;93end;94
95pure func TileUnsignedElementValue(96    value: Word,97    data_type: TileDataType) => Word98begin99    case data_type of100        when TileDataType_S8, TileDataType_U8 =>101            return ZeroExtend{PTO_XLEN}(value[7:0]);102        when TileDataType_S16, TileDataType_U16 =>103            return ZeroExtend{PTO_XLEN}(value[15:0]);104        when TileDataType_S32, TileDataType_U32 =>105            return ZeroExtend{PTO_XLEN}(value[31:0]);106        when TileDataType_S64, TileDataType_U64 =>107            return value;108        otherwise =>109            unreachable;110    end;111end;112
113pure func TileIntegerShiftAmount(114    value: Word,115    data_type: TileDataType) => integer {0..63}116begin117    case data_type of118        when TileDataType_S8, TileDataType_U8 =>119            return UInt(value[2:0]);120        when TileDataType_S16, TileDataType_U16 =>121            return UInt(value[3:0]);122        when TileDataType_S32, TileDataType_U32 =>123            return UInt(value[4:0]);124        when TileDataType_S64, TileDataType_U64 =>125            return UInt(value[5:0]);126        otherwise =>127            unreachable;128    end;129end;130
131pure func TileIntegerMinMaxValue(132    operation: TileBinaryOperation,133    data_type: TileDataType,134    left: Word,135    right: Word) => Word136begin137    assert operation == TileBinary_MIN || operation == TileBinary_MAX;138    let left_value = TileIntegerOperandValue(left, data_type);139    let right_value = TileIntegerOperandValue(right, data_type);140    if TileDataTypeIsSigned(data_type) then141        if operation == TileBinary_MIN then142            if SInt(left_value) <= SInt(right_value) then143                return left_value;144            else145                return right_value;146            end;147        else148            if SInt(left_value) >= SInt(right_value) then149                return left_value;150            else151                return right_value;152            end;153        end;154    end;155    if operation == TileBinary_MIN then156        if UInt(left_value) <= UInt(right_value) then157            return left_value;158        else159            return right_value;160        end;161    else162        if UInt(left_value) >= UInt(right_value) then163            return left_value;164        else165            return right_value;166        end;167    end;168end;169
170pure func TileIntegerBinaryValue(171    operation: TileBinaryOperation,172    data_type: TileDataType,173    left: Word,174    right: Word) => Word175begin176    let left_value = TileIntegerOperandValue(left, data_type);177    let right_value = TileIntegerOperandValue(right, data_type);178    case operation of179        when TileBinary_ADD =>180            return NormalizeTileInteger(left_value + right_value, data_type);181        when TileBinary_SUB =>182            return NormalizeTileInteger(left_value - right_value, data_type);183        when TileBinary_MUL =>184            return NormalizeTileInteger(185                MultiplyWord(left_value, right_value),186                data_type);187        when TileBinary_MAX, TileBinary_MIN =>188            return TileIntegerMinMaxValue(189                operation,190                data_type,191                left_value,192                right_value);193        when TileBinary_AND =>194            return TileUnsignedElementValue(left_value AND right_value, data_type);195        when TileBinary_OR =>196            return TileUnsignedElementValue(left_value OR right_value, data_type);197        when TileBinary_XOR =>198            return TileUnsignedElementValue(left_value XOR right_value, data_type);199        when TileBinary_SHL =>200            return TileUnsignedElementValue(201                LSL(left_value, TileIntegerShiftAmount(right_value, data_type)),202                data_type);203        when TileBinary_SHR =>204            let shifted =205                if TileDataTypeIsSigned(data_type) then206                    ASR(left_value,207                        TileIntegerShiftAmount(right_value, data_type))208                else209                    LSR(left_value,210                        TileIntegerShiftAmount(right_value, data_type));211            return TileUnsignedElementValue(shifted, data_type);212        otherwise =>213            unreachable;214    end;215end;216
217pure func TileCarrierBinaryValue(218    operation: TileBinaryOperation,219    data_type: TileDataType,220    left: Word,221    right: Word) => Word222begin223    assert operation == TileBinary_AND ||224           operation == TileBinary_OR ||225           operation == TileBinary_XOR;226    var result = Zeros{PTO_XLEN};227    case operation of228        when TileBinary_AND => result = left AND right;229        when TileBinary_OR => result = left OR right;230        when TileBinary_XOR => result = left XOR right;231        otherwise => unreachable;232    end;233    return TileRawElementValue(result, data_type);234end;235
236pure func TileSignedModulo(dividend: Word, divisor: Word) => Word237begin238    let quotient = ScalarDivideSigned(dividend, divisor);239    let remainder = dividend - MultiplyWord(quotient, divisor);240    if IsZero(remainder) ||241       remainder[PTO_XLEN - 1] == divisor[PTO_XLEN - 1] then242        return remainder;243    end;244    return remainder + divisor;245end;246
247pure func TileIntegerDivRemValue(op: TileBinaryOperation,248                                 data_type: TileDataType,249                                 left: Word, right: Word) => Word250begin251    assert op == TileBinary_DIV || op == TileBinary_REM;252    let dividend = TileIntegerOperandValue(left, data_type);253    let divisor = TileIntegerOperandValue(right, data_type);254    assert !IsZero(divisor);255    if op == TileBinary_DIV then256        if TileDataTypeIsSigned(data_type) then257            return ScalarDivideSigned(dividend, divisor);258        else259            return DivideWordUnsigned(dividend, divisor);260        end;261    elsif TileDataTypeIsSigned(data_type) then262        return TileSignedModulo(dividend, divisor);263    else264        let quotient = DivideWordUnsigned(dividend, divisor);265        return dividend - MultiplyWord(quotient, divisor);266    end;267end;268
269impdef func TileProfileFloatingModulo(data_type: TileDataType,270                                      left: Word, right: Word) => Word271begin272    return left;273end;274
275impdef func TileProfileFloatingModuloFlags(276    data_type: TileDataType,277    left: Word,278    right: Word) => bits(5)279begin280    return Zeros{5};281end;282
283func TileProfileBinaryWithFlags(284    op: TileBinaryOperation,285    data_type: TileDataType,286    left: Word,287    right: Word) => (Word, bits(5))288begin289    if (op == TileBinary_AND || op == TileBinary_OR ||290       op == TileBinary_XOR) &&291       TileCarrierOnlyDataTypeSupported(data_type) then292        return (293            TileCarrierBinaryValue(op, data_type, left, right),294            Zeros{5});295    elsif (op == TileBinary_DIV || op == TileBinary_REM) &&296       TileDataTypeIsInteger(data_type) then297        return (298            TileIntegerDivRemValue(op, data_type, left, right),299            Zeros{5});300    elsif TileDataTypeIsInteger(data_type) then301        return (302            TileIntegerBinaryValue(op, data_type, left, right),303            Zeros{5});304    elsif op == TileBinary_MIN || op == TileBinary_MAX then305        let (result, invalid) =306            TileFloatingMinMaxValue(op, data_type, left, right);307        return (308            result,309            if invalid then Zeros{5} + 1 else Zeros{5});310    elsif op == TileBinary_REM then311        return (312            TileProfileFloatingModulo(data_type, left, right),313            TileProfileFloatingModuloFlags(data_type, left, right));314    else315        let control = DefaultNumericExecutionControl();316        var operation: FloatingBinaryOperation;317        case op of318            when TileBinary_ADD => operation = FloatingBinary_ADD;319            when TileBinary_SUB => operation = FloatingBinary_SUB;320            when TileBinary_MUL => operation = FloatingBinary_MUL;321            when TileBinary_DIV => operation = FloatingBinary_DIV;322            otherwise => unreachable;323        end;324        return ScalarFPBinaryProfile(325            operation,326            control.rounding_mode,327            TileDataTypeToEncoding(data_type),328            left,329            right);330    end;331end;332
333func TileProfileBinary(op: TileBinaryOperation, data_type: TileDataType,334                       left: Word, right: Word) => Word335begin336    let (result, -) = TileProfileBinaryWithFlags(337        op,338        data_type,339        left,340        right);341    return result;342end;343
344func ExecuteTileBinary(op: TileBinaryOperation, destination: TileIndex,345                       source_left: TileIndex, source_right: TileIndex)346begin347    let left_tile = _Tiles[[source_left]];348    let right_tile = _Tiles[[source_right]];349    assert left_tile.allocated && right_tile.allocated;350    assert TileShapesMatch(left_tile, right_tile);351    assert TileShapesMatch(_Tiles[[destination]], left_tile);352    assert left_tile.data_type == right_tile.data_type;353    assert _Tiles[[destination]].data_type == left_tile.data_type;354
355    // Snapshot both sources before the first destination write. This defines356    // source/destination aliasing as read-before-write.357    for row = 0 to left_tile.valid_rows - 1 looplimit 65536 do358        for column = 0 to left_tile.valid_columns - 1 looplimit 65536 do359            let element = TileLogicalLinearIndex(left_tile,360                row as integer {0..65535}, column as integer {0..65535});361            _Tiles[[destination]] = TileInfoWithLogicalElement(362                _Tiles[[destination]], element,363                TileProfileBinary(op, left_tile.data_type,364                    TileReadLogicalElement(left_tile, element),365                    TileReadLogicalElement(right_tile, element)));366        end;367    end;368    MarkTileValidRegionDefined(destination);369    if TileBinaryUsesClosedElementwiseContract(op) then370        ApplyTilePadding(destination, CurrentBundlePadValue());371    end;372end;373
374func ExecuteTileFillScalar(destination: TileIndex, scalar: Word)375begin376    assert TileOperandsLegal_ExecuteTileFillScalar(destination, scalar);377    var result = _Tiles[[destination]];378    let normalized_scalar = TileRawElementValue(379        scalar,380        result.data_type);381    for row = 0 to result.valid_rows - 1 looplimit 65536 do382        for column = 0 to result.valid_columns - 1 looplimit 65536 do383            let element = TileLogicalLinearIndex(384                result,385                row as integer {0..65535},386                column as integer {0..65535});387            result = TileInfoWithLogicalElement(result, element,388                normalized_scalar);389        end;390    end;391    result = TileWithValidRegionDefined(result);392    result = TileWithPadding(result, CurrentBundlePadValue());393    _Tiles[[destination]] = result;394end;395
396func ExecuteTileScalar(op: TileBinaryOperation, destination: TileIndex,397                       source: TileIndex, scalar: Word)398begin399    assert TileOperandsLegal_ExecuteTileScalar(400        op,401        destination,402        source,403        scalar);404    let source_tile = _Tiles[[source]];405    var result = _Tiles[[destination]];406    let normalized_scalar = TileRawElementValue(407        scalar,408        source_tile.data_type);409    var flags = Zeros{5};410    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do411        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do412            let element = TileLogicalLinearIndex(source_tile,413                row as integer {0..65535}, column as integer {0..65535});414            let (value, element_flags) = TileProfileBinaryWithFlags(415                op,416                source_tile.data_type,417                TileReadLogicalElement(source_tile, element),418                normalized_scalar);419            result = TileInfoWithLogicalElement(result, element, value);420            flags = flags OR element_flags;421        end;422    end;423    result = TileWithValidRegionDefined(result);424    result = TileWithPadding(result, CurrentBundlePadValue());425    RecordNumericStatusFlags(flags);426    _Tiles[[destination]] = result;427end;428