PTO-TILE-MODEL-EXECUTION-COMPARISON

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-EXECUTION-COMPARISON","surface":"tile","classification":["model","execution","comparison"],"depends_on":["PTO-TILE-MODEL-EXECUTION-ELEMENTWISE"]}2// PTO-REQ-TEPL-COMPARISON-001: packed predicate compare and select semantics.3
4pure func TileCompareDataTypeSupported(data_type: TileDataType) => boolean5begin6    return TileVecArithmeticDataTypeSupported(data_type);7end;8
9pure func TileSelectDataTypeSupported(data_type: TileDataType) => boolean10begin11    return TileVecArithmeticDataTypeSupported(data_type);12end;13
14pure func TileCompareBoolean(15    comparison: TileComparison,16    left_less: boolean,17    equal: boolean) => boolean18begin19    case comparison of20        when TileComparison_EQ => return equal;21        when TileComparison_NE => return !equal;22        when TileComparison_LT => return left_less;23        when TileComparison_LE => return left_less || equal;24        when TileComparison_GT => return !left_less && !equal;25        when TileComparison_GE => return !left_less || equal;26    end;27end;28
29pure func TileFloatingOrderKey(30    data_type: TileDataType,31    value: Word) => Word32begin33    var carrier = value;34    var sign_mask = Zeros{PTO_XLEN};35    var width_mask = Ones{PTO_XLEN};36    if data_type == TileDataType_FP64 then37        sign_mask = Zeros{PTO_XLEN} + 0x8000000000000000;38    elsif data_type == TileDataType_FP32 ||39          data_type == TileDataType_TF32 ||40          data_type == TileDataType_HF32 then41        carrier = ZeroExtend{PTO_XLEN}(value[31:0]);42        sign_mask = Zeros{PTO_XLEN} + 0x80000000;43        width_mask = Zeros{PTO_XLEN} + 0xffffffff;44    elsif data_type == TileDataType_FP16 ||45          data_type == TileDataType_BF16 then46        carrier = ZeroExtend{PTO_XLEN}(value[15:0]);47        sign_mask = Zeros{PTO_XLEN} + 0x8000;48        width_mask = Zeros{PTO_XLEN} + 0xffff;49    elsif data_type == TileDataType_E4M3 ||50          data_type == TileDataType_E5M2 then51        carrier = ZeroExtend{PTO_XLEN}(value[7:0]);52        sign_mask = Zeros{PTO_XLEN} + 0x80;53        width_mask = Zeros{PTO_XLEN} + 0xff;54    else55        unreachable;56    end;57    if (carrier AND sign_mask) != Zeros{PTO_XLEN} then58        return (NOT carrier) AND width_mask;59    end;60    return carrier OR sign_mask;61end;62
63impdef func TileProfileFloatingCompare(64    comparison: TileComparison,65    data_type: TileDataType,66    left: Word,67    right: Word) => (boolean, bits(5))68begin69    let left_class = TileNumericValueClass(data_type, left);70    let right_class = TileNumericValueClass(data_type, right);71    let signaling_nan =72        left_class == NumericValue_SignalingNaN ||73        right_class == NumericValue_SignalingNaN;74    if NumericValueClassIsNaN(left_class) ||75       NumericValueClassIsNaN(right_class) then76        return (77            comparison == TileComparison_NE,78            if signaling_nan then Zeros{5} + 1 else Zeros{5});79    end;80    let both_zero = NumericValueClassIsZero(left_class) &&81        NumericValueClassIsZero(right_class);82    let equal = both_zero || left == right;83    let left_less = if both_zero then FALSE else84        UInt(TileFloatingOrderKey(data_type, left)) <85        UInt(TileFloatingOrderKey(data_type, right));86    return (TileCompareBoolean(comparison, left_less, equal), Zeros{5});87end;88
89func TileCompareElement(90    comparison: TileComparison,91    data_type: TileDataType,92    left: Word,93    right: Word) => (boolean, bits(5))94begin95    assert TileCompareDataTypeSupported(data_type);96    if TileDataTypeIsFloating(data_type) then97        return TileProfileFloatingCompare(98            comparison,99            data_type,100            left,101            right);102    end;103    let left_value = TileIntegerOperandValue(left, data_type);104    let right_value = TileIntegerOperandValue(right, data_type);105    let equal = left_value == right_value;106    let left_less = if TileDataTypeIsSigned(data_type) then107        SInt(left_value) < SInt(right_value) else108        UInt(left_value) < UInt(right_value);109    return (TileCompareBoolean(comparison, left_less, equal), Zeros{5});110end;111
112func ExecuteTileCompare(destination: TileIndex, source_left: TileIndex,113                        source_right: TileIndex, comparison: TileComparison)114begin115    assert TileOperandsLegal_ExecuteTileCompare(116        destination,117        source_left,118        source_right,119        comparison);120    let left_tile = _Tiles[[source_left]];121    let right_tile = _Tiles[[source_right]];122    var result = _Tiles[[destination]];123    var flags = Zeros{5};124    for row = 0 to left_tile.valid_rows - 1 looplimit 65536 do125        for column = 0 to left_tile.valid_columns - 1 looplimit 65536 do126            let element = TileLogicalLinearIndex(left_tile,127                row as integer {0..65535}, column as integer {0..65535});128            let (predicate, element_flags) = TileCompareElement(129                comparison,130                left_tile.data_type,131                TileReadLogicalElement(left_tile, element),132                TileReadLogicalElement(right_tile, element));133            result = TileInfoWithPredicateBit(134                result,135                row as integer {0..65535},136                column as integer {0..65535},137                predicate);138            flags = flags OR element_flags;139        end;140    end;141    result = PredicateTileWithPadding(result, CurrentBundlePadValue());142    RecordNumericStatusFlags(flags);143    _Tiles[[destination]] = result;144end;145
146func TileProfileCompare(147    comparison: TileComparison,148    data_type: TileDataType,149    left: Word,150    right: Word) => Word151begin152    let (predicate, -) = TileCompareElement(153        comparison,154        data_type,155        left,156        right);157    return if predicate then Zeros{PTO_XLEN} + 1 else Zeros{PTO_XLEN};158end;159
160func ExecuteTileCompareScalar(destination: TileIndex, source: TileIndex,161                              scalar: Word, comparison: TileComparison)162begin163    assert TileOperandsLegal_ExecuteTileCompareScalar(164        destination,165        source,166        scalar,167        comparison);168    let source_tile = _Tiles[[source]];169    var result = _Tiles[[destination]];170    let normalized_scalar = TileRawElementValue(171        scalar,172        source_tile.data_type);173    var flags = Zeros{5};174    for row = 0 to source_tile.valid_rows - 1 looplimit 65536 do175        for column = 0 to source_tile.valid_columns - 1 looplimit 65536 do176            let element = TileLogicalLinearIndex(source_tile,177                row as integer {0..65535}, column as integer {0..65535});178            let (predicate, element_flags) = TileCompareElement(179                comparison,180                source_tile.data_type,181                TileReadLogicalElement(source_tile, element),182                normalized_scalar);183            result = TileInfoWithPredicateBit(184                result,185                row as integer {0..65535},186                column as integer {0..65535},187                predicate);188            flags = flags OR element_flags;189        end;190    end;191    result = PredicateTileWithPadding(result, CurrentBundlePadValue());192    RecordNumericStatusFlags(flags);193    _Tiles[[destination]] = result;194end;195
196func ExecuteTileSelect(destination: TileIndex, mask: TileIndex,197                       source_true: TileIndex, source_false: TileIndex)198begin199    assert TileOperandsLegal_ExecuteTileSelect(200        destination,201        mask,202        source_true,203        source_false);204    let true_tile = _Tiles[[source_true]];205    let false_tile = _Tiles[[source_false]];206    let mask_tile = _Tiles[[mask]];207    var result = _Tiles[[destination]];208    for row = 0 to true_tile.valid_rows - 1 looplimit 65536 do209        for column = 0 to true_tile.valid_columns - 1 looplimit 65536 do210            let element = TileLogicalLinearIndex(true_tile,211                row as integer {0..65535}, column as integer {0..65535});212            if TilePredicateBitFromInfo(213                mask_tile,214                row as integer {0..65535},215                column as integer {0..65535}) then216                result = TileInfoWithLogicalElement(result, element,217                    TileReadLogicalElement(true_tile, element));218            else219                result = TileInfoWithLogicalElement(result, element,220                    TileReadLogicalElement(false_tile, element));221            end;222        end;223    end;224    result = TileWithValidRegionDefined(result);225    result = TileWithPadding(result, CurrentBundlePadValue());226    _Tiles[[destination]] = result;227end;228
229func ExecuteTileSelectScalar(destination: TileIndex, mask: TileIndex,230                             source_true: TileIndex, scalar_false: Word)231begin232    assert TileOperandsLegal_ExecuteTileSelectScalar(233        destination,234        mask,235        source_true,236        scalar_false);237    var result = _Tiles[[destination]];238    let true_tile = _Tiles[[source_true]];239    let mask_tile = _Tiles[[mask]];240    let normalized_scalar = TileRawElementValue(241        scalar_false,242        true_tile.data_type);243    for row = 0 to true_tile.valid_rows - 1 looplimit 65536 do244        for column = 0 to true_tile.valid_columns - 1 looplimit 65536 do245            let element = TileLogicalLinearIndex(true_tile,246                row as integer {0..65535}, column as integer {0..65535});247            if TilePredicateBitFromInfo(248                mask_tile,249                row as integer {0..65535},250                column as integer {0..65535}) then251                result = TileInfoWithLogicalElement(result, element,252                    TileReadLogicalElement(true_tile, element));253            else254                result = TileInfoWithLogicalElement(255                    result, element, normalized_scalar);256            end;257        end;258    end;259    result = TileWithValidRegionDefined(result);260    result = TileWithPadding(result, CurrentBundlePadValue());261    _Tiles[[destination]] = result;262end;263