ManagerICFGActive.cpp

Go to the documentation of this file.

#include <iostream>
#include "ManagerICFGActive.hpp"
#include <Utils/Util.hpp>



namespace OA {
 namespace Activity {

static bool debug = false;

ManagerICFGActive::ManagerICFGActive(
 OA_ptr<Activity::ActivityIRInterface> _ir) : mIR(_ir)
{
 OA_DEBUG_CTRL_MACRO("DEBUG_ManagerICFGActive:ALL", debug);
 mSolver = new DataFlow::ICFGDFSolver(DataFlow::ICFGDFSolver::Backward,*this);
}

OA_ptr<InterActive> 
ManagerICFGActive::performAnalysis(
 OA_ptr<ICFG::ICFGInterface> icfg,
 OA_ptr<DataFlow::ParamBindings> paramBind,
 OA_ptr<Alias::InterAliasInterface> interAlias,
 OA_ptr<SideEffect::InterSideEffectInterface> interSE,
 DataFlow::DFPImplement algorithm)
{
 OA_ptr<InterActive> retval;
 retval = new InterActive;

 // create a Manager that generates dep information for each statement in
 // ICFG
 OA_ptr<ManagerICFGDep> depman;
 depman = new ManagerICFGDep(mIR);
 OA_ptr<ICFGDep> icfgDep = depman->performAnalysis(icfg, paramBind,
 interAlias,
 algorithm);

 if (debug) { icfgDep->output(*mIR); }

 
 if (debug) {
 std::cout << "Calling usefulman->performAnalysis() ...\n";
 std::cout.flush();
 }

 OA_ptr<ManagerICFGUseful> usefulman;
 usefulman = new ManagerICFGUseful(mIR);
 OA_ptr<InterUseful> 
 interUseful = usefulman->performAnalysis(icfg, paramBind, interAlias, 
 interSE, icfgDep,
 algorithm);

 retval->setNumIterUseful(interUseful->getNumIter());
 if (debug) { interUseful->output(*mIR); }
 
 // ManagerICFGVaryActive does vary analysis and determines which
 // locations are active coming Into a stmt and Outof a stmt
 if (debug) {
 std::cout << "Calling varyman->performAnalysis() ...\n";
 std::cout.flush();
 }

 OA_ptr<ManagerICFGVaryActive> varyman;
 varyman = new ManagerICFGVaryActive(mIR);
 OA_ptr<ActivePerStmt> active = varyman->performAnalysis(icfg, paramBind,
 interAlias, icfgDep, interUseful,algorithm);

 retval->setNumIterVary(active->getNumIter());
 if (debug) { active->output(*mIR); }
 
 
 //-------------------------------------------------------------
 // Do backward dataflow analysis to determine which def memrefs
 // and stmts are active
 
 // store results that will be needed in callbacks
 mICFG = icfg;
 mParamBind = paramBind;
 mICFGDep = icfgDep;
 mInterAlias = interAlias;
 mActive = active;

 // call iterative data-flow solver for ICFG
 mSolver->solve(icfg,algorithm);

 // then iterate over each statement to find active use memrefs

 // For each ICFG node:
 OA_ptr<ICFG::NodesIteratorInterface> nodeIter = 
 icfg->getICFGNodesIterator();
 for ( ; nodeIter->isValid(); (*nodeIter)++) {

 OA_ptr<ICFG::NodeInterface> icfgNode = nodeIter->currentICFGNode();

 // get alias and active results for current procedure
 ProcHandle proc = icfgNode->getProc();
 OA_ptr<Alias::Interface> alias = interAlias->getAliasResults(proc);
 OA_ptr<ActiveStandard> active = mActiveMap[proc];

 // For each stmt in the ICFG node:
 OA_ptr<CFG::NodeStatementsIteratorInterface> stmtIter =
 icfgNode->getNodeStatementsIterator();
 for ( ; stmtIter->isValid(); (*stmtIter)++) {
 StmtHandle stmt = stmtIter->current();

 // if this is an active statement, mark all inVaryMemRefs as active
 if (active->isActive(stmt)) {

 OA_ptr<MemRefHandleIterator> useIter = mIR->getUseMemRefs(stmt);
 for (; useIter->isValid(); (*useIter)++ ) {
 MemRefHandle use = useIter->current();
 if (debug) {
 std::cout << "\tuse = ";
 mIR->dump(use,std::cout);
 }
 
 // iterate over locations that are active anywhere
 // in procedure, flow-insensitive active locations
 OA_ptr<LocIterator> procActiveLocIter 
 = active->getActiveLocsIterator();
 for ( ; procActiveLocIter->isValid(); (*procActiveLocIter)++ ) {
 OA_ptr<Location> activeLoc = procActiveLocIter->current();
 if (debug) { 
 std::cout << "\t activeLoc = ";
 activeLoc->dump(std::cout,mIR);
 }
 
 // iterate over may locs for use
 OA_ptr<LocIterator> mayLocIter = alias->getMayLocs(use);
 for ( ; mayLocIter->isValid(); (*mayLocIter)++ ) {
 OA_ptr<Location> useLoc = mayLocIter->current();
 if (debug) { 
 std::cout << "\t\t may loc for use, useLoc = ";
 useLoc->dump(std::cout,mIR);
 }
 if (activeLoc->mayOverlap(*useLoc)) {
 active->insertMemRef(use);
 if (debug) {
 std::cout << "\t\tinserting active memref use = ";
 mIR->dump(use,std::cout);
 std::cout << std::endl;
 }

 } // if active loc mayOverlap the mayloc of the use memref
 // then use memref is set active

 } // for each mayloc of the use memref

 } // for each active locations anywhere in the procedure

 } // iterate over use memrefs
 
 } // if active stmt
 
 } // for each stmt in the icfg node 

 } // for each icfg node






 // assign activity results for each procedure into InterActive
 std::map<ProcHandle,OA_ptr<ActiveStandard> >::iterator mapIter;
 for (mapIter=mActiveMap.begin(); mapIter!=mActiveMap.end(); mapIter++) {
 retval->mapProcToActive(mapIter->first,mapIter->second);
 }

 // how many iterations did this take?
 if (debug) 
 {
 std::cout << "ICFGActive took " << mSolver->getNumIter()
 << " iterations.\n";
 }

 retval->setNumIterActive(mSolver->getNumIter());

 return retval;
}

//========================================================
// implementation of ICFGDFProblem interface
//========================================================
//--------------------------------------------------------
// initialization callbacks
//--------------------------------------------------------

OA_ptr<DataFlow::DataFlowSet> ManagerICFGActive::initializeTop()
{
 OA_ptr<DataFlow::LocDFSet> retval;
 retval = new DataFlow::LocDFSet;
 return retval;
}

OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::initializeNodeIN(OA_ptr<ICFG::NodeInterface> n)
{
 OA_ptr<DataFlow::LocDFSet> retval;
 retval = new DataFlow::LocDFSet;
 return retval;
}

OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::initializeNodeOUT(OA_ptr<ICFG::NodeInterface> n)
{
 OA_ptr<DataFlow::LocDFSet> retval;
 retval = new DataFlow::LocDFSet;
 return retval;
}


//--------------------------------------------------------
// solver callbacks 
//--------------------------------------------------------
 
OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::meet(OA_ptr<DataFlow::DataFlowSet> set1, 
 OA_ptr<DataFlow::DataFlowSet> set2)
{
 // just return in set
 return set1;
}

OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::transfer(ProcHandle proc,
 OA_ptr<DataFlow::DataFlowSet> out, OA::StmtHandle stmt)
{ 
 
 // ignoring data flow, using outActiveSet from previous analysis
 OA_ptr<DataFlow::LocDFSet> outRecast = mActive->getOutActiveSet(stmt);

 if (debug) {
 std::cout << "In transfer, stmt(hval=" << stmt.hval() << ")= ";
 mIR->dump(stmt,std::cout);
 std::cout << "\toutRecast = ";
 outRecast->dump(std::cout,mIR);
 }

 // will be storing activity results for stmt and memrefs in
 // ActiveStandard for current procedure
 if (mActiveMap[proc].ptrEqual(0)) {
 mActiveMap[proc] = new ActiveStandard(proc);
 }
 
 // get alias and active results for current procedure
 OA_ptr<Alias::Interface> alias = mInterAlias->getAliasResults(proc);
 OA_ptr<ActiveStandard> active = mActiveMap[proc];

 // iterate over def mem refs and if any of them access a location
 // that is in the out active set then the mem ref is active and so
 // is the stmt
 bool activeStmt = false;
 OA_ptr<MemRefHandleIterator> defIter = mIR->getDefMemRefs(stmt);
 for (; defIter->isValid(); (*defIter)++ ) {
 MemRefHandle def = defIter->current();
 if (debug) {
 std::cout << "\tdef = ";
 mIR->dump(def,std::cout);
 }

 bool activeMemRef = false;
 // loop over may locs for the memref
 OA_ptr<LocIterator> locIter = alias->getMayLocs(def);
 for ( ; locIter->isValid()&&!activeMemRef; (*locIter)++ ) {
 OA_ptr<Location> loc = locIter->current();
 if (debug) { 
 std::cout << "\t\t mayloc for def = ";
 loc->dump(std::cout,mIR);
 }

 // if at least one may loc of this def overlaps with
 // something in the active set ... then we know
 // that this def is active, and we know
 // that this stmt is active as well.
 if (outRecast->hasOverlapLoc(loc)) {
 active->insertMemRef(def);

 // don't need to look at any more mayLocs, since we
 // already know that this def is active ... set flag
 activeMemRef = true;

 if (!activeStmt) { 
 // now we know it is, insert and set flag
 active->insertStmt(stmt);
 activeStmt = true;
 }
 }
 }
 } 

 // since we are ignoring in/out data flow sets, only one iteration
 // iterate through all of the active locations that come into this
 // statement and insert those locations as active within the
 // procedure
 OA_ptr<DataFlow::LocDFSet> inActiveSet = mActive->getInActiveSet(stmt);
 OA_ptr<LocIterator> locIter = inActiveSet->getLocIterator();
 for ( ; locIter->isValid(); (*locIter)++ ) {
 active->insertLoc(locIter->current());
 } 

 // If we are ignoring the incoming set (see comments at top of transfer)
 // upshot: cuts the iterations by one. (no impact on correct output)
 return out;
}

OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::entryTransfer(ProcHandle proc, OA_ptr<DataFlow::DataFlowSet> in)
{
 return in;
}

OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::exitTransfer(ProcHandle proc, OA_ptr<DataFlow::DataFlowSet> out)
{
 return out;
}


OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::callerToCallee(ProcHandle caller,
 OA_ptr<DataFlow::DataFlowSet> dfset, CallHandle call, ProcHandle callee)
{
 // no data flow for this analysis ... returning in set
 return dfset;
}
 
OA_ptr<DataFlow::DataFlowSet> 
ManagerICFGActive::calleeToCaller(ProcHandle callee,
 OA_ptr<DataFlow::DataFlowSet> dfset, CallHandle call, ProcHandle caller)
{
 // no data flow for this analysis ... returning in set
 return dfset;
}

OA_ptr<DataFlow::DataFlowSet>
ManagerICFGActive::callToReturn(ProcHandle caller,
 OA_ptr<DataFlow::DataFlowSet> dfset, CallHandle call, ProcHandle callee)
{
 // no data flow for this analysis ... returning in set
 return dfset;
}

 } // end of namespace Activity
} // end of namespace OA