This is an archive of the discontinued LLVM Phabricator instance.

Differential D127934

[mlir][math] Support vector type by erf and round libm lowering
ClosedPublic

Authored by Lewuathe on Jun 15 2022, 9:25 PM.

Details

Reviewers
ftynse
Commits
rGce07b95610f7: [mlir][math] Support vector type by erf and round libm lowering
Summary

erf and round op are able to lowered to libm supporting vector type as other math operations.

Diff Detail

Event Timeline

Lewuathe created this revision.Jun 15 2022, 9:25 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 15 2022, 9:25 PM
Herald added subscribers: bzcheeseman, sdasgup3, wenzhicui and 20 others. · View Herald Transcript
Lewuathe requested review of this revision.Jun 15 2022, 9:25 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 15 2022, 9:25 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B170188: Diff 437439.Jun 15 2022, 9:56 PM
ftynse accepted this revision.Jun 17 2022, 9:23 AM
ftynse added inline comments.
mlir/test/Conversion/MathToLibm/convert-to-libm.mlir
208

Please add a newline

This revision is now accepted and ready to land.Jun 17 2022, 9:23 AM
This revision was landed with ongoing or failed builds.Jun 21 2022, 5:44 PM
Closed by commit rGce07b95610f7: [mlir][math] Support vector type by erf and round libm lowering (authored by Lewuathe). · Explain Why
This revision was automatically updated to reflect the committed changes.
Lewuathe added a commit: rGce07b95610f7: [mlir][math] Support vector type by erf and round libm lowering.

Revision Contents

PathSize
mlir/
lib/
Conversion/
MathToLibm/
6 lines
test/
Conversion/
MathToLibm/
48 lines

Diff 438882

