#include <BFRemoveLoopChecks.hh>

Inheritance diagram for BFRemoveLoopChecksAndJump:

Collaboration diagram for BFRemoveLoopChecksAndJump:

Public Member Functions
	BFRemoveLoopChecksAndJump (BF2Scheduler &sched)

bool	operator() ()

void	undoOnlyMe ()

Public Member Functions inherited from BFOptimization
	BFOptimization (BF2Scheduler &sched)

virtual bool	isFinishFront ()

virtual void	mightBeReady (MoveNode &mn)

Public Member Functions inherited from Reversible
virtual void	undo ()

virtual	~Reversible ()

void	deleteChildren (std::stack< Reversible * > &children)

int	id ()

	Reversible ()

Private Types
typedef std::set< ProgramOperationPtr, ProgramOperationPtrComparator >	POSet

Private Member Functions
void	removePoFromQueue (POSet &queuedToRemovePo, POSet &maybeRemovePo, DataDependenceGraph::NodeSet &queuedToRemoveMove, DataDependenceGraph::NodeSet &maybeRemoveMove)

void	checkMaybePos (POSet &maybeRemove, POSet &queuedToRemove, POSet &finishedAlivePo)

void	removeMoveFromQueue (DataDependenceGraph::NodeSet &queuedToRemoveMove, DataDependenceGraph::NodeSet &maybeRemoveMove, POSet &queuedToRemovePo, POSet &maybeRemovePo)

void	checkMaybeMoves (DataDependenceGraph::NodeSet &maybeRemove, DataDependenceGraph::NodeSet &queuedToRemove, DataDependenceGraph::NodeSet &aliveNodes)

void	checkAlivePO (POSet &queuedAlivePo, POSet &finishedAlivePo, DataDependenceGraph::NodeSet &queuedAliveMoves, DataDependenceGraph::NodeSet &finishedAliveMoves)

void	checkAliveMove (DataDependenceGraph::NodeSet &queuedAliveMoves, DataDependenceGraph::NodeSet &finishedAliveMoves, POSet &queuedAlivePo, POSet &finishedAlivePo)

void	queueAliveMove (MoveNode &mn, POSet &queuedAlivePo, POSet &finishedAlivePo, DataDependenceGraph::NodeSet &queuedAliveMoves, DataDependenceGraph::NodeSet &finishedAliveMoves)

Private Attributes
DataDependenceGraph::NodeSet	removedMoves_

std::set< ProgramOperationPtr, ProgramOperationPtrComparator >	removedPOs_

Additional Inherited Members
Static Public Member Functions inherited from BFOptimization
static void	clearPrologMoves ()

static MoveNode *	getSisterTrigger (const MoveNode &mn, const TTAMachine::Machine &mach)

Protected Member Functions inherited from BFOptimization
DataDependenceGraph &	ddg ()

DataDependenceGraph *	rootDDG ()

const DataDependenceGraph &	ddg () const

DataDependenceGraph *	prologDDG ()

SimpleResourceManager &	rm () const

SimpleResourceManager *	prologRM () const

BUMoveNodeSelector &	selector ()

const TTAMachine::Machine &	targetMachine () const

unsigned int	ii () const

MoveNodeDuplicator &	duplicator () const

virtual bool	assign (int cycle, MoveNode &, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU_=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGuardWriteCycle=false)

virtual void	unassign (MoveNode &mn, bool disposePrologCopy=true)

virtual int	rmEC (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)

virtual int	rmLC (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)

virtual bool	canAssign (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGWN=false)

bool	putAlsoToPrologEpilog (int cycle, MoveNode &mn)

void	setPrologSrcFUAnno (MoveNode &prologMN, MoveNode &loopMN)

void	setPrologDstFUAnno (MoveNode &prologMN, MoveNode &loopMN)

void	setJumpGuard (MoveNode &mn)

void	unsetJumpGuard (MoveNode &mn)

