Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
//===-- MachineBlockPlacement.cpp - Basic Block Code Layout optimization --===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
// This file implements basic block placement transformations using the CFG
|
|
|
|
// structure and branch probability estimates.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
//
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
// The pass strives to preserve the structure of the CFG (that is, retain
|
2012-06-02 18:20:22 +08:00
|
|
|
// a topological ordering of basic blocks) in the absence of a *strong* signal
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
// to the contrary from probabilities. However, within the CFG structure, it
|
|
|
|
// attempts to choose an ordering which favors placing more likely sequences of
|
|
|
|
// blocks adjacent to each other.
|
|
|
|
//
|
|
|
|
// The algorithm works from the inner-most loop within a function outward, and
|
|
|
|
// at each stage walks through the basic blocks, trying to coalesce them into
|
|
|
|
// sequential chains where allowed by the CFG (or demanded by heavy
|
|
|
|
// probabilities). Finally, it walks the blocks in topological order, and the
|
|
|
|
// first time it reaches a chain of basic blocks, it schedules them in the
|
|
|
|
// function in-order.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
2011-10-21 16:57:37 +08:00
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
|
2015-03-04 19:05:34 +08:00
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
2011-10-21 16:57:37 +08:00
|
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
#include "llvm/Support/Allocator.h"
|
2013-04-12 08:48:32 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2015-03-24 03:32:43 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
2011-10-21 16:57:37 +08:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2014-08-05 05:25:23 +08:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
#include <algorithm>
|
|
|
|
using namespace llvm;
|
|
|
|
|
2015-03-05 10:28:25 +08:00
|
|
|
#define DEBUG_TYPE "block-placement"
|
2014-04-22 10:02:50 +08:00
|
|
|
|
2011-11-02 15:17:12 +08:00
|
|
|
STATISTIC(NumCondBranches, "Number of conditional branches");
|
2015-09-16 11:52:32 +08:00
|
|
|
STATISTIC(NumUncondBranches, "Number of unconditional branches");
|
2011-11-02 15:17:12 +08:00
|
|
|
STATISTIC(CondBranchTakenFreq,
|
|
|
|
"Potential frequency of taking conditional branches");
|
|
|
|
STATISTIC(UncondBranchTakenFreq,
|
|
|
|
"Potential frequency of taking unconditional branches");
|
|
|
|
|
2013-04-12 08:48:32 +08:00
|
|
|
static cl::opt<unsigned> AlignAllBlock("align-all-blocks",
|
|
|
|
cl::desc("Force the alignment of all "
|
|
|
|
"blocks in the function."),
|
|
|
|
cl::init(0), cl::Hidden);
|
|
|
|
|
2016-01-22 01:25:52 +08:00
|
|
|
static cl::opt<unsigned> AlignAllNonFallThruBlocks(
|
|
|
|
"align-all-nofallthru-blocks",
|
|
|
|
cl::desc("Force the alignment of all "
|
|
|
|
"blocks that have no fall-through predecessors (i.e. don't add "
|
|
|
|
"nops that are executed)."),
|
|
|
|
cl::init(0), cl::Hidden);
|
|
|
|
|
2013-11-21 03:08:44 +08:00
|
|
|
// FIXME: Find a good default for this flag and remove the flag.
|
2015-03-05 10:35:31 +08:00
|
|
|
static cl::opt<unsigned> ExitBlockBias(
|
|
|
|
"block-placement-exit-block-bias",
|
|
|
|
cl::desc("Block frequency percentage a loop exit block needs "
|
|
|
|
"over the original exit to be considered the new exit."),
|
|
|
|
cl::init(0), cl::Hidden);
|
2013-11-21 03:08:44 +08:00
|
|
|
|
2015-03-04 19:05:34 +08:00
|
|
|
static cl::opt<bool> OutlineOptionalBranches(
|
|
|
|
"outline-optional-branches",
|
|
|
|
cl::desc("Put completely optional branches, i.e. branches with a common "
|
|
|
|
"post dominator, out of line."),
|
|
|
|
cl::init(false), cl::Hidden);
|
|
|
|
|
2015-03-20 18:00:37 +08:00
|
|
|
static cl::opt<unsigned> OutlineOptionalThreshold(
|
|
|
|
"outline-optional-threshold",
|
|
|
|
cl::desc("Don't outline optional branches that are a single block with an "
|
|
|
|
"instruction count below this threshold"),
|
|
|
|
cl::init(4), cl::Hidden);
|
|
|
|
|
In MachineBlockPlacement, filter cold blocks off the loop chain when profile data is available.
In the current BB placement algorithm, a loop chain always contains all loop blocks. This has a drawback that cold blocks in the loop may be inserted on a hot function path, hence increasing branch cost and also reducing icache locality.
Consider a simple example shown below:
A
|
B⇆C
|
D
When B->C is quite cold, the best BB-layout should be A,B,D,C. But the current implementation produces A,C,B,D.
This patch filters those cold blocks off from the loop chain by comparing the ratio:
LoopBBFreq / LoopFreq
to 20%: if it is less than 20%, we don't include this BB to the loop chain. Here LoopFreq is the frequency of the loop when we reduce the loop into a single node. In general we have more cold blocks when the loop has few iterations. And vice versa.
Differential revision: http://reviews.llvm.org/D11662
llvm-svn: 251833
2015-11-03 05:24:00 +08:00
|
|
|
static cl::opt<unsigned> LoopToColdBlockRatio(
|
|
|
|
"loop-to-cold-block-ratio",
|
|
|
|
cl::desc("Outline loop blocks from loop chain if (frequency of loop) / "
|
|
|
|
"(frequency of block) is greater than this ratio"),
|
|
|
|
cl::init(5), cl::Hidden);
|
|
|
|
|
2015-10-20 07:16:40 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
PreciseRotationCost("precise-rotation-cost",
|
|
|
|
cl::desc("Model the cost of loop rotation more "
|
|
|
|
"precisely by using profile data."),
|
|
|
|
cl::init(false), cl::Hidden);
|
|
|
|
|
|
|
|
static cl::opt<unsigned> MisfetchCost(
|
|
|
|
"misfetch-cost",
|
|
|
|
cl::desc("Cost that models the probablistic risk of an instruction "
|
|
|
|
"misfetch due to a jump comparing to falling through, whose cost "
|
|
|
|
"is zero."),
|
|
|
|
cl::init(1), cl::Hidden);
|
|
|
|
|
|
|
|
static cl::opt<unsigned> JumpInstCost("jump-inst-cost",
|
|
|
|
cl::desc("Cost of jump instructions."),
|
|
|
|
cl::init(1), cl::Hidden);
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
namespace {
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
class BlockChain;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
/// \brief Type for our function-wide basic block -> block chain mapping.
|
|
|
|
typedef DenseMap<MachineBasicBlock *, BlockChain *> BlockToChainMapType;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// \brief A chain of blocks which will be laid out contiguously.
|
|
|
|
///
|
|
|
|
/// This is the datastructure representing a chain of consecutive blocks that
|
|
|
|
/// are profitable to layout together in order to maximize fallthrough
|
2012-06-26 13:16:37 +08:00
|
|
|
/// probabilities and code locality. We also can use a block chain to represent
|
|
|
|
/// a sequence of basic blocks which have some external (correctness)
|
|
|
|
/// requirement for sequential layout.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
///
|
2012-06-26 13:16:37 +08:00
|
|
|
/// Chains can be built around a single basic block and can be merged to grow
|
|
|
|
/// them. They participate in a block-to-chain mapping, which is updated
|
|
|
|
/// automatically as chains are merged together.
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
class BlockChain {
|
|
|
|
/// \brief The sequence of blocks belonging to this chain.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
///
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
/// This is the sequence of blocks for a particular chain. These will be laid
|
|
|
|
/// out in-order within the function.
|
|
|
|
SmallVector<MachineBasicBlock *, 4> Blocks;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
|
|
|
/// \brief A handle to the function-wide basic block to block chain mapping.
|
|
|
|
///
|
|
|
|
/// This is retained in each block chain to simplify the computation of child
|
|
|
|
/// block chains for SCC-formation and iteration. We store the edges to child
|
|
|
|
/// basic blocks, and map them back to their associated chains using this
|
|
|
|
/// structure.
|
|
|
|
BlockToChainMapType &BlockToChain;
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
public:
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
/// \brief Construct a new BlockChain.
|
|
|
|
///
|
|
|
|
/// This builds a new block chain representing a single basic block in the
|
|
|
|
/// function. It also registers itself as the chain that block participates
|
|
|
|
/// in with the BlockToChain mapping.
|
|
|
|
BlockChain(BlockToChainMapType &BlockToChain, MachineBasicBlock *BB)
|
2015-03-05 10:35:31 +08:00
|
|
|
: Blocks(1, BB), BlockToChain(BlockToChain), LoopPredecessors(0) {
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
assert(BB && "Cannot create a chain with a null basic block");
|
|
|
|
BlockToChain[BB] = this;
|
|
|
|
}
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
/// \brief Iterator over blocks within the chain.
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
typedef SmallVectorImpl<MachineBasicBlock *>::iterator iterator;
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
|
|
|
/// \brief Beginning of blocks within the chain.
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
iterator begin() { return Blocks.begin(); }
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
|
|
|
/// \brief End of blocks within the chain.
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
iterator end() { return Blocks.end(); }
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
|
|
|
/// \brief Merge a block chain into this one.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
///
|
|
|
|
/// This routine merges a block chain into this one. It takes care of forming
|
|
|
|
/// a contiguous sequence of basic blocks, updating the edge list, and
|
|
|
|
/// updating the block -> chain mapping. It does not free or tear down the
|
|
|
|
/// old chain, but the old chain's block list is no longer valid.
|
2011-12-22 07:02:08 +08:00
|
|
|
void merge(MachineBasicBlock *BB, BlockChain *Chain) {
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
assert(BB);
|
|
|
|
assert(!Blocks.empty());
|
|
|
|
|
|
|
|
// Fast path in case we don't have a chain already.
|
|
|
|
if (!Chain) {
|
|
|
|
assert(!BlockToChain[BB]);
|
|
|
|
Blocks.push_back(BB);
|
|
|
|
BlockToChain[BB] = this;
|
|
|
|
return;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
assert(BB == *Chain->begin());
|
|
|
|
assert(Chain->begin() != Chain->end());
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
// Update the incoming blocks to point to this chain, and add them to the
|
|
|
|
// chain structure.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : *Chain) {
|
|
|
|
Blocks.push_back(ChainBB);
|
|
|
|
assert(BlockToChain[ChainBB] == Chain && "Incoming blocks not in chain");
|
|
|
|
BlockToChain[ChainBB] = this;
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2012-04-08 22:37:01 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
/// \brief Dump the blocks in this chain.
|
2014-01-04 06:53:37 +08:00
|
|
|
LLVM_DUMP_METHOD void dump() {
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *MBB : *this)
|
|
|
|
MBB->dump();
|
2012-04-08 22:37:01 +08:00
|
|
|
}
|
|
|
|
#endif // NDEBUG
|
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
/// \brief Count of predecessors within the loop currently being processed.
|
|
|
|
///
|
|
|
|
/// This count is updated at each loop we process to represent the number of
|
|
|
|
/// in-loop predecessors of this chain.
|
|
|
|
unsigned LoopPredecessors;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
class MachineBlockPlacement : public MachineFunctionPass {
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
/// \brief A typedef for a block filter set.
|
|
|
|
typedef SmallPtrSet<MachineBasicBlock *, 16> BlockFilterSet;
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
/// \brief A handle to the branch probability pass.
|
|
|
|
const MachineBranchProbabilityInfo *MBPI;
|
|
|
|
|
|
|
|
/// \brief A handle to the function-wide block frequency pass.
|
|
|
|
const MachineBlockFrequencyInfo *MBFI;
|
|
|
|
|
2011-10-21 16:57:37 +08:00
|
|
|
/// \brief A handle to the loop info.
|
|
|
|
const MachineLoopInfo *MLI;
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
/// \brief A handle to the target's instruction info.
|
|
|
|
const TargetInstrInfo *TII;
|
|
|
|
|
2011-10-21 16:57:37 +08:00
|
|
|
/// \brief A handle to the target's lowering info.
|
2013-01-12 04:05:37 +08:00
|
|
|
const TargetLoweringBase *TLI;
|
2011-10-21 16:57:37 +08:00
|
|
|
|
2015-03-04 19:05:34 +08:00
|
|
|
/// \brief A handle to the post dominator tree.
|
|
|
|
MachineDominatorTree *MDT;
|
|
|
|
|
|
|
|
/// \brief A set of blocks that are unavoidably execute, i.e. they dominate
|
2015-03-05 10:35:31 +08:00
|
|
|
/// all terminators of the MachineFunction.
|
2015-03-04 19:05:34 +08:00
|
|
|
SmallPtrSet<MachineBasicBlock *, 4> UnavoidableBlocks;
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
/// \brief Allocator and owner of BlockChain structures.
|
|
|
|
///
|
2012-06-26 13:16:37 +08:00
|
|
|
/// We build BlockChains lazily while processing the loop structure of
|
|
|
|
/// a function. To reduce malloc traffic, we allocate them using this
|
|
|
|
/// slab-like allocator, and destroy them after the pass completes. An
|
|
|
|
/// important guarantee is that this allocator produces stable pointers to
|
|
|
|
/// the chains.
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
SpecificBumpPtrAllocator<BlockChain> ChainAllocator;
|
|
|
|
|
|
|
|
/// \brief Function wide BasicBlock to BlockChain mapping.
|
|
|
|
///
|
|
|
|
/// This mapping allows efficiently moving from any given basic block to the
|
|
|
|
/// BlockChain it participates in, if any. We use it to, among other things,
|
|
|
|
/// allow implicitly defining edges between chains as the existing edges
|
|
|
|
/// between basic blocks.
|
|
|
|
DenseMap<MachineBasicBlock *, BlockChain *> BlockToChain;
|
|
|
|
|
2015-03-05 10:35:31 +08:00
|
|
|
void markChainSuccessors(BlockChain &Chain, MachineBasicBlock *LoopHeaderBB,
|
2011-11-14 08:00:35 +08:00
|
|
|
SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
|
2014-04-14 08:51:57 +08:00
|
|
|
const BlockFilterSet *BlockFilter = nullptr);
|
2011-12-22 07:02:08 +08:00
|
|
|
MachineBasicBlock *selectBestSuccessor(MachineBasicBlock *BB,
|
|
|
|
BlockChain &Chain,
|
|
|
|
const BlockFilterSet *BlockFilter);
|
2015-03-05 10:35:31 +08:00
|
|
|
MachineBasicBlock *
|
|
|
|
selectBestCandidateBlock(BlockChain &Chain,
|
|
|
|
SmallVectorImpl<MachineBasicBlock *> &WorkList,
|
|
|
|
const BlockFilterSet *BlockFilter);
|
|
|
|
MachineBasicBlock *
|
|
|
|
getFirstUnplacedBlock(MachineFunction &F, const BlockChain &PlacedChain,
|
|
|
|
MachineFunction::iterator &PrevUnplacedBlockIt,
|
|
|
|
const BlockFilterSet *BlockFilter);
|
2011-11-13 19:20:44 +08:00
|
|
|
void buildChain(MachineBasicBlock *BB, BlockChain &Chain,
|
2011-11-14 08:00:35 +08:00
|
|
|
SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
|
2014-04-14 08:51:57 +08:00
|
|
|
const BlockFilterSet *BlockFilter = nullptr);
|
2012-04-16 21:33:36 +08:00
|
|
|
MachineBasicBlock *findBestLoopTop(MachineLoop &L,
|
|
|
|
const BlockFilterSet &LoopBlockSet);
|
2015-03-05 10:35:31 +08:00
|
|
|
MachineBasicBlock *findBestLoopExit(MachineFunction &F, MachineLoop &L,
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
const BlockFilterSet &LoopBlockSet);
|
In MachineBlockPlacement, filter cold blocks off the loop chain when profile data is available.
In the current BB placement algorithm, a loop chain always contains all loop blocks. This has a drawback that cold blocks in the loop may be inserted on a hot function path, hence increasing branch cost and also reducing icache locality.
Consider a simple example shown below:
A
|
B⇆C
|
D
When B->C is quite cold, the best BB-layout should be A,B,D,C. But the current implementation produces A,C,B,D.
This patch filters those cold blocks off from the loop chain by comparing the ratio:
LoopBBFreq / LoopFreq
to 20%: if it is less than 20%, we don't include this BB to the loop chain. Here LoopFreq is the frequency of the loop when we reduce the loop into a single node. In general we have more cold blocks when the loop has few iterations. And vice versa.
Differential revision: http://reviews.llvm.org/D11662
llvm-svn: 251833
2015-11-03 05:24:00 +08:00
|
|
|
BlockFilterSet collectLoopBlockSet(MachineFunction &F, MachineLoop &L);
|
2011-12-22 07:02:08 +08:00
|
|
|
void buildLoopChains(MachineFunction &F, MachineLoop &L);
|
2012-04-16 17:31:23 +08:00
|
|
|
void rotateLoop(BlockChain &LoopChain, MachineBasicBlock *ExitingBB,
|
|
|
|
const BlockFilterSet &LoopBlockSet);
|
2015-10-20 07:16:40 +08:00
|
|
|
void rotateLoopWithProfile(BlockChain &LoopChain, MachineLoop &L,
|
|
|
|
const BlockFilterSet &LoopBlockSet);
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
void buildCFGChains(MachineFunction &F);
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
|
|
|
public:
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
MachineBlockPlacement() : MachineFunctionPass(ID) {
|
|
|
|
initializeMachineBlockPlacementPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
bool runOnMachineFunction(MachineFunction &F) override;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
AU.addRequired<MachineBranchProbabilityInfo>();
|
|
|
|
AU.addRequired<MachineBlockFrequencyInfo>();
|
2015-03-04 19:05:34 +08:00
|
|
|
AU.addRequired<MachineDominatorTree>();
|
2011-10-21 16:57:37 +08:00
|
|
|
AU.addRequired<MachineLoopInfo>();
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
|
|
|
char MachineBlockPlacement::ID = 0;
|
2012-02-09 05:23:13 +08:00
|
|
|
char &llvm::MachineBlockPlacementID = MachineBlockPlacement::ID;
|
2015-03-05 10:28:25 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(MachineBlockPlacement, "block-placement",
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
"Branch Probability Basic Block Placement", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineBlockFrequencyInfo)
|
2015-03-04 19:05:34 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
|
2011-10-21 16:57:37 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
|
2015-03-05 10:28:25 +08:00
|
|
|
INITIALIZE_PASS_END(MachineBlockPlacement, "block-placement",
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
"Branch Probability Basic Block Placement", false, false)
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
/// \brief Helper to print the name of a MBB.
|
|
|
|
///
|
|
|
|
/// Only used by debug logging.
|
2011-12-22 07:02:08 +08:00
|
|
|
static std::string getBlockName(MachineBasicBlock *BB) {
|
2014-06-27 06:52:05 +08:00
|
|
|
std::string Result;
|
|
|
|
raw_string_ostream OS(Result);
|
2015-03-05 10:35:31 +08:00
|
|
|
OS << "BB#" << BB->getNumber();
|
2016-03-03 05:45:13 +08:00
|
|
|
OS << " ('" << BB->getName() << "')";
|
2014-06-27 06:52:05 +08:00
|
|
|
OS.flush();
|
|
|
|
return Result;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
#endif
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
2011-11-13 19:34:55 +08:00
|
|
|
/// \brief Mark a chain's successors as having one fewer preds.
|
|
|
|
///
|
|
|
|
/// When a chain is being merged into the "placed" chain, this routine will
|
|
|
|
/// quickly walk the successors of each block in the chain and mark them as
|
|
|
|
/// having one fewer active predecessor. It also adds any successors of this
|
|
|
|
/// chain which reach the zero-predecessor state to the worklist passed in.
|
2011-11-13 19:20:44 +08:00
|
|
|
void MachineBlockPlacement::markChainSuccessors(
|
2015-03-05 10:35:31 +08:00
|
|
|
BlockChain &Chain, MachineBasicBlock *LoopHeaderBB,
|
2011-11-13 19:20:44 +08:00
|
|
|
SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
|
2011-12-22 07:02:08 +08:00
|
|
|
const BlockFilterSet *BlockFilter) {
|
2011-11-13 19:20:44 +08:00
|
|
|
// Walk all the blocks in this chain, marking their successors as having
|
|
|
|
// a predecessor placed.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *MBB : Chain) {
|
2011-11-13 19:20:44 +08:00
|
|
|
// Add any successors for which this is the only un-placed in-loop
|
|
|
|
// predecessor to the worklist as a viable candidate for CFG-neutral
|
|
|
|
// placement. No subsequent placement of this block will violate the CFG
|
|
|
|
// shape, so we get to use heuristics to choose a favorable placement.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *Succ : MBB->successors()) {
|
|
|
|
if (BlockFilter && !BlockFilter->count(Succ))
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockChain &SuccChain = *BlockToChain[Succ];
|
2011-11-13 19:20:44 +08:00
|
|
|
// Disregard edges within a fixed chain, or edges to the loop header.
|
2015-03-05 11:19:05 +08:00
|
|
|
if (&Chain == &SuccChain || Succ == LoopHeaderBB)
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// This is a cross-chain edge that is within the loop, so decrement the
|
|
|
|
// loop predecessor count of the destination chain.
|
|
|
|
if (SuccChain.LoopPredecessors > 0 && --SuccChain.LoopPredecessors == 0)
|
2011-11-24 16:46:04 +08:00
|
|
|
BlockWorkList.push_back(*SuccChain.begin());
|
2011-11-13 19:20:44 +08:00
|
|
|
}
|
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
|
|
|
|
2011-11-13 19:34:53 +08:00
|
|
|
/// \brief Select the best successor for a block.
|
|
|
|
///
|
|
|
|
/// This looks across all successors of a particular block and attempts to
|
|
|
|
/// select the "best" one to be the layout successor. It only considers direct
|
|
|
|
/// successors which also pass the block filter. It will attempt to avoid
|
|
|
|
/// breaking CFG structure, but cave and break such structures in the case of
|
|
|
|
/// very hot successor edges.
|
|
|
|
///
|
|
|
|
/// \returns The best successor block found, or null if none are viable.
|
2015-03-05 10:35:31 +08:00
|
|
|
MachineBasicBlock *
|
|
|
|
MachineBlockPlacement::selectBestSuccessor(MachineBasicBlock *BB,
|
|
|
|
BlockChain &Chain,
|
|
|
|
const BlockFilterSet *BlockFilter) {
|
2011-11-13 19:34:53 +08:00
|
|
|
const BranchProbability HotProb(4, 5); // 80%
|
|
|
|
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *BestSucc = nullptr;
|
2015-12-01 13:29:22 +08:00
|
|
|
auto BestProb = BranchProbability::getZero();
|
|
|
|
|
|
|
|
// Adjust edge probabilities by excluding edges pointing to blocks that is
|
|
|
|
// either not in BlockFilter or is already in the current chain. Consider the
|
|
|
|
// following CFG:
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
//
|
|
|
|
// --->A
|
|
|
|
// | / \
|
|
|
|
// | B C
|
|
|
|
// | \ / \
|
|
|
|
// ----D E
|
|
|
|
//
|
|
|
|
// Assume A->C is very hot (>90%), and C->D has a 50% probability, then after
|
|
|
|
// A->C is chosen as a fall-through, D won't be selected as a successor of C
|
|
|
|
// due to CFG constraint (the probability of C->D is not greater than
|
|
|
|
// HotProb). If we exclude E that is not in BlockFilter when calculating the
|
|
|
|
// probability of C->D, D will be selected and we will get A C D B as the
|
|
|
|
// layout of this loop.
|
2015-12-01 13:29:22 +08:00
|
|
|
auto AdjustedSumProb = BranchProbability::getOne();
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
SmallVector<MachineBasicBlock *, 4> Successors;
|
2015-02-18 16:19:16 +08:00
|
|
|
for (MachineBasicBlock *Succ : BB->successors()) {
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
bool SkipSucc = false;
|
|
|
|
if (BlockFilter && !BlockFilter->count(Succ)) {
|
|
|
|
SkipSucc = true;
|
|
|
|
} else {
|
|
|
|
BlockChain *SuccChain = BlockToChain[Succ];
|
|
|
|
if (SuccChain == &Chain) {
|
|
|
|
SkipSucc = true;
|
|
|
|
} else if (Succ != *SuccChain->begin()) {
|
|
|
|
DEBUG(dbgs() << " " << getBlockName(Succ) << " -> Mid chain!\n");
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-19 18:26:02 +08:00
|
|
|
}
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
if (SkipSucc)
|
2015-12-01 13:29:22 +08:00
|
|
|
AdjustedSumProb -= MBPI->getEdgeProbability(BB, Succ);
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
else
|
|
|
|
Successors.push_back(Succ);
|
|
|
|
}
|
2011-11-13 19:34:53 +08:00
|
|
|
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
DEBUG(dbgs() << "Attempting merge from: " << getBlockName(BB) << "\n");
|
|
|
|
for (MachineBasicBlock *Succ : Successors) {
|
2015-12-01 13:29:22 +08:00
|
|
|
BranchProbability SuccProb;
|
|
|
|
uint32_t SuccProbN = MBPI->getEdgeProbability(BB, Succ).getNumerator();
|
|
|
|
uint32_t SuccProbD = AdjustedSumProb.getNumerator();
|
|
|
|
if (SuccProbN >= SuccProbD)
|
|
|
|
SuccProb = BranchProbability::getOne();
|
|
|
|
else
|
|
|
|
SuccProb = BranchProbability(SuccProbN, SuccProbD);
|
2011-11-13 19:34:53 +08:00
|
|
|
|
2015-03-04 19:05:34 +08:00
|
|
|
// If we outline optional branches, look whether Succ is unavoidable, i.e.
|
|
|
|
// dominates all terminators of the MachineFunction. If it does, other
|
|
|
|
// successors must be optional. Don't do this for cold branches.
|
|
|
|
if (OutlineOptionalBranches && SuccProb > HotProb.getCompl() &&
|
2015-03-20 18:00:37 +08:00
|
|
|
UnavoidableBlocks.count(Succ) > 0) {
|
|
|
|
auto HasShortOptionalBranch = [&]() {
|
|
|
|
for (MachineBasicBlock *Pred : Succ->predecessors()) {
|
|
|
|
// Check whether there is an unplaced optional branch.
|
|
|
|
if (Pred == Succ || (BlockFilter && !BlockFilter->count(Pred)) ||
|
|
|
|
BlockToChain[Pred] == &Chain)
|
|
|
|
continue;
|
|
|
|
// Check whether the optional branch has exactly one BB.
|
|
|
|
if (Pred->pred_size() > 1 || *Pred->pred_begin() != BB)
|
|
|
|
continue;
|
|
|
|
// Check whether the optional branch is small.
|
|
|
|
if (Pred->size() < OutlineOptionalThreshold)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
if (!HasShortOptionalBranch())
|
|
|
|
return Succ;
|
|
|
|
}
|
2015-03-04 19:05:34 +08:00
|
|
|
|
2011-11-13 19:34:53 +08:00
|
|
|
// Only consider successors which are either "hot", or wouldn't violate
|
|
|
|
// any CFG constraints.
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
BlockChain &SuccChain = *BlockToChain[Succ];
|
2011-11-20 19:22:06 +08:00
|
|
|
if (SuccChain.LoopPredecessors != 0) {
|
|
|
|
if (SuccProb < HotProb) {
|
2015-02-18 16:19:16 +08:00
|
|
|
DEBUG(dbgs() << " " << getBlockName(Succ) << " -> " << SuccProb
|
2013-11-25 08:43:41 +08:00
|
|
|
<< " (prob) (CFG conflict)\n");
|
2011-11-20 19:22:06 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:18:07 +08:00
|
|
|
// Make sure that a hot successor doesn't have a globally more
|
|
|
|
// important predecessor.
|
2015-12-01 13:29:22 +08:00
|
|
|
auto RealSuccProb = MBPI->getEdgeProbability(BB, Succ);
|
2015-02-18 16:18:07 +08:00
|
|
|
BlockFrequency CandidateEdgeFreq =
|
Improving edge probabilities computation when choosing the best successor in machine block placement.
When looking for the best successor from the outer loop for a block
belonging to an inner loop, the edge probability computation can be
improved so that edges in the inner loop are ignored. For example,
suppose we are building chains for the non-loop part of the following
code, and looking for B1's best successor. Assume the true body is very
hot, then B3 should be the best candidate. However, because of the
existence of the back edge from B1 to B0, the probability from B1 to B3
can be very small, preventing B3 to be its successor. In this patch, when
computing the probability of the edge from B1 to B3, the weight on the
back edge B1->B0 is ignored, so that B1->B3 will have 100% probability.
if (...)
do {
B0;
... // some branches
B1;
} while(...);
else
B2;
B3;
Differential revision: http://reviews.llvm.org/D10825
llvm-svn: 253414
2015-11-18 08:52:52 +08:00
|
|
|
MBFI->getBlockFreq(BB) * RealSuccProb * HotProb.getCompl();
|
2015-02-18 16:18:07 +08:00
|
|
|
bool BadCFGConflict = false;
|
2015-02-18 16:19:16 +08:00
|
|
|
for (MachineBasicBlock *Pred : Succ->predecessors()) {
|
2016-03-03 08:01:42 +08:00
|
|
|
if (Pred == Succ || BlockToChain[Pred] == &SuccChain ||
|
|
|
|
(BlockFilter && !BlockFilter->count(Pred)) ||
|
2015-02-18 16:19:16 +08:00
|
|
|
BlockToChain[Pred] == &Chain)
|
2011-11-20 19:22:06 +08:00
|
|
|
continue;
|
2015-02-18 16:18:07 +08:00
|
|
|
BlockFrequency PredEdgeFreq =
|
2015-02-18 16:19:16 +08:00
|
|
|
MBFI->getBlockFreq(Pred) * MBPI->getEdgeProbability(Pred, Succ);
|
2015-02-18 16:18:07 +08:00
|
|
|
if (PredEdgeFreq >= CandidateEdgeFreq) {
|
|
|
|
BadCFGConflict = true;
|
|
|
|
break;
|
2011-11-20 19:22:06 +08:00
|
|
|
}
|
|
|
|
}
|
2015-02-18 16:18:07 +08:00
|
|
|
if (BadCFGConflict) {
|
2015-02-18 16:19:16 +08:00
|
|
|
DEBUG(dbgs() << " " << getBlockName(Succ) << " -> " << SuccProb
|
2015-02-18 16:18:07 +08:00
|
|
|
<< " (prob) (non-cold CFG conflict)\n");
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-13 19:34:53 +08:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:19:16 +08:00
|
|
|
DEBUG(dbgs() << " " << getBlockName(Succ) << " -> " << SuccProb
|
2011-11-13 19:34:53 +08:00
|
|
|
<< " (prob)"
|
|
|
|
<< (SuccChain.LoopPredecessors != 0 ? " (CFG break)" : "")
|
|
|
|
<< "\n");
|
2015-12-01 13:29:22 +08:00
|
|
|
if (BestSucc && BestProb >= SuccProb)
|
2011-11-13 19:34:53 +08:00
|
|
|
continue;
|
2015-02-18 16:19:16 +08:00
|
|
|
BestSucc = Succ;
|
2015-12-01 13:29:22 +08:00
|
|
|
BestProb = SuccProb;
|
2011-11-13 19:34:53 +08:00
|
|
|
}
|
|
|
|
return BestSucc;
|
|
|
|
}
|
|
|
|
|
2011-11-13 19:42:26 +08:00
|
|
|
/// \brief Select the best block from a worklist.
|
|
|
|
///
|
|
|
|
/// This looks through the provided worklist as a list of candidate basic
|
|
|
|
/// blocks and select the most profitable one to place. The definition of
|
|
|
|
/// profitable only really makes sense in the context of a loop. This returns
|
|
|
|
/// the most frequently visited block in the worklist, which in the case of
|
|
|
|
/// a loop, is the one most desirable to be physically close to the rest of the
|
|
|
|
/// loop body in order to improve icache behavior.
|
|
|
|
///
|
|
|
|
/// \returns The best block found, or null if none are viable.
|
|
|
|
MachineBasicBlock *MachineBlockPlacement::selectBestCandidateBlock(
|
2011-12-22 07:02:08 +08:00
|
|
|
BlockChain &Chain, SmallVectorImpl<MachineBasicBlock *> &WorkList,
|
|
|
|
const BlockFilterSet *BlockFilter) {
|
2011-11-14 17:46:33 +08:00
|
|
|
// Once we need to walk the worklist looking for a candidate, cleanup the
|
|
|
|
// worklist of already placed entries.
|
|
|
|
// FIXME: If this shows up on profiles, it could be folded (at the cost of
|
|
|
|
// some code complexity) into the loop below.
|
|
|
|
WorkList.erase(std::remove_if(WorkList.begin(), WorkList.end(),
|
2014-03-01 19:47:00 +08:00
|
|
|
[&](MachineBasicBlock *BB) {
|
2015-03-05 10:35:31 +08:00
|
|
|
return BlockToChain.lookup(BB) == &Chain;
|
|
|
|
}),
|
2011-11-14 17:46:33 +08:00
|
|
|
WorkList.end());
|
|
|
|
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *BestBlock = nullptr;
|
2011-11-13 19:42:26 +08:00
|
|
|
BlockFrequency BestFreq;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *MBB : WorkList) {
|
|
|
|
BlockChain &SuccChain = *BlockToChain[MBB];
|
2016-03-03 06:40:51 +08:00
|
|
|
if (&SuccChain == &Chain)
|
2011-11-13 19:42:26 +08:00
|
|
|
continue;
|
2016-03-03 06:40:51 +08:00
|
|
|
|
2011-11-13 19:42:26 +08:00
|
|
|
assert(SuccChain.LoopPredecessors == 0 && "Found CFG-violating block");
|
|
|
|
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockFrequency CandidateFreq = MBFI->getBlockFreq(MBB);
|
|
|
|
DEBUG(dbgs() << " " << getBlockName(MBB) << " -> ";
|
2015-03-05 10:35:31 +08:00
|
|
|
MBFI->printBlockFreq(dbgs(), CandidateFreq) << " (freq)\n");
|
2011-11-13 19:42:26 +08:00
|
|
|
if (BestBlock && BestFreq >= CandidateFreq)
|
|
|
|
continue;
|
2015-03-05 11:19:05 +08:00
|
|
|
BestBlock = MBB;
|
2011-11-13 19:42:26 +08:00
|
|
|
BestFreq = CandidateFreq;
|
|
|
|
}
|
|
|
|
return BestBlock;
|
|
|
|
}
|
|
|
|
|
2011-11-14 08:00:35 +08:00
|
|
|
/// \brief Retrieve the first unplaced basic block.
|
|
|
|
///
|
|
|
|
/// This routine is called when we are unable to use the CFG to walk through
|
|
|
|
/// all of the basic blocks and form a chain due to unnatural loops in the CFG.
|
2011-11-15 14:26:43 +08:00
|
|
|
/// We walk through the function's blocks in order, starting from the
|
|
|
|
/// LastUnplacedBlockIt. We update this iterator on each call to avoid
|
|
|
|
/// re-scanning the entire sequence on repeated calls to this routine.
|
2011-11-14 08:00:35 +08:00
|
|
|
MachineBasicBlock *MachineBlockPlacement::getFirstUnplacedBlock(
|
2011-11-15 14:26:43 +08:00
|
|
|
MachineFunction &F, const BlockChain &PlacedChain,
|
|
|
|
MachineFunction::iterator &PrevUnplacedBlockIt,
|
2011-12-22 07:02:08 +08:00
|
|
|
const BlockFilterSet *BlockFilter) {
|
2011-11-15 14:26:43 +08:00
|
|
|
for (MachineFunction::iterator I = PrevUnplacedBlockIt, E = F.end(); I != E;
|
|
|
|
++I) {
|
2015-10-10 03:36:12 +08:00
|
|
|
if (BlockFilter && !BlockFilter->count(&*I))
|
2011-11-15 14:26:43 +08:00
|
|
|
continue;
|
2015-10-10 03:36:12 +08:00
|
|
|
if (BlockToChain[&*I] != &PlacedChain) {
|
2011-11-15 14:26:43 +08:00
|
|
|
PrevUnplacedBlockIt = I;
|
2011-11-23 11:03:21 +08:00
|
|
|
// Now select the head of the chain to which the unplaced block belongs
|
|
|
|
// as the block to place. This will force the entire chain to be placed,
|
|
|
|
// and satisfies the requirements of merging chains.
|
2015-10-10 03:36:12 +08:00
|
|
|
return *BlockToChain[&*I]->begin();
|
2011-11-14 08:00:35 +08:00
|
|
|
}
|
|
|
|
}
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2011-11-14 08:00:35 +08:00
|
|
|
}
|
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
void MachineBlockPlacement::buildChain(
|
2015-03-04 19:05:34 +08:00
|
|
|
MachineBasicBlock *BB, BlockChain &Chain,
|
2011-11-13 19:20:44 +08:00
|
|
|
SmallVectorImpl<MachineBasicBlock *> &BlockWorkList,
|
2011-12-22 07:02:08 +08:00
|
|
|
const BlockFilterSet *BlockFilter) {
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
assert(BB);
|
2011-12-22 07:02:08 +08:00
|
|
|
assert(BlockToChain[BB] == &Chain);
|
2011-11-15 14:26:43 +08:00
|
|
|
MachineFunction &F = *BB->getParent();
|
|
|
|
MachineFunction::iterator PrevUnplacedBlockIt = F.begin();
|
2011-11-14 08:00:35 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
MachineBasicBlock *LoopHeaderBB = BB;
|
|
|
|
markChainSuccessors(Chain, LoopHeaderBB, BlockWorkList, BlockFilter);
|
2014-03-02 20:27:27 +08:00
|
|
|
BB = *std::prev(Chain.end());
|
2011-11-13 19:20:44 +08:00
|
|
|
for (;;) {
|
|
|
|
assert(BB);
|
2011-12-22 07:02:08 +08:00
|
|
|
assert(BlockToChain[BB] == &Chain);
|
2014-03-02 20:27:27 +08:00
|
|
|
assert(*std::prev(Chain.end()) == BB);
|
2011-11-13 20:17:28 +08:00
|
|
|
|
2011-11-19 18:26:02 +08:00
|
|
|
// Look for the best viable successor if there is one to place immediately
|
|
|
|
// after this block.
|
2012-09-14 17:00:11 +08:00
|
|
|
MachineBasicBlock *BestSucc = selectBestSuccessor(BB, Chain, BlockFilter);
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
// If an immediate successor isn't available, look for the best viable
|
|
|
|
// block among those we've identified as not violating the loop's CFG at
|
|
|
|
// this point. This won't be a fallthrough, but it will increase locality.
|
2011-11-13 19:42:26 +08:00
|
|
|
if (!BestSucc)
|
|
|
|
BestSucc = selectBestCandidateBlock(Chain, BlockWorkList, BlockFilter);
|
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
if (!BestSucc) {
|
2015-03-05 10:35:31 +08:00
|
|
|
BestSucc =
|
|
|
|
getFirstUnplacedBlock(F, Chain, PrevUnplacedBlockIt, BlockFilter);
|
2011-11-14 08:00:35 +08:00
|
|
|
if (!BestSucc)
|
|
|
|
break;
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "Unnatural loop CFG detected, forcibly merging the "
|
|
|
|
"layout successor until the CFG reduces\n");
|
2011-11-13 19:20:44 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
// Place this block, updating the datastructures to reflect its placement.
|
2011-12-22 07:02:08 +08:00
|
|
|
BlockChain &SuccChain = *BlockToChain[BestSucc];
|
2011-11-14 08:00:35 +08:00
|
|
|
// Zero out LoopPredecessors for the successor we're about to merge in case
|
|
|
|
// we selected a successor that didn't fit naturally into the CFG.
|
|
|
|
SuccChain.LoopPredecessors = 0;
|
2016-03-03 05:45:13 +08:00
|
|
|
DEBUG(dbgs() << "Merging from " << getBlockName(BB) << " to "
|
|
|
|
<< getBlockName(BestSucc) << "\n");
|
2011-11-13 19:20:44 +08:00
|
|
|
markChainSuccessors(SuccChain, LoopHeaderBB, BlockWorkList, BlockFilter);
|
|
|
|
Chain.merge(BestSucc, &SuccChain);
|
2014-03-02 20:27:27 +08:00
|
|
|
BB = *std::prev(Chain.end());
|
2011-12-08 03:46:10 +08:00
|
|
|
}
|
2011-11-14 08:00:35 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << "Finished forming chain for header block "
|
2016-03-03 05:45:13 +08:00
|
|
|
<< getBlockName(*Chain.begin()) << "\n");
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
/// \brief Find the best loop top block for layout.
|
2011-11-27 08:38:03 +08:00
|
|
|
///
|
2012-04-16 21:33:36 +08:00
|
|
|
/// Look for a block which is strictly better than the loop header for laying
|
|
|
|
/// out at the top of the loop. This looks for one and only one pattern:
|
|
|
|
/// a latch block with no conditional exit. This block will cause a conditional
|
|
|
|
/// jump around it or will be the bottom of the loop if we lay it out in place,
|
|
|
|
/// but if it it doesn't end up at the bottom of the loop for any reason,
|
|
|
|
/// rotation alone won't fix it. Because such a block will always result in an
|
|
|
|
/// unconditional jump (for the backedge) rotating it in front of the loop
|
|
|
|
/// header is always profitable.
|
|
|
|
MachineBasicBlock *
|
|
|
|
MachineBlockPlacement::findBestLoopTop(MachineLoop &L,
|
|
|
|
const BlockFilterSet &LoopBlockSet) {
|
|
|
|
// Check that the header hasn't been fused with a preheader block due to
|
|
|
|
// crazy branches. If it has, we need to start with the header at the top to
|
|
|
|
// prevent pulling the preheader into the loop body.
|
|
|
|
BlockChain &HeaderChain = *BlockToChain[L.getHeader()];
|
|
|
|
if (!LoopBlockSet.count(*HeaderChain.begin()))
|
|
|
|
return L.getHeader();
|
|
|
|
|
2015-03-05 10:35:31 +08:00
|
|
|
DEBUG(dbgs() << "Finding best loop top for: " << getBlockName(L.getHeader())
|
|
|
|
<< "\n");
|
2012-04-16 21:33:36 +08:00
|
|
|
|
|
|
|
BlockFrequency BestPredFreq;
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *BestPred = nullptr;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *Pred : L.getHeader()->predecessors()) {
|
2012-04-16 21:33:36 +08:00
|
|
|
if (!LoopBlockSet.count(Pred))
|
|
|
|
continue;
|
|
|
|
DEBUG(dbgs() << " header pred: " << getBlockName(Pred) << ", "
|
2013-12-14 08:25:45 +08:00
|
|
|
<< Pred->succ_size() << " successors, ";
|
2015-03-05 10:35:31 +08:00
|
|
|
MBFI->printBlockFreq(dbgs(), Pred) << " freq\n");
|
2012-04-16 21:33:36 +08:00
|
|
|
if (Pred->succ_size() > 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
BlockFrequency PredFreq = MBFI->getBlockFreq(Pred);
|
|
|
|
if (!BestPred || PredFreq > BestPredFreq ||
|
|
|
|
(!(PredFreq < BestPredFreq) &&
|
|
|
|
Pred->isLayoutSuccessor(L.getHeader()))) {
|
|
|
|
BestPred = Pred;
|
|
|
|
BestPredFreq = PredFreq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If no direct predecessor is fine, just use the loop header.
|
2016-03-03 05:45:13 +08:00
|
|
|
if (!BestPred) {
|
|
|
|
DEBUG(dbgs() << " final top unchanged\n");
|
2012-04-16 21:33:36 +08:00
|
|
|
return L.getHeader();
|
2016-03-03 05:45:13 +08:00
|
|
|
}
|
2012-04-16 21:33:36 +08:00
|
|
|
|
|
|
|
// Walk backwards through any straight line of predecessors.
|
|
|
|
while (BestPred->pred_size() == 1 &&
|
|
|
|
(*BestPred->pred_begin())->succ_size() == 1 &&
|
|
|
|
*BestPred->pred_begin() != L.getHeader())
|
|
|
|
BestPred = *BestPred->pred_begin();
|
|
|
|
|
|
|
|
DEBUG(dbgs() << " final top: " << getBlockName(BestPred) << "\n");
|
|
|
|
return BestPred;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Find the best loop exiting block for layout.
|
|
|
|
///
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
/// This routine implements the logic to analyze the loop looking for the best
|
|
|
|
/// block to layout at the top of the loop. Typically this is done to maximize
|
|
|
|
/// fallthrough opportunities.
|
|
|
|
MachineBasicBlock *
|
2015-03-05 10:35:31 +08:00
|
|
|
MachineBlockPlacement::findBestLoopExit(MachineFunction &F, MachineLoop &L,
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
const BlockFilterSet &LoopBlockSet) {
|
2012-04-10 21:35:57 +08:00
|
|
|
// We don't want to layout the loop linearly in all cases. If the loop header
|
|
|
|
// is just a normal basic block in the loop, we want to look for what block
|
|
|
|
// within the loop is the best one to layout at the top. However, if the loop
|
|
|
|
// header has be pre-merged into a chain due to predecessors not having
|
|
|
|
// analyzable branches, *and* the predecessor it is merged with is *not* part
|
|
|
|
// of the loop, rotating the header into the middle of the loop will create
|
|
|
|
// a non-contiguous range of blocks which is Very Bad. So start with the
|
|
|
|
// header and only rotate if safe.
|
|
|
|
BlockChain &HeaderChain = *BlockToChain[L.getHeader()];
|
|
|
|
if (!LoopBlockSet.count(*HeaderChain.begin()))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2012-04-10 21:35:57 +08:00
|
|
|
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
BlockFrequency BestExitEdgeFreq;
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
unsigned BestExitLoopDepth = 0;
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *ExitingBB = nullptr;
|
2011-11-28 04:18:00 +08:00
|
|
|
// If there are exits to outer loops, loop rotation can severely limit
|
|
|
|
// fallthrough opportunites unless it selects such an exit. Keep a set of
|
|
|
|
// blocks where rotating to exit with that block will reach an outer loop.
|
|
|
|
SmallPtrSet<MachineBasicBlock *, 4> BlocksExitingToOuterLoop;
|
|
|
|
|
2015-03-05 10:35:31 +08:00
|
|
|
DEBUG(dbgs() << "Finding best loop exit for: " << getBlockName(L.getHeader())
|
|
|
|
<< "\n");
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *MBB : L.getBlocks()) {
|
|
|
|
BlockChain &Chain = *BlockToChain[MBB];
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
// Ensure that this block is at the end of a chain; otherwise it could be
|
2015-04-15 21:19:54 +08:00
|
|
|
// mid-way through an inner loop or a successor of an unanalyzable branch.
|
2015-03-05 11:19:05 +08:00
|
|
|
if (MBB != *std::prev(Chain.end()))
|
2011-11-27 08:38:03 +08:00
|
|
|
continue;
|
|
|
|
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
// Now walk the successors. We need to establish whether this has a viable
|
|
|
|
// exiting successor and whether it has a viable non-exiting successor.
|
|
|
|
// We store the old exiting state and restore it if a viable looping
|
|
|
|
// successor isn't found.
|
|
|
|
MachineBasicBlock *OldExitingBB = ExitingBB;
|
|
|
|
BlockFrequency OldBestExitEdgeFreq = BestExitEdgeFreq;
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
bool HasLoopingSucc = false;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *Succ : MBB->successors()) {
|
2015-08-28 07:27:47 +08:00
|
|
|
if (Succ->isEHPad())
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
continue;
|
2015-03-05 11:19:05 +08:00
|
|
|
if (Succ == MBB)
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
continue;
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockChain &SuccChain = *BlockToChain[Succ];
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
// Don't split chains, either this chain or the successor's chain.
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
if (&Chain == &SuccChain) {
|
2015-03-05 11:19:05 +08:00
|
|
|
DEBUG(dbgs() << " exiting: " << getBlockName(MBB) << " -> "
|
|
|
|
<< getBlockName(Succ) << " (chain conflict)\n");
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-12-01 13:29:22 +08:00
|
|
|
auto SuccProb = MBPI->getEdgeProbability(MBB, Succ);
|
2015-03-05 11:19:05 +08:00
|
|
|
if (LoopBlockSet.count(Succ)) {
|
|
|
|
DEBUG(dbgs() << " looping: " << getBlockName(MBB) << " -> "
|
2015-12-01 13:29:22 +08:00
|
|
|
<< getBlockName(Succ) << " (" << SuccProb << ")\n");
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
HasLoopingSucc = true;
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
unsigned SuccLoopDepth = 0;
|
2015-03-05 11:19:05 +08:00
|
|
|
if (MachineLoop *ExitLoop = MLI->getLoopFor(Succ)) {
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
SuccLoopDepth = ExitLoop->getLoopDepth();
|
|
|
|
if (ExitLoop->contains(&L))
|
2015-03-05 11:19:05 +08:00
|
|
|
BlocksExitingToOuterLoop.insert(MBB);
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
}
|
|
|
|
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockFrequency ExitEdgeFreq = MBFI->getBlockFreq(MBB) * SuccProb;
|
|
|
|
DEBUG(dbgs() << " exiting: " << getBlockName(MBB) << " -> "
|
|
|
|
<< getBlockName(Succ) << " [L:" << SuccLoopDepth << "] (";
|
2015-03-05 10:35:31 +08:00
|
|
|
MBFI->printBlockFreq(dbgs(), ExitEdgeFreq) << ")\n");
|
2013-11-21 03:08:44 +08:00
|
|
|
// Note that we bias this toward an existing layout successor to retain
|
|
|
|
// incoming order in the absence of better information. The exit must have
|
|
|
|
// a frequency higher than the current exit before we consider breaking
|
|
|
|
// the layout.
|
|
|
|
BranchProbability Bias(100 - ExitBlockBias, 100);
|
2015-04-15 21:39:42 +08:00
|
|
|
if (!ExitingBB || SuccLoopDepth > BestExitLoopDepth ||
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
ExitEdgeFreq > BestExitEdgeFreq ||
|
2015-03-05 11:19:05 +08:00
|
|
|
(MBB->isLayoutSuccessor(Succ) &&
|
2013-11-21 03:08:44 +08:00
|
|
|
!(ExitEdgeFreq < BestExitEdgeFreq * Bias))) {
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
BestExitEdgeFreq = ExitEdgeFreq;
|
2015-03-05 11:19:05 +08:00
|
|
|
ExitingBB = MBB;
|
2011-11-27 17:22:53 +08:00
|
|
|
}
|
2011-11-27 08:38:03 +08:00
|
|
|
}
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
if (!HasLoopingSucc) {
|
2015-04-15 21:26:41 +08:00
|
|
|
// Restore the old exiting state, no viable looping successor was found.
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
ExitingBB = OldExitingBB;
|
|
|
|
BestExitEdgeFreq = OldBestExitEdgeFreq;
|
2011-11-27 17:22:53 +08:00
|
|
|
continue;
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
}
|
2011-11-27 08:38:03 +08:00
|
|
|
}
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
// Without a candidate exiting block or with only a single block in the
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
// loop, just use the loop header to layout the loop.
|
|
|
|
if (!ExitingBB || L.getNumBlocks() == 1)
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
|
2011-11-28 04:18:00 +08:00
|
|
|
// Also, if we have exit blocks which lead to outer loops but didn't select
|
|
|
|
// one of them as the exiting block we are rotating toward, disable loop
|
|
|
|
// rotation altogether.
|
|
|
|
if (!BlocksExitingToOuterLoop.empty() &&
|
|
|
|
!BlocksExitingToOuterLoop.count(ExitingBB))
|
2014-04-14 08:51:57 +08:00
|
|
|
return nullptr;
|
2011-11-28 04:18:00 +08:00
|
|
|
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
DEBUG(dbgs() << " Best exiting block: " << getBlockName(ExitingBB) << "\n");
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
return ExitingBB;
|
2011-11-27 08:38:03 +08:00
|
|
|
}
|
|
|
|
|
2012-04-16 17:31:23 +08:00
|
|
|
/// \brief Attempt to rotate an exiting block to the bottom of the loop.
|
|
|
|
///
|
|
|
|
/// Once we have built a chain, try to rotate it to line up the hot exit block
|
|
|
|
/// with fallthrough out of the loop if doing so doesn't introduce unnecessary
|
|
|
|
/// branches. For example, if the loop has fallthrough into its header and out
|
|
|
|
/// of its bottom already, don't rotate it.
|
|
|
|
void MachineBlockPlacement::rotateLoop(BlockChain &LoopChain,
|
|
|
|
MachineBasicBlock *ExitingBB,
|
|
|
|
const BlockFilterSet &LoopBlockSet) {
|
|
|
|
if (!ExitingBB)
|
|
|
|
return;
|
|
|
|
|
|
|
|
MachineBasicBlock *Top = *LoopChain.begin();
|
|
|
|
bool ViableTopFallthrough = false;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *Pred : Top->predecessors()) {
|
|
|
|
BlockChain *PredChain = BlockToChain[Pred];
|
|
|
|
if (!LoopBlockSet.count(Pred) &&
|
|
|
|
(!PredChain || Pred == *std::prev(PredChain->end()))) {
|
2012-04-16 17:31:23 +08:00
|
|
|
ViableTopFallthrough = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the header has viable fallthrough, check whether the current loop
|
|
|
|
// bottom is a viable exiting block. If so, bail out as rotating will
|
|
|
|
// introduce an unnecessary branch.
|
|
|
|
if (ViableTopFallthrough) {
|
2014-03-02 20:27:27 +08:00
|
|
|
MachineBasicBlock *Bottom = *std::prev(LoopChain.end());
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *Succ : Bottom->successors()) {
|
|
|
|
BlockChain *SuccChain = BlockToChain[Succ];
|
|
|
|
if (!LoopBlockSet.count(Succ) &&
|
|
|
|
(!SuccChain || Succ == *SuccChain->begin()))
|
2012-04-16 17:31:23 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-05 10:35:31 +08:00
|
|
|
BlockChain::iterator ExitIt =
|
|
|
|
std::find(LoopChain.begin(), LoopChain.end(), ExitingBB);
|
2012-04-16 17:31:23 +08:00
|
|
|
if (ExitIt == LoopChain.end())
|
|
|
|
return;
|
|
|
|
|
2014-03-02 20:27:27 +08:00
|
|
|
std::rotate(LoopChain.begin(), std::next(ExitIt), LoopChain.end());
|
2012-04-16 17:31:23 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 07:16:40 +08:00
|
|
|
/// \brief Attempt to rotate a loop based on profile data to reduce branch cost.
|
|
|
|
///
|
|
|
|
/// With profile data, we can determine the cost in terms of missed fall through
|
|
|
|
/// opportunities when rotating a loop chain and select the best rotation.
|
|
|
|
/// Basically, there are three kinds of cost to consider for each rotation:
|
|
|
|
/// 1. The possibly missed fall through edge (if it exists) from BB out of
|
|
|
|
/// the loop to the loop header.
|
|
|
|
/// 2. The possibly missed fall through edges (if they exist) from the loop
|
|
|
|
/// exits to BB out of the loop.
|
|
|
|
/// 3. The missed fall through edge (if it exists) from the last BB to the
|
|
|
|
/// first BB in the loop chain.
|
|
|
|
/// Therefore, the cost for a given rotation is the sum of costs listed above.
|
|
|
|
/// We select the best rotation with the smallest cost.
|
|
|
|
void MachineBlockPlacement::rotateLoopWithProfile(
|
|
|
|
BlockChain &LoopChain, MachineLoop &L, const BlockFilterSet &LoopBlockSet) {
|
|
|
|
auto HeaderBB = L.getHeader();
|
|
|
|
auto HeaderIter = std::find(LoopChain.begin(), LoopChain.end(), HeaderBB);
|
|
|
|
auto RotationPos = LoopChain.end();
|
|
|
|
|
|
|
|
BlockFrequency SmallestRotationCost = BlockFrequency::getMaxFrequency();
|
|
|
|
|
|
|
|
// A utility lambda that scales up a block frequency by dividing it by a
|
|
|
|
// branch probability which is the reciprocal of the scale.
|
|
|
|
auto ScaleBlockFrequency = [](BlockFrequency Freq,
|
|
|
|
unsigned Scale) -> BlockFrequency {
|
|
|
|
if (Scale == 0)
|
|
|
|
return 0;
|
|
|
|
// Use operator / between BlockFrequency and BranchProbability to implement
|
|
|
|
// saturating multiplication.
|
|
|
|
return Freq / BranchProbability(1, Scale);
|
|
|
|
};
|
|
|
|
|
|
|
|
// Compute the cost of the missed fall-through edge to the loop header if the
|
|
|
|
// chain head is not the loop header. As we only consider natural loops with
|
|
|
|
// single header, this computation can be done only once.
|
|
|
|
BlockFrequency HeaderFallThroughCost(0);
|
|
|
|
for (auto *Pred : HeaderBB->predecessors()) {
|
|
|
|
BlockChain *PredChain = BlockToChain[Pred];
|
|
|
|
if (!LoopBlockSet.count(Pred) &&
|
|
|
|
(!PredChain || Pred == *std::prev(PredChain->end()))) {
|
|
|
|
auto EdgeFreq =
|
|
|
|
MBFI->getBlockFreq(Pred) * MBPI->getEdgeProbability(Pred, HeaderBB);
|
|
|
|
auto FallThruCost = ScaleBlockFrequency(EdgeFreq, MisfetchCost);
|
|
|
|
// If the predecessor has only an unconditional jump to the header, we
|
|
|
|
// need to consider the cost of this jump.
|
|
|
|
if (Pred->succ_size() == 1)
|
|
|
|
FallThruCost += ScaleBlockFrequency(EdgeFreq, JumpInstCost);
|
|
|
|
HeaderFallThroughCost = std::max(HeaderFallThroughCost, FallThruCost);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Here we collect all exit blocks in the loop, and for each exit we find out
|
|
|
|
// its hottest exit edge. For each loop rotation, we define the loop exit cost
|
|
|
|
// as the sum of frequencies of exit edges we collect here, excluding the exit
|
|
|
|
// edge from the tail of the loop chain.
|
|
|
|
SmallVector<std::pair<MachineBasicBlock *, BlockFrequency>, 4> ExitsWithFreq;
|
|
|
|
for (auto BB : LoopChain) {
|
2015-12-01 13:29:22 +08:00
|
|
|
auto LargestExitEdgeProb = BranchProbability::getZero();
|
2015-10-20 07:16:40 +08:00
|
|
|
for (auto *Succ : BB->successors()) {
|
|
|
|
BlockChain *SuccChain = BlockToChain[Succ];
|
|
|
|
if (!LoopBlockSet.count(Succ) &&
|
|
|
|
(!SuccChain || Succ == *SuccChain->begin())) {
|
2015-12-01 13:29:22 +08:00
|
|
|
auto SuccProb = MBPI->getEdgeProbability(BB, Succ);
|
|
|
|
LargestExitEdgeProb = std::max(LargestExitEdgeProb, SuccProb);
|
2015-10-20 07:16:40 +08:00
|
|
|
}
|
|
|
|
}
|
2015-12-01 13:29:22 +08:00
|
|
|
if (LargestExitEdgeProb > BranchProbability::getZero()) {
|
|
|
|
auto ExitFreq = MBFI->getBlockFreq(BB) * LargestExitEdgeProb;
|
2015-10-20 07:16:40 +08:00
|
|
|
ExitsWithFreq.emplace_back(BB, ExitFreq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// In this loop we iterate every block in the loop chain and calculate the
|
|
|
|
// cost assuming the block is the head of the loop chain. When the loop ends,
|
|
|
|
// we should have found the best candidate as the loop chain's head.
|
|
|
|
for (auto Iter = LoopChain.begin(), TailIter = std::prev(LoopChain.end()),
|
|
|
|
EndIter = LoopChain.end();
|
|
|
|
Iter != EndIter; Iter++, TailIter++) {
|
|
|
|
// TailIter is used to track the tail of the loop chain if the block we are
|
|
|
|
// checking (pointed by Iter) is the head of the chain.
|
|
|
|
if (TailIter == LoopChain.end())
|
|
|
|
TailIter = LoopChain.begin();
|
|
|
|
|
|
|
|
auto TailBB = *TailIter;
|
|
|
|
|
|
|
|
// Calculate the cost by putting this BB to the top.
|
|
|
|
BlockFrequency Cost = 0;
|
|
|
|
|
|
|
|
// If the current BB is the loop header, we need to take into account the
|
|
|
|
// cost of the missed fall through edge from outside of the loop to the
|
|
|
|
// header.
|
|
|
|
if (Iter != HeaderIter)
|
|
|
|
Cost += HeaderFallThroughCost;
|
|
|
|
|
|
|
|
// Collect the loop exit cost by summing up frequencies of all exit edges
|
|
|
|
// except the one from the chain tail.
|
|
|
|
for (auto &ExitWithFreq : ExitsWithFreq)
|
|
|
|
if (TailBB != ExitWithFreq.first)
|
|
|
|
Cost += ExitWithFreq.second;
|
|
|
|
|
|
|
|
// The cost of breaking the once fall-through edge from the tail to the top
|
|
|
|
// of the loop chain. Here we need to consider three cases:
|
|
|
|
// 1. If the tail node has only one successor, then we will get an
|
|
|
|
// additional jmp instruction. So the cost here is (MisfetchCost +
|
|
|
|
// JumpInstCost) * tail node frequency.
|
|
|
|
// 2. If the tail node has two successors, then we may still get an
|
|
|
|
// additional jmp instruction if the layout successor after the loop
|
|
|
|
// chain is not its CFG successor. Note that the more frequently executed
|
|
|
|
// jmp instruction will be put ahead of the other one. Assume the
|
|
|
|
// frequency of those two branches are x and y, where x is the frequency
|
|
|
|
// of the edge to the chain head, then the cost will be
|
|
|
|
// (x * MisfetechCost + min(x, y) * JumpInstCost) * tail node frequency.
|
|
|
|
// 3. If the tail node has more than two successors (this rarely happens),
|
|
|
|
// we won't consider any additional cost.
|
|
|
|
if (TailBB->isSuccessor(*Iter)) {
|
|
|
|
auto TailBBFreq = MBFI->getBlockFreq(TailBB);
|
|
|
|
if (TailBB->succ_size() == 1)
|
|
|
|
Cost += ScaleBlockFrequency(TailBBFreq.getFrequency(),
|
|
|
|
MisfetchCost + JumpInstCost);
|
|
|
|
else if (TailBB->succ_size() == 2) {
|
|
|
|
auto TailToHeadProb = MBPI->getEdgeProbability(TailBB, *Iter);
|
|
|
|
auto TailToHeadFreq = TailBBFreq * TailToHeadProb;
|
|
|
|
auto ColderEdgeFreq = TailToHeadProb > BranchProbability(1, 2)
|
|
|
|
? TailBBFreq * TailToHeadProb.getCompl()
|
|
|
|
: TailToHeadFreq;
|
|
|
|
Cost += ScaleBlockFrequency(TailToHeadFreq, MisfetchCost) +
|
|
|
|
ScaleBlockFrequency(ColderEdgeFreq, JumpInstCost);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-03 05:45:13 +08:00
|
|
|
DEBUG(dbgs() << "The cost of loop rotation by making " << getBlockName(*Iter)
|
2015-10-20 07:16:40 +08:00
|
|
|
<< " to the top: " << Cost.getFrequency() << "\n");
|
|
|
|
|
|
|
|
if (Cost < SmallestRotationCost) {
|
|
|
|
SmallestRotationCost = Cost;
|
|
|
|
RotationPos = Iter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (RotationPos != LoopChain.end()) {
|
2016-03-03 05:45:13 +08:00
|
|
|
DEBUG(dbgs() << "Rotate loop by making " << getBlockName(*RotationPos)
|
2015-10-20 07:16:40 +08:00
|
|
|
<< " to the top\n");
|
|
|
|
std::rotate(LoopChain.begin(), RotationPos, LoopChain.end());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
In MachineBlockPlacement, filter cold blocks off the loop chain when profile data is available.
In the current BB placement algorithm, a loop chain always contains all loop blocks. This has a drawback that cold blocks in the loop may be inserted on a hot function path, hence increasing branch cost and also reducing icache locality.
Consider a simple example shown below:
A
|
B⇆C
|
D
When B->C is quite cold, the best BB-layout should be A,B,D,C. But the current implementation produces A,C,B,D.
This patch filters those cold blocks off from the loop chain by comparing the ratio:
LoopBBFreq / LoopFreq
to 20%: if it is less than 20%, we don't include this BB to the loop chain. Here LoopFreq is the frequency of the loop when we reduce the loop into a single node. In general we have more cold blocks when the loop has few iterations. And vice versa.
Differential revision: http://reviews.llvm.org/D11662
llvm-svn: 251833
2015-11-03 05:24:00 +08:00
|
|
|
/// \brief Collect blocks in the given loop that are to be placed.
|
|
|
|
///
|
|
|
|
/// When profile data is available, exclude cold blocks from the returned set;
|
|
|
|
/// otherwise, collect all blocks in the loop.
|
|
|
|
MachineBlockPlacement::BlockFilterSet
|
|
|
|
MachineBlockPlacement::collectLoopBlockSet(MachineFunction &F, MachineLoop &L) {
|
|
|
|
BlockFilterSet LoopBlockSet;
|
|
|
|
|
|
|
|
// Filter cold blocks off from LoopBlockSet when profile data is available.
|
|
|
|
// Collect the sum of frequencies of incoming edges to the loop header from
|
|
|
|
// outside. If we treat the loop as a super block, this is the frequency of
|
|
|
|
// the loop. Then for each block in the loop, we calculate the ratio between
|
|
|
|
// its frequency and the frequency of the loop block. When it is too small,
|
|
|
|
// don't add it to the loop chain. If there are outer loops, then this block
|
|
|
|
// will be merged into the first outer loop chain for which this block is not
|
|
|
|
// cold anymore. This needs precise profile data and we only do this when
|
|
|
|
// profile data is available.
|
|
|
|
if (F.getFunction()->getEntryCount()) {
|
|
|
|
BlockFrequency LoopFreq(0);
|
|
|
|
for (auto LoopPred : L.getHeader()->predecessors())
|
|
|
|
if (!L.contains(LoopPred))
|
|
|
|
LoopFreq += MBFI->getBlockFreq(LoopPred) *
|
|
|
|
MBPI->getEdgeProbability(LoopPred, L.getHeader());
|
|
|
|
|
|
|
|
for (MachineBasicBlock *LoopBB : L.getBlocks()) {
|
|
|
|
auto Freq = MBFI->getBlockFreq(LoopBB).getFrequency();
|
|
|
|
if (Freq == 0 || LoopFreq.getFrequency() / Freq > LoopToColdBlockRatio)
|
|
|
|
continue;
|
|
|
|
LoopBlockSet.insert(LoopBB);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
LoopBlockSet.insert(L.block_begin(), L.block_end());
|
|
|
|
|
|
|
|
return LoopBlockSet;
|
|
|
|
}
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
/// \brief Forms basic block chains from the natural loop structures.
|
|
|
|
///
|
|
|
|
/// These chains are designed to preserve the existing *structure* of the code
|
|
|
|
/// as much as possible. We can then stitch the chains together in a way which
|
|
|
|
/// both preserves the topological structure and minimizes taken conditional
|
|
|
|
/// branches.
|
2011-11-13 19:20:44 +08:00
|
|
|
void MachineBlockPlacement::buildLoopChains(MachineFunction &F,
|
2011-12-22 07:02:08 +08:00
|
|
|
MachineLoop &L) {
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
// First recurse through any nested loops, building chains for those inner
|
|
|
|
// loops.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineLoop *InnerLoop : L)
|
|
|
|
buildLoopChains(F, *InnerLoop);
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
SmallVector<MachineBasicBlock *, 16> BlockWorkList;
|
In MachineBlockPlacement, filter cold blocks off the loop chain when profile data is available.
In the current BB placement algorithm, a loop chain always contains all loop blocks. This has a drawback that cold blocks in the loop may be inserted on a hot function path, hence increasing branch cost and also reducing icache locality.
Consider a simple example shown below:
A
|
B⇆C
|
D
When B->C is quite cold, the best BB-layout should be A,B,D,C. But the current implementation produces A,C,B,D.
This patch filters those cold blocks off from the loop chain by comparing the ratio:
LoopBBFreq / LoopFreq
to 20%: if it is less than 20%, we don't include this BB to the loop chain. Here LoopFreq is the frequency of the loop when we reduce the loop into a single node. In general we have more cold blocks when the loop has few iterations. And vice versa.
Differential revision: http://reviews.llvm.org/D11662
llvm-svn: 251833
2015-11-03 05:24:00 +08:00
|
|
|
BlockFilterSet LoopBlockSet = collectLoopBlockSet(F, L);
|
Take two on rotating the block ordering of loops. My previous attempt
was centered around the premise of laying out a loop in a chain, and
then rotating that chain. This is good for preserving contiguous layout,
but bad for actually making sane rotations. In order to keep it safe,
I had to essentially make it impossible to rotate deeply nested loops.
The information needed to correctly reason about a deeply nested loop is
actually available -- *before* we layout the loop. We know the inner
loops are already fused into chains, etc. We lose information the moment
we actually lay out the loop.
The solution was the other alternative for this algorithm I discussed
with Benjamin and some others: rather than rotating the loop
after-the-fact, try to pick a profitable starting block for the loop's
layout, and then use our existing layout logic. I was worried about the
complexity of this "pick" step, but it turns out such complexity is
needed to handle all the important cases I keep teasing out of benchmarks.
This is, I'm afraid, a bit of a work-in-progress. It is still
misbehaving on some likely important cases I'm investigating in Olden.
It also isn't really tested. I'm going to try to craft some interesting
nested-loop test cases, but it's likely to be extremely time consuming
and I don't want to go there until I'm sure I'm testing the correct
behavior. Sadly I can't come up with a way of getting simple, fine
grained test cases for this logic. We need complex loop structures to
even trigger much of it.
llvm-svn: 145183
2011-11-27 21:34:33 +08:00
|
|
|
|
2015-10-20 07:16:40 +08:00
|
|
|
// Check if we have profile data for this function. If yes, we will rotate
|
|
|
|
// this loop by modeling costs more precisely which requires the profile data
|
|
|
|
// for better layout.
|
|
|
|
bool RotateLoopWithProfile =
|
|
|
|
PreciseRotationCost && F.getFunction()->getEntryCount();
|
|
|
|
|
2012-04-16 21:33:36 +08:00
|
|
|
// First check to see if there is an obviously preferable top block for the
|
|
|
|
// loop. This will default to the header, but may end up as one of the
|
|
|
|
// predecessors to the header if there is one which will result in strictly
|
|
|
|
// fewer branches in the loop body.
|
2015-10-20 07:16:40 +08:00
|
|
|
// When we use profile data to rotate the loop, this is unnecessary.
|
|
|
|
MachineBasicBlock *LoopTop =
|
|
|
|
RotateLoopWithProfile ? L.getHeader() : findBestLoopTop(L, LoopBlockSet);
|
2012-04-16 21:33:36 +08:00
|
|
|
|
|
|
|
// If we selected just the header for the loop top, look for a potentially
|
|
|
|
// profitable exit block in the event that rotating the loop can eliminate
|
|
|
|
// branches by placing an exit edge at the bottom.
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *ExitingBB = nullptr;
|
2015-10-20 07:16:40 +08:00
|
|
|
if (!RotateLoopWithProfile && LoopTop == L.getHeader())
|
2012-04-16 21:33:36 +08:00
|
|
|
ExitingBB = findBestLoopExit(F, L, LoopBlockSet);
|
|
|
|
|
|
|
|
BlockChain &LoopChain = *BlockToChain[LoopTop];
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
// FIXME: This is a really lame way of walking the chains in the loop: we
|
|
|
|
// walk the blocks, and use a set to prevent visiting a particular chain
|
|
|
|
// twice.
|
2011-12-22 07:02:08 +08:00
|
|
|
SmallPtrSet<BlockChain *, 4> UpdatedPreds;
|
2011-12-08 03:46:10 +08:00
|
|
|
assert(LoopChain.LoopPredecessors == 0);
|
|
|
|
UpdatedPreds.insert(&LoopChain);
|
In MachineBlockPlacement, filter cold blocks off the loop chain when profile data is available.
In the current BB placement algorithm, a loop chain always contains all loop blocks. This has a drawback that cold blocks in the loop may be inserted on a hot function path, hence increasing branch cost and also reducing icache locality.
Consider a simple example shown below:
A
|
B⇆C
|
D
When B->C is quite cold, the best BB-layout should be A,B,D,C. But the current implementation produces A,C,B,D.
This patch filters those cold blocks off from the loop chain by comparing the ratio:
LoopBBFreq / LoopFreq
to 20%: if it is less than 20%, we don't include this BB to the loop chain. Here LoopFreq is the frequency of the loop when we reduce the loop into a single node. In general we have more cold blocks when the loop has few iterations. And vice versa.
Differential revision: http://reviews.llvm.org/D11662
llvm-svn: 251833
2015-11-03 05:24:00 +08:00
|
|
|
|
|
|
|
for (MachineBasicBlock *LoopBB : LoopBlockSet) {
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockChain &Chain = *BlockToChain[LoopBB];
|
2014-11-19 15:49:26 +08:00
|
|
|
if (!UpdatedPreds.insert(&Chain).second)
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
assert(Chain.LoopPredecessors == 0);
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : Chain) {
|
|
|
|
assert(BlockToChain[ChainBB] == &Chain);
|
|
|
|
for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
|
|
|
|
if (BlockToChain[Pred] == &Chain || !LoopBlockSet.count(Pred))
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
|
|
|
++Chain.LoopPredecessors;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Chain.LoopPredecessors == 0)
|
2011-11-24 16:46:04 +08:00
|
|
|
BlockWorkList.push_back(*Chain.begin());
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2012-04-16 21:33:36 +08:00
|
|
|
buildChain(LoopTop, LoopChain, BlockWorkList, &LoopBlockSet);
|
2015-10-20 07:16:40 +08:00
|
|
|
|
|
|
|
if (RotateLoopWithProfile)
|
|
|
|
rotateLoopWithProfile(LoopChain, L, LoopBlockSet);
|
|
|
|
else
|
|
|
|
rotateLoop(LoopChain, ExitingBB, LoopBlockSet);
|
2011-11-13 19:20:44 +08:00
|
|
|
|
|
|
|
DEBUG({
|
2011-11-14 05:39:51 +08:00
|
|
|
// Crash at the end so we get all of the debugging output first.
|
|
|
|
bool BadLoop = false;
|
|
|
|
if (LoopChain.LoopPredecessors) {
|
|
|
|
BadLoop = true;
|
2011-11-13 19:20:44 +08:00
|
|
|
dbgs() << "Loop chain contains a block without its preds placed!\n"
|
|
|
|
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n"
|
|
|
|
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n";
|
2011-11-14 05:39:51 +08:00
|
|
|
}
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : LoopChain) {
|
|
|
|
dbgs() << " ... " << getBlockName(ChainBB) << "\n";
|
|
|
|
if (!LoopBlockSet.erase(ChainBB)) {
|
2011-11-14 18:55:53 +08:00
|
|
|
// We don't mark the loop as bad here because there are real situations
|
|
|
|
// where this can occur. For example, with an unanalyzable fallthrough
|
2011-11-23 18:35:36 +08:00
|
|
|
// from a loop block to a non-loop block or vice versa.
|
2011-11-13 19:20:44 +08:00
|
|
|
dbgs() << "Loop chain contains a block not contained by the loop!\n"
|
|
|
|
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n"
|
|
|
|
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n"
|
2015-03-05 11:19:05 +08:00
|
|
|
<< " Bad block: " << getBlockName(ChainBB) << "\n";
|
2011-11-14 05:39:51 +08:00
|
|
|
}
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2011-11-14 05:39:51 +08:00
|
|
|
if (!LoopBlockSet.empty()) {
|
|
|
|
BadLoop = true;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *LoopBB : LoopBlockSet)
|
2011-11-13 19:20:44 +08:00
|
|
|
dbgs() << "Loop contains blocks never placed into a chain!\n"
|
|
|
|
<< " Loop header: " << getBlockName(*L.block_begin()) << "\n"
|
|
|
|
<< " Chain header: " << getBlockName(*LoopChain.begin()) << "\n"
|
2015-03-05 11:19:05 +08:00
|
|
|
<< " Bad block: " << getBlockName(LoopBB) << "\n";
|
2011-11-14 05:39:51 +08:00
|
|
|
}
|
|
|
|
assert(!BadLoop && "Detected problems with the placement of this loop.");
|
2011-11-13 19:20:44 +08:00
|
|
|
});
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
|
2011-11-13 19:20:44 +08:00
|
|
|
// Ensure that every BB in the function has an associated chain to simplify
|
|
|
|
// the assumptions of the remaining algorithm.
|
2011-11-19 18:26:02 +08:00
|
|
|
SmallVector<MachineOperand, 4> Cond; // For AnalyzeBranch.
|
|
|
|
for (MachineFunction::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) {
|
2015-10-10 03:36:12 +08:00
|
|
|
MachineBasicBlock *BB = &*FI;
|
2015-03-05 10:35:31 +08:00
|
|
|
BlockChain *Chain =
|
|
|
|
new (ChainAllocator.Allocate()) BlockChain(BlockToChain, BB);
|
2011-11-19 18:26:02 +08:00
|
|
|
// Also, merge any blocks which we cannot reason about and must preserve
|
|
|
|
// the exact fallthrough behavior for.
|
|
|
|
for (;;) {
|
|
|
|
Cond.clear();
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
|
2011-11-19 18:26:02 +08:00
|
|
|
if (!TII->AnalyzeBranch(*BB, TBB, FBB, Cond) || !FI->canFallThrough())
|
|
|
|
break;
|
|
|
|
|
2015-10-10 03:36:12 +08:00
|
|
|
MachineFunction::iterator NextFI = std::next(FI);
|
|
|
|
MachineBasicBlock *NextBB = &*NextFI;
|
2011-11-19 18:26:02 +08:00
|
|
|
// Ensure that the layout successor is a viable block, as we know that
|
|
|
|
// fallthrough is a possibility.
|
|
|
|
assert(NextFI != FE && "Can't fallthrough past the last block.");
|
|
|
|
DEBUG(dbgs() << "Pre-merging due to unanalyzable fallthrough: "
|
|
|
|
<< getBlockName(BB) << " -> " << getBlockName(NextBB)
|
|
|
|
<< "\n");
|
2014-04-14 08:51:57 +08:00
|
|
|
Chain->merge(NextBB, nullptr);
|
2011-11-19 18:26:02 +08:00
|
|
|
FI = NextFI;
|
|
|
|
BB = NextBB;
|
|
|
|
}
|
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2015-03-04 19:05:34 +08:00
|
|
|
if (OutlineOptionalBranches) {
|
|
|
|
// Find the nearest common dominator of all of F's terminators.
|
|
|
|
MachineBasicBlock *Terminator = nullptr;
|
|
|
|
for (MachineBasicBlock &MBB : F) {
|
|
|
|
if (MBB.succ_size() == 0) {
|
|
|
|
if (Terminator == nullptr)
|
|
|
|
Terminator = &MBB;
|
|
|
|
else
|
|
|
|
Terminator = MDT->findNearestCommonDominator(Terminator, &MBB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// MBBs dominating this common dominator are unavoidable.
|
|
|
|
UnavoidableBlocks.clear();
|
|
|
|
for (MachineBasicBlock &MBB : F) {
|
|
|
|
if (MDT->dominates(&MBB, Terminator)) {
|
|
|
|
UnavoidableBlocks.insert(&MBB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
// Build any loop-based chains.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineLoop *L : *MLI)
|
|
|
|
buildLoopChains(F, *L);
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
SmallVector<MachineBasicBlock *, 16> BlockWorkList;
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
SmallPtrSet<BlockChain *, 4> UpdatedPreds;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock &MBB : F) {
|
|
|
|
BlockChain &Chain = *BlockToChain[&MBB];
|
2014-11-19 15:49:26 +08:00
|
|
|
if (!UpdatedPreds.insert(&Chain).second)
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
continue;
|
2011-11-13 19:20:44 +08:00
|
|
|
|
|
|
|
assert(Chain.LoopPredecessors == 0);
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : Chain) {
|
|
|
|
assert(BlockToChain[ChainBB] == &Chain);
|
|
|
|
for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
|
|
|
|
if (BlockToChain[Pred] == &Chain)
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
|
|
|
++Chain.LoopPredecessors;
|
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
|
|
|
if (Chain.LoopPredecessors == 0)
|
2011-11-24 16:46:04 +08:00
|
|
|
BlockWorkList.push_back(*Chain.begin());
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
|
|
|
|
2011-11-13 19:20:44 +08:00
|
|
|
BlockChain &FunctionChain = *BlockToChain[&F.front()];
|
2011-11-15 14:26:43 +08:00
|
|
|
buildChain(&F.front(), FunctionChain, BlockWorkList);
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2013-12-11 02:55:37 +08:00
|
|
|
#ifndef NDEBUG
|
2013-12-06 04:02:18 +08:00
|
|
|
typedef SmallPtrSet<MachineBasicBlock *, 16> FunctionBlockSetType;
|
2013-12-11 02:55:37 +08:00
|
|
|
#endif
|
2011-11-13 19:20:44 +08:00
|
|
|
DEBUG({
|
2011-11-14 05:39:51 +08:00
|
|
|
// Crash at the end so we get all of the debugging output first.
|
|
|
|
bool BadFunc = false;
|
2011-11-13 19:20:44 +08:00
|
|
|
FunctionBlockSetType FunctionBlockSet;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock &MBB : F)
|
|
|
|
FunctionBlockSet.insert(&MBB);
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : FunctionChain)
|
|
|
|
if (!FunctionBlockSet.erase(ChainBB)) {
|
2011-11-14 05:39:51 +08:00
|
|
|
BadFunc = true;
|
2011-11-13 19:20:44 +08:00
|
|
|
dbgs() << "Function chain contains a block not in the function!\n"
|
2015-03-05 11:19:05 +08:00
|
|
|
<< " Bad block: " << getBlockName(ChainBB) << "\n";
|
2011-11-14 05:39:51 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
2011-11-14 05:39:51 +08:00
|
|
|
if (!FunctionBlockSet.empty()) {
|
|
|
|
BadFunc = true;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *RemainingBB : FunctionBlockSet)
|
2011-11-13 19:20:44 +08:00
|
|
|
dbgs() << "Function contains blocks never placed into a chain!\n"
|
2015-03-05 11:19:05 +08:00
|
|
|
<< " Bad block: " << getBlockName(RemainingBB) << "\n";
|
2011-11-14 05:39:51 +08:00
|
|
|
}
|
|
|
|
assert(!BadFunc && "Detected problems with the block placement.");
|
2011-11-13 19:20:44 +08:00
|
|
|
});
|
|
|
|
|
|
|
|
// Splice the blocks into place.
|
|
|
|
MachineFunction::iterator InsertPos = F.begin();
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : FunctionChain) {
|
|
|
|
DEBUG(dbgs() << (ChainBB == *FunctionChain.begin() ? "Placing chain "
|
|
|
|
: " ... ")
|
|
|
|
<< getBlockName(ChainBB) << "\n");
|
|
|
|
if (InsertPos != MachineFunction::iterator(ChainBB))
|
|
|
|
F.splice(InsertPos, ChainBB);
|
2011-11-13 19:20:44 +08:00
|
|
|
else
|
|
|
|
++InsertPos;
|
|
|
|
|
|
|
|
// Update the terminator of the previous block.
|
2015-03-05 11:19:05 +08:00
|
|
|
if (ChainBB == *FunctionChain.begin())
|
2011-11-13 19:20:44 +08:00
|
|
|
continue;
|
2015-10-10 03:36:12 +08:00
|
|
|
MachineBasicBlock *PrevBB = &*std::prev(MachineFunction::iterator(ChainBB));
|
2011-11-13 19:20:44 +08:00
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
// FIXME: It would be awesome of updateTerminator would just return rather
|
|
|
|
// than assert when the branch cannot be analyzed in order to remove this
|
|
|
|
// boiler plate.
|
|
|
|
Cond.clear();
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
|
2012-07-31 09:11:07 +08:00
|
|
|
if (!TII->AnalyzeBranch(*PrevBB, TBB, FBB, Cond)) {
|
2013-06-04 09:00:57 +08:00
|
|
|
// The "PrevBB" is not yet updated to reflect current code layout, so,
|
|
|
|
// o. it may fall-through to a block without explict "goto" instruction
|
2015-03-05 10:35:31 +08:00
|
|
|
// before layout, and no longer fall-through it after layout; or
|
2013-06-04 09:00:57 +08:00
|
|
|
// o. just opposite.
|
2015-03-05 10:35:31 +08:00
|
|
|
//
|
2013-06-04 09:00:57 +08:00
|
|
|
// AnalyzeBranch() may return erroneous value for FBB when these two
|
|
|
|
// situations take place. For the first scenario FBB is mistakenly set
|
|
|
|
// NULL; for the 2nd scenario, the FBB, which is expected to be NULL,
|
|
|
|
// is mistakenly pointing to "*BI".
|
|
|
|
//
|
|
|
|
bool needUpdateBr = true;
|
2015-03-05 11:19:05 +08:00
|
|
|
if (!Cond.empty() && (!FBB || FBB == ChainBB)) {
|
2013-06-04 09:00:57 +08:00
|
|
|
PrevBB->updateTerminator();
|
|
|
|
needUpdateBr = false;
|
|
|
|
Cond.clear();
|
2014-04-14 08:51:57 +08:00
|
|
|
TBB = FBB = nullptr;
|
2013-06-04 09:00:57 +08:00
|
|
|
if (TII->AnalyzeBranch(*PrevBB, TBB, FBB, Cond)) {
|
|
|
|
// FIXME: This should never take place.
|
2014-04-14 08:51:57 +08:00
|
|
|
TBB = FBB = nullptr;
|
2013-06-04 09:00:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-31 09:11:07 +08:00
|
|
|
// If PrevBB has a two-way branch, try to re-order the branches
|
2015-12-01 13:29:22 +08:00
|
|
|
// such that we branch to the successor with higher probability first.
|
2012-07-31 09:11:07 +08:00
|
|
|
if (TBB && !Cond.empty() && FBB &&
|
2015-12-01 13:29:22 +08:00
|
|
|
MBPI->getEdgeProbability(PrevBB, FBB) >
|
|
|
|
MBPI->getEdgeProbability(PrevBB, TBB) &&
|
2012-07-31 09:11:07 +08:00
|
|
|
!TII->ReverseBranchCondition(Cond)) {
|
|
|
|
DEBUG(dbgs() << "Reverse order of the two branches: "
|
|
|
|
<< getBlockName(PrevBB) << "\n");
|
2015-12-01 13:29:22 +08:00
|
|
|
DEBUG(dbgs() << " Edge probability: "
|
|
|
|
<< MBPI->getEdgeProbability(PrevBB, FBB) << " vs "
|
|
|
|
<< MBPI->getEdgeProbability(PrevBB, TBB) << "\n");
|
2015-03-05 10:35:31 +08:00
|
|
|
DebugLoc dl; // FIXME: this is nowhere
|
2012-07-31 09:11:07 +08:00
|
|
|
TII->RemoveBranch(*PrevBB);
|
|
|
|
TII->InsertBranch(*PrevBB, FBB, TBB, Cond, dl);
|
2013-06-04 09:00:57 +08:00
|
|
|
needUpdateBr = true;
|
2012-07-31 09:11:07 +08:00
|
|
|
}
|
2013-06-04 09:00:57 +08:00
|
|
|
if (needUpdateBr)
|
|
|
|
PrevBB->updateTerminator();
|
2012-07-31 09:11:07 +08:00
|
|
|
}
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
}
|
2011-11-13 19:20:44 +08:00
|
|
|
|
|
|
|
// Fixup the last block.
|
|
|
|
Cond.clear();
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineBasicBlock *TBB = nullptr, *FBB = nullptr; // For AnalyzeBranch.
|
2011-11-13 19:20:44 +08:00
|
|
|
if (!TII->AnalyzeBranch(F.back(), TBB, FBB, Cond))
|
|
|
|
F.back().updateTerminator();
|
2011-10-21 16:57:37 +08:00
|
|
|
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
// Walk through the backedges of the function now that we have fully laid out
|
|
|
|
// the basic blocks and align the destination of each backedge. We don't rely
|
2012-08-07 17:45:24 +08:00
|
|
|
// exclusively on the loop info here so that we can align backedges in
|
|
|
|
// unnatural CFGs and backedges that were introduced purely because of the
|
|
|
|
// loop rotations done during this layout pass.
|
2015-08-04 23:49:57 +08:00
|
|
|
// FIXME: Use Function::optForSize().
|
2015-02-14 09:44:41 +08:00
|
|
|
if (F.getFunction()->hasFnAttribute(Attribute::OptimizeForSize))
|
2011-10-21 16:57:37 +08:00
|
|
|
return;
|
2012-08-07 17:45:24 +08:00
|
|
|
if (FunctionChain.begin() == FunctionChain.end())
|
2015-03-05 10:35:31 +08:00
|
|
|
return; // Empty chain.
|
2011-10-21 16:57:37 +08:00
|
|
|
|
2012-08-07 17:45:24 +08:00
|
|
|
const BranchProbability ColdProb(1, 5); // 20%
|
2015-10-10 03:36:12 +08:00
|
|
|
BlockFrequency EntryFreq = MBFI->getBlockFreq(&F.front());
|
2012-08-07 17:45:24 +08:00
|
|
|
BlockFrequency WeightedEntryFreq = EntryFreq * ColdProb;
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock *ChainBB : FunctionChain) {
|
|
|
|
if (ChainBB == *FunctionChain.begin())
|
|
|
|
continue;
|
|
|
|
|
2012-08-07 17:45:24 +08:00
|
|
|
// Don't align non-looping basic blocks. These are unlikely to execute
|
|
|
|
// enough times to matter in practice. Note that we'll still handle
|
|
|
|
// unnatural CFGs inside of a natural outer loop (the common case) and
|
|
|
|
// rotated loops.
|
2015-03-05 11:19:05 +08:00
|
|
|
MachineLoop *L = MLI->getLoopFor(ChainBB);
|
2012-08-07 17:45:24 +08:00
|
|
|
if (!L)
|
|
|
|
continue;
|
|
|
|
|
2015-01-04 01:58:24 +08:00
|
|
|
unsigned Align = TLI->getPrefLoopAlignment(L);
|
|
|
|
if (!Align)
|
2015-03-05 10:35:31 +08:00
|
|
|
continue; // Don't care about loop alignment.
|
2015-01-04 01:58:24 +08:00
|
|
|
|
2012-08-07 17:45:24 +08:00
|
|
|
// If the block is cold relative to the function entry don't waste space
|
|
|
|
// aligning it.
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockFrequency Freq = MBFI->getBlockFreq(ChainBB);
|
2012-08-07 17:45:24 +08:00
|
|
|
if (Freq < WeightedEntryFreq)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If the block is cold relative to its loop header, don't align it
|
|
|
|
// regardless of what edges into the block exist.
|
|
|
|
MachineBasicBlock *LoopHeader = L->getHeader();
|
|
|
|
BlockFrequency LoopHeaderFreq = MBFI->getBlockFreq(LoopHeader);
|
|
|
|
if (Freq < (LoopHeaderFreq * ColdProb))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Check for the existence of a non-layout predecessor which would benefit
|
|
|
|
// from aligning this block.
|
2015-03-05 11:19:05 +08:00
|
|
|
MachineBasicBlock *LayoutPred =
|
|
|
|
&*std::prev(MachineFunction::iterator(ChainBB));
|
2012-08-07 17:45:24 +08:00
|
|
|
|
|
|
|
// Force alignment if all the predecessors are jumps. We already checked
|
|
|
|
// that the block isn't cold above.
|
2015-03-05 11:19:05 +08:00
|
|
|
if (!LayoutPred->isSuccessor(ChainBB)) {
|
|
|
|
ChainBB->setAlignment(Align);
|
2012-08-07 17:45:24 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Align this block if the layout predecessor's edge into this block is
|
2013-03-30 00:34:23 +08:00
|
|
|
// cold relative to the block. When this is true, other predecessors make up
|
2012-08-07 17:45:24 +08:00
|
|
|
// all of the hot entries into the block and thus alignment is likely to be
|
|
|
|
// important.
|
2015-03-05 11:19:05 +08:00
|
|
|
BranchProbability LayoutProb =
|
|
|
|
MBPI->getEdgeProbability(LayoutPred, ChainBB);
|
2012-08-07 17:45:24 +08:00
|
|
|
BlockFrequency LayoutEdgeFreq = MBFI->getBlockFreq(LayoutPred) * LayoutProb;
|
|
|
|
if (LayoutEdgeFreq <= (Freq * ColdProb))
|
2015-03-05 11:19:05 +08:00
|
|
|
ChainBB->setAlignment(Align);
|
Rewrite how machine block placement handles loop rotation.
This is a complex change that resulted from a great deal of
experimentation with several different benchmarks. The one which proved
the most useful is included as a test case, but I don't know that it
captures all of the relevant changes, as I didn't have specific
regression tests for each, they were more the result of reasoning about
what the old algorithm would possibly do wrong. I'm also failing at the
moment to craft more targeted regression tests for these changes, if
anyone has ideas, it would be welcome.
The first big thing broken with the old algorithm is the idea that we
can take a basic block which has a loop-exiting successor and a looping
successor and use the looping successor as the layout top in order to
get that particular block to be the bottom of the loop after layout.
This happens to work in many cases, but not in all.
The second big thing broken was that we didn't try to select the exit
which fell into the nearest enclosing loop (to which we exit at all). As
a consequence, even if the rotation worked perfectly, it would result in
one of two bad layouts. Either the bottom of the loop would get
fallthrough, skipping across a nearer enclosing loop and thereby making
it discontiguous, or it would be forced to take an explicit jump over
the nearest enclosing loop to earch its successor. The point of the
rotation is to get fallthrough, so we need it to fallthrough to the
nearest loop it can.
The fix to the first issue is to actually layout the loop from the loop
header, and then rotate the loop such that the correct exiting edge can
be a fallthrough edge. This is actually much easier than I anticipated
because we can handle all the hard parts of finding a viable rotation
before we do the layout. We just store that, and then rotate after
layout is finished. No inner loops get split across the post-rotation
backedge because we check for them when selecting the rotation.
That fix exposed a latent problem with our exitting block selection --
we should allow the backedge to point into the middle of some inner-loop
chain as there is no real penalty to it, the whole point is that it
*won't* be a fallthrough edge. This may have blocked the rotation at all
in some cases, I have no idea and no test case as I've never seen it in
practice, it was just noticed by inspection.
Finally, all of these fixes, and studying the loops they produce,
highlighted another problem: in rotating loops like this, we sometimes
fail to align the destination of these backwards jumping edges. Fix this
by actually walking the backwards edges rather than relying on loopinfo.
This fixes regressions on heapsort if block placement is enabled as well
as lots of other cases where the previous logic would introduce an
abundance of unnecessary branches into the execution.
llvm-svn: 154783
2012-04-16 09:12:56 +08:00
|
|
|
}
|
2011-10-21 16:57:37 +08:00
|
|
|
}
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
bool MachineBlockPlacement::runOnMachineFunction(MachineFunction &F) {
|
|
|
|
// Check for single-block functions and skip them.
|
2014-03-02 20:27:27 +08:00
|
|
|
if (std::next(F.begin()) == F.end())
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
return false;
|
|
|
|
|
2014-04-01 01:43:35 +08:00
|
|
|
if (skipOptnoneFunction(*F.getFunction()))
|
|
|
|
return false;
|
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
|
|
|
|
MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
|
2011-10-21 16:57:37 +08:00
|
|
|
MLI = &getAnalysis<MachineLoopInfo>();
|
2014-08-05 10:39:49 +08:00
|
|
|
TII = F.getSubtarget().getInstrInfo();
|
|
|
|
TLI = F.getSubtarget().getTargetLowering();
|
2015-03-04 19:05:34 +08:00
|
|
|
MDT = &getAnalysis<MachineDominatorTree>();
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
assert(BlockToChain.empty());
|
|
|
|
|
Completely re-write the algorithm behind MachineBlockPlacement based on
discussions with Andy. Fundamentally, the previous algorithm is both
counter productive on several fronts and prioritizing things which
aren't necessarily the most important: static branch prediction.
The new algorithm uses the existing loop CFG structure information to
walk through the CFG itself to layout blocks. It coalesces adjacent
blocks within the loop where the CFG allows based on the most likely
path taken. Finally, it topologically orders the block chains that have
been formed. This allows it to choose a (mostly) topologically valid
ordering which still priorizes fallthrough within the structural
constraints.
As a final twist in the algorithm, it does violate the CFG when it
discovers a "hot" edge, that is an edge that is more than 4x hotter than
the competing edges in the CFG. These are forcibly merged into
a fallthrough chain.
Future transformations that need te be added are rotation of loop exit
conditions to be fallthrough, and better isolation of cold block chains.
I'm also planning on adding statistics to model how well the algorithm
does at laying out blocks based on the probabilities it receives.
The old tests mostly still pass, and I have some new tests to add, but
the nested loops are still behaving very strangely. This almost seems
like working-as-intended as it rotated the exit branch to be
fallthrough, but I'm not convinced this is actually the best layout. It
is well supported by the probabilities for loops we currently get, but
those are pretty broken for nested loops, so this may change later.
llvm-svn: 142743
2011-10-23 17:18:45 +08:00
|
|
|
buildCFGChains(F);
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
|
|
|
BlockToChain.clear();
|
2011-11-14 18:57:23 +08:00
|
|
|
ChainAllocator.DestroyAll();
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
|
2013-04-12 09:24:16 +08:00
|
|
|
if (AlignAllBlock)
|
|
|
|
// Align all of the blocks in the function to a specific alignment.
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock &MBB : F)
|
|
|
|
MBB.setAlignment(AlignAllBlock);
|
2016-01-22 01:25:52 +08:00
|
|
|
else if (AlignAllNonFallThruBlocks) {
|
|
|
|
// Align all of the blocks that have no fall-through predecessors to a
|
|
|
|
// specific alignment.
|
|
|
|
for (auto MBI = std::next(F.begin()), MBE = F.end(); MBI != MBE; ++MBI) {
|
|
|
|
auto LayoutPred = std::prev(MBI);
|
|
|
|
if (!LayoutPred->isSuccessor(&*MBI))
|
|
|
|
MBI->setAlignment(AlignAllNonFallThruBlocks);
|
|
|
|
}
|
|
|
|
}
|
2013-04-12 09:24:16 +08:00
|
|
|
|
Implement a block placement pass based on the branch probability and
block frequency analyses. This differs substantially from the existing
block-placement pass in LLVM:
1) It operates on the Machine-IR in the CodeGen layer. This exposes much
more (and more precise) information and opportunities. Also, the
results are more stable due to fewer transforms ocurring after the
pass runs.
2) It uses the generalized probability and frequency analyses. These can
model static heuristics, code annotation derived heuristics as well
as eventual profile loading. By basing the optimization on the
analysis interface it can work from any (or a combination) of these
inputs.
3) It uses a more aggressive algorithm, both building chains from tho
bottom up to maximize benefit, and using an SCC-based walk to layout
chains of blocks in a profitable ordering without O(N^2) iterations
which the old pass involves.
The pass is currently gated behind a flag, and not enabled by default
because it still needs to grow some important features. Most notably, it
needs to support loop aligning and careful layout of loop structures
much as done by hand currently in CodePlacementOpt. Once it supports
these, and has sufficient testing and quality tuning, it should replace
both of these passes.
Thanks to Nick Lewycky and Richard Smith for help authoring & debugging
this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm
forgetting for reviewing and answering all my questions. Writing
a backend pass is *sooo* much better now than it used to be. =D
llvm-svn: 142641
2011-10-21 14:46:38 +08:00
|
|
|
// We always return true as we have no way to track whether the final order
|
|
|
|
// differs from the original order.
|
|
|
|
return true;
|
|
|
|
}
|
2011-11-02 15:17:12 +08:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// \brief A pass to compute block placement statistics.
|
|
|
|
///
|
|
|
|
/// A separate pass to compute interesting statistics for evaluating block
|
|
|
|
/// placement. This is separate from the actual placement pass so that they can
|
2012-06-02 18:20:22 +08:00
|
|
|
/// be computed in the absence of any placement transformations or when using
|
2011-11-02 15:17:12 +08:00
|
|
|
/// alternative placement strategies.
|
|
|
|
class MachineBlockPlacementStats : public MachineFunctionPass {
|
|
|
|
/// \brief A handle to the branch probability pass.
|
|
|
|
const MachineBranchProbabilityInfo *MBPI;
|
|
|
|
|
|
|
|
/// \brief A handle to the function-wide block frequency pass.
|
|
|
|
const MachineBlockFrequencyInfo *MBFI;
|
|
|
|
|
|
|
|
public:
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
MachineBlockPlacementStats() : MachineFunctionPass(ID) {
|
|
|
|
initializeMachineBlockPlacementStatsPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
bool runOnMachineFunction(MachineFunction &F) override;
|
2011-11-02 15:17:12 +08:00
|
|
|
|
2014-03-07 17:26:03 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2011-11-02 15:17:12 +08:00
|
|
|
AU.addRequired<MachineBranchProbabilityInfo>();
|
|
|
|
AU.addRequired<MachineBlockFrequencyInfo>();
|
|
|
|
AU.setPreservesAll();
|
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2011-11-02 15:17:12 +08:00
|
|
|
|
|
|
|
char MachineBlockPlacementStats::ID = 0;
|
2012-02-09 05:23:13 +08:00
|
|
|
char &llvm::MachineBlockPlacementStatsID = MachineBlockPlacementStats::ID;
|
2011-11-02 15:17:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(MachineBlockPlacementStats, "block-placement-stats",
|
|
|
|
"Basic Block Placement Stats", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineBlockFrequencyInfo)
|
|
|
|
INITIALIZE_PASS_END(MachineBlockPlacementStats, "block-placement-stats",
|
|
|
|
"Basic Block Placement Stats", false, false)
|
|
|
|
|
|
|
|
bool MachineBlockPlacementStats::runOnMachineFunction(MachineFunction &F) {
|
|
|
|
// Check for single-block functions and skip them.
|
2014-03-02 20:27:27 +08:00
|
|
|
if (std::next(F.begin()) == F.end())
|
2011-11-02 15:17:12 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
|
|
|
|
MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
|
|
|
|
|
2015-03-05 11:19:05 +08:00
|
|
|
for (MachineBasicBlock &MBB : F) {
|
|
|
|
BlockFrequency BlockFreq = MBFI->getBlockFreq(&MBB);
|
2015-03-05 10:35:31 +08:00
|
|
|
Statistic &NumBranches =
|
2015-03-05 11:19:05 +08:00
|
|
|
(MBB.succ_size() > 1) ? NumCondBranches : NumUncondBranches;
|
2015-03-05 10:35:31 +08:00
|
|
|
Statistic &BranchTakenFreq =
|
2015-03-05 11:19:05 +08:00
|
|
|
(MBB.succ_size() > 1) ? CondBranchTakenFreq : UncondBranchTakenFreq;
|
|
|
|
for (MachineBasicBlock *Succ : MBB.successors()) {
|
2011-11-02 15:17:12 +08:00
|
|
|
// Skip if this successor is a fallthrough.
|
2015-03-05 11:19:05 +08:00
|
|
|
if (MBB.isLayoutSuccessor(Succ))
|
2011-11-02 15:17:12 +08:00
|
|
|
continue;
|
|
|
|
|
2015-03-05 11:19:05 +08:00
|
|
|
BlockFrequency EdgeFreq =
|
|
|
|
BlockFreq * MBPI->getEdgeProbability(&MBB, Succ);
|
2011-11-02 15:17:12 +08:00
|
|
|
++NumBranches;
|
|
|
|
BranchTakenFreq += EdgeFreq.getFrequency();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|