mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-30 07:22:55 +01:00
411 lines
16 KiB
C++
411 lines
16 KiB
C++
//===-- MSchedGraphSB.h - Scheduling Graph ------------------------*- C++ -*-===//
|
|
//
|
|
// 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.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// A graph class for dependencies. This graph only contains true, anti, and
|
|
// output data dependencies for a vector of MachineBasicBlock. Dependencies
|
|
// across iterations are also computed. Unless data dependence analysis
|
|
// is provided, a conservative approach of adding dependencies between all
|
|
// loads and stores is taken. It also includes pseudo predicate nodes for
|
|
// modulo scheduling superblocks.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_MSCHEDGRAPHSB_H
|
|
#define LLVM_MSCHEDGRAPHSB_H
|
|
#include "DependenceAnalyzer.h"
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include "llvm/Target/TargetData.h"
|
|
#include "llvm/ADT/GraphTraits.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/iterator"
|
|
#include <vector>
|
|
|
|
|
|
namespace llvm {
|
|
|
|
class MSchedGraphSB;
|
|
class MSchedGraphSBNode;
|
|
template<class IteratorType, class NodeType>
|
|
class MSchedGraphSBNodeIterator;
|
|
|
|
//MSchedGraphSBEdge encapsulates the data dependence between nodes. It
|
|
//identifies the dependence type, on what, and the iteration
|
|
//difference
|
|
struct MSchedGraphSBEdge {
|
|
enum DataDepOrderType {
|
|
TrueDep, AntiDep, OutputDep, NonDataDep
|
|
};
|
|
|
|
enum MSchedGraphSBEdgeType {
|
|
MemoryDep, ValueDep, MachineRegister, PredDep
|
|
};
|
|
|
|
//Get or set edge data
|
|
MSchedGraphSBNode *getDest() const { return dest; }
|
|
unsigned getIteDiff() { return iteDiff; }
|
|
unsigned getDepOrderType() { return depOrderType; }
|
|
void setDest(MSchedGraphSBNode *newDest) { dest = newDest; }
|
|
|
|
private:
|
|
friend class MSchedGraphSBNode;
|
|
MSchedGraphSBEdge(MSchedGraphSBNode *destination, MSchedGraphSBEdgeType type,
|
|
unsigned deptype, unsigned diff)
|
|
: dest(destination), depType(type), depOrderType(deptype), iteDiff(diff) {}
|
|
|
|
MSchedGraphSBNode *dest;
|
|
MSchedGraphSBEdgeType depType;
|
|
unsigned depOrderType;
|
|
unsigned iteDiff;
|
|
};
|
|
|
|
//MSchedGraphSBNode represents a machine instruction and its
|
|
//corresponding latency. Each node also contains a list of its
|
|
//predecessors and sucessors.
|
|
class MSchedGraphSBNode {
|
|
|
|
const MachineInstr* Inst; //Machine Instruction
|
|
std::vector<const MachineInstr*> otherInstrs;
|
|
|
|
MSchedGraphSB* Parent; //Graph this node belongs to
|
|
unsigned index; //Index in BB
|
|
unsigned latency; //Latency of Instruction
|
|
bool isBranchInstr; //Is this node the branch instr or not
|
|
bool isPredicateNode; //Indicate if this node should be treated like a predicate
|
|
|
|
std::vector<MSchedGraphSBNode*> Predecessors; //Predecessor Nodes
|
|
std::vector<MSchedGraphSBEdge> Successors; //Successor edges
|
|
|
|
public:
|
|
MSchedGraphSBNode(const MachineInstr* inst, MSchedGraphSB *graph,
|
|
unsigned index, unsigned late=0, bool isBranch=false);
|
|
MSchedGraphSBNode(const MachineInstr* inst, std::vector<const MachineInstr*> &other,
|
|
MSchedGraphSB *graph,
|
|
unsigned index, unsigned late=0, bool isPNode=true);
|
|
MSchedGraphSBNode(const MSchedGraphSBNode &N);
|
|
|
|
//Iterators - Predecessor and Succussor
|
|
typedef std::vector<MSchedGraphSBNode*>::iterator pred_iterator;
|
|
pred_iterator pred_begin() { return Predecessors.begin(); }
|
|
pred_iterator pred_end() { return Predecessors.end(); }
|
|
unsigned pred_size() { return Predecessors.size(); }
|
|
|
|
typedef std::vector<MSchedGraphSBNode*>::const_iterator pred_const_iterator;
|
|
pred_const_iterator pred_begin() const { return Predecessors.begin(); }
|
|
pred_const_iterator pred_end() const { return Predecessors.end(); }
|
|
|
|
typedef MSchedGraphSBNodeIterator<std::vector<MSchedGraphSBEdge>::const_iterator,
|
|
const MSchedGraphSBNode> succ_const_iterator;
|
|
succ_const_iterator succ_begin() const;
|
|
succ_const_iterator succ_end() const;
|
|
|
|
typedef MSchedGraphSBNodeIterator<std::vector<MSchedGraphSBEdge>::iterator,
|
|
MSchedGraphSBNode> succ_iterator;
|
|
succ_iterator succ_begin();
|
|
succ_iterator succ_end();
|
|
unsigned succ_size() { return Successors.size(); }
|
|
|
|
//Get or set predecessor nodes, or successor edges
|
|
void setPredecessor(unsigned index, MSchedGraphSBNode *dest) {
|
|
Predecessors[index] = dest;
|
|
}
|
|
|
|
MSchedGraphSBNode* getPredecessor(unsigned index) {
|
|
return Predecessors[index];
|
|
}
|
|
|
|
MSchedGraphSBEdge* getSuccessor(unsigned index) {
|
|
return &Successors[index];
|
|
}
|
|
|
|
void deleteSuccessor(MSchedGraphSBNode *node) {
|
|
for (unsigned i = 0; i != Successors.size(); ++i)
|
|
if (Successors[i].getDest() == node) {
|
|
Successors.erase(Successors.begin()+i);
|
|
node->Predecessors.erase(std::find(node->Predecessors.begin(),
|
|
node->Predecessors.end(), this));
|
|
--i; //Decrease index var since we deleted a node
|
|
}
|
|
}
|
|
|
|
void addOutEdge(MSchedGraphSBNode *destination,
|
|
MSchedGraphSBEdge::MSchedGraphSBEdgeType type,
|
|
unsigned deptype, unsigned diff=0) {
|
|
Successors.push_back(MSchedGraphSBEdge(destination, type, deptype,diff));
|
|
destination->Predecessors.push_back(this);
|
|
}
|
|
|
|
//General methods to get and set data for the node
|
|
const MachineInstr* getInst() { return Inst; }
|
|
MSchedGraphSB* getParent() { return Parent; }
|
|
bool hasPredecessors() { return (Predecessors.size() > 0); }
|
|
bool hasSuccessors() { return (Successors.size() > 0); }
|
|
unsigned getLatency() { return latency; }
|
|
unsigned getLatency() const { return latency; }
|
|
unsigned getIndex() { return index; }
|
|
unsigned getIteDiff(MSchedGraphSBNode *succ);
|
|
MSchedGraphSBEdge getInEdge(MSchedGraphSBNode *pred);
|
|
unsigned getInEdgeNum(MSchedGraphSBNode *pred);
|
|
bool isSuccessor(MSchedGraphSBNode *);
|
|
bool isPredecessor(MSchedGraphSBNode *);
|
|
bool isBranch() { return isBranchInstr; }
|
|
bool isPredicate() { return isPredicateNode; }
|
|
bool isPredicate() const { return isPredicateNode; }
|
|
std::vector<const MachineInstr*> getOtherInstrs() { return otherInstrs; }
|
|
|
|
//Debug support
|
|
void print(std::ostream &os) const;
|
|
void setParent(MSchedGraphSB *p) { Parent = p; }
|
|
};
|
|
|
|
//Node iterator for graph generation
|
|
template<class IteratorType, class NodeType>
|
|
class MSchedGraphSBNodeIterator : public forward_iterator<NodeType*, ptrdiff_t> {
|
|
IteratorType I; // std::vector<MSchedGraphSBEdge>::iterator or const_iterator
|
|
public:
|
|
MSchedGraphSBNodeIterator(IteratorType i) : I(i) {}
|
|
|
|
bool operator==(const MSchedGraphSBNodeIterator RHS) const { return I == RHS.I; }
|
|
bool operator!=(const MSchedGraphSBNodeIterator RHS) const { return I != RHS.I; }
|
|
|
|
const MSchedGraphSBNodeIterator &operator=(const MSchedGraphSBNodeIterator &RHS) {
|
|
I = RHS.I;
|
|
return *this;
|
|
}
|
|
|
|
NodeType* operator*() const {
|
|
return I->getDest();
|
|
}
|
|
NodeType* operator->() const { return operator*(); }
|
|
|
|
MSchedGraphSBNodeIterator& operator++() { // Preincrement
|
|
++I;
|
|
return *this;
|
|
}
|
|
MSchedGraphSBNodeIterator operator++(int) { // Postincrement
|
|
MSchedGraphSBNodeIterator tmp = *this; ++*this; return tmp;
|
|
}
|
|
|
|
MSchedGraphSBEdge &getEdge() {
|
|
return *I;
|
|
}
|
|
const MSchedGraphSBEdge &getEdge() const {
|
|
return *I;
|
|
}
|
|
};
|
|
|
|
inline MSchedGraphSBNode::succ_const_iterator MSchedGraphSBNode::succ_begin() const {
|
|
return succ_const_iterator(Successors.begin());
|
|
}
|
|
inline MSchedGraphSBNode::succ_const_iterator MSchedGraphSBNode::succ_end() const {
|
|
return succ_const_iterator(Successors.end());
|
|
}
|
|
inline MSchedGraphSBNode::succ_iterator MSchedGraphSBNode::succ_begin() {
|
|
return succ_iterator(Successors.begin());
|
|
}
|
|
inline MSchedGraphSBNode::succ_iterator MSchedGraphSBNode::succ_end() {
|
|
return succ_iterator(Successors.end());
|
|
}
|
|
|
|
// ostream << operator for MSGraphNode class
|
|
inline std::ostream &operator<<(std::ostream &os,
|
|
const MSchedGraphSBNode &node) {
|
|
node.print(os);
|
|
return os;
|
|
}
|
|
|
|
|
|
// Provide specializations of GraphTraits to be able to use graph
|
|
// iterators on the scheduling graph!
|
|
//
|
|
template <> struct GraphTraits<MSchedGraphSBNode*> {
|
|
typedef MSchedGraphSBNode NodeType;
|
|
typedef MSchedGraphSBNode::succ_iterator ChildIteratorType;
|
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
return N->succ_begin();
|
|
}
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
|
return N->succ_end();
|
|
}
|
|
|
|
static NodeType *getEntryNode(NodeType* N) { return N; }
|
|
};
|
|
|
|
|
|
|
|
//Graph class to represent dependence graph
|
|
class MSchedGraphSB {
|
|
|
|
std::vector<const MachineBasicBlock *> BBs; //Machine basic block
|
|
const TargetMachine &Target; //Target Machine
|
|
|
|
//Nodes
|
|
std::map<const MachineInstr*, MSchedGraphSBNode*> GraphMap;
|
|
|
|
//Add Nodes and Edges to this graph for our BB
|
|
typedef std::pair<int, MSchedGraphSBNode*> OpIndexNodePair;
|
|
void buildNodesAndEdges(std::map<const MachineInstr*, unsigned> &ignoreInstrs, DependenceAnalyzer &DA, std::map<MachineInstr*, Instruction*> &machineTollvm, std::map<MSchedGraphSBNode*, std::set<MachineInstr*> > &liveOutsideTrace);
|
|
void addValueEdges(std::vector<OpIndexNodePair> &NodesInMap,
|
|
MSchedGraphSBNode *node,
|
|
bool nodeIsUse, bool nodeIsDef, std::vector<const MachineInstr*> &phiInstrs, int diff=0);
|
|
void addMachRegEdges(std::map<int,
|
|
std::vector<OpIndexNodePair> >& regNumtoNodeMap);
|
|
void addMemEdges(const std::vector<MSchedGraphSBNode*>& memInst,
|
|
DependenceAnalyzer &DA, std::map<MachineInstr*, Instruction*> &machineTollvm);
|
|
|
|
|
|
bool instrCauseException(MachineOpCode opCode);
|
|
|
|
public:
|
|
MSchedGraphSB(const MachineBasicBlock *bb, const TargetMachine &targ,
|
|
std::map<const MachineInstr*, unsigned> &ignoreInstrs,
|
|
DependenceAnalyzer &DA, std::map<MachineInstr*, Instruction*> &machineTollvm);
|
|
|
|
//Copy constructor with maps to link old nodes to new nodes
|
|
MSchedGraphSB(const MSchedGraphSB &G, std::map<MSchedGraphSBNode*, MSchedGraphSBNode*> &newNodes);
|
|
|
|
MSchedGraphSB(std::vector<const MachineBasicBlock*> &bbs,
|
|
const TargetMachine &targ,
|
|
std::map<const MachineInstr*, unsigned> &ignoreInstrs,
|
|
DependenceAnalyzer &DA,
|
|
std::map<MachineInstr*, Instruction*> &machineTollvm);
|
|
|
|
//Print graph
|
|
void print(std::ostream &os) const;
|
|
|
|
//Deconstructor!
|
|
~MSchedGraphSB();
|
|
|
|
//Add or delete nodes from the Graph
|
|
void addNode(const MachineInstr* MI, MSchedGraphSBNode *node);
|
|
void deleteNode(MSchedGraphSBNode *node);
|
|
int totalDelay();
|
|
|
|
//iterators
|
|
typedef std::map<const MachineInstr*, MSchedGraphSBNode*>::iterator iterator;
|
|
typedef std::map<const MachineInstr*, MSchedGraphSBNode*>::const_iterator const_iterator;
|
|
typedef std::map<const MachineInstr*, MSchedGraphSBNode*>::reverse_iterator reverse_iterator;
|
|
iterator find(const MachineInstr* I) { return GraphMap.find(I); }
|
|
iterator end() { return GraphMap.end(); }
|
|
iterator begin() { return GraphMap.begin(); }
|
|
unsigned size() { return GraphMap.size(); }
|
|
reverse_iterator rbegin() { return GraphMap.rbegin(); }
|
|
reverse_iterator rend() { return GraphMap.rend(); }
|
|
|
|
//Get Target or original machine basic block
|
|
const TargetMachine* getTarget() { return &Target; }
|
|
std::vector<const MachineBasicBlock*> getBBs() { return BBs; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Provide specializations of GraphTraits to be able to use graph
|
|
// iterators on the scheduling graph
|
|
static MSchedGraphSBNode& getSecond(std::pair<const MachineInstr* const,
|
|
MSchedGraphSBNode*> &Pair) {
|
|
return *Pair.second;
|
|
}
|
|
|
|
template <> struct GraphTraits<MSchedGraphSB*> {
|
|
typedef MSchedGraphSBNode NodeType;
|
|
typedef MSchedGraphSBNode::succ_iterator ChildIteratorType;
|
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
return N->succ_begin();
|
|
}
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
|
return N->succ_end();
|
|
}
|
|
|
|
typedef std::pointer_to_unary_function<std::pair<const MachineInstr* const,
|
|
MSchedGraphSBNode*>&, MSchedGraphSBNode&> DerefFun;
|
|
|
|
typedef mapped_iterator<MSchedGraphSB::iterator, DerefFun> nodes_iterator;
|
|
static nodes_iterator nodes_begin(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->begin(), DerefFun(getSecond));
|
|
}
|
|
static nodes_iterator nodes_end(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->end(), DerefFun(getSecond));
|
|
}
|
|
|
|
};
|
|
|
|
template <> struct GraphTraits<const MSchedGraphSB*> {
|
|
typedef const MSchedGraphSBNode NodeType;
|
|
typedef MSchedGraphSBNode::succ_const_iterator ChildIteratorType;
|
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
return N->succ_begin();
|
|
}
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
|
return N->succ_end();
|
|
}
|
|
typedef std::pointer_to_unary_function<std::pair<const MachineInstr* const,
|
|
MSchedGraphSBNode*>&, MSchedGraphSBNode&> DerefFun;
|
|
|
|
typedef mapped_iterator<MSchedGraphSB::iterator, DerefFun> nodes_iterator;
|
|
static nodes_iterator nodes_begin(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->begin(), DerefFun(getSecond));
|
|
}
|
|
static nodes_iterator nodes_end(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->end(), DerefFun(getSecond));
|
|
}
|
|
};
|
|
|
|
template <> struct GraphTraits<Inverse<MSchedGraphSB*> > {
|
|
typedef MSchedGraphSBNode NodeType;
|
|
typedef MSchedGraphSBNode::pred_iterator ChildIteratorType;
|
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
return N->pred_begin();
|
|
}
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
|
return N->pred_end();
|
|
}
|
|
typedef std::pointer_to_unary_function<std::pair<const MachineInstr* const,
|
|
MSchedGraphSBNode*>&, MSchedGraphSBNode&> DerefFun;
|
|
|
|
typedef mapped_iterator<MSchedGraphSB::iterator, DerefFun> nodes_iterator;
|
|
static nodes_iterator nodes_begin(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->begin(), DerefFun(getSecond));
|
|
}
|
|
static nodes_iterator nodes_end(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->end(), DerefFun(getSecond));
|
|
}
|
|
};
|
|
|
|
template <> struct GraphTraits<Inverse<const MSchedGraphSB*> > {
|
|
typedef const MSchedGraphSBNode NodeType;
|
|
typedef MSchedGraphSBNode::pred_const_iterator ChildIteratorType;
|
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
|
return N->pred_begin();
|
|
}
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
|
return N->pred_end();
|
|
}
|
|
|
|
typedef std::pointer_to_unary_function<std::pair<const MachineInstr* const,
|
|
MSchedGraphSBNode*>&, MSchedGraphSBNode&> DerefFun;
|
|
|
|
typedef mapped_iterator<MSchedGraphSB::iterator, DerefFun> nodes_iterator;
|
|
static nodes_iterator nodes_begin(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->begin(), DerefFun(getSecond));
|
|
}
|
|
static nodes_iterator nodes_end(MSchedGraphSB *G) {
|
|
return map_iterator(((MSchedGraphSB*)G)->end(), DerefFun(getSecond));
|
|
}
|
|
};
|
|
}
|
|
|
|
#endif
|