bool	needJumpGuard (const MoveNode &mn, int cycle)

int	jumpGuardAvailableCycle (const MoveNode &mn)

bool	canBeSpeculated (const Operation &op)

bool	canBeSpeculated (const MoveNode &mn)

bool	usePrologMove (const MoveNode &mn)

bool	canBeScheduled (const MoveNode &mn)

const TTAMachine::RegisterFile *	RFReadPortCountPreventsScheduling (const MoveNode &mn)

bool	immCountPreventsScheduling (const MoveNode &mn)

Protected Member Functions inherited from Reversible
bool	runPreChild (Reversible *preChild)

bool	runPostChild (Reversible *preChild)

bool	runChild (std::stack< Reversible * > &children, Reversible *child)

bool	runChild (Reversible *child, bool pre)

void	undoAndRemovePreChildren ()

void	undoAndRemovePostChildren ()

void	undoAndRemoveChildren (std::stack< Reversible * > &children)

Protected Attributes inherited from BFOptimization
BF2Scheduler &	sched_

Protected Attributes inherited from Reversible
std::stack< Reversible * >	preChildren_

std::stack< Reversible * >	postChildren_

Static Protected Attributes inherited from BFOptimization
static std::map< MoveNode , MoveNode , MoveNode::Comparator >	prologMoves_

Detailed Description

Definition at line 4 of file BFRemoveLoopChecks.hh.

Member Typedef Documentation

◆ POSet

typedef std::set<ProgramOperationPtr, ProgramOperationPtrComparator> BFRemoveLoopChecksAndJump::POSet

private

Definition at line 13 of file BFRemoveLoopChecks.hh.

Constructor & Destructor Documentation

◆ BFRemoveLoopChecksAndJump()

BFRemoveLoopChecksAndJump::BFRemoveLoopChecksAndJump ( BF2Scheduler & sched )

inline

Definition at line 6 of file BFRemoveLoopChecks.hh.

6 :

7 BFOptimization(sched) {}

Member Function Documentation

◆ checkAliveMove()

void BFRemoveLoopChecksAndJump::checkAliveMove	(	DataDependenceGraph::NodeSet &	queuedAliveMoves,
		DataDependenceGraph::NodeSet &	finishedAliveMoves,
		POSet &	queuedAlivePo,
		POSet &	finishedAlivePo
	)

private

Definition at line 157 of file BFRemoveLoopChecks.cc.

                                                   {
     MoveNode* mn = *queuedAliveMoves.begin();
     int ind = ddg().inDegree(*mn);
     for (int j = 0; j < ind; j++) {
         DataDependenceEdge& e = ddg().inEdge(*mn,j);
         if (e.dependenceType() == DataDependenceEdge::DEP_WAW ||
             e.dependenceType() == DataDependenceEdge::DEP_WAR) {
             continue;
         }
         queueAliveMove(ddg().tailNode(e), queuedAlivePo, finishedAlivePo,
                        queuedAliveMoves, finishedAliveMoves);
     }
     queuedAliveMoves.erase(mn);
     finishedAliveMoves.insert(mn);
 }

References BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), and queueAliveMove().

Referenced by operator()().

Here is the call graph for this function:

◆ checkAlivePO()

void BFRemoveLoopChecksAndJump::checkAlivePO	(	POSet &	queuedAlivePo,
		POSet &	finishedAlivePo,
		DataDependenceGraph::NodeSet &	queuedAliveMoves,
		DataDependenceGraph::NodeSet &	finishedAliveMoves
	)

private

