AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-19 03:20:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
2d9a325264
SPIRV-Tools/source/opt/optimizer.cpp

722 lines
27 KiB
C++
Raw Normal View History

Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
// Copyright (c) 2016 Google Inc.
//
// 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.
Publish the C++ interface.
2016-09-16 20:12:04 +00:00
#include "spirv-tools/optimizer.hpp"
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
#include "build_module.h"
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
#include "log.h"
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
#include "make_unique.h"
#include "pass_manager.h"
#include "passes.h"
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
#include "reduce_load_size.h"
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
#include "simplification_pass.h"
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
namespace spvtools {
struct Optimizer::PassToken::Impl {
Impl(std::unique_ptr<opt::Pass> p) : pass(std::move(p)) {}
std::unique_ptr<opt::Pass> pass; // Internal implementation pass.
};
Optimizer::PassToken::PassToken(
std::unique_ptr<Optimizer::PassToken::Impl> impl)
: impl_(std::move(impl)) {}
Add external interface for creating a pass token Currently it's impossible for external code to register a pass because the only source file that can create pass tokens is optimizer.cpp. This makes it hard to add passes that can't be upstreamed since you can't run them from the usual pass sequence without reimplementing Optimizer. This change adds a PassToken constructor that takes unique_ptr to opt::Pass; if out-of-tree code implements opt::Pass it can register a custom pass without having to add it to SPIRV-Tools source code.
2018-05-22 21:31:26 +00:00
Optimizer::PassToken::PassToken(std::unique_ptr<opt::Pass>&& pass)
: impl_(MakeUnique<Optimizer::PassToken::Impl>(std::move(pass))) {}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken::PassToken(PassToken&& that)
: impl_(std::move(that.impl_)) {}
Optimizer::PassToken& Optimizer::PassToken::operator=(PassToken&& that) {
impl_ = std::move(that.impl_);
return *this;
}
Optimizer::PassToken::~PassToken() {}
struct Optimizer::Impl {
explicit Impl(spv_target_env env) : target_env(env), pass_manager() {}
const spv_target_env target_env; // Target environment.
opt::PassManager pass_manager; // Internal implementation pass manager.
};
Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) {}
Optimizer::~Optimizer() {}
void Optimizer::SetMessageConsumer(MessageConsumer c) {
// All passes' message consumer needs to be updated.
for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); ++i) {
impl_->pass_manager.GetPass(i)->SetMessageConsumer(c);
}
impl_->pass_manager.SetMessageConsumer(std::move(c));
}
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
const MessageConsumer& Optimizer::consumer() const {
return impl_->pass_manager.consumer();
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer& Optimizer::RegisterPass(PassToken&& p) {
// Change to use the pass manager's consumer.
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
p.impl_->pass->SetMessageConsumer(consumer());
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
impl_->pass_manager.AddPass(std::move(p.impl_->pass));
return *this;
}
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// The legalization passes take a spir-v shader generated by an HLSL front-end
// and turn it into a valid vulkan spir-v shader. There are two ways in which
// the code will be invalid at the start:
//
// 1) There will be opaque objects, like images, which will be passed around
// in intermediate objects. Valid spir-v will have to replace the use of
// the opaque object with an intermediate object that is the result of the
// load of the global opaque object.
//
// 2) There will be variables that contain pointers to structured or uniform
// buffers. It be legal, the variables must be eliminated, and the
// references to the structured buffers must use the result of OpVariable
// in the Uniform storage class.
//
// Optimization in this list must accept shaders with these relaxation of the
// rules. There is not guarantee that this list of optimizations is able to
// legalize all inputs, but it is on a best effort basis.
//
// The legalization problem is essentially a very general copy propagation
// problem. The optimization we use are all used to either do copy propagation
// or enable more copy propagation.
Add RegisterLegalizationPasses() into the interface Add note to mention the use scenario. The original list came from Glslang.
2017-11-17 21:50:43 +00:00
Optimizer& Optimizer::RegisterLegalizationPasses() {
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
return
Change merge return pass to handle structured cfg. We are seeing shaders that have multiple returns in a functions. These functions must get inlined for legalization purposes; however, the inliner does not know how to inline functions that have multiple returns. The solution we will go with it to improve the merge return pass to handle structured control flow. Note that the merge return pass will assume the cfg has been cleanedup by dead branch elimination. Fixes #857.
2018-03-06 16:20:28 +00:00
// Remove unreachable block so that merge return works.
RegisterPass(CreateDeadBranchElimPass())
// Merge the returns so we can inline.
.RegisterPass(CreateMergeReturnPass())
// Make sure uses and definitions are in the same function.
.RegisterPass(CreateInlineExhaustivePass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Make private variable function scope
.RegisterPass(CreateEliminateDeadFunctionsPass())
.RegisterPass(CreatePrivateToLocalPass())
Clean up variables before sroa In some shaders there are a lot of very large and deeply nested structures. This creates a lot of work for scalar replacement. Also, since commit ca4457b we have been very aggressive as rewriting variables. This has causes a large increase in compile time in creating and then deleting the instructions. To help low the costs, I want to run a cleanup of some of the easy loads and stores to remove. This reduces the number of symbols sroa has to work on. It also reduces the amount of code the simplifier has to simplify because it was not generated by sroa. To confirm the improvement, I ran numbers on three different sets of shaders: Time to run --legalize-hlsl: Set #1: 55.89s -> 12.0s Set #2: 1m44s -> 1m40.5s Set #3: 6.8s -> 5.7s Time to run -O Set #1: 18.8s -> 10.9s Set #2: 5m44s -> 4m17s Set #3: 7.8s -> 7.8s Contributes to #1328.
2018-02-22 17:23:21 +00:00
// Propagate the value stored to the loads in very simple cases.
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Split up aggragates so they are easier to deal with.
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
.RegisterPass(CreateScalarReplacementPass(0))
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Remove loads and stores so everything is in intermediate values.
// Takes care of copy propagation of non-members.
Update legalization passes I've a few passes the legalization passes. The first is to add the more specialized load-store removal passes to help improve the compile time, as was suggested in #1118. I've also added dead branch elimination while we wait for the behaviour of dead branch elimination to be folded into CFG cleanup. I did not add CCP because it seems like most of the constant propagation what is needed is already being done by the load-store removal passes, which call `ReplaceAllUsesWith`. We can reconsider this if needed.
2018-01-03 19:03:07 +00:00
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
// Propagate constants to get as many constant conditions on branches
// as possible.
.RegisterPass(CreateCCPPass())
.RegisterPass(CreateDeadBranchElimPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Copy propagate members. Cleans up code sequences generated by
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
// scalar replacement. Also important for removing OpPhi nodes.
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
.RegisterPass(CreateSimplificationPass())
Copy propagate arrays The sprir-v generated from HLSL code contain many copyies of very large arrays. Not only are these time consumming, but they also cause problems for drivers because they require too much space. To work around this, we will implement an array copy propagation. Note that we will not implement a complete array data flow analysis in order to implement this. We will be looking for very simple cases: 1) The source must never be stored to. 2) The target must be stored to exactly once. 3) The store to the target must be a store to the entire array, and be a copy of the entire source. 4) All loads of the target must be dominated by the store. The hard part is keeping all of the types correct. We do not want to have to do too large a search to update everything, which may not be possible, do we give up if we see any instruction that might be hard to update. Also in types.h, the element decorations are not stored in an std::map. This change was done so the hashing algorithm for a Struct is consistent. With the std::unordered_map, the traversal order was non-deterministic leading to the same type getting hashed to different values. See |Struct::GetExtraHashWords|. Contributes to #1416.
2018-03-21 03:33:24 +00:00
.RegisterPass(CreateAggressiveDCEPass())
.RegisterPass(CreateCopyPropagateArraysPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// May need loop unrolling here see
// https://github.com/Microsoft/DirectXShaderCompiler/pull/930
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
// Get rid of unused code that contain traces of illegal code
// or unused references to unbound external objects
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
.RegisterPass(CreateVectorDCEPass())
Add Dead insert elmination back in.
2018-04-23 15:17:07 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
.RegisterPass(CreateReduceLoadSizePass())
Remove redundant passes from legalization passes With work that Alan has done, some passes have become redundant. ADCE now removed unused variables. Dead branch elimination removes unreachable blocks. This means we can remove CFG Cleanup and dead variable elimination.
2018-01-12 20:15:57 +00:00
.RegisterPass(CreateAggressiveDCEPass());
Add RegisterLegalizationPasses() into the interface Add note to mention the use scenario. The original list came from Glslang.
2017-11-17 21:50:43 +00:00
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Optimizer& Optimizer::RegisterPerformancePasses() {
Revert change and stop running remove duplicates. Revert "Don't merge types of resources" This reverts commit f393b0e48014867eaada2044841cd7e0140b3d0d, but leaves the tests that were added. Added new test. These test are the so that, if someone tries the same change I made, they will see the test that they need to handle. Don't run remove duplicates in -O and -Os Romve duplicates was run to help reduce compile time when looking for types in the type manager. I've run compile time test on three sets of shaders, and the compile time does not seem to change. It should be safe to remove it.
2018-06-29 14:21:56 +00:00
return RegisterPass(CreateMergeReturnPass())
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
.RegisterPass(CreateInlineExhaustivePass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add private to local to optimization and size passes. Many optimization will run on function scope symbols only. When symbols are moved from private scope to function scople, then these optimizations can do more. I believe it is a good idea to run this pass with both -O and -Os. To get the most out of it it should be run ASAP after inlining and something that remove all of the dead functions.
2018-07-04 19:26:32 +00:00
.RegisterPass(CreatePrivateToLocalPass())
Clean up variables before sroa In some shaders there are a lot of very large and deeply nested structures. This creates a lot of work for scalar replacement. Also, since commit ca4457b we have been very aggressive as rewriting variables. This has causes a large increase in compile time in creating and then deleting the instructions. To help low the costs, I want to run a cleanup of some of the easy loads and stores to remove. This reduces the number of symbols sroa has to work on. It also reduces the amount of code the simplifier has to simplify because it was not generated by sroa. To confirm the improvement, I ran numbers on three different sets of shaders: Time to run --legalize-hlsl: Set #1: 55.89s -> 12.0s Set #2: 1m44s -> 1m40.5s Set #3: 6.8s -> 5.7s Time to run -O Set #1: 18.8s -> 10.9s Set #2: 5m44s -> 4m17s Set #3: 7.8s -> 7.8s Contributes to #1328.
2018-02-22 17:23:21 +00:00
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
.RegisterPass(CreateScalarReplacementPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Do not insert Phi nodes in CCP propagator. In CCP we should not need to insert Phi nodes because CCP never looks at loads/stores. This required adjusting two tests that relied on Phi instructions being inserted. I changed the tests to have the Phi instructions pre-inserted. I also added a new test to make sure that CCP does not try to look through stores and loads. Finally, given that CCP does not handle loads/stores, it's better to run mem2reg before it. I've changed the -O/-Os schedules to run local multi-store elimination before CCP. Although this is just an efficiency fix for CCP, it is also working around a bug in Phi insertion. When Phi instructions are inserted, they are never associated a basic block. This causes a segfault when the propagator tries to lookup CFG edges when analyzing Phi instructions.
2018-01-03 17:38:21 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fix constant propagation of induction variables. This fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1143. When an instruction transitions from constant to bottom (varying) in the lattice, we were telling the propagator that the instruction was varying, but never updating the actual value in the values table. This led to incorrect value substitutions at the end of propagation. The patch also re-enables CCP in -O and -Os.
2018-01-08 16:56:57 +00:00
.RegisterPass(CreateCCPPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Reordering performance passes ordering to produce better opts * Moved initial insert/extract passes later to cover more opportunities * Added an extra set of passes to clean up opportunities exposed later in the pipeline
2018-01-31 15:40:33 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
.RegisterPass(CreateCombineAccessChainsPass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
.RegisterPass(CreateVectorDCEPass())
Add Dead insert elmination back in.
2018-04-23 15:17:07 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateDeadBranchElimPass())
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
.RegisterPass(CreateSimplificationPass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateIfConversionPass())
In copy-prop-arrays, indentify copies via OpCompositeInsert When the original code copies an entire array or struct one element at a time, this turns into a series of OpCompositeInsert instruction followed by a store of the whole array. We currently miss opportunities in copy propagate arrays because we do not recognize this as a copy. This commit adds code to copy propagate arrays to identify this code pattern. Also updates the performance passed to run array copy propagation.
2018-03-28 16:27:19 +00:00
.RegisterPass(CreateCopyPropagateArraysPass())
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
.RegisterPass(CreateReduceLoadSizePass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateBlockMergePass())
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Reordering performance passes ordering to produce better opts * Moved initial insert/extract passes later to cover more opportunities * Added an extra set of passes to clean up opportunities exposed later in the pipeline
2018-01-31 15:40:33 +00:00
.RegisterPass(CreateDeadBranchElimPass())
.RegisterPass(CreateBlockMergePass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass());
Reordering performance passes ordering to produce better opts * Moved initial insert/extract passes later to cover more opportunities * Added an extra set of passes to clean up opportunities exposed later in the pipeline
2018-01-31 15:40:33 +00:00
// Currently exposing driver bugs resulting in crashes (#946)
// .RegisterPass(CreateCommonUniformElimPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
}
Optimizer& Optimizer::RegisterSizePasses() {
Revert change and stop running remove duplicates. Revert "Don't merge types of resources" This reverts commit f393b0e48014867eaada2044841cd7e0140b3d0d, but leaves the tests that were added. Added new test. These test are the so that, if someone tries the same change I made, they will see the test that they need to handle. Don't run remove duplicates in -O and -Os Romve duplicates was run to help reduce compile time when looking for types in the type manager. I've run compile time test on three sets of shaders, and the compile time does not seem to change. It should be safe to remove it.
2018-06-29 14:21:56 +00:00
return RegisterPass(CreateMergeReturnPass())
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
.RegisterPass(CreateInlineExhaustivePass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add private to local to optimization and size passes. Many optimization will run on function scope symbols only. When symbols are moved from private scope to function scople, then these optimizations can do more. I believe it is a good idea to run this pass with both -O and -Os. To get the most out of it it should be run ASAP after inlining and something that remove all of the dead functions.
2018-07-04 19:26:32 +00:00
.RegisterPass(CreatePrivateToLocalPass())
Opt: Add ScalarReplacement to RegisterSizePasses
2018-01-31 01:13:30 +00:00
.RegisterPass(CreateScalarReplacementPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Do not insert Phi nodes in CCP propagator. In CCP we should not need to insert Phi nodes because CCP never looks at loads/stores. This required adjusting two tests that relied on Phi instructions being inserted. I changed the tests to have the Phi instructions pre-inserted. I also added a new test to make sure that CCP does not try to look through stores and loads. Finally, given that CCP does not handle loads/stores, it's better to run mem2reg before it. I've changed the -O/-Os schedules to run local multi-store elimination before CCP. Although this is just an efficiency fix for CCP, it is also working around a bug in Phi insertion. When Phi instructions are inserted, they are never associated a basic block. This causes a segfault when the propagator tries to lookup CFG edges when analyzing Phi instructions.
2018-01-03 17:38:21 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fix constant propagation of induction variables. This fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1143. When an instruction transitions from constant to bottom (varying) in the lattice, we were telling the propagator that the instruction was varying, but never updating the actual value in the values table. This led to incorrect value substitutions at the end of propagation. The patch also re-enables CCP in -O and -Os.
2018-01-08 16:56:57 +00:00
.RegisterPass(CreateCCPPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateAggressiveDCEPass())
.RegisterPass(CreateDeadBranchElimPass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateIfConversionPass())
.RegisterPass(CreateAggressiveDCEPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateBlockMergePass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
.RegisterPass(CreateCFGCleanupPass())
Opt: Remove CommonUniformElimination from -O and -Os (for now) It is causing crashes for some drivers. Will try to re-enable it once existing drivers are able to deal better with it.
2017-11-07 00:00:44 +00:00
// Currently exposing driver bugs resulting in crashes (#946)
// .RegisterPass(CreateCommonUniformElimPass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass());
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
}
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
bool Optimizer::RegisterPassesFromFlags(const std::vector<std::string>& flags) {
for (const auto& flag : flags) {
if (!RegisterPassFromFlag(flag)) {
return false;
}
}
return true;
}
namespace {
// Splits the string |flag|, of the form '--pass_name[=pass_args]' into two
// strings "pass_name" and "pass_args". If |flag| has no arguments, the second
// string will be empty.
std::pair<std::string, std::string> SplitFlagArgs(const std::string& flag) {
if (flag.size() < 2) return make_pair(flag, std::string());
// Detect the last dash before the pass name. Since we have to
// handle single dash options (-O and -Os), count up to two dashes.
size_t dash_ix = 0;
if (flag[0] == '-' && flag[1] == '-')
dash_ix = 2;
else if (flag[0] == '-')
dash_ix = 1;
size_t ix = flag.find('=');
return (ix != std::string::npos)
? make_pair(flag.substr(dash_ix, ix - 2), flag.substr(ix + 1))
: make_pair(flag.substr(dash_ix), std::string());
}
} // namespace
bool Optimizer::FlagHasValidForm(const std::string& flag) const {
if (flag == "-O" || flag == "-Os") {
return true;
} else if (flag.size() > 2 && flag.substr(0, 2) == "--") {
return true;
}
Errorf(consumer(), nullptr, {},
"%s is not a valid flag. Flag passes should have the form "
"'--pass_name[=pass_args]'. Special flag names also accepted: -O "
"and -Os.",
flag.c_str());
return false;
}
bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
if (!FlagHasValidForm(flag)) {
return false;
}
// Split flags of the form --pass_name=pass_args.
auto p = SplitFlagArgs(flag);
std::string pass_name = p.first;
std::string pass_args = p.second;
// FIXME(dnovillo): This should be re-factored so that pass names can be
// automatically checked against Pass::name() and PassToken instances created
// via a template function. Additionally, class Pass should have a desc()
// method that describes the pass (so it can be used in --help).
//
// Both Pass::name() and Pass::desc() should be static class members so they
// can be invoked without creating a pass instance.
if (pass_name == "strip-debug") {
RegisterPass(CreateStripDebugInfoPass());
} else if (pass_name == "strip-reflect") {
RegisterPass(CreateStripReflectInfoPass());
} else if (pass_name == "set-spec-const-default-value") {
if (pass_args.size() > 0) {
auto spec_ids_vals =
opt::SetSpecConstantDefaultValuePass::ParseDefaultValuesString(
pass_args.c_str());
if (!spec_ids_vals) {
Errorf(consumer(), nullptr, {},
"Invalid argument for --set-spec-const-default-value: %s",
pass_args.c_str());
return false;
}
RegisterPass(
CreateSetSpecConstantDefaultValuePass(std::move(*spec_ids_vals)));
} else {
Errorf(consumer(), nullptr, {},
"Invalid spec constant value string '%s'. Expected a string of "
"<spec id>:<default value> pairs.",
pass_args.c_str());
return false;
}
} else if (pass_name == "if-conversion") {
RegisterPass(CreateIfConversionPass());
} else if (pass_name == "freeze-spec-const") {
RegisterPass(CreateFreezeSpecConstantValuePass());
} else if (pass_name == "inline-entry-points-exhaustive") {
RegisterPass(CreateInlineExhaustivePass());
} else if (pass_name == "inline-entry-points-opaque") {
RegisterPass(CreateInlineOpaquePass());
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
} else if (pass_name == "combine-access-chains") {
RegisterPass(CreateCombineAccessChainsPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "convert-local-access-chains") {
RegisterPass(CreateLocalAccessChainConvertPass());
} else if (pass_name == "eliminate-dead-code-aggressive") {
RegisterPass(CreateAggressiveDCEPass());
} else if (pass_name == "eliminate-insert-extract") {
RegisterPass(CreateInsertExtractElimPass());
} else if (pass_name == "eliminate-local-single-block") {
RegisterPass(CreateLocalSingleBlockLoadStoreElimPass());
} else if (pass_name == "eliminate-local-single-store") {
RegisterPass(CreateLocalSingleStoreElimPass());
} else if (pass_name == "merge-blocks") {
RegisterPass(CreateBlockMergePass());
} else if (pass_name == "merge-return") {
RegisterPass(CreateMergeReturnPass());
} else if (pass_name == "eliminate-dead-branches") {
RegisterPass(CreateDeadBranchElimPass());
} else if (pass_name == "eliminate-dead-functions") {
RegisterPass(CreateEliminateDeadFunctionsPass());
} else if (pass_name == "eliminate-local-multi-store") {
RegisterPass(CreateLocalMultiStoreElimPass());
} else if (pass_name == "eliminate-common-uniform") {
RegisterPass(CreateCommonUniformElimPass());
} else if (pass_name == "eliminate-dead-const") {
RegisterPass(CreateEliminateDeadConstantPass());
} else if (pass_name == "eliminate-dead-inserts") {
RegisterPass(CreateDeadInsertElimPass());
} else if (pass_name == "eliminate-dead-variables") {
RegisterPass(CreateDeadVariableEliminationPass());
} else if (pass_name == "fold-spec-const-op-composite") {
RegisterPass(CreateFoldSpecConstantOpAndCompositePass());
} else if (pass_name == "loop-unswitch") {
RegisterPass(CreateLoopUnswitchPass());
} else if (pass_name == "scalar-replacement") {
if (pass_args.size() == 0) {
RegisterPass(CreateScalarReplacementPass());
} else {
uint32_t limit = atoi(pass_args.c_str());
if (limit > 0) {
RegisterPass(CreateScalarReplacementPass(limit));
} else {
Error(consumer(), nullptr, {},
"--scalar-replacement must have no arguments or a positive "
"integer argument");
return false;
}
}
} else if (pass_name == "strength-reduction") {
RegisterPass(CreateStrengthReductionPass());
} else if (pass_name == "unify-const") {
RegisterPass(CreateUnifyConstantPass());
} else if (pass_name == "flatten-decorations") {
RegisterPass(CreateFlattenDecorationPass());
} else if (pass_name == "compact-ids") {
RegisterPass(CreateCompactIdsPass());
} else if (pass_name == "cfg-cleanup") {
RegisterPass(CreateCFGCleanupPass());
} else if (pass_name == "local-redundancy-elimination") {
RegisterPass(CreateLocalRedundancyEliminationPass());
} else if (pass_name == "loop-invariant-code-motion") {
RegisterPass(CreateLoopInvariantCodeMotionPass());
} else if (pass_name == "reduce-load-size") {
RegisterPass(CreateReduceLoadSizePass());
} else if (pass_name == "redundancy-elimination") {
RegisterPass(CreateRedundancyEliminationPass());
} else if (pass_name == "private-to-local") {
RegisterPass(CreatePrivateToLocalPass());
} else if (pass_name == "remove-duplicates") {
RegisterPass(CreateRemoveDuplicatesPass());
} else if (pass_name == "workaround-1209") {
RegisterPass(CreateWorkaround1209Pass());
} else if (pass_name == "replace-invalid-opcode") {
RegisterPass(CreateReplaceInvalidOpcodePass());
} else if (pass_name == "simplify-instructions") {
RegisterPass(CreateSimplificationPass());
} else if (pass_name == "ssa-rewrite") {
RegisterPass(CreateSSARewritePass());
} else if (pass_name == "copy-propagate-arrays") {
RegisterPass(CreateCopyPropagateArraysPass());
} else if (pass_name == "loop-fission") {
int register_threshold_to_split =
(pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
if (register_threshold_to_split > 0) {
RegisterPass(CreateLoopFissionPass(
static_cast<size_t>(register_threshold_to_split)));
} else {
Error(consumer(), nullptr, {},
"--loop-fission must have a positive integer argument");
return false;
}
} else if (pass_name == "loop-fusion") {
int max_registers_per_loop =
(pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
if (max_registers_per_loop > 0) {
RegisterPass(
CreateLoopFusionPass(static_cast<size_t>(max_registers_per_loop)));
} else {
Error(consumer(), nullptr, {},
"--loop-fusion must be have a positive integer argument");
return false;
}
} else if (pass_name == "loop-unroll") {
RegisterPass(CreateLoopUnrollPass(true));
} else if (pass_name == "vector-dce") {
RegisterPass(CreateVectorDCEPass());
} else if (pass_name == "loop-unroll-partial") {
int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0;
if (factor != 0) {
RegisterPass(CreateLoopUnrollPass(false, factor));
} else {
Error(consumer(), nullptr, {},
"--loop-unroll-partial must have a non-0 integer argument");
return false;
}
} else if (pass_name == "loop-peeling") {
RegisterPass(CreateLoopPeelingPass());
} else if (pass_name == "ccp") {
RegisterPass(CreateCCPPass());
} else if (pass_name == "O") {
RegisterPerformancePasses();
} else if (pass_name == "Os") {
RegisterSizePasses();
} else if (pass_name == "legalize-hlsl") {
RegisterLegalizationPasses();
} else {
Errorf(consumer(), nullptr, {},
"Unknown flag '--%s'. Use --help for a list of valid flags",
pass_name.c_str());
return false;
}
return true;
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
bool Optimizer::Run(const uint32_t* original_binary,
const size_t original_binary_size,
std::vector<uint32_t>* optimized_binary) const {
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
std::unique_ptr<opt::IRContext> context = BuildModule(
impl_->target_env, consumer(), original_binary, original_binary_size);
Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction * Added an internal option to LinkerOptions to verify merged ids are unique * Added a test for the linker to verify merged ids are unique * Updated MergeReturnPass to supply a context * Updated DecorationManager to supply a context for cloned decorations * Reworked several portions of the def use tests in anticipation of next set of changes
2017-11-14 19:11:50 +00:00
if (context == nullptr) return false;
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction * Added an internal option to LinkerOptions to verify merged ids are unique * Added a test for the linker to verify merged ids are unique * Updated MergeReturnPass to supply a context * Updated DecorationManager to supply a context for cloned decorations * Reworked several portions of the def use tests in anticipation of next set of changes
2017-11-14 19:11:50 +00:00
auto status = impl_->pass_manager.Run(context.get());
Fix optimizer on when to write the binary The spvtools::Optimizer::Run method should also write the output binary if optimization succeeds without changes but the output binary vector does not have exactly the same contents as the input binary. We have to check both the base pointer of the storage and the size of the vector Added a test for this too. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/611
2017-04-02 06:17:41 +00:00
if (status == opt::Pass::Status::SuccessWithChange ||
(status == opt::Pass::Status::SuccessWithoutChange &&
(optimized_binary->data() != original_binary ||
optimized_binary->size() != original_binary_size))) {
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
optimized_binary->clear();
Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction * Added an internal option to LinkerOptions to verify merged ids are unique * Added a test for the linker to verify merged ids are unique * Updated MergeReturnPass to supply a context * Updated DecorationManager to supply a context for cloned decorations * Reworked several portions of the def use tests in anticipation of next set of changes
2017-11-14 19:11:50 +00:00
context->module()->ToBinary(optimized_binary, /* skip_nop = */ true);
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
}
return status != opt::Pass::Status::Failure;
}
Add --print-all optimizer option Adds optimizer API to write disassembly to a given output stream before each pass, and after the last pass. Adds spirv-opt --print-all option to write disassembly to stderr before each pass, and after the last pass.
2018-01-04 17:59:50 +00:00
Optimizer& Optimizer::SetPrintAll(std::ostream* out) {
impl_->pass_manager.SetPrintAll(out);
return *this;
}
Add --time-report to spirv-opt This patch adds a new option --time-report to spirv-opt. For each pass executed by spirv-opt, the flag prints resource utilization for the pass (CPU time, wall time, RSS and page faults) This fixes issue #1378
2018-03-07 14:25:51 +00:00
Optimizer& Optimizer::SetTimeReport(std::ostream* out) {
impl_->pass_manager.SetTimeReport(out);
return *this;
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateNullPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::NullPass>());
}
Optimizer::PassToken CreateStripDebugInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StripDebugInfoPass>());
}
Add --strip-reflect pass Strips reflection info. This is limited to decorations and decoration instructions related to the SPV_GOOGLE_hlsl_functionality1 extension. It will remove the OpExtension for SPV_GOOGLE_hlsl_functionality1. It will also remove the OpExtension for SPV_GOOGLE_decorate_string if there are no further remaining uses of OpDecorateStringGOOGLE. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1398
2018-03-09 21:08:57 +00:00
Optimizer::PassToken CreateStripReflectInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StripReflectInfoPass>());
}
Create the dead function elimination pass Creates a pass called eliminate dead functions that looks for functions that could never be called, and deletes them from the module. To support this change a new function was added to the Pass class to traverse the call trees from diffent starting points. Includes a test to ensure that annotations are removed when deleting a dead function. They were not, so fixed that up as well. Did some cleanup of the assembly for the test in pass_test.cpp. Trying to make them smaller and easier to read.
2017-09-19 14:12:13 +00:00
Optimizer::PassToken CreateEliminateDeadFunctionsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadFunctionsPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
const std::unordered_map<uint32_t, std::string>& id_value_map) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
}
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
const std::unordered_map<uint32_t, std::vector<uint32_t>>& id_value_map) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
}
Add FlattenDecoration transform Add --flatten-decorations to spirv-opt Flattens decoration groups. That is, replace OpDecorationGroup and its uses in OpGroupDecorate and OpGroupMemberDecorate with ordinary OpDecorate and OpMemberDecorate instructions. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/602
2017-04-01 20:10:16 +00:00
Optimizer::PassToken CreateFlattenDecorationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FlattenDecorationPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateFreezeSpecConstantValuePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FreezeSpecConstantValuePass>());
}
Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FoldSpecConstantOpAndCompositePass>());
}
Optimizer::PassToken CreateUnifyConstantPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::UnifyConstantPass>());
}
Optimizer::PassToken CreateEliminateDeadConstantPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadConstantPass>());
}
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
Optimizer::PassToken CreateDeadVariableEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadVariableElimination>());
}
Add strength reduction; for now replace multiply by power of 2 Create a new optimization pass, strength reduction, which will replace integer multiplication by a constant power of 2 with an equivalent bit shift. More changes could be added later. - Does not duplicate constants - Adds vector |Concat| utility function to a common test header.
2017-09-08 16:08:03 +00:00
Optimizer::PassToken CreateStrengthReductionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StrengthReductionPass>());
}
BlockMerge: Add BlockMergePass Also, add BasicBlock::tail()
2017-06-07 21:28:53 +00:00
Optimizer::PassToken CreateBlockMergePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::BlockMergePass>());
}
Inline: Split out InlineExhaustivePass from InlinePass
2017-08-01 23:20:13 +00:00
Optimizer::PassToken CreateInlineExhaustivePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InlineExhaustivePass>());
Add exhaustive function call inlining to spirv-opt Inlining is done for all functions designated as entry points. Add optional validation to test fixture method SinglePassRunAndCheck.
2016-11-10 17:11:50 +00:00
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Opt: Create InlineOpaquePass Only inline calls to functions with opaque params or return TODO: Handle parameter type or return type where the opqaue type is buried within an array.
2017-08-15 23:58:28 +00:00
Optimizer::PassToken CreateInlineOpaquePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InlineOpaquePass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Mem2Reg: Add Local Access Chain Convert pass - Supports OpAccessChain and OpInBoundsAccessChain - Does not process modules with non-32-bit integer types.
2017-05-12 23:27:21 +00:00
Optimizer::PassToken CreateLocalAccessChainConvertPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalAccessChainConvertPass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
mem2reg: Add pass to eliminate local loads and stores in single block.
2017-05-18 20:51:55 +00:00
Optimizer::PassToken CreateLocalSingleBlockLoadStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalSingleBlockLoadStoreElimPass>());
}
Mem2Reg: Add Local Access Chain Convert pass - Supports OpAccessChain and OpInBoundsAccessChain - Does not process modules with non-32-bit integer types.
2017-05-12 23:27:21 +00:00
mem2reg: Add LocalSingleStoreElimPass Eliminate function scope variables with one store, if possible.
2017-05-19 23:31:28 +00:00
Optimizer::PassToken CreateLocalSingleStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalSingleStoreElimPass>());
}
mem2reg: Add InsertExtractElimPass
2017-05-26 16:33:11 +00:00
Optimizer::PassToken CreateInsertExtractElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
Delete the insert-extract-elim pass. Replaces anything that creates an insert-extract-elim pass and create a simplifiation pass instead. Then delete the implementation of the pass. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-31 03:50:07 +00:00
MakeUnique<opt::SimplificationPass>());
mem2reg: Add InsertExtractElimPass
2017-05-26 16:33:11 +00:00
}
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
Optimizer::PassToken CreateDeadInsertElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadInsertElimPass>());
}
DeadBranchElim: Add DeadBranchElimPass
2017-06-02 19:23:20 +00:00
Optimizer::PassToken CreateDeadBranchElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadBranchElimPass>());
}
Add LocalMultiStoreElim pass A SSA local variable load/store elimination pass. For every entry point function, eliminate all loads and stores of function scope variables only referenced with non-access-chain loads and stores. Eliminate the variables as well. The presence of access chain references and function calls can inhibit the above optimization. Only shader modules with logical addressing are currently processed. Currently modules with any extensions enabled are not processed. This is left for future work. This pass is most effective if preceeded by Inlining and LocalAccessChainConvert. LocalSingleStoreElim and LocalSingleBlockElim will reduce the work that this pass has to do.
2017-06-16 21:37:31 +00:00
Optimizer::PassToken CreateLocalMultiStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalMultiStoreElimPass>());
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
Optimizer::PassToken CreateAggressiveDCEPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AggressiveDCEPass>());
}
Add CommonUniformElim pass - UniformElim: Only process reachable blocks - UniformElim: Don't reuse loads of samplers and images across blocks. Added a second phase which only reuses loads within a block for samplers and images. - UniformElim: Upgrade CopyObject skipping in GetPtr - UniformElim: Add extensions whitelist Currently disallowing SPV_KHR_variable_pointers because it doesn't handle extended pointer forms. - UniformElim: Do not process shaders with GroupDecorate - UniformElim: Bail on shaders with non-32-bit ints. - UniformElim: Document support for only single index and add TODO.
2017-07-03 23:23:04 +00:00
Optimizer::PassToken CreateCommonUniformElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CommonUniformElimPass>());
}
Added --compact-ids to /tools/opt The pass remaps ids to a compact set which starts with %1 and has no gaps.
2017-04-11 19:11:04 +00:00
Optimizer::PassToken CreateCompactIdsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CompactIdsPass>());
}
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
Optimizer::PassToken CreateMergeReturnPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::MergeReturnPass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
std::vector<const char*> Optimizer::GetPassNames() const {
std::vector<const char*> v;
for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); i++) {
v.push_back(impl_->pass_manager.GetPass(i)->name());
}
return v;
}
The reviewed cfg_cleanup optimize pass
2017-10-19 19:22:02 +00:00
Optimizer::PassToken CreateCFGCleanupPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CFGCleanupPass>());
}
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
Optimizer::PassToken CreateLocalRedundancyEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalRedundancyEliminationPass>());
}
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
Support loop fission. Adds support for spliting loops whose register pressure exceeds a user provided level. This pass will split a loop into two or more loops given that the loop is a top level loop and that spliting the loop is legal. Control flow is left intact for dead code elimination to remove. This pass is enabled with the --loop-fission flag to spirv-opt.
2018-04-23 20:01:12 +00:00
Optimizer::PassToken CreateLoopFissionPass(size_t threshold) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopFissionPass>(threshold));
}
Add a loop fusion pass. This pass will look for adjacent loops that are compatible and legal to be fused. Loops are compatible if: - they both have one induction variable - they have the same upper and lower bounds - same initial value - same condition - they have the same update step - they are adjacent - there are no break/continue in either of them Fusion is legal if: - fused loops do not have any dependencies with dependence distance greater than 0 that did not exist in the original loops. - there are no function calls in the loops (could have side-effects) - there are no barriers in the loops It will fuse all such loops as long as the number of registers used for the fused loop stays under the threshold defined by max_registers_per_loop.
2018-04-20 14:14:45 +00:00
Optimizer::PassToken CreateLoopFusionPass(size_t max_registers_per_loop) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopFusionPass>(max_registers_per_loop));
}
Loop invariant code motion initial implementation
2018-01-29 10:39:55 +00:00
Optimizer::PassToken CreateLoopInvariantCodeMotionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::LICMPass>());
}
Add a loop peeling pass. For each loop in a function, the pass walks the loops from inner to outer most loop and tries to peel loop for which a certain amount of iteration can be done before or after the loop. To limit code growth, peeling will not happen if the growth in code size goes above a configurable threshold.
2018-03-29 11:22:42 +00:00
Optimizer::PassToken CreateLoopPeelingPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopPeelingPass>());
}
Add loop unswitch pass. It moves all conditional branching and switch whose conditions are loop invariant and uniform. Before performing the loop unswitch we check that the loop does not contain any instruction that would prevent it (barriers, group instructions etc.).
2018-02-12 21:42:15 +00:00
Optimizer::PassToken CreateLoopUnswitchPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopUnswitchPass>());
}
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
Optimizer::PassToken CreateRedundancyEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RedundancyEliminationPass>());
}
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
Improving the usability of the type manager. The type manager hashes types. This allows the lookup of type declaration ids from arbitrarily constructed types. Users should be cautious when dealing with non-unique types (structs and potentially pointers) to get the exact id if necessary. * Changed the spec composite constant folder to handle ambiguous composites * Added functionality to create necessary instructions for a type * Added ability to remove ids from the type manager
2017-12-08 20:33:19 +00:00
Optimizer::PassToken CreateRemoveDuplicatesPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RemoveDuplicatesPass>());
}
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit) {
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
MakeUnique<opt::ScalarReplacementPass>(size_limit));
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
}
Convert private variables to function scope. When a private variable is used in a single function, it can be converted to a function scope variable in that function. This adds a pass that does that. The pass can be enabled using the option `--private-to-local`. This transformation allows other transformations to act on these variables. Also moved `FindPointerToType` from the inline class to the type manager.
2017-12-11 18:10:24 +00:00
Optimizer::PassToken CreatePrivateToLocalPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::PrivateToLocalPass>());
}
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
Optimizer::PassToken CreateCCPPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::CCPPass>());
}
Create a pass to work around a driver bug related to OpUnreachable. We have come across a driver bug where and OpUnreachable inside a loop is causing the shader to go into an infinite loop. This commit will try to avoid this bug by turning OpUnreachable instructions that are contained in a loop into branches to the loop merge block. This is not added to "-O" and "-Os" because it should only be used if the driver being targeted has this problem. Fixes #1209.
2018-01-17 19:57:37 +00:00
Optimizer::PassToken CreateWorkaround1209Pass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::Workaround1209>());
}
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
Optimizer::PassToken CreateIfConversionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::IfConversion>());
}
Add pass to reaplce invalid opcodes Creates a pass that will remove instructions that are invalid for the current shader stage. For the instruction to be considered for replacement 1) The opcode must be valid for a shader modules. 2) The opcode must be invalid for the current shader stage. 3) All entry points to the module must be for the same shader stage. 4) The function containing the instruction must be reachable from an entry point. Fixes #1247.
2018-01-30 16:24:03 +00:00
Optimizer::PassToken CreateReplaceInvalidOpcodePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ReplaceInvalidOpcodePass>());
}
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
Optimizer::PassToken CreateSimplificationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SimplificationPass>());
}
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
Unroller support for multiple induction variables Support for multiple induction variables within a loop and support for loop condition operands <= and >=.
2018-02-27 11:50:08 +00:00
Optimizer::PassToken CreateLoopUnrollPass(bool fully_unroll, int factor) {
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Unroller support for multiple induction variables Support for multiple induction variables within a loop and support for loop condition operands <= and >=.
2018-02-27 11:50:08 +00:00
MakeUnique<opt::LoopUnroller>(fully_unroll, factor));
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
}
SSA rewrite pass. This pass replaces the load/store elimination passes. It implements the SSA re-writing algorithm proposed in Simple and Efficient Construction of Static Single Assignment Form. Braun M., Buchwald S., Hack S., Leißa R., Mallon C., Zwinkau A. (2013) In: Jhala R., De Bosschere K. (eds) Compiler Construction. CC 2013. Lecture Notes in Computer Science, vol 7791. Springer, Berlin, Heidelberg https://link.springer.com/chapter/10.1007/978-3-642-37051-9_6 In contrast to common eager algorithms based on dominance and dominance frontier information, this algorithm works backwards from load operations. When a target variable is loaded, it queries the variable's reaching definition. If the reaching definition is unknown at the current location, it searches backwards in the CFG, inserting Phi instructions at join points in the CFG along the way until it finds the desired store instruction. The algorithm avoids repeated lookups using memoization. For reducible CFGs, which are a superset of the structured CFGs in SPIRV, this algorithm is proven to produce minimal SSA. That is, it inserts the minimal number of Phi instructions required to ensure the SSA property, but some Phi instructions may be dead (https://en.wikipedia.org/wiki/Static_single_assignment_form).
2018-02-22 21:18:29 +00:00
Optimizer::PassToken CreateSSARewritePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SSARewritePass>());
}
Copy propagate arrays The sprir-v generated from HLSL code contain many copyies of very large arrays. Not only are these time consumming, but they also cause problems for drivers because they require too much space. To work around this, we will implement an array copy propagation. Note that we will not implement a complete array data flow analysis in order to implement this. We will be looking for very simple cases: 1) The source must never be stored to. 2) The target must be stored to exactly once. 3) The store to the target must be a store to the entire array, and be a copy of the entire source. 4) All loads of the target must be dominated by the store. The hard part is keeping all of the types correct. We do not want to have to do too large a search to update everything, which may not be possible, do we give up if we see any instruction that might be hard to update. Also in types.h, the element decorations are not stored in an std::map. This change was done so the hashing algorithm for a Struct is consistent. With the std::unordered_map, the traversal order was non-deterministic leading to the same type getting hashed to different values. See |Struct::GetExtraHashWords|. Contributes to #1416.
2018-03-21 03:33:24 +00:00
Optimizer::PassToken CreateCopyPropagateArraysPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CopyPropagateArrays>());
}
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
Optimizer::PassToken CreateVectorDCEPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::VectorDCE>());
}
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
Optimizer::PassToken CreateReduceLoadSizePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ReduceLoadSize>());
}
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
Optimizer::PassToken CreateCombineAccessChainsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CombineAccessChains>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
} // namespace spvtools
Reference in New Issue Copy Permalink