BFShareOperand Class Reference

#include <BFShareOperand.hh>

Inheritance diagram for BFShareOperand:

Collaboration diagram for BFShareOperand:

Public Member Functions
	BFShareOperand (BF2Scheduler &sched, MoveNode &removed, MoveNode &shared)
virtual bool	operator() ()
virtual	~BFShareOperand ()
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 ()

Protected Member Functions
virtual void	undoOnlyMe ()
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
MoveNode &	removed_
MoveNode &	shared_
std::vector< ProgramOperationPtr >	ops_
std::set< ProgramOperationPtr >	createdPrologPOs_
Protected Attributes inherited from BFOptimization
BF2Scheduler &	sched_
Protected Attributes inherited from Reversible
std::stack< Reversible * >	preChildren_
std::stack< Reversible * >	postChildren_

Additional Inherited Members
Static Public Member Functions inherited from BFOptimization
static void	clearPrologMoves ()
static MoveNode *	getSisterTrigger (const MoveNode &mn, const TTAMachine::Machine &mach)
Static Protected Attributes inherited from BFOptimization
static std::map< MoveNode *, MoveNode *, MoveNode::Comparator >	prologMoves_

Detailed Description

Definition at line 43 of file BFShareOperand.hh.

Constructor & Destructor Documentation

BFShareOperand()

BFShareOperand::BFShareOperand ( BF2Scheduler &  sched, MoveNode &  removed, MoveNode &  shared  )

inline

Definition at line 45 of file BFShareOperand.hh.

                                     :
        BFOptimization(sched), removed_(removed), shared_(shared) {}

~BFShareOperand()

virtual BFShareOperand::~BFShareOperand ( )

inlinevirtual

Definition at line 49 of file BFShareOperand.hh.

{}

Member Function Documentation

operator()()

bool BFShareOperand::operator() ( )

virtual

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

Implements Reversible.

Reimplemented in BFShareOperandLate, and BFShareOperandWithScheduled.

Definition at line 43 of file BFShareOperand.cc.

                                {
    if (removed_.move().destination().operationIndex()
        != shared_.move().destination().operationIndex()) {
        return false;
    }
    while (removed_.destinationOperationCount()) {
        ProgramOperationPtr op = removed_.destinationOperationPtr(0);
        removed_.removeDestinationOperation(&*op);
        op->removeInputNode(removed_);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\t\t\tRemoved: " << removed_.toString()
                  << " from: " << op->toString() << std::endl;
#endif
 
        shared_.addDestinationOperationPtr(op);
        op->addInputNode(shared_);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\t\t\tAdded: " << shared_.toString()
                  << " to: " << op->toString() << std::endl;
#endif
 
        // update also prolog movenodes.
        if (ii()) {
            MoveNode* prologMNOfRemoved = duplicator().getMoveNode(removed_);
            ProgramOperationPtr prologPO;
            if (prologMNOfRemoved) {
                prologPO = prologMNOfRemoved->destinationOperationPtr(0);
                prologMNOfRemoved->removeDestinationOperation(&*prologPO);
                prologPO->removeInputNode(*prologMNOfRemoved);
            } else {
                prologPO = duplicator().getProgramOperation(op);
            }
 
            MoveNode* prologMNOfShared = duplicator().getMoveNode(shared_);
            if (prologMNOfShared) {
                if (prologPO == nullptr) {
                    prologPO = duplicator().duplicateProgramOperationPtr(op);
                    createdPrologPOs_.insert(prologPO);
                }
                prologMNOfShared->addDestinationOperationPtr(prologPO);
                prologPO->addInputNode(*prologMNOfShared);
            }
        }
        ops_.push_back(op);
    }
    return true;
}