Definition at line 105 of file BFRemoveLoopChecks.cc.

                                                     {
     ProgramOperationPtr po = *queuedAlivePo.begin();
    for (int i = 0; i < po->inputMoveCount(); i++) {
         MoveNode& mn = po->inputMove(i);
         int ind = ddg().inDegree(mn);
         for (int j = 0; j < ind; j++) {
             DataDependenceEdge& e = ddg().inEdge(mn,j);
             if (e.dependenceType() == DataDependenceEdge::DEP_WAW ||
                 e.dependenceType() == DataDependenceEdge::DEP_WAR) {
                 continue;
             }
             queueAliveMove(ddg().tailNode(e), queuedAlivePo, finishedAlivePo,
                            queuedAliveMoves, finishedAliveMoves);
         }
    }
    queuedAlivePo.erase(po);
    finishedAlivePo.insert(po);
 }

References BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), and queueAliveMove().

Referenced by operator()().

Here is the call graph for this function:

◆ checkMaybeMoves()

void BFRemoveLoopChecksAndJump::checkMaybeMoves	(	DataDependenceGraph::NodeSet &	maybeRemove,
		DataDependenceGraph::NodeSet &	queuedToRemove,
		DataDependenceGraph::NodeSet &	aliveNodes
	)

private

Definition at line 289 of file BFRemoveLoopChecks.cc.

                                             {
     MoveNode* mn = *maybeRemove.begin();
     if (aliveNodes.find(mn) == aliveNodes.end()) {
         queuedToRemove.insert(mn);
     }
     maybeRemove.erase(mn);
 }

Referenced by operator()().

◆ checkMaybePos()

void BFRemoveLoopChecksAndJump::checkMaybePos	(	POSet &	maybeRemove,
		POSet &	queuedToRemove,
		POSet &	finishedAlivePo
	)

private

Definition at line 281 of file BFRemoveLoopChecks.cc.

                                                                                                         {
     ProgramOperationPtr po = *maybeRemove.begin();
     if (alivePos.find(po) == alivePos.end()) {
         queuedToRemove.insert(po);
     }
     maybeRemove.erase(maybeRemove.begin());
 }

Referenced by operator()().

◆ operator()()

bool BFRemoveLoopChecksAndJump::operator() ( )

virtual

This performs the operation. Returns true if success, false if fail.

Implements Reversible.

Definition at line 7 of file BFRemoveLoopChecks.cc.

                                       {
  
     POSet queuedToRemovePo;
     POSet maybeRemovePo;
     POSet queuedAlivePo;
     POSet finishedAlivePo;
  
     DataDependenceGraph::NodeSet queuedToRemoveMove;
     DataDependenceGraph::NodeSet maybeRemoveMove;
     DataDependenceGraph::NodeSet queuedAliveMoves;
     DataDependenceGraph::NodeSet finishedAliveMoves;
  
     DataDependenceGraph& rootddg = static_cast<DataDependenceGraph&>
         (*ddg().rootGraph());
  
     int count = 0;
     for (int i = 0; i < ddg().nodeCount(); i++) {
         MoveNode& mn = ddg().node(i);
         if (mn.move().isJump()) {
             assert(mn.destinationOperationCount() == 1);
             queuedToRemovePo.insert(mn.destinationOperationPtr());
             continue;
         }
  
         // Mark other nodes alive
         if (mn.isDestinationOperation()) {
             ProgramOperation& po = mn.destinationOperation();
             const Operation& op = po.operation();
             if (op.hasSideEffects() || op.writesMemory() ||
                 op.isControlFlowOperation()) {
                 queueAliveMove(mn, queuedAlivePo, finishedAlivePo,
                                queuedAliveMoves, finishedAliveMoves);
                 continue;
             }
         }
  
         int outd = rootddg.outDegree(mn);
         for (int j = 0; j < outd; j++) {
             DataDependenceEdge& e = rootddg.outEdge(mn,j);
             if (e.dependenceType() == DataDependenceEdge::DEP_WAW ||
                 e.dependenceType() == DataDependenceEdge::DEP_WAR) {
                 continue;
             }
         
             // edges out from this BB are considered alive
             MoveNode& head = rootddg.headNode(e);                    
             if (!ddg().hasNode(head)) {
                 queueAliveMove(mn, queuedAlivePo, finishedAlivePo,
                                queuedAliveMoves, finishedAliveMoves);
             }
         }
     }
     
     // propagate alive status
     while (!queuedAlivePo.empty() || !queuedAliveMoves.empty()) {
         if (!queuedAlivePo.empty()) {
             checkAlivePO(queuedAlivePo, finishedAlivePo, queuedAliveMoves, finishedAliveMoves);
         } 
         if (!queuedAliveMoves.empty()) {
             checkAliveMove(queuedAliveMoves, finishedAliveMoves, queuedAlivePo, finishedAlivePo);
         }
     }
  
     // then remove POs and movenodes that are not alive
     while (!queuedToRemovePo.empty() || !maybeRemovePo.empty() ||
            !queuedToRemoveMove.empty() || !maybeRemoveMove.empty()) {
         if (!queuedToRemovePo.empty()) {
             removePoFromQueue(queuedToRemovePo, maybeRemovePo,
                               queuedToRemoveMove, maybeRemoveMove);
             count++;
             continue;
         }
  
         if (!queuedToRemoveMove.empty()) {
             removeMoveFromQueue(queuedToRemoveMove, maybeRemoveMove,
                                 queuedToRemovePo, maybeRemovePo);
             count++;
             continue;
         }
  
         if (!maybeRemovePo.empty()) {
             checkMaybePos(maybeRemovePo, queuedToRemovePo, finishedAlivePo);
         }
         
         if (!maybeRemoveMove.empty()) {
             checkMaybeMoves(maybeRemoveMove, queuedToRemoveMove, finishedAliveMoves);
         }
     }
     for (auto i: removedPOs_) {
         ddg().dropProgramOperation(i);
     }
  
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "count of removed POs: " << count << std::endl;
 #endif
     return count!=0;
 }

