mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-12-28 10:41:04 +00:00
2f6a87f610
* Remove Impl struct in Reducer; we can re-add it later (in a cleaner fashion) if we need to. * Add cleanup passes in Reducer; needed so that removal of constants can be disabled during the main passes, and then enabled during cleanup passes, otherwise some main passes can perform worse due to lack of available constants. * Delete passes: remove op name, remove relaxed precision. And delete associated tests. * Add more tests for remove unreferenced instructions. * Always return and write the output file, even if there was a reduction failure. * Only exit with 0 if the reduction completed or we hit the reduction step limit.
243 lines
10 KiB
C++
243 lines
10 KiB
C++
// Copyright (c) 2018 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 "source/reduce/reducer.h"
|
|
|
|
#include <cassert>
|
|
#include <sstream>
|
|
|
|
#include "source/reduce/conditional_branch_to_simple_conditional_branch_opportunity_finder.h"
|
|
#include "source/reduce/merge_blocks_reduction_opportunity_finder.h"
|
|
#include "source/reduce/operand_to_const_reduction_opportunity_finder.h"
|
|
#include "source/reduce/operand_to_dominating_id_reduction_opportunity_finder.h"
|
|
#include "source/reduce/operand_to_undef_reduction_opportunity_finder.h"
|
|
#include "source/reduce/remove_block_reduction_opportunity_finder.h"
|
|
#include "source/reduce/remove_function_reduction_opportunity_finder.h"
|
|
#include "source/reduce/remove_selection_reduction_opportunity_finder.h"
|
|
#include "source/reduce/remove_unreferenced_instruction_reduction_opportunity_finder.h"
|
|
#include "source/reduce/simple_conditional_branch_to_branch_opportunity_finder.h"
|
|
#include "source/reduce/structured_loop_to_selection_reduction_opportunity_finder.h"
|
|
#include "source/spirv_reducer_options.h"
|
|
|
|
namespace spvtools {
|
|
namespace reduce {
|
|
|
|
Reducer::Reducer(spv_target_env target_env) : target_env_(target_env) {}
|
|
|
|
Reducer::~Reducer() = default;
|
|
|
|
void Reducer::SetMessageConsumer(MessageConsumer c) {
|
|
for (auto& pass : passes_) {
|
|
pass->SetMessageConsumer(c);
|
|
}
|
|
for (auto& pass : cleanup_passes_) {
|
|
pass->SetMessageConsumer(c);
|
|
}
|
|
consumer_ = std::move(c);
|
|
}
|
|
|
|
void Reducer::SetInterestingnessFunction(
|
|
Reducer::InterestingnessFunction interestingness_function) {
|
|
interestingness_function_ = std::move(interestingness_function);
|
|
}
|
|
|
|
Reducer::ReductionResultStatus Reducer::Run(
|
|
std::vector<uint32_t>&& binary_in, std::vector<uint32_t>* binary_out,
|
|
spv_const_reducer_options options,
|
|
spv_validator_options validator_options) {
|
|
std::vector<uint32_t> current_binary(std::move(binary_in));
|
|
|
|
spvtools::SpirvTools tools(target_env_);
|
|
assert(tools.IsValid() && "Failed to create SPIRV-Tools interface");
|
|
|
|
// Keeps track of how many reduction attempts have been tried. Reduction
|
|
// bails out if this reaches a given limit.
|
|
uint32_t reductions_applied = 0;
|
|
|
|
// Initial state should be valid.
|
|
if (!tools.Validate(¤t_binary[0], current_binary.size(),
|
|
validator_options)) {
|
|
consumer_(SPV_MSG_INFO, nullptr, {},
|
|
"Initial binary is invalid; stopping.");
|
|
return Reducer::ReductionResultStatus::kInitialStateInvalid;
|
|
}
|
|
|
|
// Initial state should be interesting.
|
|
if (!interestingness_function_(current_binary, reductions_applied)) {
|
|
consumer_(SPV_MSG_INFO, nullptr, {},
|
|
"Initial state was not interesting; stopping.");
|
|
return Reducer::ReductionResultStatus::kInitialStateNotInteresting;
|
|
}
|
|
|
|
Reducer::ReductionResultStatus result =
|
|
RunPasses(&passes_, options, validator_options, tools, ¤t_binary,
|
|
&reductions_applied);
|
|
|
|
if (result == Reducer::ReductionResultStatus::kComplete) {
|
|
// Cleanup passes.
|
|
result = RunPasses(&cleanup_passes_, options, validator_options, tools,
|
|
¤t_binary, &reductions_applied);
|
|
}
|
|
|
|
if (result == Reducer::ReductionResultStatus::kComplete) {
|
|
consumer_(SPV_MSG_INFO, nullptr, {}, "No more to reduce; stopping.");
|
|
}
|
|
|
|
// Even if the reduction has failed by this point (e.g. due to producing an
|
|
// invalid binary), we still update the output binary for better debugging.
|
|
*binary_out = std::move(current_binary);
|
|
|
|
return result;
|
|
}
|
|
|
|
void Reducer::AddDefaultReductionPasses() {
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<
|
|
RemoveUnreferencedInstructionReductionOpportunityFinder>(false));
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<OperandToUndefReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<OperandToConstReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<OperandToDominatingIdReductionOpportunityFinder>());
|
|
AddReductionPass(spvtools::MakeUnique<
|
|
StructuredLoopToSelectionReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<MergeBlocksReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<RemoveFunctionReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<RemoveBlockReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<RemoveSelectionReductionOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<
|
|
ConditionalBranchToSimpleConditionalBranchOpportunityFinder>());
|
|
AddReductionPass(
|
|
spvtools::MakeUnique<SimpleConditionalBranchToBranchOpportunityFinder>());
|
|
|
|
// Cleanup passes.
|
|
|
|
AddCleanupReductionPass(
|
|
spvtools::MakeUnique<
|
|
RemoveUnreferencedInstructionReductionOpportunityFinder>(true));
|
|
}
|
|
|
|
void Reducer::AddReductionPass(
|
|
std::unique_ptr<ReductionOpportunityFinder>&& finder) {
|
|
passes_.push_back(
|
|
spvtools::MakeUnique<ReductionPass>(target_env_, std::move(finder)));
|
|
}
|
|
|
|
void Reducer::AddCleanupReductionPass(
|
|
std::unique_ptr<ReductionOpportunityFinder>&& finder) {
|
|
cleanup_passes_.push_back(
|
|
spvtools::MakeUnique<ReductionPass>(target_env_, std::move(finder)));
|
|
}
|
|
|
|
bool Reducer::ReachedStepLimit(uint32_t current_step,
|
|
spv_const_reducer_options options) {
|
|
return current_step >= options->step_limit;
|
|
}
|
|
|
|
Reducer::ReductionResultStatus Reducer::RunPasses(
|
|
std::vector<std::unique_ptr<ReductionPass>>* passes,
|
|
spv_const_reducer_options options, spv_validator_options validator_options,
|
|
const SpirvTools& tools, std::vector<uint32_t>* current_binary,
|
|
uint32_t* const reductions_applied) {
|
|
// Determines whether, on completing one round of reduction passes, it is
|
|
// worthwhile trying a further round.
|
|
bool another_round_worthwhile = true;
|
|
|
|
// Apply round after round of reduction passes until we hit the reduction
|
|
// step limit, or deem that another round is not going to be worthwhile.
|
|
while (!ReachedStepLimit(*reductions_applied, options) &&
|
|
another_round_worthwhile) {
|
|
// At the start of a round of reduction passes, assume another round will
|
|
// not be worthwhile unless we find evidence to the contrary.
|
|
another_round_worthwhile = false;
|
|
|
|
// Iterate through the available passes.
|
|
for (auto& pass : *passes) {
|
|
// If this pass hasn't reached its minimum granularity then it's
|
|
// worth eventually doing another round of reductions, in order to
|
|
// try this pass at a finer granularity.
|
|
another_round_worthwhile |= !pass->ReachedMinimumGranularity();
|
|
|
|
// Keep applying this pass at its current granularity until it stops
|
|
// working or we hit the reduction step limit.
|
|
consumer_(SPV_MSG_INFO, nullptr, {},
|
|
("Trying pass " + pass->GetName() + ".").c_str());
|
|
do {
|
|
auto maybe_result = pass->TryApplyReduction(*current_binary);
|
|
if (maybe_result.empty()) {
|
|
// For this round, the pass has no more opportunities (chunks) to
|
|
// apply, so move on to the next pass.
|
|
consumer_(
|
|
SPV_MSG_INFO, nullptr, {},
|
|
("Pass " + pass->GetName() + " did not make a reduction step.")
|
|
.c_str());
|
|
break;
|
|
}
|
|
bool interesting = false;
|
|
std::stringstream stringstream;
|
|
(*reductions_applied)++;
|
|
stringstream << "Pass " << pass->GetName() << " made reduction step "
|
|
<< *reductions_applied << ".";
|
|
consumer_(SPV_MSG_INFO, nullptr, {}, (stringstream.str().c_str()));
|
|
if (!tools.Validate(&maybe_result[0], maybe_result.size(),
|
|
validator_options)) {
|
|
// The reduction step went wrong and an invalid binary was produced.
|
|
// By design, this shouldn't happen; this is a safeguard to stop an
|
|
// invalid binary from being regarded as interesting.
|
|
consumer_(SPV_MSG_INFO, nullptr, {},
|
|
"Reduction step produced an invalid binary.");
|
|
if (options->fail_on_validation_error) {
|
|
// In this mode, we fail, so we update the current binary so it is
|
|
// output for debugging.
|
|
*current_binary = std::move(maybe_result);
|
|
return Reducer::ReductionResultStatus::kStateInvalid;
|
|
}
|
|
} else if (interestingness_function_(maybe_result,
|
|
*reductions_applied)) {
|
|
// Success! The binary produced by this reduction step is
|
|
// interesting, so make it the binary of interest henceforth, and
|
|
// note that it's worth doing another round of reduction passes.
|
|
consumer_(SPV_MSG_INFO, nullptr, {}, "Reduction step succeeded.");
|
|
*current_binary = std::move(maybe_result);
|
|
interesting = true;
|
|
another_round_worthwhile = true;
|
|
}
|
|
// We must call this before the next call to TryApplyReduction.
|
|
pass->NotifyInteresting(interesting);
|
|
// Bail out if the reduction step limit has been reached.
|
|
} while (!ReachedStepLimit(*reductions_applied, options));
|
|
}
|
|
}
|
|
|
|
// Report whether reduction completed, or bailed out early due to reaching
|
|
// the step limit.
|
|
if (ReachedStepLimit(*reductions_applied, options)) {
|
|
consumer_(SPV_MSG_INFO, nullptr, {},
|
|
"Reached reduction step limit; stopping.");
|
|
return Reducer::ReductionResultStatus::kReachedStepLimit;
|
|
}
|
|
|
|
// The passes completed successfully, although we may still run more passes.
|
|
return Reducer::ReductionResultStatus::kComplete;
|
|
}
|
|
|
|
} // namespace reduce
|
|
} // namespace spvtools
|