Skip to content

Commit 4a83125

Browse files
unterumarmungdcaballe
unterumarmung
authored and
dcaballe
committed
[mlir][vector] Rename vector reductions: maxf → maximumf, minf → minimumf
This patch is part of a larger initiative aimed at fixing floating-point `max` and `min` operations in MLIR: https://discourse.llvm.org/t/rfc-fix-floating-point-max-and-min-operations-in-mlir/72671. Here, we are addressing task 2.1 from the plan, which involves renaming the vector reductions to align with the semantics of the corresponding LLVM intrinsics. Reviewed By: dcaballe Differential Revision: https://reviews.llvm.org/D158618
1 parent 8ddedbf commit 4a83125

File tree

17 files changed

+67
-44
lines changed

17 files changed

+67
-44
lines changed

‎mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,14 +48,17 @@ def COMBINING_KIND_MAXF : I32BitEnumAttrCaseBit<"MAXF", 7, "maxf">;
4848
def COMBINING_KIND_AND : I32BitEnumAttrCaseBit<"AND", 8, "and">;
4949
def COMBINING_KIND_OR : I32BitEnumAttrCaseBit<"OR", 9, "or">;
5050
def COMBINING_KIND_XOR : I32BitEnumAttrCaseBit<"XOR", 10, "xor">;
51+
def COMBINING_KIND_MINIMUMF : I32BitEnumAttrCaseBit<"MINIMUMF", 11, "minimumf">;
52+
def COMBINING_KIND_MAXIMUMF : I32BitEnumAttrCaseBit<"MAXIMUMF", 12, "maximumf">;
5153

5254
def CombiningKind : I32BitEnumAttr<
5355
"CombiningKind",
5456
"Kind of combining function for contractions and reductions",
5557
[COMBINING_KIND_ADD, COMBINING_KIND_MUL, COMBINING_KIND_MINUI,
5658
COMBINING_KIND_MINSI, COMBINING_KIND_MINF, COMBINING_KIND_MAXUI,
5759
COMBINING_KIND_MAXSI, COMBINING_KIND_MAXF, COMBINING_KIND_AND,
58-
COMBINING_KIND_OR, COMBINING_KIND_XOR]> {
60+
COMBINING_KIND_OR, COMBINING_KIND_XOR,
61+
COMBINING_KIND_MAXIMUMF, COMBINING_KIND_MINIMUMF]> {
5962
let cppNamespace = "::mlir::vector";
6063
let genSpecializedAttr = 0;
6164
}

‎mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -762,11 +762,11 @@ class VectorReductionOpConversion
762762
result = lowerReductionWithStartValue<LLVM::vector_reduce_fmul,
763763
ReductionNeutralFPOne>(
764764
rewriter, loc, llvmType, operand, acc, reassociateFPReductions);
765-
} else if (kind == vector::CombiningKind::MINF) {
765+
} else if (kind == vector::CombiningKind::MINIMUMF) {
766766
result =
767767
createFPReductionComparisonOpLowering<LLVM::vector_reduce_fminimum>(
768768
rewriter, loc, llvmType, operand, acc);
769-
} else if (kind == vector::CombiningKind::MAXF) {
769+
} else if (kind == vector::CombiningKind::MAXIMUMF) {
770770
result =
771771
createFPReductionComparisonOpLowering<LLVM::vector_reduce_fmaximum>(
772772
rewriter, loc, llvmType, operand, acc);
@@ -893,6 +893,10 @@ class MaskedReductionOpConversion
893893
ReductionNeutralFPMin>(
894894
rewriter, loc, llvmType, operand, acc, maskOp.getMask());
895895
break;
896+
default:
897+
return rewriter.notifyMatchFailure(
898+
maskOp,
899+
"lowering to LLVM is not implemented for this masked operation");
896900
}
897901

898902
// Replace `vector.mask` operation altogether.

‎mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -391,7 +391,8 @@ struct VectorReductionPattern final
391391