References MoveNode::addDestinationOperationPtr(), createdPrologPOs_, TTAProgram::Move::destination(), MoveNode::destinationOperationCount(), MoveNode::destinationOperationPtr(), MoveNodeDuplicator::duplicateProgramOperationPtr(), BFOptimization::duplicator(), MoveNodeDuplicator::getMoveNode(), MoveNodeDuplicator::getProgramOperation(), BFOptimization::ii(), MoveNode::move(), TTAProgram::Terminal::operationIndex(), ops_, removed_, MoveNode::removeDestinationOperation(), shared_, and MoveNode::toString().

Here is the call graph for this function:

undoOnlyMe()

void BFShareOperand::undoOnlyMe ( )

protectedvirtual

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

Reimplemented from Reversible.

Reimplemented in BFShareOperandLate, and BFShareOperandWithScheduled.

Definition at line 92 of file BFShareOperand.cc.

                           {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
    std::cerr << "\t\t\t\tBFShareOperand undoing itseld, shared: "
              << shared_.toString() << std::endl;
#endif
    while(ops_.size()) {
        ProgramOperationPtr op = *ops_.rbegin();
 
        if (ii()) {
            ProgramOperationPtr prologPO =
                duplicator().getProgramOperation(op);
 
            MoveNode* prologMNOfShared = duplicator().getMoveNode(shared_);
            MoveNode* prologMNOfRemoved = duplicator().getMoveNode(removed_);
 
            if (prologMNOfShared) {
                // if the mn is duplicated, also the PO should be duplicated
                assert(prologPO != nullptr);
                prologPO->removeInputNode(*prologMNOfShared);
                prologMNOfShared->removeDestinationOperation(&*prologPO);
            }
 
            if (prologMNOfRemoved) {
                // if the mn is duplicated, also the PO should be duplicated
                assert(prologPO != nullptr);
                prologPO->addInputNode(*prologMNOfRemoved);
                prologMNOfRemoved->addDestinationOperationPtr(prologPO);
            }
        }
 
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\t\t\t\tRestoring, op: "
                  << op->toString() << std::endl;
#endif
        op->removeInputNode(shared_);
        shared_.removeDestinationOperation(&*op);
        op->addInputNode(removed_);
        removed_.addDestinationOperationPtr(op);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\t\t\t\tRestored: " << removed_.toString()
                  << " to: " << op->toString() << std::endl;
#endif
        ops_.pop_back();
    }
}

References MoveNode::addDestinationOperationPtr(), assert, BFOptimization::duplicator(), MoveNodeDuplicator::getMoveNode(), MoveNodeDuplicator::getProgramOperation(), BFOptimization::ii(), ops_, removed_, MoveNode::removeDestinationOperation(), shared_, and MoveNode::toString().

Referenced by BFShareOperandLate::operator()(), BFShareOperandWithScheduled::undoOnlyMe(), and BFShareOperandLate::undoOnlyMe().

Here is the call graph for this function:

Member Data Documentation

createdPrologPOs_

std::set<ProgramOperationPtr> BFShareOperand::createdPrologPOs_

protected

Definition at line 55 of file BFShareOperand.hh.

Referenced by operator()().

ops_

std::vector<ProgramOperationPtr> BFShareOperand::ops_

protected

Definition at line 54 of file BFShareOperand.hh.

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

removed_

MoveNode& BFShareOperand::removed_

protected

Definition at line 52 of file BFShareOperand.hh.

Referenced by operator()(), BFShareOperandWithScheduled::operator()(), BFShareOperandLate::operator()(), BFShareOperandLate::revert(), undoOnlyMe(), and BFShareOperandWithScheduled::undoOnlyMe().

shared_

MoveNode& BFShareOperand::shared_

protected

Definition at line 53 of file BFShareOperand.hh.

Referenced by operator()(), BFShareOperandWithScheduled::operator()(), BFShareOperandLate::operator()(), BFShareOperandLate::revert(), undoOnlyMe(), BFShareOperandWithScheduled::undoOnlyMe(), and BFShareOperandLate::undoOnlyMe().

---

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

• BFShareOperand.hh
• BFShareOperand.cc