SPIRV-Tools/test/opt/cfg_test.cpp
Steven Perron 66d88508dd
Build struct order only for the section needed when unrolling. (#4830)
We currently build the structured order for all nodes reachable from the
loop header when unrolling a loop.  However, unrolling only needs the
nodes in the loop and possibly the merge node.

To avoid needless computation, I have implemented a search that will
stop at the merge node.

Fixes #4827
2022-06-29 09:53:26 -04:00

325 lines
8.9 KiB
C++

// Copyright (c) 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "source/opt/ir_context.h"
#include "test/opt/pass_fixture.h"
#include "test/opt/pass_utils.h"
namespace spvtools {
namespace opt {
namespace {
using ::testing::ContainerEq;
using CFGTest = PassTest<::testing::Test>;
TEST_F(CFGTest, ForEachBlockInPostOrderIf) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
OpName %main "main"
%bool = OpTypeBool
%true = OpConstantTrue %bool
%void = OpTypeVoid
%4 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%5 = OpConstant %uint 5
%main = OpFunction %void None %4
%8 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %true %9 %10
%9 = OpLabel
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
CFG* cfg = context->cfg();
Module* module = context->module();
Function* function = &*module->begin();
std::vector<uint32_t> order;
cfg->ForEachBlockInPostOrder(&*function->begin(), [&order](BasicBlock* bb) {
order.push_back(bb->id());
});
std::vector<uint32_t> expected_result = {10, 9, 8};
EXPECT_THAT(order, ContainerEq(expected_result));
}
TEST_F(CFGTest, ForEachBlockInPostOrderLoop) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
OpName %main "main"
%bool = OpTypeBool
%true = OpConstantTrue %bool
%void = OpTypeVoid
%4 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%5 = OpConstant %uint 5
%main = OpFunction %void None %4
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpLoopMerge %11 %10 None
OpBranchConditional %true %11 %10
%10 = OpLabel
OpBranch %9
%11 = OpLabel
OpReturn
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
CFG* cfg = context->cfg();
Module* module = context->module();
Function* function = &*module->begin();
std::vector<uint32_t> order;
cfg->ForEachBlockInPostOrder(&*function->begin(), [&order](BasicBlock* bb) {
order.push_back(bb->id());
});
std::vector<uint32_t> expected_result1 = {10, 11, 9, 8};
std::vector<uint32_t> expected_result2 = {11, 10, 9, 8};
EXPECT_THAT(order, AnyOf(ContainerEq(expected_result1),
ContainerEq(expected_result2)));
}
TEST_F(CFGTest, ForEachBlockInReversePostOrderIf) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
OpName %main "main"
%bool = OpTypeBool
%true = OpConstantTrue %bool
%void = OpTypeVoid
%4 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%5 = OpConstant %uint 5
%main = OpFunction %void None %4
%8 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %true %9 %10
%9 = OpLabel
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
CFG* cfg = context->cfg();
Module* module = context->module();
Function* function = &*module->begin();
std::vector<uint32_t> order;
cfg->ForEachBlockInReversePostOrder(
&*function->begin(),
[&order](BasicBlock* bb) { order.push_back(bb->id()); });
std::vector<uint32_t> expected_result = {8, 9, 10};
EXPECT_THAT(order, ContainerEq(expected_result));
}
TEST_F(CFGTest, ForEachBlockInReversePostOrderLoop) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
OpName %main "main"
%bool = OpTypeBool
%true = OpConstantTrue %bool
%void = OpTypeVoid
%4 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%5 = OpConstant %uint 5
%main = OpFunction %void None %4
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpLoopMerge %11 %10 None
OpBranchConditional %true %11 %10
%10 = OpLabel
OpBranch %9
%11 = OpLabel
OpReturn
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
CFG* cfg = context->cfg();
Module* module = context->module();
Function* function = &*module->begin();
std::vector<uint32_t> order;
cfg->ForEachBlockInReversePostOrder(
&*function->begin(),
[&order](BasicBlock* bb) { order.push_back(bb->id()); });
std::vector<uint32_t> expected_result1 = {8, 9, 10, 11};
std::vector<uint32_t> expected_result2 = {8, 9, 11, 10};
EXPECT_THAT(order, AnyOf(ContainerEq(expected_result1),
ContainerEq(expected_result2)));
}
TEST_F(CFGTest, SplitLoopHeaderForSingleBlockLoop) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
%void = OpTypeVoid
%uint = OpTypeInt 32 0
%uint_0 = OpConstant %uint 0
%6 = OpTypeFunction %void
%2 = OpFunction %void None %6
%7 = OpLabel
OpBranch %8
%8 = OpLabel
%9 = OpPhi %uint %uint_0 %7 %9 %8
OpLoopMerge %10 %8 None
OpBranch %8
%10 = OpLabel
OpUnreachable
OpFunctionEnd
)";
const std::string expected_result = R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
%void = OpTypeVoid
%uint = OpTypeInt 32 0
%uint_0 = OpConstant %uint 0
%6 = OpTypeFunction %void
%2 = OpFunction %void None %6
%7 = OpLabel
OpBranch %8
%8 = OpLabel
OpBranch %11
%11 = OpLabel
%9 = OpPhi %uint %9 %11 %uint_0 %8
OpLoopMerge %10 %11 None
OpBranch %11
%10 = OpLabel
OpUnreachable
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
BasicBlock* loop_header = context->get_instr_block(8);
ASSERT_TRUE(loop_header->GetLoopMergeInst() != nullptr);
CFG* cfg = context->cfg();
cfg->SplitLoopHeader(loop_header);
std::vector<uint32_t> binary;
bool skip_nop = false;
context->module()->ToBinary(&binary, skip_nop);
std::string optimized_asm;
SpirvTools tools(SPV_ENV_UNIVERSAL_1_1);
EXPECT_TRUE(tools.Disassemble(binary, &optimized_asm,
SpirvTools::kDefaultDisassembleOption))
<< "Disassembling failed for shader\n"
<< std::endl;
EXPECT_EQ(optimized_asm, expected_result);
}
TEST_F(CFGTest, ComputeStructedOrderForLoop) {
const std::string test = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
OpName %main "main"
%bool = OpTypeBool
%true = OpConstantTrue %bool
%void = OpTypeVoid
%4 = OpTypeFunction %void
%uint = OpTypeInt 32 0
%5 = OpConstant %uint 5
%main = OpFunction %void None %4
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpLoopMerge %11 %10 None
OpBranchConditional %true %11 %10
%10 = OpLabel
OpBranch %9
%11 = OpLabel
OpBranch %12
%12 = OpLabel
OpReturn
OpFunctionEnd
)";
std::unique_ptr<IRContext> context =
BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, test,
SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
ASSERT_NE(nullptr, context);
CFG* cfg = context->cfg();
Module* module = context->module();
Function* function = &*module->begin();
std::list<BasicBlock*> order;
cfg->ComputeStructuredOrder(function, context->get_instr_block(9),
context->get_instr_block(11), &order);
// Order should contain the loop header, the continue target, and the merge
// node.
std::list<BasicBlock*> expected_result = {context->get_instr_block(9),
context->get_instr_block(10),
context->get_instr_block(11)};
EXPECT_THAT(order, ContainerEq(expected_result));
}
} // namespace
} // namespace opt
} // namespace spvtools