BFRemoveLoopChecksAndJump Class Reference

#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.

                                                   : 
        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_, BoostGraph< GraphNode, GraphEdge >::restoreNodeFromParent(), and MoveNode::toString().

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:

• BFRemoveLoopChecks.hh
• BFRemoveLoopChecks.cc