This is an archive of the discontinued LLVM Phabricator instance.

Differential D121227

[mlir][spirv] Handle another form of folding comparsion into clamp
ClosedPublic

Authored by antiagainst on Mar 8 2022, 9:21 AM.

Details

Reviewers
ThomasRaoux
hanchung
mravishankar
Commits
rG55a4df9c1424: [mlir][spirv] Handle another form of folding comparsion into clamp

Diff Detail

Event Timeline

antiagainst created this revision.Mar 8 2022, 9:21 AM
Herald added a reviewer: mravishankar. · View Herald TranscriptMar 8 2022, 9:21 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: sdasgup3, wenzhicui, wrengr and 19 others. · View Herald Transcript
antiagainst requested review of this revision.Mar 8 2022, 9:21 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 8 2022, 9:21 AM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B153173: Diff 413832.Mar 8 2022, 9:21 AM
antiagainst added a parent revision: D121222: [mlir][spirv] NFC: Move GLSL canonicalization pass to Transforms/.Mar 8 2022, 9:21 AM
antiagainst updated this revision to Diff 413865.Mar 8 2022, 10:23 AM

Update

Harbormaster completed remote builds in B153195: Diff 413865.Mar 8 2022, 10:33 AM
antiagainst updated this revision to Diff 413888.Mar 8 2022, 11:25 AM

Update

Harbormaster completed remote builds in B153209: Diff 413888.Mar 8 2022, 11:44 AM
antiagainst added a child revision: D121238: [mlir][spirv] Fix spv.GLSL.{S|U}Clamp type checking.Mar 8 2022, 12:43 PM
hanchung accepted this revision.Mar 8 2022, 12:46 PM
This revision is now accepted and ready to land.Mar 8 2022, 12:46 PM
Closed by commit rG55a4df9c1424: [mlir][spirv] Handle another form of folding comparsion into clamp (authored by antiagainst). · Explain WhyMar 8 2022, 12:56 PM
This revision was automatically updated to reflect the committed changes.
antiagainst added a commit: rG55a4df9c1424: [mlir][spirv] Handle another form of folding comparsion into clamp.

Revision Contents

PathSize
mlir/
lib/
Dialect/
SPIRV/
IR/
19 lines
18 lines
test/
Dialect/
SPIRV/
Transforms/
140 lines

Diff 413918

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.td

Show All 34 Linesdef ConvertLogicalNotOfLogicalEqual : Pat<
(SPV_LogicalNotOp (SPV_LogicalEqualOp $lhs, $rhs)), (SPV_LogicalNotOp (SPV_LogicalEqualOp $lhs, $rhs)),
(SPV_LogicalNotEqualOp $lhs, $rhs)>; (SPV_LogicalNotEqualOp $lhs, $rhs)>;
def ConvertLogicalNotOfLogicalNotEqual : Pat< def ConvertLogicalNotOfLogicalNotEqual : Pat<
(SPV_LogicalNotOp (SPV_LogicalNotEqualOp $lhs, $rhs)), (SPV_LogicalNotOp (SPV_LogicalNotEqualOp $lhs, $rhs)),
(SPV_LogicalEqualOp $lhs, $rhs)>; (SPV_LogicalEqualOp $lhs, $rhs)>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Re-write spv.Select + spv.<less_than_op> to a suitable variant of // spv.Select -> spv.GLSL.*Clamp
// spv.<glsl_clamp_op>
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ValuesAreEqual : Constraint<CPred<"$0 == $1">>; def ValuesAreEqual : Constraint<CPred<"$0 == $1">>;
foreach CmpClampPair = [ foreach CmpClampPair = [
[SPV_FOrdLessThanOp, SPV_GLSLFClampOp], [SPV_FOrdLessThanOp, SPV_GLSLFClampOp],
[SPV_FOrdLessThanEqualOp, SPV_GLSLFClampOp], [SPV_FOrdLessThanEqualOp, SPV_GLSLFClampOp],
[SPV_SLessThanOp, SPV_GLSLSClampOp], [SPV_SLessThanOp, SPV_GLSLSClampOp],
[SPV_SLessThanEqualOp, SPV_GLSLSClampOp], [SPV_SLessThanEqualOp, SPV_GLSLSClampOp],
[SPV_ULessThanOp, SPV_GLSLUClampOp], [SPV_ULessThanOp, SPV_GLSLUClampOp],
[SPV_ULessThanEqualOp, SPV_GLSLUClampOp]] in { [SPV_ULessThanEqualOp, SPV_GLSLUClampOp]] in {
def ConvertComparisonIntoClamp#CmpClampPair[0] : Pat<
// Detect: $min < $input, $input < $max
def ConvertComparisonIntoClamp1_#CmpClampPair[0] : Pat<
(SPV_SelectOp (SPV_SelectOp
(CmpClampPair[0] (CmpClampPair[0]
(SPV_SelectOp:$middle0 (SPV_SelectOp:$middle0
(CmpClampPair[0] $min, $input), (CmpClampPair[0] $min, $input),
$input, $input,
$min $min
), ),
$max $max
), ),
$middle1, $middle1,
$max), $max),
(CmpClampPair[1] $input, $min, $max), (CmpClampPair[1] $input, $min, $max),
[(ValuesAreEqual $middle0, $middle1)]>; [(ValuesAreEqual $middle0, $middle1)]>;
// Detect: $input < $min, $max < $input
def ConvertComparisonIntoClamp2_#CmpClampPair[0] : Pat<
(SPV_SelectOp
(CmpClampPair[0] $max, $input),
$max,
(SPV_SelectOp
(CmpClampPair[0] $input, $min),
$min,
$input
)),
(CmpClampPair[1] $input, $min, $max)>;
} }

