mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-12 22:28:22 +00:00
* Eliminate `using' directive
* Make code layout more consistent git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9427 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman
parent
5e152593e0
commit
0849f5ace9
@ -22,7 +22,6 @@
|
||||
#include "llvm/CodeGen/MachineBasicBlock.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "Support/PostOrderIterator.h"
|
||||
using std::cerr;
|
||||
|
||||
std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd) {
|
||||
return os << "Delay for node " << nd->node->getNodeId()
|
||||
@ -43,41 +42,35 @@ SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G,
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::initialize()
|
||||
{
|
||||
SchedPriorities::initialize() {
|
||||
initializeReadyHeap(graph);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::computeDelays(const SchedGraph* graph)
|
||||
{
|
||||
SchedPriorities::computeDelays(const SchedGraph* graph) {
|
||||
po_iterator<const SchedGraph*> poIter = po_begin(graph), poEnd =po_end(graph);
|
||||
for ( ; poIter != poEnd; ++poIter)
|
||||
{
|
||||
const SchedGraphNode* node = *poIter;
|
||||
cycles_t nodeDelay;
|
||||
if (node->beginOutEdges() == node->endOutEdges())
|
||||
nodeDelay = node->getLatency();
|
||||
else
|
||||
{
|
||||
// Iterate over the out-edges of the node to compute delay
|
||||
nodeDelay = 0;
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E)
|
||||
{
|
||||
cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
|
||||
nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
getNodeDelayRef(node) = nodeDelay;
|
||||
for ( ; poIter != poEnd; ++poIter) {
|
||||
const SchedGraphNode* node = *poIter;
|
||||
cycles_t nodeDelay;
|
||||
if (node->beginOutEdges() == node->endOutEdges())
|
||||
nodeDelay = node->getLatency();
|
||||
else {
|
||||
// Iterate over the out-edges of the node to compute delay
|
||||
nodeDelay = 0;
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E) {
|
||||
cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
|
||||
nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
getNodeDelayRef(node) = nodeDelay;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
{
|
||||
SchedPriorities::initializeReadyHeap(const SchedGraph* graph) {
|
||||
const SchedGraphNode* graphRoot = (const SchedGraphNode*)graph->getRoot();
|
||||
assert(graphRoot->getMachineInstr() == NULL && "Expect dummy root");
|
||||
|
||||
@ -88,9 +81,9 @@ SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
|
||||
#undef TEST_HEAP_CONVERSION
|
||||
#ifdef TEST_HEAP_CONVERSION
|
||||
cerr << "Before heap conversion:\n";
|
||||
std::cerr << "Before heap conversion:\n";
|
||||
copy(candsAsHeap.begin(), candsAsHeap.end(),
|
||||
ostream_iterator<NodeDelayPair*>(cerr,"\n"));
|
||||
ostream_iterator<NodeDelayPair*>(std::cerr,"\n"));
|
||||
#endif
|
||||
|
||||
candsAsHeap.makeHeap();
|
||||
@ -98,55 +91,54 @@ SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
nextToTry = candsAsHeap.begin();
|
||||
|
||||
#ifdef TEST_HEAP_CONVERSION
|
||||
cerr << "After heap conversion:\n";
|
||||
std::cerr << "After heap conversion:\n";
|
||||
copy(candsAsHeap.begin(), candsAsHeap.end(),
|
||||
ostream_iterator<NodeDelayPair*>(cerr,"\n"));
|
||||
ostream_iterator<NodeDelayPair*>(std::cerr,"\n"));
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
SchedPriorities::insertReady(const SchedGraphNode* node)
|
||||
{
|
||||
SchedPriorities::insertReady(const SchedGraphNode* node) {
|
||||
candsAsHeap.insert(node, nodeDelayVec[node->getNodeId()]);
|
||||
candsAsSet.insert(node);
|
||||
mcands.clear(); // ensure reset choices is called before any more choices
|
||||
earliestReadyTime = std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(node));
|
||||
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace)
|
||||
{
|
||||
cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
|
||||
<< getEarliestReadyTimeForNode(node) << "; "
|
||||
<< " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n";
|
||||
cerr << " " << *node->getMachineInstr() << "\n";
|
||||
}
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace) {
|
||||
std::cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
|
||||
<< getEarliestReadyTimeForNode(node) << "; "
|
||||
<< " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n"
|
||||
<< " " << *node->getMachineInstr() << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
|
||||
const SchedGraphNode* node)
|
||||
{
|
||||
const SchedGraphNode* node) {
|
||||
candsAsHeap.removeNode(node);
|
||||
candsAsSet.erase(node);
|
||||
mcands.clear(); // ensure reset choices is called before any more choices
|
||||
|
||||
if (earliestReadyTime == getEarliestReadyTimeForNode(node))
|
||||
{// earliestReadyTime may have been due to this node, so recompute it
|
||||
earliestReadyTime = HUGE_LATENCY;
|
||||
for (NodeHeap::const_iterator I=candsAsHeap.begin();
|
||||
I != candsAsHeap.end(); ++I)
|
||||
if (candsAsHeap.getNode(I))
|
||||
earliestReadyTime = std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
|
||||
}
|
||||
if (earliestReadyTime == getEarliestReadyTimeForNode(node)) {
|
||||
// earliestReadyTime may have been due to this node, so recompute it
|
||||
earliestReadyTime = HUGE_LATENCY;
|
||||
for (NodeHeap::const_iterator I=candsAsHeap.begin();
|
||||
I != candsAsHeap.end(); ++I)
|
||||
if (candsAsHeap.getNode(I)) {
|
||||
earliestReadyTime =
|
||||
std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
|
||||
}
|
||||
}
|
||||
|
||||
// Now update ready times for successors
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E)
|
||||
{
|
||||
cycles_t& etime = getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
|
||||
etime = std::max(etime, curTime + (*E)->getMinDelay());
|
||||
}
|
||||
E != node->endOutEdges(); ++E) {
|
||||
cycles_t& etime =
|
||||
getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
|
||||
etime = std::max(etime, curTime + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -160,15 +152,13 @@ SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule1(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule1(std::vector<candIndex>& mcands) {
|
||||
return (mcands.size() == 1)? 0 // only one choice exists so take it
|
||||
: -1; // -1 indicates multiple choices
|
||||
}
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands) {
|
||||
assert(mcands.size() >= 1 && "Should have at least one candidate here.");
|
||||
for (unsigned i=0, N = mcands.size(); i < N; i++)
|
||||
if (instructionHasLastUse(methodLiveVarInfo,
|
||||
@ -178,67 +168,60 @@ SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands)
|
||||
}
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule3(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule3(std::vector<candIndex>& mcands) {
|
||||
assert(mcands.size() >= 1 && "Should have at least one candidate here.");
|
||||
int maxUses = candsAsHeap.getNode(mcands[0])->getNumOutEdges();
|
||||
int indexWithMaxUses = 0;
|
||||
for (unsigned i=1, N = mcands.size(); i < N; i++)
|
||||
{
|
||||
int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
|
||||
if (numUses > maxUses)
|
||||
{
|
||||
maxUses = numUses;
|
||||
indexWithMaxUses = i;
|
||||
}
|
||||
for (unsigned i=1, N = mcands.size(); i < N; i++) {
|
||||
int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
|
||||
if (numUses > maxUses) {
|
||||
maxUses = numUses;
|
||||
indexWithMaxUses = i;
|
||||
}
|
||||
}
|
||||
return indexWithMaxUses;
|
||||
}
|
||||
|
||||
const SchedGraphNode*
|
||||
SchedPriorities::getNextHighest(const SchedulingManager& S,
|
||||
cycles_t curTime)
|
||||
{
|
||||
cycles_t curTime) {
|
||||
int nextIdx = -1;
|
||||
const SchedGraphNode* nextChoice = NULL;
|
||||
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
|
||||
while (nextIdx < 0 && mcands.size() > 0)
|
||||
{
|
||||
nextIdx = chooseByRule1(mcands); // rule 1
|
||||
while (nextIdx < 0 && mcands.size() > 0) {
|
||||
nextIdx = chooseByRule1(mcands); // rule 1
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule2(mcands); // rule 2
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule2(mcands); // rule 2
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule3(mcands); // rule 3
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule3(mcands); // rule 3
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = 0; // default to first choice by delays
|
||||
if (nextIdx == -1)
|
||||
nextIdx = 0; // default to first choice by delays
|
||||
|
||||
// We have found the next best candidate. Check if it ready in
|
||||
// the current cycle, and if it is feasible.
|
||||
// If not, remove it from mcands and continue. Refill mcands if
|
||||
// it becomes empty.
|
||||
nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
|
||||
if (getEarliestReadyTimeForNode(nextChoice) > curTime
|
||||
|| ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
|
||||
{
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
nextIdx = -1;
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
}
|
||||
}
|
||||
|
||||
if (nextIdx >= 0)
|
||||
// We have found the next best candidate. Check if it ready in
|
||||
// the current cycle, and if it is feasible.
|
||||
// If not, remove it from mcands and continue. Refill mcands if
|
||||
// it becomes empty.
|
||||
nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
|
||||
if (getEarliestReadyTimeForNode(nextChoice) > curTime
|
||||
|| ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
|
||||
{
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
return nextChoice;
|
||||
nextIdx = -1;
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
}
|
||||
else
|
||||
}
|
||||
|
||||
if (nextIdx >= 0) {
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
return nextChoice;
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -258,15 +241,14 @@ SchedPriorities::findSetWithMaxDelay(std::vector<candIndex>& mcands,
|
||||
|
||||
nextToTry = next;
|
||||
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace)
|
||||
{
|
||||
cerr << " Cycle " << (long)getTime() << ": "
|
||||
<< "Next highest delay = " << (long)maxDelay << " : "
|
||||
<< mcands.size() << " Nodes with this delay: ";
|
||||
for (unsigned i=0; i < mcands.size(); i++)
|
||||
cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
|
||||
cerr << "\n";
|
||||
}
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace) {
|
||||
std::cerr << " Cycle " << (long)getTime() << ": "
|
||||
<< "Next highest delay = " << (long)maxDelay << " : "
|
||||
<< mcands.size() << " Nodes with this delay: ";
|
||||
for (unsigned i=0; i < mcands.size(); i++)
|
||||
std::cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
|
||||
std::cerr << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -22,7 +22,6 @@
|
||||
#include "llvm/CodeGen/MachineBasicBlock.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "Support/PostOrderIterator.h"
|
||||
using std::cerr;
|
||||
|
||||
std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd) {
|
||||
return os << "Delay for node " << nd->node->getNodeId()
|
||||
@ -43,41 +42,35 @@ SchedPriorities::SchedPriorities(const Function *, const SchedGraph *G,
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::initialize()
|
||||
{
|
||||
SchedPriorities::initialize() {
|
||||
initializeReadyHeap(graph);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::computeDelays(const SchedGraph* graph)
|
||||
{
|
||||
SchedPriorities::computeDelays(const SchedGraph* graph) {
|
||||
po_iterator<const SchedGraph*> poIter = po_begin(graph), poEnd =po_end(graph);
|
||||
for ( ; poIter != poEnd; ++poIter)
|
||||
{
|
||||
const SchedGraphNode* node = *poIter;
|
||||
cycles_t nodeDelay;
|
||||
if (node->beginOutEdges() == node->endOutEdges())
|
||||
nodeDelay = node->getLatency();
|
||||
else
|
||||
{
|
||||
// Iterate over the out-edges of the node to compute delay
|
||||
nodeDelay = 0;
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E)
|
||||
{
|
||||
cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
|
||||
nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
getNodeDelayRef(node) = nodeDelay;
|
||||
for ( ; poIter != poEnd; ++poIter) {
|
||||
const SchedGraphNode* node = *poIter;
|
||||
cycles_t nodeDelay;
|
||||
if (node->beginOutEdges() == node->endOutEdges())
|
||||
nodeDelay = node->getLatency();
|
||||
else {
|
||||
// Iterate over the out-edges of the node to compute delay
|
||||
nodeDelay = 0;
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E) {
|
||||
cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
|
||||
nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
getNodeDelayRef(node) = nodeDelay;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
{
|
||||
SchedPriorities::initializeReadyHeap(const SchedGraph* graph) {
|
||||
const SchedGraphNode* graphRoot = (const SchedGraphNode*)graph->getRoot();
|
||||
assert(graphRoot->getMachineInstr() == NULL && "Expect dummy root");
|
||||
|
||||
@ -88,9 +81,9 @@ SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
|
||||
#undef TEST_HEAP_CONVERSION
|
||||
#ifdef TEST_HEAP_CONVERSION
|
||||
cerr << "Before heap conversion:\n";
|
||||
std::cerr << "Before heap conversion:\n";
|
||||
copy(candsAsHeap.begin(), candsAsHeap.end(),
|
||||
ostream_iterator<NodeDelayPair*>(cerr,"\n"));
|
||||
ostream_iterator<NodeDelayPair*>(std::cerr,"\n"));
|
||||
#endif
|
||||
|
||||
candsAsHeap.makeHeap();
|
||||
@ -98,55 +91,54 @@ SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
|
||||
nextToTry = candsAsHeap.begin();
|
||||
|
||||
#ifdef TEST_HEAP_CONVERSION
|
||||
cerr << "After heap conversion:\n";
|
||||
std::cerr << "After heap conversion:\n";
|
||||
copy(candsAsHeap.begin(), candsAsHeap.end(),
|
||||
ostream_iterator<NodeDelayPair*>(cerr,"\n"));
|
||||
ostream_iterator<NodeDelayPair*>(std::cerr,"\n"));
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
SchedPriorities::insertReady(const SchedGraphNode* node)
|
||||
{
|
||||
SchedPriorities::insertReady(const SchedGraphNode* node) {
|
||||
candsAsHeap.insert(node, nodeDelayVec[node->getNodeId()]);
|
||||
candsAsSet.insert(node);
|
||||
mcands.clear(); // ensure reset choices is called before any more choices
|
||||
earliestReadyTime = std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(node));
|
||||
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace)
|
||||
{
|
||||
cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
|
||||
<< getEarliestReadyTimeForNode(node) << "; "
|
||||
<< " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n";
|
||||
cerr << " " << *node->getMachineInstr() << "\n";
|
||||
}
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace) {
|
||||
std::cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
|
||||
<< getEarliestReadyTimeForNode(node) << "; "
|
||||
<< " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n"
|
||||
<< " " << *node->getMachineInstr() << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
|
||||
const SchedGraphNode* node)
|
||||
{
|
||||
const SchedGraphNode* node) {
|
||||
candsAsHeap.removeNode(node);
|
||||
candsAsSet.erase(node);
|
||||
mcands.clear(); // ensure reset choices is called before any more choices
|
||||
|
||||
if (earliestReadyTime == getEarliestReadyTimeForNode(node))
|
||||
{// earliestReadyTime may have been due to this node, so recompute it
|
||||
earliestReadyTime = HUGE_LATENCY;
|
||||
for (NodeHeap::const_iterator I=candsAsHeap.begin();
|
||||
I != candsAsHeap.end(); ++I)
|
||||
if (candsAsHeap.getNode(I))
|
||||
earliestReadyTime = std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
|
||||
}
|
||||
if (earliestReadyTime == getEarliestReadyTimeForNode(node)) {
|
||||
// earliestReadyTime may have been due to this node, so recompute it
|
||||
earliestReadyTime = HUGE_LATENCY;
|
||||
for (NodeHeap::const_iterator I=candsAsHeap.begin();
|
||||
I != candsAsHeap.end(); ++I)
|
||||
if (candsAsHeap.getNode(I)) {
|
||||
earliestReadyTime =
|
||||
std::min(earliestReadyTime,
|
||||
getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
|
||||
}
|
||||
}
|
||||
|
||||
// Now update ready times for successors
|
||||
for (SchedGraphNode::const_iterator E=node->beginOutEdges();
|
||||
E != node->endOutEdges(); ++E)
|
||||
{
|
||||
cycles_t& etime = getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
|
||||
etime = std::max(etime, curTime + (*E)->getMinDelay());
|
||||
}
|
||||
E != node->endOutEdges(); ++E) {
|
||||
cycles_t& etime =
|
||||
getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
|
||||
etime = std::max(etime, curTime + (*E)->getMinDelay());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -160,15 +152,13 @@ SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule1(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule1(std::vector<candIndex>& mcands) {
|
||||
return (mcands.size() == 1)? 0 // only one choice exists so take it
|
||||
: -1; // -1 indicates multiple choices
|
||||
}
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands) {
|
||||
assert(mcands.size() >= 1 && "Should have at least one candidate here.");
|
||||
for (unsigned i=0, N = mcands.size(); i < N; i++)
|
||||
if (instructionHasLastUse(methodLiveVarInfo,
|
||||
@ -178,67 +168,60 @@ SchedPriorities::chooseByRule2(std::vector<candIndex>& mcands)
|
||||
}
|
||||
|
||||
inline int
|
||||
SchedPriorities::chooseByRule3(std::vector<candIndex>& mcands)
|
||||
{
|
||||
SchedPriorities::chooseByRule3(std::vector<candIndex>& mcands) {
|
||||
assert(mcands.size() >= 1 && "Should have at least one candidate here.");
|
||||
int maxUses = candsAsHeap.getNode(mcands[0])->getNumOutEdges();
|
||||
int indexWithMaxUses = 0;
|
||||
for (unsigned i=1, N = mcands.size(); i < N; i++)
|
||||
{
|
||||
int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
|
||||
if (numUses > maxUses)
|
||||
{
|
||||
maxUses = numUses;
|
||||
indexWithMaxUses = i;
|
||||
}
|
||||
for (unsigned i=1, N = mcands.size(); i < N; i++) {
|
||||
int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
|
||||
if (numUses > maxUses) {
|
||||
maxUses = numUses;
|
||||
indexWithMaxUses = i;
|
||||
}
|
||||
}
|
||||
return indexWithMaxUses;
|
||||
}
|
||||
|
||||
const SchedGraphNode*
|
||||
SchedPriorities::getNextHighest(const SchedulingManager& S,
|
||||
cycles_t curTime)
|
||||
{
|
||||
cycles_t curTime) {
|
||||
int nextIdx = -1;
|
||||
const SchedGraphNode* nextChoice = NULL;
|
||||
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
|
||||
while (nextIdx < 0 && mcands.size() > 0)
|
||||
{
|
||||
nextIdx = chooseByRule1(mcands); // rule 1
|
||||
while (nextIdx < 0 && mcands.size() > 0) {
|
||||
nextIdx = chooseByRule1(mcands); // rule 1
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule2(mcands); // rule 2
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule2(mcands); // rule 2
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule3(mcands); // rule 3
|
||||
if (nextIdx == -1)
|
||||
nextIdx = chooseByRule3(mcands); // rule 3
|
||||
|
||||
if (nextIdx == -1)
|
||||
nextIdx = 0; // default to first choice by delays
|
||||
if (nextIdx == -1)
|
||||
nextIdx = 0; // default to first choice by delays
|
||||
|
||||
// We have found the next best candidate. Check if it ready in
|
||||
// the current cycle, and if it is feasible.
|
||||
// If not, remove it from mcands and continue. Refill mcands if
|
||||
// it becomes empty.
|
||||
nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
|
||||
if (getEarliestReadyTimeForNode(nextChoice) > curTime
|
||||
|| ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
|
||||
{
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
nextIdx = -1;
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
}
|
||||
}
|
||||
|
||||
if (nextIdx >= 0)
|
||||
// We have found the next best candidate. Check if it ready in
|
||||
// the current cycle, and if it is feasible.
|
||||
// If not, remove it from mcands and continue. Refill mcands if
|
||||
// it becomes empty.
|
||||
nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
|
||||
if (getEarliestReadyTimeForNode(nextChoice) > curTime
|
||||
|| ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
|
||||
{
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
return nextChoice;
|
||||
nextIdx = -1;
|
||||
if (mcands.size() == 0)
|
||||
findSetWithMaxDelay(mcands, S);
|
||||
}
|
||||
else
|
||||
}
|
||||
|
||||
if (nextIdx >= 0) {
|
||||
mcands.erase(mcands.begin() + nextIdx);
|
||||
return nextChoice;
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -258,15 +241,14 @@ SchedPriorities::findSetWithMaxDelay(std::vector<candIndex>& mcands,
|
||||
|
||||
nextToTry = next;
|
||||
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace)
|
||||
{
|
||||
cerr << " Cycle " << (long)getTime() << ": "
|
||||
<< "Next highest delay = " << (long)maxDelay << " : "
|
||||
<< mcands.size() << " Nodes with this delay: ";
|
||||
for (unsigned i=0; i < mcands.size(); i++)
|
||||
cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
|
||||
cerr << "\n";
|
||||
}
|
||||
if (SchedDebugLevel >= Sched_PrintSchedTrace) {
|
||||
std::cerr << " Cycle " << (long)getTime() << ": "
|
||||
<< "Next highest delay = " << (long)maxDelay << " : "
|
||||
<< mcands.size() << " Nodes with this delay: ";
|
||||
for (unsigned i=0; i < mcands.size(); i++)
|
||||
std::cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
|
||||
std::cerr << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user