#include <BFShareOperands.hh>

Inheritance diagram for BFShareOperands:

Collaboration diagram for BFShareOperands:

Public Member Functions
	BFShareOperands (BF2Scheduler &sched, MoveNode &mn, int lc)

virtual bool	operator() ()

virtual bool	removedNode ()

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)

Private Attributes
MoveNode &	mn_

int	maxCycle_

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

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

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 40 of file BFShareOperands.hh.

Constructor & Destructor Documentation

◆ BFShareOperands()

BFShareOperands::BFShareOperands	(	BF2Scheduler &	sched,
		MoveNode &	mn,
		int	lc
	)

inline

Definition at line 42 of file BFShareOperands.hh.

                                                                :
         BFOptimization(sched), mn_(mn), maxCycle_(lc+6) {
     SchedulerCmdLineOptions* opts =
         dynamic_cast<SchedulerCmdLineOptions*>(Application::cmdLineOptions());
     if (opts != NULL) {
         if (opts->operandShareDistance() > -1) {
         maxCycle_ = lc + opts->operandShareDistance();
         }
     }
     }

References Application::cmdLineOptions(), maxCycle_, and SchedulerCmdLineOptions::operandShareDistance().

Here is the call graph for this function:

Member Function Documentation

◆ operator()()

bool BFShareOperands::operator() ( )

virtual

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

Implements Reversible.

Definition at line 49 of file BFShareOperands.cc.

                                  {
     // TODO: alctually check the guards
     if (!mn_.move().isUnconditional()) {
         return false;
     }
  
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\tShareOperands operator() called for:"
               << mn_.toString() <<  std::endl;
 #endif
  
     if (sched_.currentFront()->illegalOperandShares_.find(&mn_) !=
         sched_.currentFront()->illegalOperandShares_.end()) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
         std::cerr << "\t\t\tIllegal operand share: " << mn_.toString()
                   << std::endl;
 #endif
         return false;
     }
  
     bool didSomething = false;
     ProgramOperation& po = mn_.destinationOperation();
     const Operation& op = po.operation();
     const TTAMachine::FunctionUnit* forcedFU = po.scheduledFU();
  
     DataDependenceGraph::NodeSet siblings = ddg().regDepSiblings(mn_);
     for (auto i : siblings) {
         if (!i->isDestinationOperation()) {
             continue;
         }
  
         if (i->isScheduled()) {
             if (i->cycle() > maxCycle_) {
                 continue;
             }
             // limit operand sharing for reasonable distances
             // TODO: use the cmd line parameter
             int ddglc = ddg().latestCycle(mn_, ii(), false, false);
             if (i->cycle() < ddglc - 5) {
                 continue;
             }
  
             // try share with already scheduled
             const TTAProgram::Terminal& dt = i->move().destination();
             if (dt.isFUPort()) {
                 const TTAMachine::FunctionUnit& fu = dt.functionUnit();
                 if (!fu.hasOperation(op.name())) {
                     continue;
                 }
                 const TTAMachine::HWOperation* hwop = fu.operation(op.name());
                 const TTAMachine::FUPort *sharedPort =
                     hwop->port(mn_.move().destination().operationIndex());
                 if (sharedPort != &dt.port()) {
                     continue;
                 }
                 if (dt.isTriggering()) {
                     // TODO: is sibling commutative?
                     continue;
                 }
                 if (forcedFU != NULL) {
                     if (&fu == forcedFU) {
                         MoveNode* trigger =
                             BF2ScheduleFront::getSisterTrigger(
                                 mn_, targetMachine());
                         if (trigger == &mn_) {
                             continue;
                         }
  
                         BFShareOperandWithScheduled* sows =
                             new BFShareOperandWithScheduled(sched_, *i, mn_);
                         if (runPreChild(sows)) {
                             didSomething = true;
                         }
                     }
                 } else {
                     if (fu.hasOperation(op.name())) {
                         if (sched_.isTrigger(fu, mn_)) {
                             // TODO: change commutative
                             continue;
                         }
  
                         BFShareOperandWithScheduled* sows =
                             new BFShareOperandWithScheduled(sched_, *i, mn_);
                         if (runPreChild(sows)) {
                             didSomething = true;
                         }
                     }
                 }
             }
         }
     }
     return didSomething;
 }

References BF2Scheduler::currentFront(), BFOptimization::ddg(), TTAProgram::Move::destination(), MoveNode::destinationOperation(), TTAProgram::Terminal::functionUnit(), BFOptimization::getSisterTrigger(), TTAMachine::FunctionUnit::hasOperation(), BFOptimization::ii(), BF2ScheduleFront::illegalOperandShares_, TTAProgram::Terminal::isFUPort(), BF2Scheduler::isTrigger(), TTAProgram::Terminal::isTriggering(), TTAProgram::Move::isUnconditional(), DataDependenceGraph::latestCycle(), maxCycle_, mn_, MoveNode::move(), Operation::name(), TTAMachine::FunctionUnit::operation(), ProgramOperation::operation(), TTAProgram::Terminal::operationIndex(), TTAMachine::HWOperation::port(), TTAProgram::Terminal::port(), DataDependenceGraph::regDepSiblings(), Reversible::runPreChild(), BFOptimization::sched_, ProgramOperation::scheduledFU(), BFOptimization::targetMachine(), and MoveNode::toString().

Here is the call graph for this function:

◆ removedNode()

bool BFShareOperands::removedNode ( )

virtual

Definition at line 145 of file BFShareOperands.cc.

145 { return false; }

◆ undoOnlyMe()

void BFShareOperands::undoOnlyMe ( )

protectedvirtual

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 143 of file BFShareOperands.cc.

143 {}

Member Data Documentation

◆ maxCycle_

int BFShareOperands::maxCycle_

private

Definition at line 59 of file BFShareOperands.hh.

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

◆ mn_

MoveNode& BFShareOperands::mn_

private

Definition at line 58 of file BFShareOperands.hh.

Referenced by operator()().

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

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members