This is an archive of the discontinued LLVM Phabricator instance.

Differential D83292

[mlir][VectorOps] Lower vector.outerproduct of int vectors
ClosedPublic

Authored by bkramer on Jul 7 2020, 3:53 AM.

Details

Reviewers
nicolasvasilache
aartbik
Commits
rGcca4ac523e18: [mlir][VectorOps] Lower vector.outerproduct of int vectors
Summary

vector.fma and mulf don't work on integers. Use a muli/addi pair or
plain muli instead.

Diff Detail

Event Timeline

bkramer created this revision.Jul 7 2020, 3:53 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 7 2020, 3:53 AM
Herald added subscribers: msifontes, jurahul, Kayjukh and 12 others. · View Herald Transcript
nicolasvasilache accepted this revision.Jul 7 2020, 4:40 AM
nicolasvasilache added inline comments.
mlir/lib/Dialect/Vector/VectorTransforms.cpp
1299

nit: this inner if/else has become trivial so you can remove the braces

This revision is now accepted and ready to land.Jul 7 2020, 4:40 AM
Closed by commit rGcca4ac523e18: [mlir][VectorOps] Lower vector.outerproduct of int vectors (authored by bkramer). · Explain WhyJul 7 2020, 5:42 AM
This revision was automatically updated to reflect the committed changes.
aartbik added a comment.Jul 7 2020, 11:08 AM

LGTM, thanks!

Revision Contents

PathSize
mlir/
lib/
Dialect/
Vector/
13 lines
test/
Dialect/
Vector/
44 lines

Diff 275984

mlir/lib/Dialect/Vector/VectorTransforms.cpp

Show First 20 Lines • Show All 1,283 Lines • ▼ Show 20 Lines Value result = rewriter.create<ConstantOp>(loc, resType,
rewriter.getZeroAttr(resType)); rewriter.getZeroAttr(resType));
for (int64_t d = 0, e = resType.getDimSize(0); d < e; ++d) { for (int64_t d = 0, e = resType.getDimSize(0); d < e; ++d) {
auto pos = rewriter.getI64ArrayAttr(d); auto pos = rewriter.getI64ArrayAttr(d);
Value x = rewriter.create<vector::ExtractOp>(loc, eltType, op.lhs(), pos); Value x = rewriter.create<vector::ExtractOp>(loc, eltType, op.lhs(), pos);
Value b = rewriter.create<vector::BroadcastOp>(loc, rhsType, x); Value b = rewriter.create<vector::BroadcastOp>(loc, rhsType, x);
Value m; Value m;
if (acc) { if (acc) {
Value e = rewriter.create<vector::ExtractOp>(loc, rhsType, acc, pos); Value e = rewriter.create<vector::ExtractOp>(loc, rhsType, acc, pos);
if (eltType.isa<IntegerType>()) {
m = rewriter.create<MulIOp>(loc, b, op.rhs());
m = rewriter.create<AddIOp>(loc, m, e);
} else {
m = rewriter.create<vector::FMAOp>(loc, b, op.rhs(), e); m = rewriter.create<vector::FMAOp>(loc, b, op.rhs(), e);
}
} else {
if (eltType.isa<IntegerType>()) {
nicolasvasilacheUnsubmitted
Not Done
ReplyInline Actions

nit: this inner if/else has become trivial so you can remove the braces

nicolasvasilache: nit: this inner if/else has become trivial so you can remove the braces
m = rewriter.create<MulIOp>(loc, b, op.rhs());
} else { } else {
m = rewriter.create<MulFOp>(loc, b, op.rhs()); m = rewriter.create<MulFOp>(loc, b, op.rhs());
} }
}
result = rewriter.create<vector::InsertOp>(loc, resType, m, result, pos); result = rewriter.create<vector::InsertOp>(loc, resType, m, result, pos);
} }
rewriter.replaceOp(op, result); rewriter.replaceOp(op, result);
return success(); return success();
} }
}; };
/// Progressive lowering of ConstantMaskOp. /// Progressive lowering of ConstantMaskOp.
▲ Show 20 Lines • Show All 733 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/vector-contract-transforms.mlir

