-// -*-C++-*-
-//***************************************************************************
-// File:
-// SchedPriorities.h
+//===-- SchedPriorities.h - Encapsulate scheduling heuristics --*- C++ -*--===//
//
-// Purpose:
-// Encapsulate heuristics for instruction scheduling.
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// Strategy:
// Priority ordering rules:
// (3) Instruction that has the maximum number of dependent instructions.
// Note that rules 2 and 3 are only used if issue conflicts prevent
// choosing a higher priority instruction by rule 1.
-//
-// History:
-// 7/30/01 - Vikram Adve - Created
-//**************************************************************************/
+//
+//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_SCHEDPRIORITIES_H
#define LLVM_CODEGEN_SCHEDPRIORITIES_H
#include "SchedGraph.h"
#include "llvm/CodeGen/InstrScheduling.h"
-#include "llvm/Target/MachineSchedInfo.h"
-#include "Support/CommandLine.h"
+#include "llvm/Target/TargetSchedInfo.h"
+#include "llvm/ADT/hash_set"
#include <list>
-#include <hash_set>
-class Method;
+
+namespace llvm {
+
+class Function;
class MachineInstr;
class SchedulingManager;
-class MethodLiveVarInfo;
+class FunctionLiveVarInfo;
//---------------------------------------------------------------------------
// Debug option levels for instruction scheduling
enum SchedDebugLevel_t {
Sched_NoDebugInfo,
+ Sched_Disable,
Sched_PrintMachineCode,
Sched_PrintSchedTrace,
Sched_PrintSchedGraphs,
};
-extern cl::Enum<SchedDebugLevel_t> SchedDebugLevel;
+extern SchedDebugLevel_t SchedDebugLevel;
//---------------------------------------------------------------------------
// Function: instrIsFeasible
return np1->delay < np2->delay;
}
-class NodeHeap: public std::list<NodeDelayPair*>, public NonCopyable {
+class NodeHeap : public std::list<NodeDelayPair*> {
+ NodeHeap(const NodeHeap&); // DO NOT IMPLEMENT
+ void operator=(const NodeHeap&); // DO NOT IMPLEMENT
public:
typedef std::list<NodeDelayPair*>::iterator iterator;
typedef std::list<NodeDelayPair*>::const_iterator const_iterator;
};
-class SchedPriorities: public NonCopyable {
+class SchedPriorities {
+ SchedPriorities(const SchedPriorities&); // DO NOT IMPLEMENT
+ void operator=(const SchedPriorities &); // DO NOT IMPLEMENT
public:
- SchedPriorities(const Method *M, const SchedGraph *G, MethodLiveVarInfo &LVI);
+ SchedPriorities(const Function *F, const SchedGraph *G,
+ FunctionLiveVarInfo &LVI);
// This must be called before scheduling begins.
private:
cycles_t curTime;
const SchedGraph* graph;
- MethodLiveVarInfo &methodLiveVarInfo;
- std::hash_map<const MachineInstr*, bool> lastUseMap;
+ FunctionLiveVarInfo &methodLiveVarInfo;
+ hash_map<const MachineInstr*, bool> lastUseMap;
std::vector<cycles_t> nodeDelayVec;
- std::vector<cycles_t> earliestForNode;
+ std::vector<cycles_t> nodeEarliestUseVec;
+ std::vector<cycles_t> earliestReadyTimeForNode;
cycles_t earliestReadyTime;
NodeHeap candsAsHeap; // candidate nodes, ready to go
- std::hash_set<const SchedGraphNode*> candsAsSet;//same entries as candsAsHeap,
+ hash_set<const SchedGraphNode*> candsAsSet; //same entries as candsAsHeap,
// but as set for fast lookup
std::vector<candIndex> mcands; // holds pointers into cands
candIndex nextToTry; // next cand after the last
void initializeReadyHeap (const SchedGraph* graph);
- bool instructionHasLastUse (MethodLiveVarInfo& methodLiveVarInfo,
+ bool instructionHasLastUse (FunctionLiveVarInfo& LVI,
const SchedGraphNode* graphNode);
// NOTE: The next two return references to the actual vector entries.
- // Use with care.
+ // Use the following two if you don't need to modify the value.
cycles_t& getNodeDelayRef (const SchedGraphNode* node) {
assert(node->getNodeId() < nodeDelayVec.size());
return nodeDelayVec[node->getNodeId()];
}
- cycles_t& getEarliestForNodeRef (const SchedGraphNode* node) {
- assert(node->getNodeId() < earliestForNode.size());
- return earliestForNode[node->getNodeId()];
+ cycles_t& getEarliestReadyTimeForNodeRef (const SchedGraphNode* node) {
+ assert(node->getNodeId() < earliestReadyTimeForNode.size());
+ return earliestReadyTimeForNode[node->getNodeId()];
+ }
+
+ cycles_t getNodeDelay (const SchedGraphNode* node) const {
+ return ((SchedPriorities*) this)->getNodeDelayRef(node);
+ }
+ cycles_t getEarliestReadyTimeForNode(const SchedGraphNode* node) const {
+ return ((SchedPriorities*) this)->getEarliestReadyTimeForNodeRef(node);
}
};
mcands.clear();
}
-inline std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd) {
- return os << "Delay for node " << nd->node->getNodeId()
- << " = " << (long)nd->delay << "\n";
-}
+std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd);
+
+} // End llvm namespace
#endif