References assert, checkAliveMove(), checkAlivePO(), checkMaybeMoves(), checkMaybePos(), BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), MoveNode::destinationOperation(), MoveNode::destinationOperationCount(), MoveNode::destinationOperationPtr(), DataDependenceGraph::dropProgramOperation(), Operation::hasSideEffects(), BoostGraph< GraphNode, GraphEdge >::headNode(), Operation::isControlFlowOperation(), MoveNode::isDestinationOperation(), TTAProgram::Move::isJump(), MoveNode::move(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), ProgramOperation::operation(), BoostGraph< GraphNode, GraphEdge >::outDegree(), BoostGraph< GraphNode, GraphEdge >::outEdge(), queueAliveMove(), removedPOs_, removeMoveFromQueue(), removePoFromQueue(), BoostGraph< GraphNode, GraphEdge >::rootGraph(), and Operation::writesMemory().

Here is the call graph for this function:

◆ queueAliveMove()

void BFRemoveLoopChecksAndJump::queueAliveMove	(	MoveNode &	mn,
		POSet &	queuedAlivePo,
		POSet &	finishedAlivePo,
		DataDependenceGraph::NodeSet &	queuedAliveMoves,
		DataDependenceGraph::NodeSet &	finishedAliveMoves
	)

private

Definition at line 127 of file BFRemoveLoopChecks.cc.

                                                     {
  
     if (mn.isSourceOperation()) {
         if (finishedAlivePo.find(mn.sourceOperationPtr()) == finishedAlivePo.end()) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
             std::cerr << "alive PO: " << mn.toString() << std::endl;
 #endif
             queuedAlivePo.insert(mn.sourceOperationPtr());
         }
     } else if (mn.isDestinationOperation()) {
         if (finishedAlivePo.find(mn.destinationOperationPtr()) == finishedAlivePo.end()) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
             std::cerr << "alive PO: " << mn.toString() << std::endl;
 #endif
             queuedAlivePo.insert(mn.destinationOperationPtr());
         }
     } else {
         if (finishedAliveMoves.find(&mn) == finishedAliveMoves.end()) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
             std::cerr << "alive MN: " << mn.toString() << std::endl;
 #endif
             queuedAliveMoves.insert(&mn);
         }
     }
 }