Show First 20 Lines • Show All 287 Lines • ▼ Show 20 Lines
func @outerproduct_acc(%arg0: vector<2xf32>, func @outerproduct_acc(%arg0: vector<2xf32>,
%arg1: vector<3xf32>, %arg1: vector<3xf32>,
%arg2: vector<2x3xf32>) -> vector<2x3xf32> { %arg2: vector<2x3xf32>) -> vector<2x3xf32> {
%0 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32> %0 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32>
return %0: vector<2x3xf32> return %0: vector<2x3xf32>
} }
// CHECK-LABEL: func @outerproduct_noacc_int
// CHECK-SAME: %[[A:.*0]]: vector<2xi32>,
// CHECK-SAME: %[[B:.*1]]: vector<3xi32>
// CHECK: %[[C0:.*]] = constant dense<0> : vector<2x3xi32>
// CHECK: %[[T0:.*]] = vector.extract %[[A]][0] : vector<2xi32>
// CHECK: %[[T1:.*]] = splat %[[T0]] : vector<3xi32>
// CHECK: %[[T2:.*]] = muli %[[T1]], %[[B]] : vector<3xi32>
// CHECK: %[[T3:.*]] = vector.insert %[[T2]], %[[C0]] [0] : vector<3xi32> into vector<2x3xi32>
// CHECK: %[[T4:.*]] = vector.extract %[[A]][1] : vector<2xi32>
// CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xi32>
// CHECK: %[[T6:.*]] = muli %[[T5]], %[[B]] : vector<3xi32>
// CHECK: %[[T7:.*]] = vector.insert %[[T6]], %[[T3]] [1] : vector<3xi32> into vector<2x3xi32>
// CHECK: return %[[T7]] : vector<2x3xi32>
func @outerproduct_noacc_int(%arg0: vector<2xi32>,
%arg1: vector<3xi32>) -> vector<2x3xi32> {
%0 = vector.outerproduct %arg0, %arg1 : vector<2xi32>, vector<3xi32>
return %0: vector<2x3xi32>
}
// CHECK-LABEL: func @outerproduct_acc_int
// CHECK-SAME: %[[A:.*0]]: vector<2xi32>,
// CHECK-SAME: %[[B:.*1]]: vector<3xi32>,
// CHECK-SAME: %[[C:.*2]]: vector<2x3xi32>
// CHECK: %[[C0:.*]] = constant dense<0> : vector<2x3xi32>
// CHECK: %[[T0:.*]] = vector.extract %[[A]][0] : vector<2xi32>
// CHECK: %[[T1:.*]] = splat %[[T0]] : vector<3xi32>
// CHECK: %[[T2:.*]] = vector.extract %[[C]][0] : vector<2x3xi32>
// CHECK: %[[T3:.*]] = muli %[[T1]], %[[B]] : vector<3xi32>
// CHECK: %[[T4:.*]] = addi %[[T3]], %[[T2]] : vector<3xi32>
// CHECK: %[[T5:.*]] = vector.insert %[[T4]], %[[C0]] [0] : vector<3xi32> into vector<2x3xi32>
// CHECK: %[[T6:.*]] = vector.extract %[[A]][1] : vector<2xi32>
// CHECK: %[[T7:.*]] = splat %[[T6]] : vector<3xi32>
// CHECK: %[[T8:.*]] = vector.extract %[[C]][1] : vector<2x3xi32>
// CHECK: %[[T9:.*]] = muli %[[T7]], %[[B]] : vector<3xi32>
// CHECK: %[[T10:.*]] = addi %[[T9]], %[[T8]] : vector<3xi32>
// CHECK: %[[T11:.*]] = vector.insert %[[T10]], %[[T5]] [1] : vector<3xi32> into vector<2x3xi32>
// CHECK: return %[[T11]] : vector<2x3xi32>
func @outerproduct_acc_int(%arg0: vector<2xi32>,
%arg1: vector<3xi32>,
%arg2: vector<2x3xi32>) -> vector<2x3xi32> {
%0 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xi32>, vector<3xi32>
return %0: vector<2x3xi32>
}
// CHECK-LABEL: func @transpose23 // CHECK-LABEL: func @transpose23
// CHECK-SAME: %[[A:.*]]: vector<2x3xf32> // CHECK-SAME: %[[A:.*]]: vector<2x3xf32>
// CHECK: %[[Z:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> // CHECK: %[[Z:.*]] = constant dense<0.000000e+00> : vector<3x2xf32>
// CHECK: %[[T0:.*]] = vector.extract %[[A]][0, 0] : vector<2x3xf32> // CHECK: %[[T0:.*]] = vector.extract %[[A]][0, 0] : vector<2x3xf32>
// CHECK: %[[T1:.*]] = vector.insert %[[T0]], %[[Z]] [0, 0] : f32 into vector<3x2xf32> // CHECK: %[[T1:.*]] = vector.insert %[[T0]], %[[Z]] [0, 0] : f32 into vector<3x2xf32>
// CHECK: %[[T2:.*]] = vector.extract %[[A]][1, 0] : vector<2x3xf32> // CHECK: %[[T2:.*]] = vector.extract %[[A]][1, 0] : vector<2x3xf32>
// CHECK: %[[T3:.*]] = vector.insert %[[T2]], %[[T1]] [0, 1] : f32 into vector<3x2xf32> // CHECK: %[[T3:.*]] = vector.insert %[[T2]], %[[T1]] [0, 1] : f32 into vector<3x2xf32>
// CHECK: %[[T4:.*]] = vector.extract %[[A]][0, 1] : vector<2x3xf32> // CHECK: %[[T4:.*]] = vector.extract %[[A]][0, 1] : vector<2x3xf32>
▲ Show 20 Lines • Show All 656 Lines • Show Last 20 Lines