#include <BFRegCopyBefore.hh>

Inheritance diagram for BFRegCopyBefore:

Collaboration diagram for BFRegCopyBefore:

Public Member Functions
	BFRegCopyBefore (BF2Scheduler &sched, MoveNode &mn, int lc, const TTAMachine::RegisterFile *forbiddenRF=nullptr)

virtual	~BFRegCopyBefore ()

Public Member Functions inherited from BFRegCopy
	BFRegCopy (BF2Scheduler &sched, MoveNode &mn, int lc)

bool	operator() ()

MoveNode *	getRegCopy ()

void	undoOnlyMe ()

void	undoDDG ()

void	createAntidepsForReg (MoveNode &firstMove, MoveNode &lastMove, const TTAMachine::RegisterFile &rf, int index, TCEString regName, BasicBlockNode &bbn, bool loopScheduling)

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
bool	splitMove (BasicBlockNode &bbn)

void	undoSplit ()

Protected Member Functions inherited from BFRegCopy
MoveNode *	createRegCopy (bool after)

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
const TTAMachine::RegisterFile *	forbiddenRF_

Protected Attributes inherited from BFRegCopy
MoveNode &	mn_

MoveNode *	regCopy_

int	lc_

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 44 of file BFRegCopyBefore.hh.

Constructor & Destructor Documentation

◆ BFRegCopyBefore()

BFRegCopyBefore::BFRegCopyBefore	(	BF2Scheduler &	sched,
		MoveNode &	mn,
		int	lc,
		const TTAMachine::RegisterFile *	forbiddenRF = `nullptr`
	)

inline

Definition at line 46 of file BFRegCopyBefore.hh.

48 : BFRegCopy(sched,mn,lc), forbiddenRF_(forbiddenRF) {}

◆ ~BFRegCopyBefore()

virtual BFRegCopyBefore::~BFRegCopyBefore ( )

inlinevirtual

Definition at line 49 of file BFRegCopyBefore.hh.

49 {}

Member Function Documentation

◆ splitMove()

bool BFRegCopyBefore::splitMove ( BasicBlockNode & bbn )

protectedvirtual

Implements BFRegCopy.

Definition at line 51 of file BFRegCopyBefore.cc.

                                               {
  
     std::set<const TTAMachine::RegisterFile*,
         TTAMachine::MachinePart::Comparator>
         rfs = sched_.possibleTempRegRFs(mn_, false, forbiddenRF_);
  
     // cannot create reg copy if no temp regs available.
     if (rfs.empty()) {
         return false;
     }
  
     const TTAMachine::RegisterFile& rf = **rfs.rbegin();
  
     int lastRegisterIndex = rf.size()-1;
     TTAMachine::Port* dstRFPort = rf.firstWritePort();
     TTAMachine::Port* srcRFPort = rf.firstReadPort();
  
     TTAProgram::TerminalRegister* tempWrite =
         new TTAProgram::TerminalRegister(*dstRFPort, lastRegisterIndex);
  
     TTAProgram::TerminalRegister* tempRead =
         new TTAProgram::TerminalRegister(*srcRFPort, lastRegisterIndex);
  
     regCopy_->move().setDestination(tempWrite);
     mn_.move().setSource(tempRead);
  
     auto iEdges = ddg().rootGraph()->inEdges(mn_);
     for (auto iEdge : iEdges) {
         if (!iEdge->isRegisterOrRA() || iEdge->headPseudo()) {
             continue;
         }
  
         //copy guard use edge to the regcopy.
         if (iEdge->guardUse() &&
             iEdge->dependenceType() == DataDependenceEdge::DEP_RAW) {
             MoveNode& tail = ddg().rootGraph()->tailNode(*iEdge);
             runPostChild(
                 new BFConnectNodes(sched_, tail, *regCopy_, iEdge, true));
         } else if (iEdge->isRAW()) {
             MoveNode& tail = ddg().rootGraph()->tailNode(*iEdge);
             runPostChild(new BFRemoveEdge(sched_, tail, mn_, *iEdge));
             runPostChild(new BFConnectNodes(sched_, tail, *regCopy_, iEdge));
         }
     }
  
     auto oEdges = ddg().rootGraph()->outEdges(mn_);
     for (auto oEdge : oEdges) {
         if (!oEdge->isRegisterOrRA() || oEdge->tailPseudo()) {
             continue;
         }
         if (oEdge->dependenceType() == DataDependenceEdge::DEP_WAR &&
             !oEdge->guardUse()) {
             MoveNode& head = ddg().rootGraph()->headNode(*oEdge);
             runPostChild(new BFRemoveEdge(sched_, mn_, head, *oEdge));
             runPostChild(new BFConnectNodes(sched_, *regCopy_, head, oEdge));
         }
     }
  
     TCEString tempRegName = rf.name() + '.' +
         Conversion::toString(lastRegisterIndex);
  
     DataDependenceEdge* newEdge =
         new DataDependenceEdge(
             DataDependenceEdge::EDGE_REGISTER,
             DataDependenceEdge::DEP_RAW, tempRegName);
  
     runPostChild(new BFConnectNodes(sched_, *regCopy_, mn_, newEdge));
  
     createAntidepsForReg(
         *regCopy_, mn_, rf, lastRegisterIndex,
         tempRegName, bbn, ii()!= 0);
  
     return true;
 }

References BFRegCopy::createAntidepsForReg(), BFOptimization::ddg(), DataDependenceEdge::DEP_RAW, DataDependenceEdge::DEP_WAR, DataDependenceEdge::EDGE_REGISTER, TTAMachine::RegisterFile::firstReadPort(), TTAMachine::RegisterFile::firstWritePort(), forbiddenRF_, BoostGraph< GraphNode, GraphEdge >::headNode(), BFOptimization::ii(), BoostGraph< GraphNode, GraphEdge >::inEdges(), BFRegCopy::mn_, MoveNode::move(), TTAMachine::Component::name(), BoostGraph< GraphNode, GraphEdge >::outEdges(), BF2Scheduler::possibleTempRegRFs(), BFRegCopy::regCopy_, BoostGraph< GraphNode, GraphEdge >::rootGraph(), Reversible::runPostChild(), BFOptimization::sched_, TTAProgram::Move::setDestination(), TTAProgram::Move::setSource(), TTAMachine::BaseRegisterFile::size(), BoostGraph< GraphNode, GraphEdge >::tailNode(), and Conversion::toString().

Here is the call graph for this function:

◆ undoSplit()

void BFRegCopyBefore::undoSplit ( )

protectedvirtual

Implements BFRegCopy.

Definition at line 126 of file BFRegCopyBefore.cc.

                                 {
     mn_.move().setSource(regCopy_->move().source().copy());
 }

References TTAProgram::Terminal::copy(), BFRegCopy::mn_, MoveNode::move(), BFRegCopy::regCopy_, TTAProgram::Move::setSource(), and TTAProgram::Move::source().

Here is the call graph for this function:

Member Data Documentation

◆ forbiddenRF_

const TTAMachine::RegisterFile* BFRegCopyBefore::forbiddenRF_

protected

Definition at line 53 of file BFRegCopyBefore.hh.

Referenced by splitMove().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members