mlir/lib/Conversion/MathToLibm/MathToLibm.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 LinesScalarOpToLibmCall<Op>::matchAndRewrite(Op op,
return success(); return success();
} }
void mlir::populateMathToLibmConversionPatterns(RewritePatternSet &patterns, void mlir::populateMathToLibmConversionPatterns(RewritePatternSet &patterns,
PatternBenefit benefit) { PatternBenefit benefit) {
patterns.add<VecOpToScalarOp<math::Atan2Op>, VecOpToScalarOp<math::ExpM1Op>, patterns.add<VecOpToScalarOp<math::Atan2Op>, VecOpToScalarOp<math::ExpM1Op>,
VecOpToScalarOp<math::TanhOp>, VecOpToScalarOp<math::CosOp>, VecOpToScalarOp<math::TanhOp>, VecOpToScalarOp<math::CosOp>,
VecOpToScalarOp<math::SinOp>>(patterns.getContext(), benefit); VecOpToScalarOp<math::SinOp>, VecOpToScalarOp<math::ErfOp>,
VecOpToScalarOp<math::RoundOp>>(patterns.getContext(), benefit);
patterns.add<PromoteOpToF32<math::Atan2Op>, PromoteOpToF32<math::ExpM1Op>, patterns.add<PromoteOpToF32<math::Atan2Op>, PromoteOpToF32<math::ExpM1Op>,
PromoteOpToF32<math::TanhOp>, PromoteOpToF32<math::CosOp>, PromoteOpToF32<math::TanhOp>, PromoteOpToF32<math::CosOp>,
PromoteOpToF32<math::SinOp>>(patterns.getContext(), benefit); PromoteOpToF32<math::SinOp>, PromoteOpToF32<math::ErfOp>,
PromoteOpToF32<math::RoundOp>>(patterns.getContext(), benefit);
patterns.add<ScalarOpToLibmCall<math::Atan2Op>>(patterns.getContext(), patterns.add<ScalarOpToLibmCall<math::Atan2Op>>(patterns.getContext(),
"atan2f", "atan2", benefit); "atan2f", "atan2", benefit);
patterns.add<ScalarOpToLibmCall<math::ErfOp>>(patterns.getContext(), "erff", patterns.add<ScalarOpToLibmCall<math::ErfOp>>(patterns.getContext(), "erff",
"erf", benefit); "erf", benefit);
patterns.add<ScalarOpToLibmCall<math::ExpM1Op>>(patterns.getContext(), patterns.add<ScalarOpToLibmCall<math::ExpM1Op>>(patterns.getContext(),
"expm1f", "expm1", benefit); "expm1f", "expm1", benefit);
patterns.add<ScalarOpToLibmCall<math::TanhOp>>(patterns.getContext(), "tanhf", patterns.add<ScalarOpToLibmCall<math::TanhOp>>(patterns.getContext(), "tanhf",
"tanh", benefit); "tanh", benefit);
Show All 32 Lines

mlir/test/Conversion/MathToLibm/convert-to-libm.mlir

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesfunc.func @erf_caller(%float: f32, %double: f64) -> (f32, f64) {
// CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @erff(%[[FLOAT]]) : (f32) -> f32 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @erff(%[[FLOAT]]) : (f32) -> f32
%float_result = math.erf %float : f32 %float_result = math.erf %float : f32
// CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @erf(%[[DOUBLE]]) : (f64) -> f64 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @erf(%[[DOUBLE]]) : (f64) -> f64
%double_result = math.erf %double : f64 %double_result = math.erf %double : f64
// CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]] // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
return %float_result, %double_result : f32, f64 return %float_result, %double_result : f32, f64
} }
// CHECK-LABEL: func @erf_vec_caller(
// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {
func.func @erf_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {
// CHECK-DAG: %[[CVF:.*]] = arith.constant dense<0.000000e+00> : vector<2xf32>
// CHECK-DAG: %[[CVD:.*]] = arith.constant dense<0.000000e+00> : vector<2xf64>
// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : vector<2xf32>
// CHECK: %[[OUT0_F32:.*]] = call @erff(%[[IN0_F32]]) : (f32) -> f32
// CHECK: %[[VAL_8:.*]] = vector.insert %[[OUT0_F32]], %[[CVF]] [0] : f32 into vector<2xf32>
// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : vector<2xf32>
// CHECK: %[[OUT1_F32:.*]] = call @erff(%[[IN1_F32]]) : (f32) -> f32
// CHECK: %[[VAL_11:.*]] = vector.insert %[[OUT1_F32]], %[[VAL_8]] [1] : f32 into vector<2xf32>
%float_result = math.erf %float : vector<2xf32>
// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : vector<2xf64>
// CHECK: %[[OUT0_F64:.*]] = call @erf(%[[IN0_F64]]) : (f64) -> f64
// CHECK: %[[VAL_14:.*]] = vector.insert %[[OUT0_F64]], %[[CVD]] [0] : f64 into vector<2xf64>
// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : vector<2xf64>
// CHECK: %[[OUT1_F64:.*]] = call @erf(%[[IN1_F64]]) : (f64) -> f64
// CHECK: %[[VAL_17:.*]] = vector.insert %[[OUT1_F64]], %[[VAL_14]] [1] : f64 into vector<2xf64>
%double_result = math.erf %double : vector<2xf64>
// CHECK: return %[[VAL_11]], %[[VAL_17]] : vector<2xf32>, vector<2xf64>
return %float_result, %double_result : vector<2xf32>, vector<2xf64>
}
// CHECK-LABEL: func @expm1_caller // CHECK-LABEL: func @expm1_caller
// CHECK-SAME: %[[FLOAT:.*]]: f32 // CHECK-SAME: %[[FLOAT:.*]]: f32
// CHECK-SAME: %[[DOUBLE:.*]]: f64 // CHECK-SAME: %[[DOUBLE:.*]]: f64
func.func @expm1_caller(%float: f32, %double: f64) -> (f32, f64) { func.func @expm1_caller(%float: f32, %double: f64) -> (f32, f64) {
// CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @expm1f(%[[FLOAT]]) : (f32) -> f32 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @expm1f(%[[FLOAT]]) : (f32) -> f32
%float_result = math.expm1 %float : f32 %float_result = math.expm1 %float : f32
// CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @expm1(%[[DOUBLE]]) : (f64) -> f64 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @expm1(%[[DOUBLE]]) : (f64) -> f64
%double_result = math.expm1 %double : f64 %double_result = math.expm1 %double : f64
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
func.func @sin_caller(%float: f32, %double: f64) -> (f32, f64) { func.func @sin_caller(%float: f32, %double: f64) -> (f32, f64) {
// CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @sinf(%[[FLOAT]]) : (f32) -> f32 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @sinf(%[[FLOAT]]) : (f32) -> f32
%float_result = math.sin %float : f32 %float_result = math.sin %float : f32
// CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @sin(%[[DOUBLE]]) : (f64) -> f64 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @sin(%[[DOUBLE]]) : (f64) -> f64
%double_result = math.sin %double : f64 %double_result = math.sin %double : f64
// CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]] // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
return %float_result, %double_result : f32, f64 return %float_result, %double_result : f32, f64
} }
// CHECK-LABEL: func @round_vec_caller(
// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,
// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {
func.func @round_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {
// CHECK-DAG: %[[CVF:.*]] = arith.constant dense<0.000000e+00> : vector<2xf32>
// CHECK-DAG: %[[CVD:.*]] = arith.constant dense<0.000000e+00> : vector<2xf64>
// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : vector<2xf32>
// CHECK: %[[OUT0_F32:.*]] = call @roundf(%[[IN0_F32]]) : (f32) -> f32
// CHECK: %[[VAL_8:.*]] = vector.insert %[[OUT0_F32]], %[[CVF]] [0] : f32 into vector<2xf32>
// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : vector<2xf32>
// CHECK: %[[OUT1_F32:.*]] = call @roundf(%[[IN1_F32]]) : (f32) -> f32
// CHECK: %[[VAL_11:.*]] = vector.insert %[[OUT1_F32]], %[[VAL_8]] [1] : f32 into vector<2xf32>
%float_result = math.round %float : vector<2xf32>
// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : vector<2xf64>
// CHECK: %[[OUT0_F64:.*]] = call @round(%[[IN0_F64]]) : (f64) -> f64
// CHECK: %[[VAL_14:.*]] = vector.insert %[[OUT0_F64]], %[[CVD]] [0] : f64 into vector<2xf64>
// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : vector<2xf64>
// CHECK: %[[OUT1_F64:.*]] = call @round(%[[IN1_F64]]) : (f64) -> f64
// CHECK: %[[VAL_17:.*]] = vector.insert %[[OUT1_F64]], %[[VAL_14]] [1] : f64 into vector<2xf64>
%double_result = math.round %double : vector<2xf64>
// CHECK: return %[[VAL_11]], %[[VAL_17]] : vector<2xf32>, vector<2xf64>
return %float_result, %double_result : vector<2xf32>, vector<2xf64>
}
ftynseUnsubmitted
Not Done
ReplyInline Actions

Please add a newline

ftynse: Please add a newline