mlir/lib/Dialect/SPIRV/IR/SPIRVGLSLCanonicalization.cpp

Show All 17 Lines
namespace { namespace {
#include "SPIRVCanonicalization.inc" #include "SPIRVCanonicalization.inc"
} // namespace } // namespace
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
void populateSPIRVGLSLCanonicalizationPatterns(RewritePatternSet &results) { void populateSPIRVGLSLCanonicalizationPatterns(RewritePatternSet &results) {
results.add<ConvertComparisonIntoClampSPV_FOrdLessThanOp, results.add<ConvertComparisonIntoClamp1_SPV_FOrdLessThanOp,
ConvertComparisonIntoClampSPV_FOrdLessThanEqualOp, ConvertComparisonIntoClamp1_SPV_FOrdLessThanEqualOp,
ConvertComparisonIntoClampSPV_SLessThanOp, ConvertComparisonIntoClamp1_SPV_SLessThanOp,
ConvertComparisonIntoClampSPV_SLessThanEqualOp, ConvertComparisonIntoClamp1_SPV_SLessThanEqualOp,
ConvertComparisonIntoClampSPV_ULessThanOp, ConvertComparisonIntoClamp1_SPV_ULessThanOp,
ConvertComparisonIntoClampSPV_ULessThanEqualOp>( ConvertComparisonIntoClamp1_SPV_ULessThanEqualOp,
ConvertComparisonIntoClamp2_SPV_FOrdLessThanOp,
ConvertComparisonIntoClamp2_SPV_FOrdLessThanEqualOp,
ConvertComparisonIntoClamp2_SPV_SLessThanOp,
ConvertComparisonIntoClamp2_SPV_SLessThanEqualOp,
ConvertComparisonIntoClamp2_SPV_ULessThanOp,
ConvertComparisonIntoClamp2_SPV_ULessThanEqualOp>(
results.getContext()); results.getContext());
} }
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir

mlir/test/Dialect/SPIRV/Transforms/glsl-canonicalize.mlir

// RUN: mlir-opt -split-input-file -spirv-canonicalize-glsl %s | FileCheck %s // RUN: mlir-opt -split-input-file -spirv-canonicalize-glsl %s | FileCheck %s
// CHECK: func @clamp_fordlessthan(%[[INPUT:.*]]: f32) // CHECK-LABEL: func @clamp_fordlessthan
func @clamp_fordlessthan(%input: f32) -> f32 { // CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_fordlessthan(%input: f32, %min: f32, %max: f32) -> f32 {
%min = spv.Constant 0.5 : f32
// CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.Constant 1.0 : f32
// CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.FOrdLessThan %min, %input : f32 %0 = spv.FOrdLessThan %min, %input : f32
%mid = spv.Select %0, %input, %min : i1, f32 %mid = spv.Select %0, %input, %min : i1, f32
%1 = spv.FOrdLessThan %mid, %max : f32 %1 = spv.FOrdLessThan %mid, %max : f32
%2 = spv.Select %1, %mid, %max : i1, f32 %2 = spv.Select %1, %mid, %max : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
// ----- // -----
// CHECK: func @clamp_fordlessthanequal(%[[INPUT:.*]]: f32) // CHECK-LABEL: func @clamp_fordlessthan
func @clamp_fordlessthanequal(%input: f32) -> f32 { // CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_fordlessthan(%input: f32, %min: f32, %max: f32) -> f32 {
%min = spv.Constant 0.5 : f32 // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
// CHECK: %[[MAX:.*]] = spv.Constant %0 = spv.FOrdLessThan %input, %min : f32
%max = spv.Constant 1.0 : f32 %mid = spv.Select %0, %min, %input : i1, f32
%1 = spv.FOrdLessThan %max, %input : f32
%2 = spv.Select %1, %max, %mid : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32
}
// -----
// CHECK-LABEL: func @clamp_fordlessthanequal
// CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
func @clamp_fordlessthanequal(%input: f32, %min: f32, %max: f32) -> f32 {
// CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.FOrdLessThanEqual %min, %input : f32 %0 = spv.FOrdLessThanEqual %min, %input : f32
%mid = spv.Select %0, %input, %min : i1, f32 %mid = spv.Select %0, %input, %min : i1, f32
%1 = spv.FOrdLessThanEqual %mid, %max : f32 %1 = spv.FOrdLessThanEqual %mid, %max : f32
%2 = spv.Select %1, %mid, %max : i1, f32 %2 = spv.Select %1, %mid, %max : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
// ----- // -----
// CHECK: func @clamp_slessthan(%[[INPUT:.*]]: si32) // CHECK-LABEL: func @clamp_fordlessthanequal
func @clamp_slessthan(%input: si32) -> si32 { // CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_fordlessthanequal(%input: f32, %min: f32, %max: f32) -> f32 {
%min = spv.Constant 0 : si32 // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
// CHECK: %[[MAX:.*]] = spv.Constant %0 = spv.FOrdLessThanEqual %input, %min : f32
%max = spv.Constant 10 : si32 %mid = spv.Select %0, %min, %input : i1, f32
%1 = spv.FOrdLessThanEqual %max, %input : f32
%2 = spv.Select %1, %max, %mid : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32
}
// -----
// CHECK-LABEL: func @clamp_slessthan
// CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
func @clamp_slessthan(%input: si32, %min: si32, %max: si32) -> si32 {
// CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.SLessThan %min, %input : si32 %0 = spv.SLessThan %min, %input : si32
%mid = spv.Select %0, %input, %min : i1, si32 %mid = spv.Select %0, %input, %min : i1, si32
%1 = spv.SLessThan %mid, %max : si32 %1 = spv.SLessThan %mid, %max : si32
%2 = spv.Select %1, %mid, %max : i1, si32 %2 = spv.Select %1, %mid, %max : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32 spv.ReturnValue %2 : si32
} }
// ----- // -----
// CHECK: func @clamp_slessthanequal(%[[INPUT:.*]]: si32) // CHECK-LABEL: func @clamp_slessthan
func @clamp_slessthanequal(%input: si32) -> si32 { // CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_slessthan(%input: si32, %min: si32, %max: si32) -> si32 {
%min = spv.Constant 0 : si32 // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
// CHECK: %[[MAX:.*]] = spv.Constant %0 = spv.SLessThan %input, %min : si32
%max = spv.Constant 10 : si32 %mid = spv.Select %0, %min, %input : i1, si32
%1 = spv.SLessThan %max, %input : si32
%2 = spv.Select %1, %max, %mid : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32
}
// -----
// CHECK-LABEL: func @clamp_slessthanequal
// CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
func @clamp_slessthanequal(%input: si32, %min: si32, %max: si32) -> si32 {
// CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.SLessThanEqual %min, %input : si32 %0 = spv.SLessThanEqual %min, %input : si32
%mid = spv.Select %0, %input, %min : i1, si32 %mid = spv.Select %0, %input, %min : i1, si32
%1 = spv.SLessThanEqual %mid, %max : si32 %1 = spv.SLessThanEqual %mid, %max : si32
%2 = spv.Select %1, %mid, %max : i1, si32 %2 = spv.Select %1, %mid, %max : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32 spv.ReturnValue %2 : si32
} }
// ----- // -----
// CHECK: func @clamp_ulessthan(%[[INPUT:.*]]: i32) // CHECK-LABEL: func @clamp_slessthanequal
func @clamp_ulessthan(%input: i32) -> i32 { // CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_slessthanequal(%input: si32, %min: si32, %max: si32) -> si32 {
%min = spv.Constant 0 : i32 // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
// CHECK: %[[MAX:.*]] = spv.Constant %0 = spv.SLessThanEqual %input, %min : si32
%max = spv.Constant 10 : i32 %mid = spv.Select %0, %min, %input : i1, si32
%1 = spv.SLessThanEqual %max, %input : si32
%2 = spv.Select %1, %max, %mid : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32
}
// -----
// CHECK-LABEL: func @clamp_ulessthan
// CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
func @clamp_ulessthan(%input: i32, %min: i32, %max: i32) -> i32 {
// CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.ULessThan %min, %input : i32 %0 = spv.ULessThan %min, %input : i32
%mid = spv.Select %0, %input, %min : i1, i32 %mid = spv.Select %0, %input, %min : i1, i32
%1 = spv.ULessThan %mid, %max : i32 %1 = spv.ULessThan %mid, %max : i32
%2 = spv.Select %1, %mid, %max : i1, i32 %2 = spv.Select %1, %mid, %max : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }
// ----- // -----
// CHECK: func @clamp_ulessthanequal(%[[INPUT:.*]]: i32) // CHECK-LABEL: func @clamp_ulessthan
func @clamp_ulessthanequal(%input: i32) -> i32 { // CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
// CHECK: %[[MIN:.*]] = spv.Constant func @clamp_ulessthan(%input: i32, %min: i32, %max: i32) -> i32 {
%min = spv.Constant 0 : i32 // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
// CHECK: %[[MAX:.*]] = spv.Constant %0 = spv.ULessThan %input, %min : i32
%max = spv.Constant 10 : i32 %mid = spv.Select %0, %min, %input : i1, i32
%1 = spv.ULessThan %max, %input : i32
%2 = spv.Select %1, %max, %mid : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32
}
// -----
// CHECK-LABEL: func @clamp_ulessthanequal
// CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
func @clamp_ulessthanequal(%input: i32, %min: i32, %max: i32) -> i32 {
// CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.ULessThanEqual %min, %input : i32 %0 = spv.ULessThanEqual %min, %input : i32
%mid = spv.Select %0, %input, %min : i1, i32 %mid = spv.Select %0, %input, %min : i1, i32
%1 = spv.ULessThanEqual %mid, %max : i32 %1 = spv.ULessThanEqual %mid, %max : i32
%2 = spv.Select %1, %mid, %max : i1, i32 %2 = spv.Select %1, %mid, %max : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }
// -----
// CHECK-LABEL: func @clamp_ulessthanequal
// CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
func @clamp_ulessthanequal(%input: i32, %min: i32, %max: i32) -> i32 {
// CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.ULessThanEqual %input, %min : i32
%mid = spv.Select %0, %min, %input : i1, i32
%1 = spv.ULessThanEqual %max, %input : i32
%2 = spv.Select %1, %max, %mid : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32
}