References MoveNode::destinationOperationPtr(), MoveNode::isDestinationOperation(), MoveNode::isSourceOperation(), MoveNode::sourceOperationPtr(), and MoveNode::toString().

Referenced by checkAliveMove(), checkAlivePO(), and operator()().

Here is the call graph for this function:

◆ removeMoveFromQueue()

void BFRemoveLoopChecksAndJump::removeMoveFromQueue	(	DataDependenceGraph::NodeSet &	queuedToRemoveMove,
		DataDependenceGraph::NodeSet &	maybeRemoveMove,
		POSet &	queuedToRemovePo,
		POSet &	maybeRemovePo
	)

private

Definition at line 234 of file BFRemoveLoopChecks.cc.

                                                    {
     MoveNode* mn = *queuedToRemoveMove.begin();
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\tRemoving move: " << mn->toString()
               << std::endl;
 #endif
     int ind = ddg().inDegree(*mn);
     for (int j = 0; j < ind; j++) {
         DataDependenceEdge& e = ddg().inEdge(*mn,j);
         if (e.dependenceType() == DataDependenceEdge::DEP_WAW ||
             e.dependenceType() == DataDependenceEdge::DEP_WAR) {
             continue;
         }
         MoveNode& tail = ddg().tailNode(e);
         if (!tail.isSourceOperation()) {
             if (tail.isDestinationOperation()) {
                 ProgramOperationPtr tailOp = tail.destinationOperationPtr();
                 // if already is to be remoed, no need to put tho
                 // checking queue again
                 if (queuedToRemovePo.find(tailOp) == queuedToRemovePo.end()) {
                     maybeRemovePo.insert(tailOp);
                 }
             } else {
                 if (queuedToRemoveMove.find(&tail) == queuedToRemoveMove.end()) {
                     maybeRemoveMove.insert(&tail);
                 }
             }
         } else {
             ProgramOperationPtr tailOp = tail.sourceOperationPtr();
             // if already is to be remoed, no need to put tho
             // checking queue again
             if (queuedToRemovePo.find(tailOp) == queuedToRemovePo.end()) {
                 maybeRemovePo.insert(tailOp);
             }
         }
     }
     ddg().dropNode(*mn);
     removedMoves_.insert(mn);
     
     // TODO: remove the PO from the ddg!
     removedMoves_.insert(mn);
     queuedToRemoveMove.erase(queuedToRemoveMove.begin());
 }

References BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), MoveNode::destinationOperationPtr(), BoostGraph< GraphNode, GraphEdge >::dropNode(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), MoveNode::isDestinationOperation(), MoveNode::isSourceOperation(), removedMoves_, MoveNode::sourceOperationPtr(), BoostGraph< GraphNode, GraphEdge >::tailNode(), and MoveNode::toString().

Referenced by operator()().

Here is the call graph for this function:

◆ removePoFromQueue()

void BFRemoveLoopChecksAndJump::removePoFromQueue	(	POSet &	queuedToRemovePo,
		POSet &	maybeRemovePo,
		DataDependenceGraph::NodeSet &	queuedToRemoveMove,
		DataDependenceGraph::NodeSet &	maybeRemoveMove
	)

private

