6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-23 15:29:51 +00:00
Code Issues Projects Releases Wiki Activity
bfedb912cd
llvm-6502/lib/Target/SparcV9/ModuloScheduling/ModuloSchedGraph.cpp
Guochun Shi f325261856 cleaned code 
add some comments


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6674 91177308-0d34-0410-b5e6-96231b3b80d8
2003-06-10 19:09:00 +00:00

1508 lines
40 KiB
C++
Raw Blame History

//===- ModuloSchedGraph.cpp - Graph datastructure for Modulo Scheduling ---===//
//
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Target/TargetSchedInfo.h"
#include "Support/StringExtras.h"
#include "Support/STLExtras.h"
#include "Support/hash_map"
#include "Support/Statistic.h"
#include "ModuloScheduling.h"
#include "ModuloSchedGraph.h"
#include <algorithm>
#include <ostream>
#include <vector>
#include <math.h>
#define UNIDELAY 1
using std::cerr;
using std::endl;
using std::vector;
/***********member functions for ModuloSchedGraphNode*********/
ModuloSchedGraphNode::ModuloSchedGraphNode(unsigned int in_nodeId,
const BasicBlock * in_bb,
const Instruction * in_inst,
int indexInBB,
const TargetMachine & target)
:SchedGraphNodeCommon(in_nodeId, indexInBB), inst(in_inst){
if (inst) {
//FIXME: find the latency
//currently set the latency to zero
latency = 0;
}
}
/***********member functions for ModuloSchedGraph*********/
void
ModuloSchedGraph::addDefUseEdges(const BasicBlock *bb){
//collect def instructions, store them in vector
const TargetInstrInfo & mii = target.getInstrInfo();
vector < ModuloSchedGraphNode * > defVec;
//find those def instructions
for (BasicBlock::const_iterator I = bb->begin(), E = bb->end(); I != E; ++I) {
if (I->getType() != Type::VoidTy) {
defVec.push_back(this->getGraphNodeForInst(I));
}
}
for (unsigned int i = 0; i < defVec.size(); i++) {
for (Value::use_const_iterator I = defVec[i]->getInst()->use_begin();
I != defVec[i]->getInst()->use_end(); I++) {
//for each use of a def, add a flow edge from the def instruction to the
//ref instruction
const Instruction *value = defVec[i]->getInst();
Instruction *inst = (Instruction *) (*I);
ModuloSchedGraphNode *node = NULL;
for (BasicBlock::const_iterator ins = bb->begin(), E = bb->end();
ins != E; ++ins)
if ((const Instruction *) ins == inst) {
node = (*this)[inst];
break;
}
if (node == NULL){
//inst is not an instruction in this block
//do nothing
} else {
// Add a flow edge from the def instruction to the ref instruction
// This is a true dependence, so the delay is equal to the
//delay of the preceding node.
int delay = 0;
// self loop will not happen in SSA form
assert(defVec[i] != node && "same node?");
MachineCodeForInstruction & tempMvec =
MachineCodeForInstruction::get(value);
for (unsigned j = 0; j < tempMvec.size(); j++) {
MachineInstr *temp = tempMvec[j];
delay = std::max(delay, mii.minLatency(temp->getOpCode()));
}
SchedGraphEdge *trueEdge =
new SchedGraphEdge(defVec[i], node, value,
SchedGraphEdge::TrueDep, delay);
// if the ref instruction is before the def instrution
// then the def instruction must be a phi instruction
// add an anti-dependence edge to from the ref instruction to the def
// instruction
if (node->getOrigIndexInBB() < defVec[i]->getOrigIndexInBB()) {
assert(PHINode::classof(inst)
&& "the ref instruction befre def is not PHINode?");
trueEdge->setIteDiff(1);
}
}
}
}
}
void
ModuloSchedGraph::addCDEdges(const BasicBlock * bb) {
// find the last instruction in the basic block
// see if it is an branch instruction.
// If yes, then add an edge from each node expcept the last node
// to the last node
const Instruction *inst = &(bb->back());
ModuloSchedGraphNode *lastNode = (*this)[inst];
if (TerminatorInst::classof(inst))
for (BasicBlock::const_iterator I = bb->begin(), E = bb->end(); I != E;
I++) {
if (inst != I) {
ModuloSchedGraphNode *node = (*this)[I];
//use latency of 0
(void) new SchedGraphEdge(node, lastNode, SchedGraphEdge::CtrlDep,
SchedGraphEdge::NonDataDep, 0);
}
}
}
static const int SG_LOAD_REF = 0;
static const int SG_STORE_REF = 1;
static const int SG_CALL_REF = 2;
static const unsigned int SG_DepOrderArray[][3] = {
{SchedGraphEdge::NonDataDep,
SchedGraphEdge::AntiDep,
SchedGraphEdge::AntiDep},
{SchedGraphEdge::TrueDep,
SchedGraphEdge::OutputDep,
SchedGraphEdge::TrueDep | SchedGraphEdge::OutputDep},
{SchedGraphEdge::TrueDep,
SchedGraphEdge::AntiDep | SchedGraphEdge::OutputDep,
SchedGraphEdge::TrueDep | SchedGraphEdge::AntiDep
| SchedGraphEdge::OutputDep}
};
// Add a dependence edge between every pair of machine load/store/call
// instructions, where at least one is a store or a call.
// Use latency 1 just to ensure that memory operations are ordered;
// latency does not otherwise matter (true dependences enforce that).
//
void
ModuloSchedGraph::addMemEdges(const BasicBlock * bb) {
vector<ModuloSchedGraphNode*> memNodeVec;
//construct the memNodeVec
for (BasicBlock::const_iterator I = bb->begin(),
E = bb->end(); I != E; ++I) {
if (LoadInst::classof(I) || StoreInst::classof(I)
|| CallInst::classof(I)) {
ModuloSchedGraphNode *node = (*this)[(const Instruction *) I];
memNodeVec.push_back(node);
}
}
// Instructions in memNodeVec are in execution order within the
// basic block, so simply look at all pairs
// <memNodeVec[i], memNodeVec[j: j > i]>.
for (unsigned im = 0, NM = memNodeVec.size(); im < NM; im++) {
const Instruction *fromInst,*toInst;
int toType, fromType;
//get the first mem instruction and instruction type
fromInst = memNodeVec[im]->getInst();
fromType = CallInst::classof(fromInst) ? SG_CALL_REF
: LoadInst::classof(fromInst) ? SG_LOAD_REF : SG_STORE_REF;
for (unsigned jm = im + 1; jm < NM; jm++) {
//get the second mem instruction and instruction type
toInst = memNodeVec[jm]->getInst();
toType = CallInst::classof(toInst) ? SG_CALL_REF
: LoadInst::classof(toInst) ? SG_LOAD_REF : SG_STORE_REF;
//add two edges if not both of them are LOAD instructions
if (fromType != SG_LOAD_REF || toType != SG_LOAD_REF) {
(void) new SchedGraphEdge(memNodeVec[im], memNodeVec[jm],
SchedGraphEdge::MemoryDep,
SG_DepOrderArray[fromType][toType], 1);
SchedGraphEdge *edge =
new SchedGraphEdge(memNodeVec[jm], memNodeVec[im],
SchedGraphEdge::MemoryDep,
SG_DepOrderArray[toType][fromType], 1);
//set the iteration difference for this edge to 1.
edge->setIteDiff(1);
}
}
}
}
/*
this function build graph nodes for each instruction
in the basicblock
*/
void
ModuloSchedGraph::buildNodesforBB(const TargetMachine &target,
const BasicBlock *bb){
int i = 0;
ModuloSchedGraphNode *node;
for (BasicBlock::const_iterator I = bb->begin(), E = bb->end();
I != E; ++I) {
node=new ModuloSchedGraphNode(getNumNodes(), bb, I, i, target);
i++;
this->addHash(I, node);
}
}
/*
determine if this basicblock includes a loop or not
*/
bool
ModuloSchedGraph::isLoop(const BasicBlock *bb) {
//only if the last instruction in the basicblock is branch instruction and
//there is at least an option to branch itself
const Instruction *inst = &(bb->back());
if (BranchInst::classof(inst)) {
for (unsigned i = 0; i < ((BranchInst *) inst)->getNumSuccessors();
i++) {
BasicBlock *sb = ((BranchInst *) inst)->getSuccessor(i);
if (sb == bb)
return true;
}
}
return false;
}
/*
compute every node's ASAP
*/
//FIXME: now assume the only backward edges come from the edges from other
//nodes to the phi Node so i will ignore all edges to the phi node; after
//this, there shall be no recurrence.
void
ModuloSchedGraph::computeNodeASAP(const BasicBlock *bb) {
unsigned numNodes = bb->size();
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
node->setPropertyComputed(false);
}
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
node->ASAP = 0;
if (i == 2 || node->getNumInEdges() == 0) {
node->setPropertyComputed(true);
continue;
}
for (ModuloSchedGraphNode::const_iterator I = node->beginInEdges(), E =
node->endInEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
ModuloSchedGraphNode *pred =
(ModuloSchedGraphNode *) (edge->getSrc());
assert(pred->getPropertyComputed()
&& "pred node property is not computed!");
int temp =
pred->ASAP + edge->getMinDelay() -
edge->getIteDiff() * this->MII;
node->ASAP = std::max(node->ASAP, temp);
}
node->setPropertyComputed(true);
}
}
/*
compute every node's ALAP in the basic block
*/
void
ModuloSchedGraph::computeNodeALAP(const BasicBlock *bb) {
unsigned numNodes = bb->size();
int maxASAP = 0;
for (unsigned i = numNodes + 1; i >= 2; i--) {
ModuloSchedGraphNode *node = getNode(i);
node->setPropertyComputed(false);
maxASAP = std::max(maxASAP, node->ASAP);
}
for (unsigned i = numNodes + 1; i >= 2; i--) {
ModuloSchedGraphNode *node = getNode(i);
node->ALAP = maxASAP;
for (ModuloSchedGraphNode::const_iterator I =
node->beginOutEdges(), E = node->endOutEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
ModuloSchedGraphNode *succ =
(ModuloSchedGraphNode *) (edge->getSink());
if (PHINode::classof(succ->getInst()))
continue;
assert(succ->getPropertyComputed()
&& "succ node property is not computed!");
int temp =
succ->ALAP - edge->getMinDelay() +
edge->getIteDiff() * this->MII;
node->ALAP = std::min(node->ALAP, temp);
}
node->setPropertyComputed(true);
}
}
/*
compute every node's mov in this basicblock
*/
void
ModuloSchedGraph::computeNodeMov(const BasicBlock *bb){
unsigned numNodes = bb->size();
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
node->mov = node->ALAP - node->ASAP;
assert(node->mov >= 0
&& "move freedom for this node is less than zero? ");
}
}
/*
compute every node's depth in this basicblock
*/
void
ModuloSchedGraph::computeNodeDepth(const BasicBlock * bb){
unsigned numNodes = bb->size();
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
node->setPropertyComputed(false);
}
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
node->depth = 0;
if (i == 2 || node->getNumInEdges() == 0) {
node->setPropertyComputed(true);
continue;
}
for (ModuloSchedGraphNode::const_iterator I = node->beginInEdges(), E =
node->endInEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
ModuloSchedGraphNode *pred =
(ModuloSchedGraphNode *) (edge->getSrc());
assert(pred->getPropertyComputed()
&& "pred node property is not computed!");
int temp = pred->depth + edge->getMinDelay();
node->depth = std::max(node->depth, temp);
}
node->setPropertyComputed(true);
}
}
/*
compute every node's height in this basic block
*/
void
ModuloSchedGraph::computeNodeHeight(const BasicBlock *bb){
unsigned numNodes = bb->size();
for (unsigned i = numNodes + 1; i >= 2; i--) {
ModuloSchedGraphNode *node = getNode(i);
node->setPropertyComputed(false);
}
for (unsigned i = numNodes + 1; i >= 2; i--) {
ModuloSchedGraphNode *node = getNode(i);
node->height = 0;
for (ModuloSchedGraphNode::const_iterator I =
node->beginOutEdges(), E = node->endOutEdges(); I != E; ++I) {
SchedGraphEdge *edge = *I;
ModuloSchedGraphNode *succ =
(ModuloSchedGraphNode *) (edge->getSink());
if (PHINode::classof(succ->getInst()))
continue;
assert(succ->getPropertyComputed()
&& "succ node property is not computed!");
node->height = std::max(node->height, succ->height + edge->getMinDelay());
}
node->setPropertyComputed(true);
}
}
/*
compute every node's property in a basicblock
*/
void ModuloSchedGraph::computeNodeProperty(const BasicBlock * bb)
{
//FIXME: now assume the only backward edges come from the edges from other
//nodes to the phi Node so i will ignore all edges to the phi node; after
//this, there shall be no recurrence.
this->computeNodeASAP(bb);
this->computeNodeALAP(bb);
this->computeNodeMov(bb);
this->computeNodeDepth(bb);
this->computeNodeHeight(bb);
}
/*
compute the preset of this set without considering the edges
between backEdgeSrc and backEdgeSink
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::predSet(std::vector<ModuloSchedGraphNode*> set,
unsigned backEdgeSrc,
unsigned
backEdgeSink){
std::vector<ModuloSchedGraphNode*> predS;
for (unsigned i = 0; i < set.size(); i++) {
ModuloSchedGraphNode *node = set[i];
for (ModuloSchedGraphNode::const_iterator I = node->beginInEdges(), E =
node->endInEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
//if edges between backEdgeSrc and backEdgeSink, omitted
if (edge->getSrc()->getNodeId() == backEdgeSrc
&& edge->getSink()->getNodeId() == backEdgeSink)
continue;
ModuloSchedGraphNode *pred =
(ModuloSchedGraphNode *) (edge->getSrc());
//if pred is not in the predSet ....
bool alreadyInset = false;
for (unsigned j = 0; j < predS.size(); ++j)
if (predS[j]->getNodeId() == pred->getNodeId()) {
alreadyInset = true;
break;
}
// and pred is not in the set ....
for (unsigned j = 0; j < set.size(); ++j)
if (set[j]->getNodeId() == pred->getNodeId()) {
alreadyInset = true;
break;
}
//push it into the predS
if (!alreadyInset)
predS.push_back(pred);
}
}
return predS;
}
/*
return pred set to this set
*/
ModuloSchedGraph::NodeVec
ModuloSchedGraph::predSet(NodeVec set){
//node number increases from 2,
return predSet(set, 0, 0);
}
/*
return pred set to _node, ignoring
any edge between backEdgeSrc and backEdgeSink
*/
std::vector <ModuloSchedGraphNode*>
ModuloSchedGraph::predSet(ModuloSchedGraphNode *_node,
unsigned backEdgeSrc, unsigned backEdgeSink){
std::vector<ModuloSchedGraphNode*> set;
set.push_back(_node);
return predSet(set, backEdgeSrc, backEdgeSink);
}
/*
return pred set to _node, ignoring
*/
std::vector <ModuloSchedGraphNode*>
ModuloSchedGraph::predSet(ModuloSchedGraphNode * _node){
return predSet(_node, 0, 0);
}
/*
return successor set to the input set
ignoring any edge between src and sink
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::succSet(std::vector<ModuloSchedGraphNode*> set,
unsigned src, unsigned sink){
std::vector<ModuloSchedGraphNode*> succS;
for (unsigned i = 0; i < set.size(); i++) {
ModuloSchedGraphNode *node = set[i];
for (ModuloSchedGraphNode::const_iterator I =
node->beginOutEdges(), E = node->endOutEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
//if the edge is between src and sink, skip
if (edge->getSrc()->getNodeId() == src
&& edge->getSink()->getNodeId() == sink)
continue;
ModuloSchedGraphNode *succ =
(ModuloSchedGraphNode *) (edge->getSink());
//if pred is not in the successor set ....
bool alreadyInset = false;
for (unsigned j = 0; j < succS.size(); j++)
if (succS[j]->getNodeId() == succ->getNodeId()) {
alreadyInset = true;
break;
}
//and not in this set ....
for (unsigned j = 0; j < set.size(); j++)
if (set[j]->getNodeId() == succ->getNodeId()) {
alreadyInset = true;
break;
}
//push it into the successor set
if (!alreadyInset)
succS.push_back(succ);
}
}
return succS;
}
/*
return successor set to the input set
*/
ModuloSchedGraph::NodeVec ModuloSchedGraph::succSet(NodeVec set){
return succSet(set, 0, 0);
}
/*
return successor set to the input node
ignoring any edge between src and sink
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::succSet(ModuloSchedGraphNode *_node,
unsigned src, unsigned sink){
std::vector<ModuloSchedGraphNode*>set;
set.push_back(_node);
return succSet(set, src, sink);
}
/*
return successor set to the input node
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::succSet(ModuloSchedGraphNode * _node){
return succSet(_node, 0, 0);
}
/*
find maximum delay between srcId and sinkId
*/
SchedGraphEdge*
ModuloSchedGraph::getMaxDelayEdge(unsigned srcId,
unsigned sinkId){
ModuloSchedGraphNode *node = getNode(srcId);
SchedGraphEdge *maxDelayEdge = NULL;
int maxDelay = -1;
for (ModuloSchedGraphNode::const_iterator I = node->beginOutEdges(), E =
node->endOutEdges(); I != E; I++) {
SchedGraphEdge *edge = *I;
if (edge->getSink()->getNodeId() == sinkId)
if (edge->getMinDelay() > maxDelay) {
maxDelayEdge = edge;
maxDelay = edge->getMinDelay();
}
}
assert(maxDelayEdge != NULL && "no edge between the srcId and sinkId?");
return maxDelayEdge;
}
/*
dump all circuits found
*/
void
ModuloSchedGraph::dumpCircuits(){
DEBUG_PRINT(std::cerr << "dumping circuits for graph:\n");
int j = -1;
while (circuits[++j][0] != 0) {
int k = -1;
while (circuits[j][++k] != 0)
DEBUG_PRINT(std::cerr << circuits[j][k] << "\t");
DEBUG_PRINT(std::cerr << "\n");
}
}
/*
dump all sets found
*/
void
ModuloSchedGraph::dumpSet(std::vector < ModuloSchedGraphNode * >set){
for (unsigned i = 0; i < set.size(); i++)
DEBUG_PRINT(std::cerr << set[i]->getNodeId() << "\t");
DEBUG_PRINT(std::cerr << "\n");
}
/*
return union of set1 and set2
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::vectorUnion(std::vector<ModuloSchedGraphNode*> set1,
std::vector<ModuloSchedGraphNode*> set2){
std::vector<ModuloSchedGraphNode*> unionVec;
for (unsigned i = 0; i < set1.size(); i++)
unionVec.push_back(set1[i]);
for (unsigned j = 0; j < set2.size(); j++) {
bool inset = false;
for (unsigned i = 0; i < unionVec.size(); i++)
if (set2[j] == unionVec[i])
inset = true;
if (!inset)
unionVec.push_back(set2[j]);
}
return unionVec;
}
/*
return conjuction of set1 and set2
*/
std::vector<ModuloSchedGraphNode*>
ModuloSchedGraph::vectorConj(std::vector<ModuloSchedGraphNode*> set1,
std::vector<ModuloSchedGraphNode*> set2){
std::vector<ModuloSchedGraphNode*> conjVec;
for (unsigned i = 0; i < set1.size(); i++)
for (unsigned j = 0; j < set2.size(); j++)
if (set1[i] == set2[j])
conjVec.push_back(set1[i]);
return conjVec;
}
/*
return the result of subtracting set2 from set1
(set1 -set2)
*/
ModuloSchedGraph::NodeVec
ModuloSchedGraph::vectorSub(NodeVec set1,
NodeVec set2){
NodeVec newVec;
for (NodeVec::iterator I = set1.begin(); I != set1.end(); I++) {
bool inset = false;
for (NodeVec::iterator II = set2.begin(); II != set2.end(); II++)
if ((*I)->getNodeId() == (*II)->getNodeId()) {
inset = true;
break;
}
if (!inset)
newVec.push_back(*I);
}
return newVec;
}
/*
order all nodes in the basicblock
based on the sets information and node property
output: ordered nodes are stored in oNodes
*/
void ModuloSchedGraph::orderNodes() {
oNodes.clear();
std::vector < ModuloSchedGraphNode * >set;
unsigned numNodes = bb->size();
// first order all the sets
int j = -1;
int totalDelay = -1;
int preDelay = -1;
while (circuits[++j][0] != 0) {
int k = -1;
preDelay = totalDelay;
while (circuits[j][++k] != 0) {
ModuloSchedGraphNode *node = getNode(circuits[j][k]);
unsigned nextNodeId;
nextNodeId =
circuits[j][k + 1] != 0 ? circuits[j][k + 1] : circuits[j][0];
SchedGraphEdge *edge = getMaxDelayEdge(circuits[j][k], nextNodeId);
totalDelay += edge->getMinDelay();
}
if (preDelay != -1 && totalDelay > preDelay) {
// swap circuits[j][] and cuicuits[j-1][]
unsigned temp[MAXNODE];
for (int k = 0; k < MAXNODE; k++) {
temp[k] = circuits[j - 1][k];
circuits[j - 1][k] = circuits[j][k];
circuits[j][k] = temp[k];
}
//restart
j = -1;
}
}
// build the first set
int backEdgeSrc;
int backEdgeSink;
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "building the first set" << "\n");
int setSeq = -1;
int k = -1;
setSeq++;
while (circuits[setSeq][++k] != 0)
set.push_back(getNode(circuits[setSeq][k]));
if (circuits[setSeq][0] != 0) {
backEdgeSrc = circuits[setSeq][k - 1];
backEdgeSink = circuits[setSeq][0];
}
if (ModuloScheduling::printScheduleProcess()) {
DEBUG_PRINT(std::cerr << "the first set is:");
dumpSet(set);
}
// implement the ordering algorithm
enum OrderSeq { bottom_up, top_down };
OrderSeq order;
std::vector<ModuloSchedGraphNode*> R;
while (!set.empty()) {
std::vector<ModuloSchedGraphNode*> pset = predSet(oNodes);
std::vector<ModuloSchedGraphNode*> sset = succSet(oNodes);
if (!pset.empty() && !vectorConj(pset, set).empty()) {
R = vectorConj(pset, set);
order = bottom_up;
} else if (!sset.empty() && !vectorConj(sset, set).empty()) {
R = vectorConj(sset, set);
order = top_down;
} else {
int maxASAP = -1;
int position = -1;
for (unsigned i = 0; i < set.size(); i++) {
int temp = set[i]->getASAP();
if (temp > maxASAP) {
maxASAP = temp;
position = i;
}
}
R.push_back(set[position]);
order = bottom_up;
}
while (!R.empty()) {
if (order == top_down) {
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "in top_down round\n");
while (!R.empty()) {
int maxHeight = -1;
NodeVec::iterator chosenI;
for (NodeVec::iterator I = R.begin(); I != R.end(); I++) {
int temp = (*I)->height;
if ((temp > maxHeight)
|| (temp == maxHeight && (*I)->mov <= (*chosenI)->mov)) {
if ((temp > maxHeight)
|| (temp == maxHeight && (*I)->mov < (*chosenI)->mov)) {
maxHeight = temp;
chosenI = I;
continue;
}
//possible case: instruction A and B has the same height and mov,
//but A has dependence to B e.g B is the branch instruction in the
//end, or A is the phi instruction at the beginning
if ((*I)->mov == (*chosenI)->mov)
for (ModuloSchedGraphNode::const_iterator oe =
(*I)->beginOutEdges(), end = (*I)->endOutEdges();
oe != end; oe++) {
if ((*oe)->getSink() == (*chosenI)) {
maxHeight = temp;
chosenI = I;
continue;
}
}
}
}
ModuloSchedGraphNode *mu = *chosenI;
oNodes.push_back(mu);
R.erase(chosenI);
std::vector<ModuloSchedGraphNode*> succ_mu =
succSet(mu, backEdgeSrc, backEdgeSink);
std::vector<ModuloSchedGraphNode*> comm =
vectorConj(succ_mu, set);
comm = vectorSub(comm, oNodes);
R = vectorUnion(comm, R);
}
order = bottom_up;
R = vectorConj(predSet(oNodes), set);
} else {
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "in bottom up round\n");
while (!R.empty()) {
int maxDepth = -1;
NodeVec::iterator chosenI;
for (NodeVec::iterator I = R.begin(); I != R.end(); I++) {
int temp = (*I)->depth;
if ((temp > maxDepth)
|| (temp == maxDepth && (*I)->mov < (*chosenI)->mov)) {
maxDepth = temp;
chosenI = I;
}
}
ModuloSchedGraphNode *mu = *chosenI;
oNodes.push_back(mu);
R.erase(chosenI);
std::vector<ModuloSchedGraphNode*> pred_mu =
predSet(mu, backEdgeSrc, backEdgeSink);
std::vector<ModuloSchedGraphNode*> comm =
vectorConj(pred_mu, set);
comm = vectorSub(comm, oNodes);
R = vectorUnion(comm, R);
}
order = top_down;
R = vectorConj(succSet(oNodes), set);
}
}
if (ModuloScheduling::printScheduleProcess()) {
DEBUG_PRINT(std::cerr << "order finished\n");
DEBUG_PRINT(std::cerr << "dumping the ordered nodes:\n");
dumpSet(oNodes);
dumpCircuits();
}
//create a new set
//FIXME: the nodes between onodes and this circuit should also be include in
//this set
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "building the next set\n");
set.clear();
int k = -1;
setSeq++;
while (circuits[setSeq][++k] != 0)
set.push_back(getNode(circuits[setSeq][k]));
if (circuits[setSeq][0] != 0) {
backEdgeSrc = circuits[setSeq][k - 1];
backEdgeSink = circuits[setSeq][0];
}
if (set.empty()) {
//no circuits any more
//collect all other nodes
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "no circuits any more, collect the rest nodes\n");
for (unsigned i = 2; i < numNodes + 2; i++) {
bool inset = false;
for (unsigned j = 0; j < oNodes.size(); j++)
if (oNodes[j]->getNodeId() == i) {
inset = true;
break;
}
if (!inset)
set.push_back(getNode(i));
}
}
if (ModuloScheduling::printScheduleProcess()) {
DEBUG_PRINT(std::cerr << "next set is:\n");
dumpSet(set);
}
}
}
/*
build graph for instructions in this basic block
*/
void ModuloSchedGraph::buildGraph(const TargetMachine & target)
{
assert(this->bb && "The basicBlock is NULL?");
// Make a dummy root node. We'll add edges to the real roots later.
graphRoot = new ModuloSchedGraphNode(0, NULL, NULL, -1, target);
graphLeaf = new ModuloSchedGraphNode(1, NULL, NULL, -1, target);
if (ModuloScheduling::printScheduleProcess())
this->dump(bb);
if (isLoop(bb)) {
DEBUG_PRINT(cerr << "building nodes for this BasicBlock\n");
buildNodesforBB(target, bb);
DEBUG_PRINT(cerr << "adding def-use edge to this basic block\n");
this->addDefUseEdges(bb);
DEBUG_PRINT(cerr << "adding CD edges to this basic block\n");
this->addCDEdges(bb);
DEBUG_PRINT(cerr << "adding memory edges to this basicblock\n");
this->addMemEdges(bb);
int ResII = this->computeResII(bb);
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "ResII is " << ResII << "\n");
int RecII = this->computeRecII(bb);
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "RecII is " << RecII << "\n");
this->MII = std::max(ResII, RecII);
this->computeNodeProperty(bb);
if (ModuloScheduling::printScheduleProcess())
this->dumpNodeProperty();
this->orderNodes();
if (ModuloScheduling::printScheduleProcess())
this->dump();
}
}
/*
get node with nodeId
*/
ModuloSchedGraphNode *
ModuloSchedGraph::getNode(const unsigned nodeId) const{
for (const_iterator I = begin(), E = end(); I != E; I++)
if ((*I).second->getNodeId() == nodeId)
return (ModuloSchedGraphNode *) (*I).second;
return NULL;
}
/*
compute RecurrenceII
*/
int
ModuloSchedGraph::computeRecII(const BasicBlock *bb){
int RecII = 0;
//FIXME: only deal with circuits starting at the first node: the phi node
//nodeId=2;
//search all elementary circuits in the dependance graph
//assume maximum number of nodes is MAXNODE
unsigned path[MAXNODE];
unsigned stack[MAXNODE][MAXNODE];
for (int j = 0; j < MAXNODE; j++) {
path[j] = 0;
for (int k = 0; k < MAXNODE; k++)
stack[j][k] = 0;
}
//in our graph, the node number starts at 2
const unsigned numNodes = bb->size();
int i = 0;
path[i] = 2;
ModuloSchedGraphNode *initNode = getNode(path[0]);
unsigned initNodeId = initNode->getNodeId();
ModuloSchedGraphNode *currentNode = initNode;
while (currentNode != NULL) {
unsigned currentNodeId = currentNode->getNodeId();
// DEBUG_PRINT(std::cerr<<"current node is "<<currentNodeId<<"\n");
ModuloSchedGraphNode *nextNode = NULL;
for (ModuloSchedGraphNode::const_iterator I =
currentNode->beginOutEdges(), E = currentNode->endOutEdges();
I != E; I++) {
//DEBUG_PRINT(std::cerr <<" searching in outgoint edges of node
//"<<currentNodeId<<"\n";
unsigned nodeId = ((SchedGraphEdge *) * I)->getSink()->getNodeId();
bool inpath = false, instack = false;
int k;
//DEBUG_PRINT(std::cerr<<"nodeId is "<<nodeId<<"\n");
k = -1;
while (path[++k] != 0)
if (nodeId == path[k]) {
inpath = true;
break;
}
k = -1;
while (stack[i][++k] != 0)
if (nodeId == stack[i][k]) {
instack = true;
break;
}
if (nodeId > currentNodeId && !inpath && !instack) {
nextNode =
(ModuloSchedGraphNode *) ((SchedGraphEdge *) * I)->getSink();
break;
}
}
if (nextNode != NULL) {
//DEBUG_PRINT(std::cerr<<"find the next Node "<<nextNode->getNodeId()<<"\n");
int j = 0;
while (stack[i][j] != 0)
j++;
stack[i][j] = nextNode->getNodeId();
i++;
path[i] = nextNode->getNodeId();
currentNode = nextNode;
} else {
//DEBUG_PRINT(std::cerr<<"no expansion any more"<<"\n");
//confirmCircuit();
for (ModuloSchedGraphNode::const_iterator I =
currentNode->beginOutEdges(), E = currentNode->endOutEdges();
I != E; I++) {
unsigned nodeId = ((SchedGraphEdge *) * I)->getSink()->getNodeId();
if (nodeId == initNodeId) {
int j = -1;
while (circuits[++j][0] != 0);
for (int k = 0; k < MAXNODE; k++)
circuits[j][k] = path[k];
}
}
//remove this node in the path and clear the corresponding entries in the
//stack
path[i] = 0;
int j = 0;
for (j = 0; j < MAXNODE; j++)
stack[i][j] = 0;
i--;
currentNode = getNode(path[i]);
}
if (i == 0) {
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "circuits found are:\n");
int j = -1;
while (circuits[++j][0] != 0) {
int k = -1;
while (circuits[j][++k] != 0)
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << circuits[j][k] << "\t");
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "\n");
//for this circuit, compute the sum of all edge delay
int sumDelay = 0;
k = -1;
while (circuits[j][++k] != 0) {
//ModuloSchedGraphNode* node =getNode(circuits[j][k]);
unsigned nextNodeId;
nextNodeId =
circuits[j][k + 1] !=
0 ? circuits[j][k + 1] : circuits[j][0];
sumDelay +=
getMaxDelayEdge(circuits[j][k], nextNodeId)->getMinDelay();
}
// assume we have distance 1, in this case the sumDelay is RecII
// this is correct for SSA form only
//
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "The total Delay in the circuit is " << sumDelay
<< "\n");
RecII = RecII > sumDelay ? RecII : sumDelay;
}
return RecII;
}
}
return -1;
}
/*
update resource usage vector (ruVec)
*/
void
ModuloSchedGraph::addResourceUsage(std::vector<std::pair<int,int> > &ruVec,
int rid){
bool alreadyExists = false;
for (unsigned i = 0; i < ruVec.size(); i++) {
if (rid == ruVec[i].first) {
ruVec[i].second++;
alreadyExists = true;
break;
}
}
if (!alreadyExists)
ruVec.push_back(std::make_pair(rid, 1));
}
/*
dump the resource usage vector
*/
void
ModuloSchedGraph::dumpResourceUsage(std::vector<std::pair<int,int> > &ru){
TargetSchedInfo & msi = (TargetSchedInfo &) target.getSchedInfo();
std::vector<std::pair<int,int> > resourceNumVector = msi.resourceNumVector;
DEBUG_PRINT(std::cerr << "resourceID\t" << "resourceNum\n");
for (unsigned i = 0; i < resourceNumVector.size(); i++)
DEBUG_PRINT(std::cerr << resourceNumVector[i].
first << "\t" << resourceNumVector[i].second << "\n");
DEBUG_PRINT(std::cerr << " maxNumIssueTotal(issue slot in one cycle) = " << msi.
maxNumIssueTotal << "\n");
DEBUG_PRINT(std::cerr << "resourceID\t resourceUsage\t ResourceNum\n");
for (unsigned i = 0; i < ru.size(); i++) {
DEBUG_PRINT(std::cerr << ru[i].first << "\t" << ru[i].second);
const unsigned resNum = msi.getCPUResourceNum(ru[i].first);
DEBUG_PRINT(std::cerr << "\t" << resNum << "\n");
}
}
/*
compute thre resource restriction II
*/
int
ModuloSchedGraph::computeResII(const BasicBlock * bb){
const TargetInstrInfo & mii = target.getInstrInfo();
const TargetSchedInfo & msi = target.getSchedInfo();
int ResII;
std::vector<std::pair<int,int> > resourceUsage;
for (BasicBlock::const_iterator I = bb->begin(), E = bb->end(); I != E;
I++) {
if (ModuloScheduling::printScheduleProcess()) {
DEBUG_PRINT(std::cerr << "machine instruction for llvm instruction( node " <<
getGraphNodeForInst(I)->getNodeId() << ")\n");
DEBUG_PRINT(std::cerr << "\t" << *I);
}
MachineCodeForInstruction & tempMvec =
MachineCodeForInstruction::get(I);
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "size =" << tempMvec.size() << "\n");
for (unsigned i = 0; i < tempMvec.size(); i++) {
MachineInstr *minstr = tempMvec[i];
unsigned minDelay = mii.minLatency(minstr->getOpCode());
InstrRUsage rUsage = msi.getInstrRUsage(minstr->getOpCode());
InstrClassRUsage classRUsage =
msi.getClassRUsage(mii.getSchedClass(minstr->getOpCode()));
unsigned totCycles = classRUsage.totCycles;
std::vector<std::vector<resourceId_t> > resources=rUsage.resourcesByCycle;
assert(totCycles == resources.size());
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "resources Usage for this Instr(totCycles="
<< totCycles << ",mindLatency="
<< mii.minLatency(minstr->getOpCode()) << "): " << *minstr
<< "\n");
for (unsigned j = 0; j < resources.size(); j++) {
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "cycle " << j << ": ");
for (unsigned k = 0; k < resources[j].size(); k++) {
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "\t" << resources[j][k]);
addResourceUsage(resourceUsage, resources[j][k]);
}
if (ModuloScheduling::printScheduleProcess())
DEBUG_PRINT(std::cerr << "\n");
}
}
}
if (ModuloScheduling::printScheduleProcess())
this->dumpResourceUsage(resourceUsage);
//compute ResII
ResII = 0;
int issueSlots = msi.maxNumIssueTotal;
for (unsigned i = 0; i < resourceUsage.size(); i++) {
int resourceNum = msi.getCPUResourceNum(resourceUsage[i].first);
int useNum = resourceUsage[i].second;
double tempII;
if (resourceNum <= issueSlots)
tempII = ceil(1.0 * useNum / resourceNum);
else
tempII = ceil(1.0 * useNum / issueSlots);
ResII = std::max((int) tempII, ResII);
}
return ResII;
}
/*
dump the basicblock
*/
void
ModuloSchedGraph::dump(const BasicBlock * bb){
DEBUG_PRINT(std::cerr << "dumping basic block:");
DEBUG_PRINT(std::cerr << (bb->hasName()? bb->getName() : "block")
<< " (" << bb << ")" << "\n");
}
/*
dump the basicblock to ostream os
*/
void
ModuloSchedGraph::dump(const BasicBlock * bb, std::ostream & os){
os << "dumping basic block:";
os << (bb->hasName()? bb->getName() : "block")
<< " (" << bb << ")" << "\n";
}
/*
dump the graph
*/
void ModuloSchedGraph::dump() const
{
DEBUG_PRINT(std::cerr << " ModuloSchedGraph for basic Blocks:");
DEBUG_PRINT(std::cerr << (bb->hasName()? bb->getName() : "block")
<< " (" << bb << ")" << "");
DEBUG_PRINT(std::cerr << "\n\n Actual Root nodes : ");
for (unsigned i = 0, N = graphRoot->outEdges.size(); i < N; i++)
DEBUG_PRINT(std::cerr << graphRoot->outEdges[i]->getSink()->getNodeId()
<< ((i == N - 1) ? "" : ", "));
DEBUG_PRINT(std::cerr << "\n Graph Nodes:\n");
unsigned numNodes = bb->size();
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
DEBUG_PRINT(std::cerr << "\n" << *node);
}
DEBUG_PRINT(std::cerr << "\n");
}
/*
dump all node property
*/
void ModuloSchedGraph::dumpNodeProperty() const
{
unsigned numNodes = bb->size();
for (unsigned i = 2; i < numNodes + 2; i++) {
ModuloSchedGraphNode *node = getNode(i);
DEBUG_PRINT(std::cerr << "NodeId " << node->getNodeId() << "\t");
DEBUG_PRINT(std::cerr << "ASAP " << node->getASAP() << "\t");
DEBUG_PRINT(std::cerr << "ALAP " << node->getALAP() << "\t");
DEBUG_PRINT(std::cerr << "mov " << node->getMov() << "\t");
DEBUG_PRINT(std::cerr << "depth " << node->getDepth() << "\t");
DEBUG_PRINT(std::cerr << "height " << node->getHeight() << "\t\n");
}
}
/************member functions for ModuloSchedGraphSet**************/
/*
constructor
*/
ModuloSchedGraphSet::ModuloSchedGraphSet(const Function *function,
const TargetMachine &target)
: method(function){
buildGraphsForMethod(method, target);
}
/*
destructor
*/
ModuloSchedGraphSet::~ModuloSchedGraphSet(){
//delete all the graphs
for (iterator I = begin(), E = end(); I != E; ++I)
delete *I;
}
/*
build graph for each basicblock in this method
*/
void
ModuloSchedGraphSet::buildGraphsForMethod(const Function *F,
const TargetMachine &target){
for (Function::const_iterator BI = F->begin(); BI != F->end(); ++BI){
const BasicBlock* local_bb;
local_bb=BI;
addGraph(new ModuloSchedGraph((BasicBlock*)local_bb, target));
}
}
/*
dump the graph set
*/
void
ModuloSchedGraphSet::dump() const{
DEBUG_PRINT(std::cerr << " ====== ModuloSched graphs for function `" <<
method->getName() << "' =========\n\n");
for (const_iterator I = begin(); I != end(); ++I)
(*I)->dump();
DEBUG_PRINT(std::cerr << "\n=========End graphs for function `" << method->getName()
<< "' ==========\n\n");
}
/********************misc functions***************************/
/*
dump the input basic block
*/
static void
dumpBasicBlock(const BasicBlock * bb){
DEBUG_PRINT(std::cerr << "dumping basic block:");
DEBUG_PRINT(std::cerr << (bb->hasName()? bb->getName() : "block")
<< " (" << bb << ")" << "\n");
}
/*
dump the input node
*/
std::ostream& operator<<(std::ostream &os,
const ModuloSchedGraphNode &node)
{
os << std::string(8, ' ')
<< "Node " << node.nodeId << " : "
<< "latency = " << node.latency << "\n" << std::string(12, ' ');
if (node.getInst() == NULL)
os << "(Dummy node)\n";
else {
os << *node.getInst() << "\n" << std::string(12, ' ');
os << node.inEdges.size() << " Incoming Edges:\n";
for (unsigned i = 0, N = node.inEdges.size(); i < N; i++)
os << std::string(16, ' ') << *node.inEdges[i];
os << std::string(12, ' ') << node.outEdges.size()
<< " Outgoing Edges:\n";
for (unsigned i = 0, N = node.outEdges.size(); i < N; i++)
os << std::string(16, ' ') << *node.outEdges[i];
}
return os;
}
Reference in New Issue View Git Blame Copy Permalink