392392
INT_AND_FLOAT_CASE(ADD, IAddOp, FAddOp);
393393
INT_AND_FLOAT_CASE(MUL, IMulOp, FMulOp);
394-
394+
INT_OR_FLOAT_CASE(MAXIMUMF, SPIRVFMaxOp);
395+
INT_OR_FLOAT_CASE(MINIMUMF, SPIRVFMinOp);
395396
INT_OR_FLOAT_CASE(MAXF, SPIRVFMaxOp);
396397
INT_OR_FLOAT_CASE(MINF, SPIRVFMinOp);
397398
INT_OR_FLOAT_CASE(MINUI, SPIRVUMinOp);

‎mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -505,10 +505,10 @@ mlir::linalg::getCombinerOpKind(Operation *combinerOp) {
505505
.Case<arith::AndIOp>([&](auto op) { return CombiningKind::AND; })
506506
.Case<arith::MaxSIOp>([&](auto op) { return CombiningKind::MAXSI; })
507507
.Case<arith::MaxUIOp>([&](auto op) { return CombiningKind::MAXUI; })
508-
.Case<arith::MaximumFOp>([&](auto op) { return CombiningKind::MAXF; })
508+
.Case<arith::MaximumFOp>([&](auto op) { return CombiningKind::MAXIMUMF; })
509509
.Case<arith::MinSIOp>([&](auto op) { return CombiningKind::MINSI; })
510510
.Case<arith::MinUIOp>([&](auto op) { return CombiningKind::MINUI; })
511-
.Case<arith::MinimumFOp>([&](auto op) { return CombiningKind::MINF; })
511+
.Case<arith::MinimumFOp>([&](auto op) { return CombiningKind::MINIMUMF; })
512512
.Case<arith::MulIOp, arith::MulFOp>(
513513
[&](auto op) { return CombiningKind::MUL; })
514514
.Case<arith::OrIOp>([&](auto op) { return CombiningKind::OR; })
@@ -2416,9 +2416,11 @@ bool isSupportedPoolKind(vector::CombiningKind kind) {
24162416
switch (kind) {
24172417
case vector::CombiningKind::ADD:
24182418
case vector::CombiningKind::MAXF:
2419+
case vector::CombiningKind::MAXIMUMF:
24192420
case vector::CombiningKind::MAXSI:
24202421
case vector::CombiningKind::MAXUI:
24212422
case vector::CombiningKind::MINF:
2423+
case vector::CombiningKind::MINIMUMF:
24222424
case vector::CombiningKind::MINSI:
24232425
case vector::CombiningKind::MINUI:
24242426
return true;

‎mlir/lib/Dialect/Vector/IR/VectorOps.cpp

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,8 @@ static bool isSupportedCombiningKind(CombiningKind combiningKind,
125125
return elementType.isIntOrIndex();
126126
case CombiningKind::MINF:
127127
case CombiningKind::MAXF:
128+
case CombiningKind::MINIMUMF:
129+
case CombiningKind::MAXIMUMF:
128130
return llvm::isa<FloatType>(elementType);
129131
}
130132
return false;
@@ -495,7 +497,7 @@ Value mlir::vector::getVectorReductionOp(arith::AtomicRMWKind op,
495497
CombiningKind::MUL, vector);
496498
case arith::AtomicRMWKind::minimumf:
497499
return builder.create<vector::ReductionOp>(vector.getLoc(),
498-
CombiningKind::MINF, vector);
500+
CombiningKind::MINIMUMF, vector);
499501
case arith::AtomicRMWKind::mins:
500502
return builder.create<vector::ReductionOp>(vector.getLoc(),
501503
CombiningKind::MINSI, vector);
@@ -504,7 +506,7 @@ Value mlir::vector::getVectorReductionOp(arith::AtomicRMWKind op,
504506
CombiningKind::MINUI, vector);
505507
case arith::AtomicRMWKind::maximumf:
506508
return builder.create<vector::ReductionOp>(vector.getLoc(),
507-
CombiningKind::MAXF, vector);
509+
CombiningKind::MAXIMUMF, vector);
508510
case arith::AtomicRMWKind::maxs:
509511
return builder.create<vector::ReductionOp>(vector.getLoc(),
510512
CombiningKind::MAXSI, vector);
@@ -5947,11 +5949,13 @@ Value mlir::vector::makeArithReduction(OpBuilder &b, Location loc,
59475949
result = b.createOrFold<arith::AndIOp>(loc, v1, acc);
59485950
break;
59495951
case CombiningKind::MAXF:
5952+
case CombiningKind::MAXIMUMF:
59505953
assert(llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc) &&
59515954
"expected float values");
59525955
result = b.createOrFold<arith::MaximumFOp>(loc, v1, acc);
59535956
break;
59545957
case CombiningKind::MINF:
5958+
case CombiningKind::MINIMUMF:
59555959
assert(llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc) &&
59565960
"expected float values");
59575961
result = b.createOrFold<arith::MinimumFOp>(loc, v1, acc);

