RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-03 05:41:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove trailing whitespace, no functionality changes.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@107244 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
John Mosby 2010-06-30 03:40:54 +00:00
parent 555bea62dd
commit 9f71f801b5
1 changed files with 18 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/CodeGen/ScheduleDAG.cpp
View File

@ -380,26 +380,26 @@ void ScheduleDAG::VerifySchedule(bool isBottomUp) {
} }
#endif #endif
/// InitDAGTopologicalSorting - create the initial topological /// InitDAGTopologicalSorting - create the initial topological
/// ordering from the DAG to be scheduled. /// ordering from the DAG to be scheduled.
/// ///
/// The idea of the algorithm is taken from /// The idea of the algorithm is taken from
/// "Online algorithms for managing the topological order of /// "Online algorithms for managing the topological order of
/// a directed acyclic graph" by David J. Pearce and Paul H.J. Kelly /// a directed acyclic graph" by David J. Pearce and Paul H.J. Kelly
/// This is the MNR algorithm, which was first introduced by /// This is the MNR algorithm, which was first introduced by
/// A. Marchetti-Spaccamela, U. Nanni and H. Rohnert in /// A. Marchetti-Spaccamela, U. Nanni and H. Rohnert in
/// "Maintaining a topological order under edge insertions". /// "Maintaining a topological order under edge insertions".
/// ///
/// Short description of the algorithm: /// Short description of the algorithm:
/// ///
/// Topological ordering, ord, of a DAG maps each node to a topological /// Topological ordering, ord, of a DAG maps each node to a topological
/// index so that for all edges X->Y it is the case that ord(X) < ord(Y). /// index so that for all edges X->Y it is the case that ord(X) < ord(Y).
/// ///
/// This means that if there is a path from the node X to the node Z, /// This means that if there is a path from the node X to the node Z,
/// then ord(X) < ord(Z). /// then ord(X) < ord(Z).
/// ///
/// This property can be used to check for reachability of nodes: /// This property can be used to check for reachability of nodes:
/// if Z is reachable from X, then an insertion of the edge Z->X would /// if Z is reachable from X, then an insertion of the edge Z->X would
/// create a cycle. /// create a cycle.
/// ///
/// The algorithm first computes a topological ordering for the DAG by /// The algorithm first computes a topological ordering for the DAG by
@ -431,7 +431,7 @@ void ScheduleDAGTopologicalSort::InitDAGTopologicalSorting() {
// Collect leaf nodes. // Collect leaf nodes.
WorkList.push_back(SU); WorkList.push_back(SU);
} }
} }
int Id = DAGSize; int Id = DAGSize;
while (!WorkList.empty()) { while (!WorkList.empty()) {
@ -456,7 +456,7 @@ void ScheduleDAGTopologicalSort::InitDAGTopologicalSorting() {
SUnit *SU = &SUnits[i]; SUnit *SU = &SUnits[i];
for (SUnit::const_pred_iterator I = SU->Preds.begin(), E = SU->Preds.end(); for (SUnit::const_pred_iterator I = SU->Preds.begin(), E = SU->Preds.end();
I != E; ++I) { I != E; ++I) {
assert(Node2Index[SU->NodeNum] > Node2Index[I->getSUnit()->NodeNum] && assert(Node2Index[SU->NodeNum] > Node2Index[I->getSUnit()->NodeNum] &&
"Wrong topological sorting"); "Wrong topological sorting");
} }
} }
@ -494,7 +494,7 @@ void ScheduleDAGTopologicalSort::RemovePred(SUnit *M, SUnit *N) {
void ScheduleDAGTopologicalSort::DFS(const SUnit *SU, int UpperBound, void ScheduleDAGTopologicalSort::DFS(const SUnit *SU, int UpperBound,
bool& HasLoop) { bool& HasLoop) {
std::vector<const SUnit*> WorkList; std::vector<const SUnit*> WorkList;
WorkList.reserve(SUnits.size()); WorkList.reserve(SUnits.size());
WorkList.push_back(SU); WorkList.push_back(SU);
do { do {
@ -504,20 +504,20 @@ void ScheduleDAGTopologicalSort::DFS(const SUnit *SU, int UpperBound,
for (int I = SU->Succs.size()-1; I >= 0; --I) { for (int I = SU->Succs.size()-1; I >= 0; --I) {
int s = SU->Succs[I].getSUnit()->NodeNum; int s = SU->Succs[I].getSUnit()->NodeNum;
if (Node2Index[s] == UpperBound) { if (Node2Index[s] == UpperBound) {
HasLoop = true; HasLoop = true;
return; return;
} }
// Visit successors if not already and in affected region. // Visit successors if not already and in affected region.
if (!Visited.test(s) && Node2Index[s] < UpperBound) { if (!Visited.test(s) && Node2Index[s] < UpperBound) {
WorkList.push_back(SU->Succs[I].getSUnit()); WorkList.push_back(SU->Succs[I].getSUnit());
} }
} }
} while (!WorkList.empty()); } while (!WorkList.empty());
} }
/// Shift - Renumber the nodes so that the topological ordering is /// Shift - Renumber the nodes so that the topological ordering is
/// preserved. /// preserved.
void ScheduleDAGTopologicalSort::Shift(BitVector& Visited, int LowerBound, void ScheduleDAGTopologicalSort::Shift(BitVector& Visited, int LowerBound,
int UpperBound) { int UpperBound) {
std::vector<int> L; std::vector<int> L;
int shift = 0; int shift = 0;
@ -568,7 +568,7 @@ bool ScheduleDAGTopologicalSort::IsReachable(const SUnit *SU,
// Is Ord(TargetSU) < Ord(SU) ? // Is Ord(TargetSU) < Ord(SU) ?
if (LowerBound < UpperBound) { if (LowerBound < UpperBound) {
Visited.reset(); Visited.reset();
// There may be a path from TargetSU to SU. Check for it. // There may be a path from TargetSU to SU. Check for it.
DFS(TargetSU, UpperBound, HasLoop); DFS(TargetSU, UpperBound, HasLoop);
} }
return HasLoop; return HasLoop;
@ -580,8 +580,7 @@ void ScheduleDAGTopologicalSort::Allocate(int n, int index) {
Index2Node[index] = n; Index2Node[index] = n;
} }
ScheduleDAGTopologicalSort::ScheduleDAGTopologicalSort( ScheduleDAGTopologicalSort::
std::vector<SUnit> &sunits) ScheduleDAGTopologicalSort(std::vector<SUnit> &sunits) : SUnits(sunits) {}
: SUnits(sunits) {}
ScheduleHazardRecognizer::~ScheduleHazardRecognizer() {} ScheduleHazardRecognizer::~ScheduleHazardRecognizer() {}