Definition at line 180 of file BFRemoveLoopChecks.cc.

                                                  {
     ProgramOperationPtr po = *queuedToRemovePo.begin();
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "Removing programoperation: " << po->toString()
               << std::endl;
 #endif
     for (int i = 0; i < po->inputMoveCount(); i++) {
         MoveNode& mn = po->inputMove(i);
         int ind = ddg().inDegree(mn);
         for (int j = 0; j < ind; j++) {
             DataDependenceEdge& e = ddg().inEdge(mn,j);
             if (e.dependenceType() == DataDependenceEdge::DEP_WAW ||
                 e.dependenceType() == DataDependenceEdge::DEP_WAR) {
                 continue;
             }
             MoveNode& tail = ddg().tailNode(e);
             if (!tail.isSourceOperation()) {
                 if (tail.isDestinationOperation()) {
                     ProgramOperationPtr tailOp = tail.destinationOperationPtr();
                     if (queuedToRemovePo.find(tailOp) == queuedToRemovePo.end()) {
                         maybeRemovePo.insert(tailOp);
                     }
                 } else {
                     if (queuedToRemoveMove.find(&tail) == queuedToRemoveMove.end()) {
                         maybeRemoveMove.insert(&tail);
                     }
                 }
             } else {
                 ProgramOperationPtr tailOp = tail.sourceOperationPtr();
                 // if already is to be remoed, no need to put tho
                 // checking queue again
                 if (queuedToRemovePo.find(tailOp) == queuedToRemovePo.end()) {
                     maybeRemovePo.insert(tailOp);
                 }
             }
         }
         ddg().dropNode(mn);
         removedMoves_.insert(&mn);
     }
     
     for (int i = 0; i < po->outputMoveCount(); i++) {
         MoveNode& mn = po->outputMove(i);
         ddg().dropNode(mn);
         removedMoves_.insert(&mn);
     }
     
     // TODO: remove the PO from the ddg!
     removedPOs_.insert(po);
     queuedToRemovePo.erase(queuedToRemovePo.begin());
 }

References BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), MoveNode::destinationOperationPtr(), BoostGraph< GraphNode, GraphEdge >::dropNode(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), MoveNode::isDestinationOperation(), MoveNode::isSourceOperation(), removedMoves_, removedPOs_, MoveNode::sourceOperationPtr(), and BoostGraph< GraphNode, GraphEdge >::tailNode().

Referenced by operator()().

Here is the call graph for this function:

◆ undoOnlyMe()

void BFRemoveLoopChecksAndJump::undoOnlyMe ( )

virtual

Undoes the operations done by this class but not children. This method should be overloaded by most derived classes.

Reimplemented from Reversible.

Definition at line 301 of file BFRemoveLoopChecks.cc.

                                       {
     for (auto i: removedMoves_) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
         std::cerr << "Restoring node: " << (*i).toString() << std::endl;
 #endif
         ddg().restoreNodeFromParent(*i);
     }
     removedMoves_.clear();
  
     for (auto i: removedPOs_) {
         ddg().addProgramOperation(i);
     }
 }

References DataDependenceGraph::addProgramOperation(), BFOptimization::ddg(), removedMoves_, removedPOs_, and BoostGraph< GraphNode, GraphEdge >::restoreNodeFromParent().

Here is the call graph for this function:

Member Data Documentation

◆ removedMoves_

DataDependenceGraph::NodeSet BFRemoveLoopChecksAndJump::removedMoves_

private

Definition at line 48 of file BFRemoveLoopChecks.hh.

Referenced by removeMoveFromQueue(), removePoFromQueue(), and undoOnlyMe().

◆ removedPOs_

std::set<ProgramOperationPtr, ProgramOperationPtrComparator> BFRemoveLoopChecksAndJump::removedPOs_

private

Definition at line 49 of file BFRemoveLoopChecks.hh.

Referenced by operator()(), removePoFromQueue(), and undoOnlyMe().

The documentation for this class was generated from the following files:

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ POSet

Constructor & Destructor Documentation

◆ BFRemoveLoopChecksAndJump()

Member Function Documentation

◆ checkAliveMove()

◆ checkAlivePO()

◆ checkMaybeMoves()

◆ checkMaybePos()

◆ operator()()

◆ queueAliveMove()

◆ removeMoveFromQueue()

◆ removePoFromQueue()

◆ undoOnlyMe()

Member Data Documentation

◆ removedMoves_

◆ removedPOs_