‎mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,8 @@ createContractArithOp(Location loc, Value x, Value y, Value acc,
140140
Value mul;
141141

142142
if (isInt) {
143-
if (kind == CombiningKind::MINF || kind == CombiningKind::MAXF)
143+
if (kind == CombiningKind::MINF || kind == CombiningKind::MAXF ||
144+
kind == CombiningKind::MINIMUMF || kind == CombiningKind::MAXIMUMF)
144145
// Only valid for floating point types.
145146
return std::nullopt;
146147
mul = rewriter.create<arith::MulIOp>(loc, x, y);

‎mlir/lib/Dialect/Vector/Transforms/LowerVectorScan.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -87,9 +87,11 @@ static Value genOperator(Location loc, Value x, Value y,
8787
combinedResult = rewriter.create<arith::XOrIOp>(loc, x, y);
8888
break;
8989
case CombiningKind::MINF:
90+
case CombiningKind::MINIMUMF:
9091
combinedResult = rewriter.create<arith::MinimumFOp>(loc, x, y);
9192
break;
9293
case CombiningKind::MAXF:
94+
case CombiningKind::MAXIMUMF:
9395
combinedResult = rewriter.create<arith::MaximumFOp>(loc, x, y);
9496
break;
9597
}
@@ -104,7 +106,9 @@ static bool isValidKind(bool isInt, vector::CombiningKind kind) {
104106
KindType type{KindType::INVALID};
105107
switch (kind) {
106108
case CombiningKind::MINF:
109+
case CombiningKind::MINIMUMF:
107110
case CombiningKind::MAXF:
111+
case CombiningKind::MAXIMUMF:
108112
type = KindType::FLOAT;
109113
break;
110114
case CombiningKind::MINUI:

‎mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1317,23 +1317,23 @@ func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
13171317

13181318
// -----
13191319

1320-
func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
1321-
%0 = vector.reduction <maxf>, %arg0, %arg1 : vector<16xf32> into f32
1320+
func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
1321+
%0 = vector.reduction <maximumf>, %arg0, %arg1 : vector<16xf32> into f32
13221322
return %0 : f32
13231323
}
1324-
// CHECK-LABEL: @reduce_fmax_f32(
1324+
// CHECK-LABEL: @reduce_fmaximum_f32(
13251325
// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)
13261326
// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmaximum(%[[A]]) : (vector<16xf32>) -> f32
13271327
// CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f32
13281328
// CHECK: return %[[R]] : f32
13291329

13301330
// -----
13311331

1332-
func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
1333-
%0 = vector.reduction <minf>, %arg0, %arg1 : vector<16xf32> into f32
1332+
func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
1333+
%0 = vector.reduction <minimumf>, %arg0, %arg1 : vector<16xf32> into f32
13341334
return %0 : f32
13351335
}
1336-
// CHECK-LABEL: @reduce_fmin_f32(
1336+
// CHECK-LABEL: @reduce_fminimum_f32(
13371337
// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)
13381338
// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fminimum(%[[A]]) : (vector<16xf32>) -> f32
13391339
// CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f32

‎mlir/test/Conversion/VectorToSPIRV/vector-to-spirv.mlir

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ func.func @cl_fma_size1_vector(%a: vector<1xf32>, %b: vector<1xf32>, %c: vector<
5050
return %0 : vector<1xf32>
5151
}
5252

53-
// CHECK-LABEL: func @cl_reduction_maxf
53+
// CHECK-LABEL: func @cl_reduction_maximumf
5454
// CHECK-SAME: (%[[V:.+]]: vector<3xf32>, %[[S:.+]]: f32)
5555
// CHECK: %[[S0:.+]] = spirv.CompositeExtract %[[V]][0 : i32] : vector<3xf32>
5656
// CHECK: %[[S1:.+]] = spirv.CompositeExtract %[[V]][1 : i32] : vector<3xf32>
@@ -59,12 +59,12 @@ func.func @cl_fma_size1_vector(%a: vector<1xf32>, %b: vector<1xf32>, %c: vector<
5959
// CHECK: %[[MAX1:.+]] = spirv.CL.fmax %[[MAX0]], %[[S2]]
6060
// CHECK: %[[MAX2:.+]] = spirv.CL.fmax %[[MAX1]], %[[S]]
6161
// CHECK: return %[[MAX2]]
62-
func.func @cl_reduction_maxf(%v : vector<3xf32>, %s: f32) -> f32 {
63-
%reduce = vector.reduction <maxf>, %v, %s : vector<3xf32> into f32
62+
func.func @cl_reduction_maximumf(%v : vector<3xf32>, %s: f32) -> f32 {
63+
%reduce = vector.reduction <maximumf>, %v, %s : vector<3xf32> into f32
6464
return %reduce : f32
6565
}
6666

67-
// CHECK-LABEL: func @cl_reduction_minf
67+
// CHECK-LABEL: func @cl_reduction_minimumf
6868
// CHECK-SAME: (%[[V:.+]]: vector<3xf32>, %[[S:.+]]: f32)
6969
// CHECK: %[[S0:.+]] = spirv.CompositeExtract %[[V]][0 : i32] : vector<3xf32>
7070
// CHECK: %[[S1:.+]] = spirv.CompositeExtract %[[V]][1 : i32] : vector<3xf32>
@@ -73,8 +73,8 @@ func.func @cl_reduction_maxf(%v : vector<3xf32>, %s: f32) -> f32 {
7373
// CHECK: %[[MIN1:.+]] = spirv.CL.fmin %[[MIN0]], %[[S2]]
7474
// CHECK: %[[MIN2:.+]] = spirv.CL.fmin %[[MIN1]], %[[S]]
7575
// CHECK: return %[[MIN2]]
76-
func.func @cl_reduction_minf(%v : vector<3xf32>, %s: f32) -> f32 {
77-
%reduce = vector.reduction <minf>, %v, %s : vector<3xf32> into f32
76+
func.func @cl_reduction_minimumf(%v : vector<3xf32>, %s: f32) -> f32 {
77+
%reduce = vector.reduction <minimumf>, %v, %s : vector<3xf32> into f32
7878
return %reduce : f32
7979
}
8080

@@ -516,7 +516,7 @@ func.func @reduction_mul(%v : vector<3xf32>, %s: f32) -> f32 {
516516

517517
// -----
518518

519-
// CHECK-LABEL: func @reduction_maxf
519+
// CHECK-LABEL: func @reduction_maximumf
520520
// CHECK-SAME: (%[[V:.+]]: vector<3xf32>, %[[S:.+]]: f32)
521521
// CHECK: %[[S0:.+]] = spirv.CompositeExtract %[[V]][0 : i32] : vector<3xf32>
522522
// CHECK: %[[S1:.+]] = spirv.CompositeExtract %[[V]][1 : i32] : vector<3xf32>
@@ -525,14 +525,14 @@ func.func @reduction_mul(%v : vector<3xf32>, %s: f32) -> f32 {
525525
// CHECK: %[[MAX1:.+]] = spirv.GL.FMax %[[MAX0]], %[[S2]]
526526
// CHECK: %[[MAX2:.+]] = spirv.GL.FMax %[[MAX1]], %[[S]]
527527
// CHECK: return %[[MAX2]]
528-
func.func @reduction_maxf(%v : vector<3xf32>, %s: f32) -> f32 {
529-
%reduce = vector.reduction <maxf>, %v, %s : vector<3xf32> into f32
528+
func.func @reduction_maximumf(%v : vector<3xf32>, %s: f32) -> f32 {
529+
%reduce = vector.reduction <maximumf>, %v, %s : vector<3xf32> into f32
530530
return %reduce : f32
531531
}
532532

533533
// -----
534534

535-
// CHECK-LABEL: func @reduction_minf
535+
// CHECK-LABEL: func @reduction_minimumf
536536
// CHECK-SAME: (%[[V:.+]]: vector<3xf32>, %[[S:.+]]: f32)
537537
// CHECK: %[[S0:.+]] = spirv.CompositeExtract %[[V]][0 : i32] : vector<3xf32>
538538
// CHECK: %[[S1:.+]] = spirv.CompositeExtract %[[V]][1 : i32] : vector<3xf32>
@@ -541,8 +541,8 @@ func.func @reduction_maxf(%v : vector<3xf32>, %s: f32) -> f32 {
541541
// CHECK: %[[MIN1:.+]] = spirv.GL.FMin %[[MIN0]], %[[S2]]
542542
// CHECK: %[[MIN2:.+]] = spirv.GL.FMin %[[MIN1]], %[[S]]
543543
// CHECK: return %[[MIN2]]
544-
func.func @reduction_minf(%v : vector<3xf32>, %s: f32) -> f32 {
545-
%reduce = vector.reduction <minf>, %v, %s : vector<3xf32> into f32
544+
func.func @reduction_minimumf(%v : vector<3xf32>, %s: f32) -> f32 {
545+
%reduce = vector.reduction <minimumf>, %v, %s : vector<3xf32> into f32
546546
return %reduce : f32
547547
}
548548

‎mlir/test/Dialect/Affine/SuperVectorize/vectorize_reduction.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ func.func @vecdim_reduction_minf(%in: memref<256x512xf32>, %out: memref<256xf32>
5050
// CHECK: %[[min:.*]] = arith.minimumf %[[red_iter]], %[[ld]] : vector<128xf32>
5151
// CHECK: affine.yield %[[min]] : vector<128xf32>
5252
// CHECK: }
53-
// CHECK: %[[final_min:.*]] = vector.reduction <minf>, %[[vred:.*]] : vector<128xf32> into f32
53+
// CHECK: %[[final_min:.*]] = vector.reduction <minimumf>, %[[vred:.*]] : vector<128xf32> into f32
5454
// CHECK: affine.store %[[final_min]], %{{.*}} : memref<256xf32>
5555
// CHECK: }
5656

@@ -77,7 +77,7 @@ func.func @vecdim_reduction_maxf(%in: memref<256x512xf32>, %out: memref<256xf32>
7777
// CHECK: %[[max:.*]] = arith.maximumf %[[red_iter]], %[[ld]] : vector<128xf32>
7878
// CHECK: affine.yield %[[max]] : vector<128xf32>
7979
// CHECK: }
80-
// CHECK: %[[final_max:.*]] = vector.reduction <maxf>, %[[vred:.*]] : vector<128xf32> into f32
80+
// CHECK: %[[final_max:.*]] = vector.reduction <maximumf>, %[[vred:.*]] : vector<128xf32> into f32
8181
// CHECK: affine.store %[[final_max]], %{{.*}} : memref<256xf32>
8282
// CHECK: }
8383

‎mlir/test/Dialect/Linalg/vectorization.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1172,7 +1172,7 @@ transform.sequence failures(propagate) {
11721172
func.func @red_max_2d(%arg0: tensor<4x4xf32>) -> tensor<4xf32> {
11731173
// CHECK: %[[CMINF:.+]] = arith.constant dense<-3.402820e+38> : vector<4xf32>
11741174
// CHECK: tensor.empty() : tensor<4xf32>
1175-
// CHECK: vector.multi_reduction <maxf>, {{.*}}, %[[CMINF]] [1] : vector<4x4xf32> to vector<4xf32>
1175+
// CHECK: vector.multi_reduction <maximumf>, {{.*}}, %[[CMINF]] [1] : vector<4x4xf32> to vector<4xf32>
11761176
// CHECK: vector.transfer_write {{.*}} : vector<4xf32>, tensor<4xf32>
11771177
%ident = arith.constant -3.40282e+38 : f32
11781178
%init = tensor.empty() : tensor<4xf32>
@@ -1203,7 +1203,7 @@ func.func @red_min_2d(%arg0: tensor<4x4xf32>) -> tensor<4xf32> {
12031203
// CHECK: %[[CMAXF:.+]] = arith.constant dense<3.402820e+38> : vector<4xf32>
12041204
// CHECK: tensor.empty() : tensor<4xf32>
12051205
// CHECK: vector.transfer_read {{.*}} : tensor<4x4xf32>, vector<4x4xf32>
1206-
// CHECK: vector.multi_reduction <minf>, {{.*}}, %[[CMAXF]] [1] : vector<4x4xf32> to vector<4xf32>
1206+
// CHECK: vector.multi_reduction <minimumf>, {{.*}}, %[[CMAXF]] [1] : vector<4x4xf32> to vector<4xf32>
12071207
// CHECK: vector.transfer_write {{.*}} : vector<4xf32>, tensor<4xf32>
12081208
%maxf32 = arith.constant 3.40282e+38 : f32
12091209
%init = tensor.empty() : tensor<4xf32>

‎mlir/test/Dialect/Vector/canonicalize.mlir

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1992,13 +1992,13 @@ func.func @dont_reduce_one_element_vector(%a : vector<4xf32>) -> f32 {
19921992

19931993
// -----
19941994

1995-
// CHECK-LABEL: func @reduce_one_element_vector_maxf
1995+
// CHECK-LABEL: func @reduce_one_element_vector_maximumf
19961996
// CHECK-SAME: (%[[V:.+]]: vector<1xf32>, %[[B:.+]]: f32)
19971997
// CHECK: %[[A:.+]] = vector.extract %[[V]][0] : vector<1xf32>
19981998
// CHECK: %[[S:.+]] = arith.maximumf %[[A]], %[[B]] : f32
19991999
// CHECK: return %[[S]]
2000-
func.func @reduce_one_element_vector_maxf(%a : vector<1xf32>, %b: f32) -> f32 {
2001-
%s = vector.reduction <maxf>, %a, %b : vector<1xf32> into f32
2000+
func.func @reduce_one_element_vector_maximumf(%a : vector<1xf32>, %b: f32) -> f32 {
2001+
%s = vector.reduction <maximumf>, %a, %b : vector<1xf32> into f32
20022002
return %s : f32
20032003
}
20042004

‎mlir/test/Dialect/Vector/ops.mlir

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -576,9 +576,13 @@ func.func @reduce_fp(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
576576
vector.reduction <mul>, %arg0, %arg1 : vector<16xf32> into f32
577577
// CHECK: vector.reduction <minf>, %{{.*}} : vector<16xf32> into f32
578578
vector.reduction <minf>, %arg0 : vector<16xf32> into f32
579-
// CHECK: %[[X:.*]] = vector.reduction <maxf>, %{{.*}} : vector<16xf32> into f32
579+
// CHECK: %[[X0:.*]] = vector.reduction <maxf>, %{{.*}} : vector<16xf32> into f32
580580
%0 = vector.reduction <maxf>, %arg0 : vector<16xf32> into f32
581-
// CHECK: return %[[X]] : f32
581+
// CHECK: vector.reduction <minimumf>, %{{.*}} : vector<16xf32> into f32
582+
vector.reduction <minimumf>, %arg0 : vector<16xf32> into f32
583+
// CHECK: %[[X1:.*]] = vector.reduction <maximumf>, %{{.*}} : vector<16xf32> into f32
584+
%1 = vector.reduction <maximumf>, %arg0 : vector<16xf32> into f32
585+
// CHECK: return %[[X0]] : f32
582586
return %0 : f32
583587
}
584588

‎mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32-reassoc.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,10 +27,10 @@ func.func @entry() {
2727
%1 = vector.reduction <mul>, %v2 : vector<64xf32> into f32
2828
vector.print %1 : f32
2929
// CHECK: 6
30-
%2 = vector.reduction <minf>, %v2 : vector<64xf32> into f32
30+
%2 = vector.reduction <minimumf>, %v2 : vector<64xf32> into f32
3131
vector.print %2 : f32
3232
// CHECK: 1
33-
%3 = vector.reduction <maxf>, %v2 : vector<64xf32> into f32
33+
%3 = vector.reduction <maximumf>, %v2 : vector<64xf32> into f32
3434
vector.print %3 : f32
3535
// CHECK: 3
3636

‎mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,10 +39,10 @@ func.func @entry() {
3939
%1 = vector.reduction <mul>, %v9 : vector<10xf32> into f32
4040
vector.print %1 : f32
4141
// CHECK: -5760
42-
%2 = vector.reduction <minf>, %v9 : vector<10xf32> into f32
42+
%2 = vector.reduction <minimumf>, %v9 : vector<10xf32> into f32
4343
vector.print %2 : f32
4444
// CHECK: -16
45-
%3 = vector.reduction <maxf>, %v9 : vector<10xf32> into f32
45+
%3 = vector.reduction <maximumf>, %v9 : vector<10xf32> into f32
4646
vector.print %3 : f32
4747
// CHECK: 5
4848

‎mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64-reassoc.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,10 +27,10 @@ func.func @entry() {
2727
%1 = vector.reduction <mul>, %v2 : vector<64xf64> into f64
2828
vector.print %1 : f64
2929
// CHECK: 6
30-
%2 = vector.reduction <minf>, %v2 : vector<64xf64> into f64
30+
%2 = vector.reduction <minimumf>, %v2 : vector<64xf64> into f64
3131
vector.print %2 : f64
3232
// CHECK: 1
33-
%3 = vector.reduction <maxf>, %v2 : vector<64xf64> into f64
33+
%3 = vector.reduction <maximumf>, %v2 : vector<64xf64> into f64
3434
vector.print %3 : f64
3535
// CHECK: 3
3636

‎mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64.mlir

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,10 +39,10 @@ func.func @entry() {
3939
%1 = vector.reduction <mul>, %v9 : vector<10xf64> into f64
4040
vector.print %1 : f64
4141
// CHECK: -5760
42-
%2 = vector.reduction <minf>, %v9 : vector<10xf64> into f64
42+
%2 = vector.reduction <minimumf>, %v9 : vector<10xf64> into f64
4343
vector.print %2 : f64
4444
// CHECK: -16
45-
%3 = vector.reduction <maxf>, %v9 : vector<10xf64> into f64
45+
%3 = vector.reduction <maximumf>, %v9 : vector<10xf64> into f64
4646
vector.print %3 : f64
4747
// CHECK: 5
4848

0 commit comments

Comments
 (0)