+//===- SchedGraphCommon.cpp - Scheduling Graphs Base Class- ---------------===//
+//
+// Scheduling graph base class that contains common information for SchedGraph
+// and ModuloSchedGraph scheduling graphs.
+//
+//===----------------------------------------------------------------------===//
+
#include "llvm/CodeGen/SchedGraphCommon.h"
#include "Support/STLExtras.h"
class SchedGraphCommon;
-//
+//
// class SchedGraphEdge
//
-
-/*ctor*/
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
SchedGraphNodeCommon* _sink,
SchedGraphEdgeDepType _depType,
unsigned int _depOrderType,
int _minDelay)
- : src(_src),
- sink(_sink),
- depType(_depType),
- depOrderType(_depOrderType),
- minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
- val(NULL)
-{
+ : src(_src), sink(_sink), depType(_depType), depOrderType(_depOrderType),
+ minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()), val(NULL) {
+
iteDiff=0;
assert(src != sink && "Self-loop in scheduling graph!");
src->addOutEdge(this);
sink->addInEdge(this);
}
-
-/*ctor*/
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
SchedGraphNodeCommon* _sink,
const Value* _val,
unsigned int _depOrderType,
int _minDelay)
- : src(_src),
- sink(_sink),
- depType(ValueDep),
- depOrderType(_depOrderType),
- minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
- val(_val)
-{
+ : src(_src), sink(_sink), depType(ValueDep), depOrderType(_depOrderType),
+ minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()), val(_val) {
iteDiff=0;
assert(src != sink && "Self-loop in scheduling graph!");
src->addOutEdge(this);
sink->addInEdge(this);
}
-
-/*ctor*/
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
SchedGraphNodeCommon* _sink,
unsigned int _regNum,
unsigned int _depOrderType,
int _minDelay)
- : src(_src),
- sink(_sink),
- depType(MachineRegister),
+ : src(_src), sink(_sink), depType(MachineRegister),
depOrderType(_depOrderType),
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
- machineRegNum(_regNum)
-{
+ machineRegNum(_regNum) {
iteDiff=0;
assert(src != sink && "Self-loop in scheduling graph!");
src->addOutEdge(this);
sink->addInEdge(this);
}
-
-/*ctor*/
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
SchedGraphNodeCommon* _sink,
ResourceId _resourceId,
int _minDelay)
- : src(_src),
- sink(_sink),
- depType(MachineResource),
- depOrderType(NonDataDep),
+ : src(_src), sink(_sink), depType(MachineResource), depOrderType(NonDataDep),
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
- resourceId(_resourceId)
-{
+ resourceId(_resourceId) {
iteDiff=0;
assert(src != sink && "Self-loop in scheduling graph!");
src->addOutEdge(this);
sink->addInEdge(this);
}
-/*dtor*/
-SchedGraphEdge::~SchedGraphEdge()
-{
-}
-
-void SchedGraphEdge::dump(int indent) const {
- std::cerr << std::string(indent*2, ' ') << *this;
-}
-/*ctor*/
-
-SchedGraphNodeCommon::SchedGraphNodeCommon(unsigned _nodeId)
- :ID(_nodeId),
- latency(0){
-
+void SchedGraphEdge::dump(int indent) const {
+ std::cerr << std::string(indent*2, ' ') << *this;
}
/*dtor*/
deleter<SchedGraphEdge>);
}
-
-void SchedGraphNodeCommon::dump(int indent) const {
- std::cerr << std::string(indent*2, ' ') << *this;
-}
-
-
-inline void
-SchedGraphNodeCommon::addInEdge(SchedGraphEdge* edge)
-{
- inEdges.push_back(edge);
-}
-
-
-inline void
-SchedGraphNodeCommon::addOutEdge(SchedGraphEdge* edge)
-{
- outEdges.push_back(edge);
-}
-
-inline void
-SchedGraphNodeCommon::removeInEdge(const SchedGraphEdge* edge)
-{
+void SchedGraphNodeCommon::removeInEdge(const SchedGraphEdge* edge) {
assert(edge->getSink() == this);
for (iterator I = beginInEdges(); I != endInEdges(); ++I)
- if ((*I) == edge)
- {
- inEdges.erase(I);
- break;
- }
+ if ((*I) == edge) {
+ inEdges.erase(I);
+ break;
+ }
}
-inline void
-SchedGraphNodeCommon::removeOutEdge(const SchedGraphEdge* edge)
-{
+void SchedGraphNodeCommon::removeOutEdge(const SchedGraphEdge* edge) {
assert(edge->getSrc() == this);
for (iterator I = beginOutEdges(); I != endOutEdges(); ++I)
- if ((*I) == edge)
- {
- outEdges.erase(I);
- break;
- }
+ if ((*I) == edge) {
+ outEdges.erase(I);
+ break;
+ }
}
-
-//class SchedGraphCommon
-
-/*ctor*/
-SchedGraphCommon::SchedGraphCommon()
-{
+void SchedGraphNodeCommon::dump(int indent) const {
+ std::cerr << std::string(indent*2, ' ') << *this;
}
+//class SchedGraphCommon
-/*dtor*/
-SchedGraphCommon::~SchedGraphCommon()
-{
-
+SchedGraphCommon::~SchedGraphCommon() {
delete graphRoot;
delete graphLeaf;
}
-void
-SchedGraphCommon::eraseIncomingEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
-{
+void SchedGraphCommon::eraseIncomingEdges(SchedGraphNodeCommon* node,
+ bool addDummyEdges) {
// Delete and disconnect all in-edges for the node
for (SchedGraphNodeCommon::iterator I = node->beginInEdges();
- I != node->endInEdges(); ++I)
- {
- SchedGraphNodeCommon* srcNode = (*I)->getSrc();
- srcNode->removeOutEdge(*I);
- delete *I;
+ I != node->endInEdges(); ++I) {
+ SchedGraphNodeCommon* srcNode = (*I)->getSrc();
+ srcNode->removeOutEdge(*I);
+ delete *I;
+
+ if (addDummyEdges && srcNode != getRoot() &&
+ srcNode->beginOutEdges() == srcNode->endOutEdges()) {
- if (addDummyEdges &&
- srcNode != getRoot() &&
- srcNode->beginOutEdges() == srcNode->endOutEdges())
- { // srcNode has no more out edges, so add an edge to dummy EXIT node
- assert(node != getLeaf() && "Adding edge that was just removed?");
- (void) new SchedGraphEdge(srcNode, getLeaf(),
- SchedGraphEdge::CtrlDep, SchedGraphEdge::NonDataDep, 0);
- }
+ // srcNode has no more out edges, so add an edge to dummy EXIT node
+ assert(node != getLeaf() && "Adding edge that was just removed?");
+ (void) new SchedGraphEdge(srcNode, getLeaf(),
+ SchedGraphEdge::CtrlDep,
+ SchedGraphEdge::NonDataDep, 0);
}
+ }
node->inEdges.clear();
}
-void
-SchedGraphCommon::eraseOutgoingEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
-{
+void SchedGraphCommon::eraseOutgoingEdges(SchedGraphNodeCommon* node,
+ bool addDummyEdges) {
// Delete and disconnect all out-edges for the node
for (SchedGraphNodeCommon::iterator I = node->beginOutEdges();
- I != node->endOutEdges(); ++I)
- {
- SchedGraphNodeCommon* sinkNode = (*I)->getSink();
- sinkNode->removeInEdge(*I);
- delete *I;
+ I != node->endOutEdges(); ++I) {
+ SchedGraphNodeCommon* sinkNode = (*I)->getSink();
+ sinkNode->removeInEdge(*I);
+ delete *I;
+
+ if (addDummyEdges &&
+ sinkNode != getLeaf() &&
+ sinkNode->beginInEdges() == sinkNode->endInEdges()) {
- if (addDummyEdges &&
- sinkNode != getLeaf() &&
- sinkNode->beginInEdges() == sinkNode->endInEdges())
- { //sinkNode has no more in edges, so add an edge from dummy ENTRY node
- assert(node != getRoot() && "Adding edge that was just removed?");
- (void) new SchedGraphEdge(getRoot(), sinkNode,
- SchedGraphEdge::CtrlDep, SchedGraphEdge::NonDataDep, 0);
- }
+ //sinkNode has no more in edges, so add an edge from dummy ENTRY node
+ assert(node != getRoot() && "Adding edge that was just removed?");
+ (void) new SchedGraphEdge(getRoot(), sinkNode,
+ SchedGraphEdge::CtrlDep,
+ SchedGraphEdge::NonDataDep, 0);
}
+ }
node->outEdges.clear();
}
-void
-SchedGraphCommon::eraseIncidentEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
-{
+void SchedGraphCommon::eraseIncidentEdges(SchedGraphNodeCommon* node,
+ bool addDummyEdges) {
this->eraseIncomingEdges(node, addDummyEdges);
this->eraseOutgoingEdges(node, addDummyEdges);
}
-std::ostream &operator<<(std::ostream &os, const SchedGraphNodeCommon& node)
-{
-
- return os;
-}
projects / oota-llvm.git / blobdiff