#include <BFOptimization.hh>

Inheritance diagram for BFOptimization:

Collaboration diagram for BFOptimization:

Public Member Functions
	BFOptimization (BF2Scheduler &sched)

virtual bool	isFinishFront ()

virtual void	mightBeReady (MoveNode &mn)

Public Member Functions inherited from Reversible
virtual bool	operator() ()=0

virtual void	undo ()

virtual	~Reversible ()

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

int	id ()

	Reversible ()

Static Public Member Functions
static void	clearPrologMoves ()

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

Protected Member Functions
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)

virtual void	undoOnlyMe ()

Protected Attributes
BF2Scheduler &	sched_

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

std::stack< Reversible * >	postChildren_

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

Private Member Functions
void	unsetJumpGuardIfNeeded (MoveNode &mn, int cycle)

void	assignCopyToPrologEpilog (int cycle, MoveNode &mn, MoveNode &loopMN, const TTAMachine::Bus *prologBus, int prologImmWriteCycle)

void	unassignCopyFromPrologEpilog (MoveNode &mh, bool disposePrologCopy=true)

std::pair< MoveNode *, bool >	createCopyForPrologEpilog (MoveNode &mn)

bool	addJumpGuardIfNeeded (MoveNode &mn, int cycle, bool ignoreGuardWriteCycle=false)

void	setPrologFUAnnos (MoveNode &prologMN, MoveNode &loopMN)

bool	hasAmbiguousResources (MoveNode &mn) const

const TTAMachine::FunctionUnit *	sourceFU (const MoveNode &mn)

const TTAMachine::FunctionUnit *	destinationFU (const MoveNode &mn)

const TTAMachine::FunctionUnit *	fuOfTerminal (const TTAProgram::Terminal &t)

void	checkPrologDDG (MoveNode &prologEpilogMN)

Detailed Description

Definition at line 73 of file BFOptimization.hh.

Constructor & Destructor Documentation

◆ BFOptimization()

BFOptimization::BFOptimization ( BF2Scheduler & sched )

inline

Definition at line 75 of file BFOptimization.hh.

                                         : sched_(sched) {
 #ifdef CHECK_DDG_EQUALITY
         getDDGSnapshot();
 #endif
 }

Member Function Documentation

◆ addJumpGuardIfNeeded()

bool BFOptimization::addJumpGuardIfNeeded	(	MoveNode &	mn,
		int	cycle,
		bool	ignoreGuardWriteCycle = `false`
	)

private

Returns false if needs guard but guard not available yet

Definition at line 889 of file BFOptimization.cc.

                                                                       {
     if (needJumpGuard(mn, cycle)) {
         if (jumpGuardAvailableCycle(mn) > cycle && !ignoreGuardWriteCycle) {
 #ifdef DEBUG_LOOP_SCHEDULER
             std::cerr << "jump guard available at "
                       << jumpGuardAvailableCycle(mn)
                       << " , not in cycle: " << cycle << std::endl;
 #endif
             return false;
         }
         if (!mn.move().isUnconditional()) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
             std::cerr << "Cannot add guard to already-conditional move "
                       << std::endl;
 #endif
             return false;
         }
         setJumpGuard(mn);
     }
     return true;
 }

References TTAProgram::Move::isUnconditional(), jumpGuardAvailableCycle(), MoveNode::move(), needJumpGuard(), and setJumpGuard().

Referenced by assign().

Here is the call graph for this function:

◆ assign()

bool BFOptimization::assign	(	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	ignoreGuardWriteCycle = `false`
	)

protectedvirtual

Definition at line 103 of file BFOptimization.cc.

                                             {
  
     bool createdPrologCopy = false;
 #ifdef DEBUG_LOOP_SCHEDULER
     if (ii() != 0) {
         std::cerr << "\t\t\t\tAssigning in loop sched: " << mn.toString()
                   << " to cycle: " << cycle << " imm write cycle: "
                   << immWriteCycle << std::endl;
     }
 #else
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tAssigning mn: " << mn.toString()
               << " imm write cycle: " << immWriteCycle << std::endl;
 #endif
 #endif
     bool usePrologMN = usePrologMove(mn);
     MoveNode* prologEpilogMN = NULL;
     // TODO: why trying to assign all to prolog fails???
     if (usePrologMN) {
         auto a = createCopyForPrologEpilog(mn);
         prologEpilogMN = a.first;
         createdPrologCopy = a.second;
     }
  
     // TODO: assert if too early due the integrated epilog and guard.
     if (!(addJumpGuardIfNeeded(mn, cycle, ignoreGWC))) {
         std::cerr << "Adding jump guard failed for node: "
                   << mn.toString() << std::endl;
         ddg().writeToDotFile("adding_jump_guard_fail.dot");
         assert(false);
     }
  
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     if (!rm().canAssign(
         cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex)) {
         std::cerr << "cannot assign move in assign: " << mn.toString()
                   << " cycle: " << cycle << std::endl;
         TTAProgram::Move& m = mn.move();
         std::cerr << "set bus: " << m.bus().name() << std::endl;
         if (bus != NULL) {
             std::cerr << "bus: " << bus->name() << std::endl;
         }
         if (srcFU != NULL) {
             std::cerr << "src FU: " << srcFU->name() << std::endl;
         }
         if (dstFU != NULL) {
             std::cerr << "dst FU: " << dstFU->name() << std::endl;
         }
  
         std::cerr << "annotations:" << std::endl;
         for (int i = 0 ; i < m.annotationCount(); i++) {
             const TTAProgram::ProgramAnnotation& anno = m.annotation(i);
             std::cerr << "\thas anno, id: " << anno.id()
                       << " data: " << anno.stringValue() << std::endl;
         }
         if (mn.isSourceOperation()) {
             std::cerr << "Source op: " << mn.sourceOperation().toString()
                       << std::endl;
         }
         if (mn.isDestinationOperation()) {
             std::cerr << "Destination op: "
                       << mn.destinationOperation().toString() << std::endl;
         }
         ddg().writeToDotFile("cannot_assign_on_assign.dot");
         assert(false);
     }
 #endif
  
     rm().assign(
     cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex);
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tAssigned mn: " << mn.toString() << std::endl;
 #endif
     assert(bus == NULL || bus == &mn.move().bus());
     if (usePrologMN) {
         assignCopyToPrologEpilog(cycle, *prologEpilogMN, mn, prologBus,
                                  prologImmWriteCycle);
 #ifdef CHECK_PROLOG_DDG
         checkPrologDDG(*prologEpilogMN);
 #endif
     }
     return createdPrologCopy;
 }

References addJumpGuardIfNeeded(), TTAProgram::AnnotatedInstructionElement::annotation(), TTAProgram::AnnotatedInstructionElement::annotationCount(), assert, SimpleResourceManager::assign(), assignCopyToPrologEpilog(), TTAProgram::Move::bus(), canAssign(), checkPrologDDG(), createCopyForPrologEpilog(), ddg(), MoveNode::destinationOperation(), TTAProgram::ProgramAnnotation::id(), ii(), MoveNode::isDestinationOperation(), MoveNode::isSourceOperation(), MoveNode::move(), TTAMachine::Component::name(), rm(), MoveNode::sourceOperation(), TTAProgram::ProgramAnnotation::stringValue(), MoveNode::toString(), ProgramOperation::toString(), usePrologMove(), and GraphBase< GraphNode, GraphEdge >::writeToDotFile().

Referenced by BFLateBypassGuard::operator()(), BFShareOperandWithScheduled::operator()(), BFScheduleTD::operator()(), BFLateBypass::operator()(), BFPushMoveUp::operator()(), BFPushAntidepDown::operator()(), BFScheduleExact::operator()(), BFSchedule::operator()(), BFScheduleBU::operator()(), BFShareOperandLate::operator()(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), BFLateBypassGuard::undoOnlyMe(), BFLateBypass::undoOnlyMe(), and BFShareOperandWithScheduled::undoOnlyMe().

Here is the call graph for this function:

◆ assignCopyToPrologEpilog()

void BFOptimization::assignCopyToPrologEpilog	(	int	cycle,
		MoveNode &	mn,
		MoveNode &	loopMN,
		const TTAMachine::Bus *	prologBus,
		int	prologImmWriteCycle
	)

private

Definition at line 747 of file BFOptimization.cc.

                              {
  
     const TTAMachine::ImmediateUnit* immu = nullptr;
     int immRegIndex = -1;
     if (oldMN.isSourceImmediateRegister()) {
         immRegIndex = oldMN.move().source().index();
         immu = &oldMN.move().source().immediateUnit();
     }
  
 #ifdef DEBUG_LOOP_SCHEDULER
     std::cerr << "\t\t\t\t\tAssigning copy to prolog: " << cycle
               << " " << prologMN.toString() <<
         " prolog cycle: " << cycle + BF2Scheduler::PROLOG_CYCLE_BIAS
               << std::endl;
  
     if (!prologRM()->canAssign(
             BF2Scheduler::PROLOG_CYCLE_BIAS + cycle, prologMN, prologBus,
             sourceFU(oldMN), destinationFU(oldMN), prologImmWriteCycle,
             immu, immRegIndex)) {
         TTAProgram::Move& m = prologMN.move();
  
         std::cerr << std::endl << "Cannot assign move to prolog! "
                   << prologMN.toString() << std::endl << std::endl;
         std::cerr << "Preassigned bus: " << m.bus().name() << std::endl;
         if (prologBus != nullptr) {
             std::cerr << "prolog bus: " << prologBus->name() << std::endl;
         }
         std::cerr << "Cycle: " << cycle << " prolog cycle: "
                   << cycle + BF2Scheduler::PROLOG_CYCLE_BIAS << std::endl;
  
         if (prologMN.isDestinationOperation()) {
             std::cerr << "destpo: "
                       << prologMN.destinationOperation().toString()
                       << std::endl;
         }
  
         ddg().writeToDotFile("cannot_assign_prolog.dot");
         prologDDG()->writeToDotFile("prologddg.dot");
         int sc = prologRM()->smallestCycle();
         int lc = prologRM()->largestCycle();
         for (int i = sc; i <= lc; i++) {
             std::cerr << "\t" << i << "\t"
                       << prologRM()->instruction(i)->toString() << std::endl;
         }
  
         assert(false && "Cannot asign copy to prolog");
     }
 #endif
  
     prologRM()->assign(
         BF2Scheduler::PROLOG_CYCLE_BIAS + cycle, prologMN, prologBus,
         sourceFU(oldMN), destinationFU(oldMN), prologImmWriteCycle,
         immu, immRegIndex);
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\tAassigned copy to prolog, original mn: "
               << oldMN.toString()
               << " copy: " << prologMN.toString() << std::endl;
 #endif
 }

References assert, SimpleResourceManager::assign(), TTAProgram::Move::bus(), canAssign(), ddg(), destinationFU(), MoveNode::destinationOperation(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), SimpleResourceManager::instruction(), MoveNode::isDestinationOperation(), MoveNode::isSourceImmediateRegister(), SimpleResourceManager::largestCycle(), MoveNode::move(), TTAMachine::Component::name(), BF2Scheduler::PROLOG_CYCLE_BIAS, prologDDG(), prologRM(), SimpleResourceManager::smallestCycle(), TTAProgram::Move::source(), sourceFU(), TTAProgram::Instruction::toString(), MoveNode::toString(), ProgramOperation::toString(), and GraphBase< GraphNode, GraphEdge >::writeToDotFile().

Referenced by assign().

Here is the call graph for this function:

◆ canAssign()

bool BFOptimization::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`
	)

protectedvirtual

Definition at line 495 of file BFOptimization.cc.

                                                           {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     if (ii()) {
         std::cerr << "\t\t\t\t\tCalling BFOpt::canassign for: "
                   << mn.toString() << " cycle: " << cycle << std::endl;
     } else {
         std::cerr << "\t\t\t\t\tCalling BFOpt::canassign for: "
                   << mn.toString() << " cycle: " << cycle << std::endl;
     }
     if (bus) {
         std::cerr << "\t\t\t\t\t\tBus: " << bus->name() << std::endl;
     }
     if (prologBus) {
         std::cerr << "\t\t\t\t\t\tProlog bus: " << prologBus->name()
                   << std::endl;
     }
     if (srcFU) {
         std::cerr << "\t\t\t\t\t\tSrc FU: " << srcFU->name() << std::endl;
     }
     if (dstFU) {
         std::cerr << "\t\t\t\t\t\tDst FU: " << dstFU->name() << std::endl;
     }
     if (mn.isDestinationOperation()) {
         std::cerr << "\t\t\t\t\t\tDst po: "
                   << mn.destinationOperation().toString() << std::endl;
     }
 #endif
     bool addGuard = needJumpGuard(mn, cycle);
     if (addGuard) {
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "\t\t\t\t\t\tNeed jump guard, cycle: " << cycle
                   << "ii: " << ii() << std::endl;
 #endif
         // cannot add guard if already has guard.
         if (!mn.move().isUnconditional()) {
 #ifdef DEBUG_LOOP_SCHEDULER
             std::cerr << "\t\t\t\t\tcanassin over with uncond" << std::endl;
 #endif
             return false;
         }
         if (cycle < jumpGuardAvailableCycle(mn) && !ignoreGuardWriteNode) {
 #ifdef DEBUG_LOOP_SCHEDULER
             std::cerr << "\t\t\t\t\tjump guard not yet available so"
                       << " cannot scheudle this." << std::endl;
             std::cerr << "\t\t\t\t\t\tAvailable on cycle: "
                       << jumpGuardAvailableCycle(mn) << std::endl;
 #endif
             return false;
         }
         setJumpGuard(mn);
     }
     bool ok =  rm().canAssign(
         cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex);
 #ifdef DEBUG_LOOP_SCHEDULER
     if (ii()) {
         std::cerr << "\t\t\t\t\t for this: " << ok << " , what about prolog?"
                   << std::endl;
     }
 #endif
  
     // then test assigning to prolog
     bool usePrologMN = usePrologMove(mn);
     if (ok && usePrologMN) {
         // may not have the added jump guard when duplicating.
         if (addGuard) unsetJumpGuard(mn);
         auto a = duplicator().duplicateMoveNode(mn, false, false);
         if (addGuard) setJumpGuard(mn);
         MoveNode* prologMN = a.first;
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "\t\t\t\t\t\tProlog mn: " << prologMN->toString()
                   << std::endl;
 #endif
         bool assignedMN = false;
         if (hasAmbiguousResources(mn)) {
             rm().assign(cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu,
                         immRegIndex);
             srcFU = sourceFU(mn);
             dstFU = destinationFU(mn);
             if (mn.isSourceImmediateRegister()) {
                 immRegIndex = mn.move().source().index();
                 immu = &mn.move().source().immediateUnit();
             }
             assignedMN = true;
         }
         ok &= prologRM()->canAssign(
             BF2Scheduler::PROLOG_CYCLE_BIAS + cycle, *prologMN, prologBus,
             srcFU, dstFU, prologImmWriteCycle, immu, immRegIndex);
         if (assignedMN) {
             rm().unassign(mn);
         }
         if (a.second) { //disposePrologCopy) {
             duplicator().disposeMoveNode(prologMN);
         }
     }
     unsetJumpGuardIfNeeded(mn, cycle);
  
 #ifdef DEBUG_LOOP_SCHEDULER
     if (ii()) {
         std::cerr << "\t\t\t\t\tcanassin over:" << ok << std::endl;
     }
 #else
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tcanassin over:" << ok << std::endl;
 #endif
 #endif
     return ok;
 }

References SimpleResourceManager::assign(), SimpleResourceManager::canAssign(), destinationFU(), MoveNode::destinationOperation(), MoveNodeDuplicator::disposeMoveNode(), MoveNodeDuplicator::duplicateMoveNode(), duplicator(), hasAmbiguousResources(), ii(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), MoveNode::isDestinationOperation(), MoveNode::isSourceImmediateRegister(), TTAProgram::Move::isUnconditional(), jumpGuardAvailableCycle(), MoveNode::move(), TTAMachine::Component::name(), needJumpGuard(), BF2Scheduler::PROLOG_CYCLE_BIAS, prologRM(), rm(), setJumpGuard(), TTAProgram::Move::source(), sourceFU(), MoveNode::toString(), ProgramOperation::toString(), SimpleResourceManager::unassign(), unsetJumpGuard(), unsetJumpGuardIfNeeded(), and usePrologMove().

Referenced by assign(), assignCopyToPrologEpilog(), BFLateBypassGuard::operator()(), BFAssignToBody::operator()(), BFPostpassLoopDRE::operator()(), BFDRELoop::operator()(), BFPushAntidepDown::operator()(), BFScheduleExact::operator()(), BFSchedule::operator()(), BFShareOperandLate::operator()(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), BFLateBypassGuard::undoOnlyMe(), BFLateBypass::undoOnlyMe(), BFUnscheduleFromBody::unscheduleOriginal(), and BFUnscheduleMove::unscheduleOriginal().

Here is the call graph for this function:

◆ canBeScheduled()

bool BFOptimization::canBeScheduled ( const MoveNode & mn )

protected

Definition at line 1067 of file BFOptimization.cc.

                                                       {
     if (!MachineConnectivityCheck::canTransportMove(mn, rm().machine()))
         return false;
     if (RFReadPortCountPreventsScheduling(mn)) {
         return false;
     }
     if (immCountPreventsScheduling(mn)) {
         return false;
     }
     return true;
 }

References MachineConnectivityCheck::canTransportMove(), immCountPreventsScheduling(), machine, RFReadPortCountPreventsScheduling(), and rm().

Referenced by BFScheduleTD::operator()(), BFScheduleBU::operator()(), and BFScheduleExact::operator()().

Here is the call graph for this function:

◆ canBeSpeculated() [1/2]

bool BFOptimization::canBeSpeculated ( const MoveNode & mn )

protected

Definition at line 865 of file BFOptimization.cc.

                                                        {
     if (!mn.isDestinationOperation()) {
         return false;
     }
     const MoveNode* trig = getSisterTrigger(mn, targetMachine());
     // operand writes can be always speculated
     if (&mn != trig && trig != NULL) {
         return true;
     }
     const Operation& op = mn.destinationOperation().operation();
     return canBeSpeculated(op);
 }

References canBeSpeculated(), MoveNode::destinationOperation(), getSisterTrigger(), MoveNode::isDestinationOperation(), ProgramOperation::operation(), and targetMachine().

Here is the call graph for this function:

◆ canBeSpeculated() [2/2]

bool BFOptimization::canBeSpeculated ( const Operation & op )

protected

Definition at line 857 of file BFOptimization.cc.

                                                         {
     return
         !op.usesMemory() &&
         !op.hasSideEffects() &&
         !op.isControlFlowOperation() &&
         op.affectsCount() == 0;
 }

References Operation::affectsCount(), Operation::hasSideEffects(), Operation::isControlFlowOperation(), and Operation::usesMemory().

Referenced by canBeSpeculated(), needJumpGuard(), BFTryRemoveGuard::operator()(), and BFRemoveGuardsFromSuccs::operator()().

Here is the call graph for this function:

◆ checkPrologDDG()

void BFOptimization::checkPrologDDG ( MoveNode & prologEpilogMN )

private

Definition at line 1079 of file BFOptimization.cc.

                                                             {
     auto oEdges = prologDDG()->outEdges(prologEpilogMN);
     auto iEdges = prologDDG()->inEdges(prologEpilogMN);
  
     for (auto e: oEdges) {
         if (!e->isRAW())
             continue;
         MoveNode& head = prologDDG()->headNode(*e);
         if (head.isScheduled() && head.cycle() <= prologEpilogMN.cycle()) {
             prologDDG()->writeToDotFile("illegal_assign_in_prolog.dot");
  
             ddg().writeToDotFile("mainddg.dot");
  
             std::cerr << "Illegal assign of: " << prologEpilogMN.toString()
                       << std::endl;
             assert(false);
         }
     }
  
     for (auto e: iEdges) {
         if (!e->isRAW())
             continue;
         MoveNode& tail = prologDDG()->tailNode(*e);
         if (tail.isScheduled() && tail.cycle() >= prologEpilogMN.cycle()) {
             prologDDG()->writeToDotFile("illegal_assign_in_prolog.dot");
  
             ddg().writeToDotFile("mainddg.dot");
  
             std::cerr << "Illegal assign(2) of: " << prologEpilogMN.toString()
                       << std::endl;
             assert(false);
         }
     }
 }

References assert, MoveNode::cycle(), ddg(), BoostGraph< GraphNode, GraphEdge >::headNode(), BoostGraph< GraphNode, GraphEdge >::inEdges(), MoveNode::isScheduled(), BoostGraph< GraphNode, GraphEdge >::outEdges(), prologDDG(), BoostGraph< GraphNode, GraphEdge >::tailNode(), MoveNode::toString(), and GraphBase< GraphNode, GraphEdge >::writeToDotFile().

Referenced by assign().

Here is the call graph for this function:

◆ clearPrologMoves()

void BFOptimization::clearPrologMoves ( )

static

Definition at line 844 of file BFOptimization.cc.

                                       {
     prologMoves_.clear();
 }

References prologMoves_.

Referenced by BF2Scheduler::handleLoopDDG(), and BF2Scheduler::scheduleDDG().

◆ createCopyForPrologEpilog()

std::pair< MoveNode *, bool > BFOptimization::createCopyForPrologEpilog ( MoveNode & mn )

private

Definition at line 674 of file BFOptimization.cc.

                   {
     auto a = duplicator().duplicateMoveNode(mn, true, true);
     prologMoves_[&mn] = a.first;
     return a; //prologMN;
 }

References MoveNodeDuplicator::duplicateMoveNode(), duplicator(), and prologMoves_.

Referenced by assign().

Here is the call graph for this function:

◆ ddg() [1/2]

const DataDependenceGraph & BFOptimization::ddg ( )

protected

Definition at line 70 of file BFOptimization.cc.

70 { return sched_.ddg(); }

References BF2Scheduler::ddg(), and sched_.

Referenced by BF2ScheduleFront::allNodesOfSameOperation(), assign(), assignCopyToPrologEpilog(), BFEarlyBypasser::bypassSourceLatestCycle(), BFRemoveLoopChecksAndJump::checkAliveMove(), BFRemoveLoopChecksAndJump::checkAlivePO(), checkPrologDDG(), BFRegCopy::createAntidepsForReg(), BFDRELoop::dreAllowed(), BFPostpassLoopDRE::dreAllowed(), BF2ScheduleFront::getMoveNodeFromFrontBU(), BFPushMoveUp2::isLoopBypass(), BFRenameLiveRange::notifySelector(), BFRemoveLoopChecksAndJump::operator()(), BFLateBypassGuard::operator()(), BFEarlyGuardBypass::operator()(), BFEarlyBypass::operator()(), BFDRELate::operator()(), BFDREEarly::operator()(), BFShareOperandsLate::operator()(), BFDropPreShared::operator()(), BFEarlyBypasser::operator()(), BFPostpassBypasser::operator()(), BFPostpassDRE::operator()(), BFRenameSource::operator()(), BFConnectNodes::operator()(), BFKillNode::operator()(), BFLateBypasses::operator()(), BFRemoveEdge::operator()(), BFPostpassBypass::operator()(), BFPostpassLoopDRE::operator()(), BFPushAntidepsDown::operator()(), BFPushDepsUp::operator()(), BFDRELoop::operator()(), BFRegCopy::operator()(), BFRemoveGuardsFromSuccs::operator()(), BFMergeAndKeepUser::operator()(), BFShareOperandWithScheduled::operator()(), BFScheduleTD::operator()(), BFShareOperands::operator()(), BFLateBypass::operator()(), BFPushMoveUp::operator()(), BFPushAntidepDown::operator()(), BFRescheduleSuccessorsClose::operator()(), BFRemoveGuard::operator()(), BFPushMoveUp2::operator()(), BFScheduleBU::operator()(), BFScheduleExact::operator()(), BFRemoveGuardFromSucc::operator()(), BFShareOperandLate::operator()(), BFRemoveLoopChecksAndJump::removeMoveFromQueue(), BFRemoveLoopChecksAndJump::removePoFromQueue(), BFRenameLiveRange::renameLiveRange(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), rootDDG(), BF2ScheduleFront::scheduleFrontFromMove(), BFCopyRegWithOp::splitMove(), BFRegCopyAfter::splitMove(), BFRegCopyBefore::splitMove(), BFPostpassBypasser::tryBypassNode(), BFRegCopy::undoDDG(), BFRenameLiveRange::undoNewAntiDeps(), BFRemoveLoopChecksAndJump::undoOnlyMe(), BFEarlyGuardBypass::undoOnlyMe(), BFLateBypassGuard::undoOnlyMe(), BFDropPreShared::undoOnlyMe(), BFKillNode::undoOnlyMe(), BFConnectNodes::undoOnlyMe(), BFRemoveEdge::undoOnlyMe(), BFPostpassLoopDRE::undoOnlyMe(), BFLateBypass::undoOnlyMe(), BFShareOperandWithScheduled::undoOnlyMe(), BFRenameLiveRange::undoOnlyMe(), BFCopyRegWithOp::undoSplit(), BFUnscheduleFromBody::unscheduleOriginal(), BFUnscheduleMove::unscheduleOriginal(), unsetJumpGuard(), and BFMergeAndKeepUser::updateEdges().

Here is the call graph for this function:

◆ ddg() [2/2]

const DataDependenceGraph& BFOptimization::ddg ( ) const

protected

◆ destinationFU()

const TTAMachine::FunctionUnit * BFOptimization::destinationFU ( const MoveNode & mn )

private

Definition at line 731 of file BFOptimization.cc.

                                                 {
     return fuOfTerminal(mn.move().destination());
 }

References TTAProgram::Move::destination(), fuOfTerminal(), and MoveNode::move().

Referenced by assignCopyToPrologEpilog(), canAssign(), rmEC(), and rmLC().

Here is the call graph for this function:

◆ duplicator()

MoveNodeDuplicator & BFOptimization::duplicator ( ) const

protected

Definition at line 87 of file BFOptimization.cc.

                                                      {
     return sched_.duplicator();
 }

References BF2Scheduler::duplicator(), and sched_.

Referenced by canAssign(), createCopyForPrologEpilog(), BFSchedulePreLoopShared::operator()(), BFShareOperand::operator()(), BFPostpassLoopDRE::operator()(), BFDRELoop::operator()(), BFMergeAndKeepUser::operator()(), BFShareOperandWithScheduled::operator()(), BFLateBypass::operator()(), BFRemoveGuardFromSucc::operator()(), BFShareOperandLate::operator()(), rmEC(), rmLC(), unassignCopyFromPrologEpilog(), BFSchedulePreLoopShared::undoOnlyMe(), BFShareOperand::undoOnlyMe(), BFDRELoop::undoOnlyMe(), BFMergeAndKeepUser::undoOnlyMe(), BFRemoveGuardFromSucc::undoOnlyMe(), and BFUnscheduleMove::unscheduleOriginal().

Here is the call graph for this function:

◆ fuOfTerminal()

const TTAMachine::FunctionUnit * BFOptimization::fuOfTerminal ( const TTAProgram::Terminal & t )

private

Definition at line 736 of file BFOptimization.cc.

                                                         {
     if (!t.isFUPort())
         return NULL;
     return &t.functionUnit();
 }

References TTAProgram::Terminal::functionUnit(), and TTAProgram::Terminal::isFUPort().

Referenced by destinationFU(), and sourceFU().

Here is the call graph for this function:

◆ getSisterTrigger()

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

static

Definition at line 848 of file BFOptimization.cc.

                                                        {
     if (!mn.isDestinationOperation()) {
         return NULL;
     }
     ProgramOperation& po = mn.destinationOperation();
     return BasicBlockScheduler::findTrigger(po, mach);
 }

References MoveNode::destinationOperation(), BasicBlockScheduler::findTrigger(), and MoveNode::isDestinationOperation().

Referenced by canBeSpeculated(), BF2ScheduleFront::getMoveNodeFromFrontBU(), BF2ScheduleFront::getPreferredLimits(), BFDropPreShared::operator()(), and BFShareOperands::operator()().

Here is the call graph for this function:

◆ hasAmbiguousResources()

bool BFOptimization::hasAmbiguousResources ( MoveNode & mn ) const

private

Definition at line 957 of file BFOptimization.cc.

                                                              {
     if (mn.isSourceOperation() &&
         (mn.move().annotationCount(
              TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC) !=1)
         && (mn.move().annotationCount(
                 TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC) !=1)) {
         return true;
     }
     if (mn.isDestinationOperation() &&
         (mn.move().annotationCount(
              TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST) !=1)
         && (mn.move().annotationCount(
                 TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC) !=1)) {
         return true;
     }
     // LIMM unit may be ambiguous resource
     if (mn.isSourceConstant())
         return true;
  
     return false;
 }

References TTAProgram::ProgramAnnotation::ANN_ALLOWED_UNIT_SRC, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST, TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC, TTAProgram::AnnotatedInstructionElement::annotationCount(), MoveNode::isDestinationOperation(), MoveNode::isSourceConstant(), MoveNode::isSourceOperation(), and MoveNode::move().

Referenced by canAssign(), rmEC(), and rmLC().

Here is the call graph for this function:

◆ ii()

unsigned int BFOptimization::ii ( ) const

protected

Definition at line 85 of file BFOptimization.cc.

85 { return 0; }

Referenced by assign(), canAssign(), jumpGuardAvailableCycle(), needJumpGuard(), BFEarlyBypass::operator()(), BFEarlyBypasser::operator()(), BFShareOperandsLate::operator()(), BFRenameSource::operator()(), BFShareOperand::operator()(), BFPostpassBypass::operator()(), BFPushDepsUp::operator()(), BFDRELoop::operator()(), BFRemoveGuardsFromSuccs::operator()(), BFMergeAndKeepUser::operator()(), BFRenameLiveRange::operator()(), BFShareOperandWithScheduled::operator()(), BFLateBypass::operator()(), BFPushMoveUp::operator()(), BFScheduleTD::operator()(), BFShareOperands::operator()(), BFPushMoveUp2::operator()(), BFScheduleExact::operator()(), BFScheduleBU::operator()(), BFRemoveGuardFromSucc::operator()(), BFShareOperandLate::operator()(), rmEC(), rmLC(), BFRegCopyAfter::splitMove(), BFRegCopyBefore::splitMove(), BFShareOperand::undoOnlyMe(), BFRemoveGuardFromSucc::undoOnlyMe(), and BFUnscheduleMove::unscheduleOriginal().

◆ immCountPreventsScheduling()

bool BFOptimization::immCountPreventsScheduling ( const MoveNode & mn )

protected

Definition at line 979 of file BFOptimization.cc.

                                                                   {
  
     auto& move = mn.move();
     if (!move.source().isImmediate()) {
         return false;
     }
  
     if (!mn.isDestinationOperation()) {
         return false;
     }
  
     int simmCount = MachineConnectivityCheck::maxSIMMCount(targetMachine());
     int limmCount = MachineConnectivityCheck::maxLIMMCount(targetMachine());
  
     ProgramOperation& po = mn.destinationOperation();
     for (int i = 0; i < po.inputMoveCount(); i++) {
         MoveNode& input = po.inputMove(i);
         auto& inputMove = input.move();
         if (input.move().destination().isFUPort() && input.isScheduled()) {
             auto& fu = inputMove.destination().functionUnit();
             auto hwop = fu.operation(po.operation().name());
             auto port = hwop->port(move.destination().operationIndex());
             if (!port->noRegister()) {
                 return false;
             }
             if (inputMove.source().isImmediate()) {
                 simmCount--;
             }
             if (inputMove.source().isImmediateRegister()) {
                 limmCount--;
             }
             // all ways to transport immediate used.
             if (simmCount + limmCount < 1) {
                 return true;
             }
             // needs LIMM but no LIMM available, only too narrow SIMMs available.
             if (limmCount < 1 &&
                 !MachineConnectivityCheck::canTransportImmediate(
                     static_cast<TTAProgram::TerminalImmediate&>(
                         move.source()), *port,
                     move.isUnconditional()
                     ? nullptr
                     : &move.guard().guard())) {
                 return true;
             }
         }
     }
     return false;
 }

References MachineConnectivityCheck::canTransportImmediate(), TTAProgram::Move::destination(), MoveNode::destinationOperation(), TTAProgram::Terminal::functionUnit(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isDestinationOperation(), TTAProgram::Terminal::isFUPort(), MoveNode::isScheduled(), MachineConnectivityCheck::maxLIMMCount(), MachineConnectivityCheck::maxSIMMCount(), MoveNode::move(), Operation::name(), TTAMachine::FunctionUnit::operation(), ProgramOperation::operation(), TTAMachine::HWOperation::port(), and targetMachine().

Referenced by canBeScheduled().

Here is the call graph for this function:

◆ isFinishFront()

virtual bool BFOptimization::isFinishFront ( )

inlinevirtual

Definition at line 81 of file BFOptimization.hh.

81 { return false; }

◆ jumpGuardAvailableCycle()

int BFOptimization::jumpGuardAvailableCycle ( const MoveNode & mn )

protected

Definition at line 918 of file BFOptimization.cc.

                                                               {
  
     if (!sched_.jumpNode() || sched_.jumpNode()->isGuardOperation()) {
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "jump node is null or guard operation!" << std::endl;
 #endif
         return INT_MAX;
     }
     if (sched_.guardWriteNode() == NULL) {
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "Guard write node not known!" << std::endl;
 #endif
         return INT_MAX;
     }
     if (&mn == sched_.guardWriteNode()) {
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "I AM guard write node!" << std::endl << std::endl;
 #endif
         return 0;
     }
     if (!sched_.guardWriteNode()->isScheduled()) {
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "guardwrite node is null or not sched:"
                   << sched_.guardWriteNode()->toString() << std::endl;
 #endif
         return INT_MAX;
     }
  
     int glat = sched_.guardWriteNode()->move().destination().registerFile().
         guardLatency()+
         targetMachine().controlUnit()->globalGuardLatency();
  
     return glat+ sched_.guardWriteNode()->cycle() - ii();
 }

References TTAMachine::Machine::controlUnit(), MoveNode::cycle(), TTAProgram::Move::destination(), TTAMachine::ControlUnit::globalGuardLatency(), BF2Scheduler::guardWriteNode(), ii(), MoveNode::isGuardOperation(), MoveNode::isScheduled(), BF2Scheduler::jumpNode(), MoveNode::move(), TTAProgram::Terminal::registerFile(), sched_, targetMachine(), and MoveNode::toString().

Referenced by addJumpGuardIfNeeded(), canAssign(), rmEC(), and rmLC().

Here is the call graph for this function:

◆ mightBeReady()

void BFOptimization::mightBeReady ( MoveNode & mn )

virtual

Reimplemented in BF2ScheduleFront.

Definition at line 953 of file BFOptimization.cc.

                                              {
     sched_.currentFront()->mightBeReady(n);
 }

References BF2Scheduler::currentFront(), BF2ScheduleFront::mightBeReady(), and sched_.

Referenced by BFEarlyBypass::operator()(), BFDRELate::operator()(), BFDREEarly::operator()(), and BFLateBypass::operator()().

Here is the call graph for this function:

◆ needJumpGuard()

bool BFOptimization::needJumpGuard	(	const MoveNode &	mn,
		int	cycle
	)

protected

Definition at line 878 of file BFOptimization.cc.

                                                                {
     if (cycle >= (int)(ii())) {
         return false;
     }
  
     return !canBeSpeculated(mn);
 }

References canBeSpeculated(), and ii().

Referenced by addJumpGuardIfNeeded(), canAssign(), rmEC(), rmLC(), and unsetJumpGuardIfNeeded().

Here is the call graph for this function:

◆ prologDDG()

DataDependenceGraph * BFOptimization::prologDDG ( )

protected

Definition at line 75 of file BFOptimization.cc.

75 { return sched_.prologDDG();}

References BF2Scheduler::prologDDG(), and sched_.

Referenced by assignCopyToPrologEpilog(), checkPrologDDG(), and BFSchedulePreLoopShared::operator()().

Here is the call graph for this function:

◆ prologRM()

SimpleResourceManager * BFOptimization::prologRM ( ) const

protected

Definition at line 77 of file BFOptimization.cc.

                                                       {
     return sched_.prologRM();
 }

References BF2Scheduler::prologRM(), and sched_.

Referenced by assignCopyToPrologEpilog(), canAssign(), BFSchedulePreLoopShared::operator()(), BFPostpassLoopDRE::operator()(), BFDRELoop::operator()(), BFShareOperandWithScheduled::operator()(), BFShareOperandLate::operator()(), rmEC(), rmLC(), BF2ScheduleFront::tryToScheduleMoveOuter(), unassignCopyFromPrologEpilog(), BFSchedulePreLoopShared::undoOnlyMe(), BFPostpassLoopDRE::undoOnlyMe(), BFDRELoop::undoOnlyMe(), BFUnscheduleMove::unscheduleOriginal(), and usePrologMove().

Here is the call graph for this function:

◆ putAlsoToPrologEpilog()

bool BFOptimization::putAlsoToPrologEpilog	(	int	cycle,
		MoveNode &	mn
	)

protected

◆ RFReadPortCountPreventsScheduling()

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

protected

Definition at line 1030 of file BFOptimization.cc.

                                                                     {
  
     auto& move = mn.move();
     if (!move.source().isGPR()) {
         return nullptr;
     }
  
     auto& rf = move.source().registerFile();
     int freeRFPorts = rf.maxReads();
  
     if (!move.destination().isFUPort() || !mn.isDestinationOperation()) {
         return nullptr;
     }
  
     ProgramOperation& po = mn.destinationOperation();
     for (int i = 0; i < po.inputMoveCount(); i++) {
         MoveNode& input = po.inputMove(i);
         auto& inputMove = input.move();
         if (input.move().destination().isFUPort() && input.isScheduled()) {
             auto& fu = inputMove.destination().functionUnit();
             auto hwop = fu.operation(po.operation().name());
             auto port = hwop->port(move.destination().operationIndex());
             if (!port->noRegister()) {
                 return nullptr;
             }
             if (inputMove.source().isGPR() &&
                 &inputMove.source().registerFile() == &rf) {
                 freeRFPorts--;
                 if (freeRFPorts < 1) {
                     return &rf;
                 }
             }
         }
     }
     return nullptr;
 }

References TTAProgram::Move::destination(), MoveNode::destinationOperation(), TTAProgram::Terminal::functionUnit(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isDestinationOperation(), TTAProgram::Terminal::isFUPort(), MoveNode::isScheduled(), TTAMachine::RegisterFile::maxReads(), MoveNode::move(), Operation::name(), TTAMachine::FunctionUnit::operation(), ProgramOperation::operation(), TTAMachine::HWOperation::port(), TTAProgram::Terminal::registerFile(), and TTAProgram::Move::source().

Referenced by canBeScheduled(), and BFScheduleBU::operator()().

Here is the call graph for this function:

◆ rm()

SimpleResourceManager & BFOptimization::rm ( ) const

protected

Definition at line 76 of file BFOptimization.cc.

76 { return sched_.rm(); }

References BF2Scheduler::rm(), and sched_.

Referenced by assign(), canAssign(), canBeScheduled(), BFSchedulePreLoopShared::operator()(), BFShareOperandsLate::operator()(), BFLateBypasses::operator()(), BFAssignToBody::operator()(), BFRemoveGuardsFromSuccs::operator()(), BFShareOperandWithScheduled::operator()(), BFShareOperandLate::operator()(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), rmEC(), rmLC(), BF2ScheduleFront::scheduleFrontFromMove(), unassign(), BFAssignToBody::undoOnlyMe(), BFUnscheduleMove::unscheduleOriginal(), and BFUnscheduleFromBody::unscheduleOriginal().

Here is the call graph for this function:

◆ rmEC()

int BFOptimization::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`
	)

protectedvirtual

Definition at line 213 of file BFOptimization.cc.

                                           {
 #ifdef DEBUG_LOOP_SCHEDULER
     if (ii()) {
         std::cerr << "\t\t\t\t\tbfopt::rmec called, cycle: " << cycle
                   << " mn: " << mn.toString() <<
             std::endl;
  
     }
 #else
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tCalling rmec for: " << mn.toString()
               << " cycle: " << cycle <<  "dispose: "
               << disposePrologCopy << std::endl;
 #endif
 #endif
     if (!ii()) {
         return rm().earliestCycle(
         cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex);
     }
     // cannot add guard if already has guard. so limit cycle to 2nd round.
     if (!mn.move().isUnconditional() && needJumpGuard(mn, cycle)) {
         cycle = ii();
     }
  
     MoveNode* prologMN = nullptr;
     bool createdCopy = false;
     bool usePrologMN = usePrologMove(mn);
     if (usePrologMN) {
         auto a = duplicator().duplicateMoveNode(mn, false, false);
         prologMN = a.first;
         createdCopy = a.second;
     }
  
     bool setGuard = false;
     int ec = rm().earliestCycle(
         cycle, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex);
     if (ec == INT_MAX || ec == -1) {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
         std::cerr << "\t\t\t\t\trmec over with -1" << std::endl;
 #endif
         if (createdCopy) {
             duplicator().disposeMoveNode(prologMN);
         }
         return ec;
     }
  
     while (ec < (signed)(2*ii())) {
         if (needJumpGuard(mn, ec)) {
             if (ec < jumpGuardAvailableCycle(mn)) {
                 ec++;
                 continue;
             }
             if (!setGuard) {
                 assert(mn.move().isUnconditional());
                 setJumpGuard(mn);
                 setGuard = true;
                 continue;
             }
         } else { // no longer need jump guard.
             if (setGuard) {
                 assert(!mn.move().isUnconditional());
                 unsetJumpGuard(mn);
                 setGuard = false;
                 continue;
             }
         }
  
         if (!setGuard) {
             ec = rm().earliestCycle(
         ec, mn, bus, srcFU, dstFU, immWriteCycle, immu, immRegIndex);
             if (ec == -1) {
                 break;
             }
         } else {
             int newEC = rm().earliestCycle(
                 ec, mn, bus, srcFU, dstFU, immWriteCycle);
             // if set guard, guard may reduce too much..
             if (newEC > ec) {
                 ec = std::min(newEC, (signed)(ii()));
                 continue;
             }
             if (newEC == -1) {
                 ec = -1;
                 break;
             }
         }
         if (ec == INT_MAX) {
             break;
         }
  
  
         if (usePrologMN) {
             bool assignedMN = false;
             auto mySrcFU = srcFU;
             auto myDstFU = dstFU;
             auto myImmu = immu;
             auto myImmReg = immRegIndex;
             if (hasAmbiguousResources(mn)) {
                 rm().assign(ec, mn, bus, srcFU, dstFU, immWriteCycle, immu,
                 immRegIndex);
                 mySrcFU = sourceFU(mn);
                 myDstFU = destinationFU(mn);
                 if (mn.isSourceImmediateRegister()) {
                     myImmReg = mn.move().source().index();
                     myImmu = &mn.move().source().immediateUnit();
                 }
                 assignedMN = true;
             }
             bool ok = prologRM()->canAssign(
                 ec + BF2Scheduler::PROLOG_CYCLE_BIAS, *prologMN, prologBus,
                 mySrcFU, myDstFU, prologImmWriteCycle, myImmu, myImmReg);
             if (assignedMN) {
                 rm().unassign(mn);
             }
             if (!ok) {
                 ec++;
                 continue;
             } else {
                 break;
             }
         } else { // no prolog
             if (createdCopy) {
                 duplicator().disposeMoveNode(prologMN);
             }
             if (setGuard) {
                 unsetJumpGuard(mn);
             }
             return ec;
         }
     }
     if (createdCopy) {
         duplicator().disposeMoveNode(prologMN);
     }
     if (setGuard) {
         unsetJumpGuard(mn);
     }
 #ifdef DEBUG_LOOP_SCHEDULER
     std::cerr << "\t\t\t\t\trmec over" << std::endl;
 #endif
     return ec;
 }

References assert, SimpleResourceManager::assign(), SimpleResourceManager::canAssign(), destinationFU(), MoveNodeDuplicator::disposeMoveNode(), MoveNodeDuplicator::duplicateMoveNode(), duplicator(), SimpleResourceManager::earliestCycle(), hasAmbiguousResources(), ii(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), MoveNode::isSourceImmediateRegister(), TTAProgram::Move::isUnconditional(), jumpGuardAvailableCycle(), MoveNode::move(), needJumpGuard(), BF2Scheduler::PROLOG_CYCLE_BIAS, prologRM(), rm(), setJumpGuard(), TTAProgram::Move::source(), sourceFU(), MoveNode::toString(), SimpleResourceManager::unassign(), unsetJumpGuard(), and usePrologMove().

Referenced by BFScheduleTD::operator()(), and BFPushAntidepDown::operator()().

Here is the call graph for this function:

◆ rmLC()

int BFOptimization::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`
	)

protectedvirtual

Definition at line 363 of file BFOptimization.cc.

                                           {
 #ifdef DEBUG_LOOP_SCHEDULER
     if (ii()) {
         std::cerr << "\t\t\t\t\tbfopt::rmlc called, cycle: " << cycle
                   << " mn: " << mn.toString() << std::endl;
     }
 #else
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tbfopt::rmlc called, cycle: " << cycle
               << " mn: " << mn.toString() << std::endl;
 #endif
 #endif
     int lc = cycle;
     bool setGuard = false;
     MoveNode* prologMN = NULL;
     bool createdCopy = false;
     bool usePrologMN = usePrologMove(mn);
     if (usePrologMN) {
         auto a = duplicator().duplicateMoveNode(mn, false, false);
         prologMN = a.first;
         createdCopy = a.second;
     }
  
     while (lc >= 0) {
         lc = rm().latestCycle(lc,mn, bus, srcFU, dstFU, immWriteCycle);
 #ifdef DEBUG_LOOP_SCHEDULER
         if (ii()) {
             std::cerr << "\t\t\t\t\tgot lc from rm: " << lc << std::endl;
         }
 #else
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
         std::cerr << "\t\t\t\t\tgot lc from rm: " << lc << std::endl;
 #endif
 #endif
         if (lc == -1) {
             break;
         }
         if (needJumpGuard(mn, lc)) {
 #ifdef DEBUG_LOOP_SCHEDULER
             std::cerr << "\t\t\t\t\tNeed jump guard for mn: "
                       << mn.toString() << " cycle: " << lc << std::endl;
 #endif
             if (lc < jumpGuardAvailableCycle(mn)) {
 #ifdef DEBUG_LOOP_SCHEDULER
                 std::cerr << "\t\t\t\t\tjump guard not yet available so "
                           << "cannot schedule this ever" << std::endl;
 #endif
                 if (createdCopy) {
                     duplicator().disposeMoveNode(prologMN);
                 }
                 if (setGuard) {
                     unsetJumpGuard(mn);
                 }
                 return -1;
             }
             if (!setGuard) {
                 // cannot add guard if already has guard.
                 if (!mn.move().isUnconditional()) {
                     if (createdCopy) {
                         duplicator().disposeMoveNode(prologMN);
                     }
                     return -1;
                 }
                 setJumpGuard(mn);
                 setGuard = true;
                 continue;
             }
         }
         if (usePrologMN) {
             // then check that this can be assigned to prolog/epilog
             // need to use the correct FU - only way to get it is to
             // assign loop move first
             bool assignedMN = false;
             auto mySrcFU = srcFU;
             auto myDstFU = dstFU;
             auto myImmu = immu;
             auto myImmReg = immRegIndex;
  
             if (hasAmbiguousResources(mn)) {
                 rm().assign(lc, mn, bus, srcFU, dstFU, immWriteCycle);
                 mySrcFU = sourceFU(mn);
                 myDstFU = destinationFU(mn);
                 if (mn.isSourceImmediateRegister()) {
                     myImmReg = mn.move().source().index();
                     myImmu = &mn.move().source().immediateUnit();
                 }
                 assignedMN = true;
             }
             bool ok = prologRM()->canAssign(
                 lc + BF2Scheduler::PROLOG_CYCLE_BIAS, *prologMN, prologBus,
                 mySrcFU, myDstFU, prologImmWriteCycle, myImmu, myImmReg);
             if (assignedMN) {
                 rm().unassign(mn);
             }
             if (!ok) {
 #ifdef DEBUG_LOOP_SCHEDULER
                 std::cerr << "prolog RM cannot assign to cycle: "
                           << lc << std::endl;
                 std::cerr << "instr in prolog rm: " <<
                     POMDisassembler::disassemble(
                         *prologRM()->instruction(
                             lc + BF2Scheduler::PROLOG_CYCLE_BIAS));
 #endif
                 lc--;
                 continue;
             } else {
                 break;
             }
         } else { // not in a prolog.
             if (createdCopy) {
                 duplicator().disposeMoveNode(prologMN);
             }
             return lc;
         }
     }
     if (createdCopy) {
         duplicator().disposeMoveNode(prologMN);
     }
     if (setGuard) {
         unsetJumpGuard(mn);
     }
     return lc;
 }

References SimpleResourceManager::assign(), SimpleResourceManager::canAssign(), destinationFU(), POMDisassembler::disassemble(), MoveNodeDuplicator::disposeMoveNode(), MoveNodeDuplicator::duplicateMoveNode(), duplicator(), hasAmbiguousResources(), ii(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), MoveNode::isSourceImmediateRegister(), TTAProgram::Move::isUnconditional(), jumpGuardAvailableCycle(), SimpleResourceManager::latestCycle(), MoveNode::move(), needJumpGuard(), BF2Scheduler::PROLOG_CYCLE_BIAS, prologRM(), rm(), setJumpGuard(), TTAProgram::Move::source(), sourceFU(), MoveNode::toString(), SimpleResourceManager::unassign(), unsetJumpGuard(), and usePrologMove().

Referenced by BFPushMoveUp::operator()(), BFPushAntidepDown::operator()(), and BFScheduleBU::operator()().

Here is the call graph for this function:

◆ rootDDG()

DataDependenceGraph * BFOptimization::rootDDG ( )

protected

Definition at line 71 of file BFOptimization.cc.

                                              {
     return static_cast<DataDependenceGraph*>(ddg().rootGraph());
 }

References ddg(), and BoostGraph< GraphNode, GraphEdge >::rootGraph().

Here is the call graph for this function:

◆ selector()

BUMoveNodeSelector & BFOptimization::selector ( )

protected

Definition at line 80 of file BFOptimization.cc.

80 { return sched_.selector(); }

References sched_, and BF2Scheduler::selector().

Referenced by BF2ScheduleFront::scheduleFrontFromMove().

Here is the call graph for this function:

◆ setJumpGuard()

void BFOptimization::setJumpGuard ( MoveNode & mn )

protected

Definition at line 612 of file BFOptimization.cc.

                                               {
 #ifdef DEBUG_LOOP_SCHEDULER
     std::cerr << "\t\t\t\t\tsetting jump guard to: " << mn.toString()
               << std::endl;
 #endif
  
     if (!mn.move().isUnconditional()) {
         std::cerr << "Cannot set jump guard because already conditional: "
                   << mn.toString() << std::endl;
     }
     assert(mn.move().isUnconditional());
  
     assert(!dynamic_cast<const TTAMachine::PortGuard*>(
                &sched_.jumpGuard()->guard()));
  
     TTAProgram::MoveGuard* newGuard = sched_.jumpGuard()->copy();
 //        TTAProgram::CodeGenerator::createInverseGuard(*sched_.jumpGuard());
  
     mn.move().setGuard(newGuard);
  
 /*
     TTAMachine::Guard& g = newGuard->guard();
     TTAMachine::RegisterGuard* rg =
         dynamic_cast<TTAMachine::RegisterGuard*>(&g);
  
  
  
  
     TCEString regName;
     regName << rg->registerFile()->name() << "." <<
         rg->registerIndex();
  
     DataDependenceEdge* e = new DataDependenceEdge(
         DataDependenceEdge::EDGE_REGISTER,
         DataDependenceEdge::DEP_RAW,
         regName,
         true, // guard
         false, // true_alias mem dep
         false, // tail pseudo
         false, // head pseudo
         1); // loop depth
     ddg().connectNodes(*sched_.guardWriteNode(), mn,*e);
  
 */
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tset jump guard: " << mn.toString() << std::endl;
 #endif
  
 }

References assert, TTAProgram::MoveGuard::copy(), TTAProgram::MoveGuard::guard(), TTAProgram::Move::isUnconditional(), BF2Scheduler::jumpGuard(), MoveNode::move(), sched_, TTAProgram::Move::setGuard(), and MoveNode::toString().

Referenced by addJumpGuardIfNeeded(), canAssign(), rmEC(), and rmLC().

Here is the call graph for this function:

◆ setPrologDstFUAnno()

void BFOptimization::setPrologDstFUAnno	(	MoveNode &	prologMN,
		MoveNode &	loopMN
	)

protected

Definition at line 703 of file BFOptimization.cc.

                                                                            {
     TTAProgram::Move& m = prologMN.move();
  
     if (loopMN.isDestinationOperation()) {
         m.removeAnnotations(
             TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST);
         TTAProgram::Terminal& dest = loopMN.move().destination();
         assert(dest.isFUPort());
         std::string fuName = dest.functionUnit().name();
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "\t\tSetting dst Fu anno, loop MN: "
                   << loopMN.toString() << " prolog MN: "
                   << prologMN.toString() << std::endl;
 #endif
         //TODO: which is the correct annotation here?
         TTAProgram::ProgramAnnotation dstUnit(
             TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST,
             fuName);
         m.setAnnotation(dstUnit);
     }
 }

References TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_DST, assert, TTAProgram::Move::destination(), TTAProgram::Terminal::functionUnit(), MoveNode::isDestinationOperation(), TTAProgram::Terminal::isFUPort(), MoveNode::move(), TTAMachine::Component::name(), TTAProgram::AnnotatedInstructionElement::removeAnnotations(), TTAProgram::AnnotatedInstructionElement::setAnnotation(), and MoveNode::toString().

Referenced by setPrologFUAnnos().

Here is the call graph for this function:

◆ setPrologFUAnnos()

void BFOptimization::setPrologFUAnnos	(	MoveNode &	prologMN,
		MoveNode &	loopMN
	)

private

Definition at line 742 of file BFOptimization.cc.

                                                                           {
     setPrologSrcFUAnno(prologMN, loopMN);
     setPrologDstFUAnno(prologMN, loopMN);
 }

References setPrologDstFUAnno(), and setPrologSrcFUAnno().

Here is the call graph for this function:

◆ setPrologSrcFUAnno()

void BFOptimization::setPrologSrcFUAnno	(	MoveNode &	prologMN,
		MoveNode &	loopMN
	)

protected

Definition at line 681 of file BFOptimization.cc.

                                                                            {
     TTAProgram::Move& m = prologMN.move();
  
     if (loopMN.isSourceOperation()) {
         m.removeAnnotations(
             TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC);
         TTAProgram::Terminal& source = loopMN.move().source();
         assert(source.isFUPort());
         std::string fuName = source.functionUnit().name();
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "\t\tSetting src Fu anno, loop MN: "
                   << loopMN.toString() << " prolog MN: "
                   << prologMN.toString() << std::endl;
 #endif
         //TODO: which is the correct annotation here?
         TTAProgram::ProgramAnnotation srcUnit(
             TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC,
             fuName);
         m.setAnnotation(srcUnit);
     }
 }

References TTAProgram::ProgramAnnotation::ANN_CONN_CANDIDATE_UNIT_SRC, assert, TTAProgram::Terminal::functionUnit(), TTAProgram::Terminal::isFUPort(), MoveNode::isSourceOperation(), MoveNode::move(), TTAMachine::Component::name(), TTAProgram::AnnotatedInstructionElement::removeAnnotations(), TTAProgram::AnnotatedInstructionElement::setAnnotation(), TTAProgram::Move::source(), and MoveNode::toString().

Referenced by setPrologFUAnnos().

Here is the call graph for this function:

◆ sourceFU()

const TTAMachine::FunctionUnit * BFOptimization::sourceFU ( const MoveNode & mn )

private

Definition at line 726 of file BFOptimization.cc.

                                            {
     return fuOfTerminal(mn.move().source());
 }

References fuOfTerminal(), MoveNode::move(), and TTAProgram::Move::source().

Referenced by assignCopyToPrologEpilog(), canAssign(), rmEC(), and rmLC().

Here is the call graph for this function:

◆ targetMachine()

const TTAMachine::Machine & BFOptimization::targetMachine ( ) const

protected

Definition at line 81 of file BFOptimization.cc.

                                                               {
     return sched_.targetMachine();
 }

References sched_, and BF2Scheduler::targetMachine().

Referenced by canBeSpeculated(), BF2ScheduleFront::getMoveNodeFromFrontBU(), BF2ScheduleFront::getPreferredLimits(), immCountPreventsScheduling(), jumpGuardAvailableCycle(), BFEarlyGuardBypass::operator()(), BFEarlyBypass::operator()(), BFDREEarly::operator()(), BFDRELate::operator()(), BFDropPreShared::operator()(), BFPostpassDRE::operator()(), BFTryRemoveGuard::operator()(), BFLateBypasses::operator()(), BFDRELoop::operator()(), BFShareOperands::operator()(), BFScheduleBU::operator()(), BFRenameLiveRange::renameLiveRange(), BF2ScheduleFront::scheduleFrontFromMove(), BFRenameLiveRange::setTerminals(), and BFCopyRegWithOp::splitMove().

Here is the call graph for this function:

◆ unassign()

void BFOptimization::unassign	(	MoveNode &	mn,
		bool	disposePrologCopy = `true`
	)

protectedvirtual

Definition at line 196 of file BFOptimization.cc.

                                                                   {
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tUnassigning mn: " << mn.toString()
               << "dispose: " << disposePrologCopy << std::endl;
 #endif
     int cycle = mn.cycle();
     rm().unassign(mn);
     bool usePrologMN = usePrologMove(mn);
     if (usePrologMN) {
         unassignCopyFromPrologEpilog(mn, disposePrologCopy);
     }
     unsetJumpGuardIfNeeded(mn, cycle);
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tUnassignined mn: " << mn.toString() << std::endl;
 #endif
 }

References MoveNode::cycle(), rm(), MoveNode::toString(), SimpleResourceManager::unassign(), unassignCopyFromPrologEpilog(), unsetJumpGuardIfNeeded(), and usePrologMove().

Referenced by BFLateBypassGuard::operator()(), BFShareOperandWithScheduled::operator()(), BFLateBypass::operator()(), BFShareOperandLate::operator()(), BFScheduleMove::undoOnlyMe(), BFRescheduleMove::undoOnlyMe(), BFScheduleTD::undoOnlyMe(), BFScheduleExact::undoOnlyMe(), BFScheduleBU::undoOnlyMe(), BFShareOperandLate::undoOnlyMe(), and BFUnscheduleMove::unscheduleOriginal().

Here is the call graph for this function:

◆ unassignCopyFromPrologEpilog()

void BFOptimization::unassignCopyFromPrologEpilog	(	MoveNode &	mh,
		bool	disposePrologCopy = `true`
	)

private

Definition at line 810 of file BFOptimization.cc.

                                           {
 #ifdef DEBUG_LOOP_SCHEDULER
     std::cerr << "\t\tUnassigning copy from prolog, original mn: "
               << mn.toString() << "dispose: "
               << disposePrologCopy << std::endl;
 #endif
     MoveNode* copy = prologMoves_[&mn];
     if (copy != NULL) {
         prologRM()->unassign(*copy);
         prologMoves_.erase(&mn);
 #ifdef DEBUG_LOOP_SCHEDULER
         std::cerr << "\t\t\tcopy after unassign: " << copy->toString()
                   << std::endl;
 #endif
         if (disposePrologCopy) {
             duplicator().disposeMoveNode(copy);
         }
         // TODO: program ops memory leak now
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     } else {
         std::cerr << "\t\t\tCopy not found." << std::endl;
 #endif
     }
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\tUnassigned copy from prolog, original mn: "
               << mn.toString() << std::endl;
 #endif
     prologMoves_.erase(&mn);
 }

References MoveNodeDuplicator::disposeMoveNode(), duplicator(), prologMoves_, prologRM(), MoveNode::toString(), and SimpleResourceManager::unassign().

Referenced by unassign().

Here is the call graph for this function:

◆ unsetJumpGuard()

void BFOptimization::unsetJumpGuard ( MoveNode & mn )

protected

Definition at line 662 of file BFOptimization.cc.

                                                 {
 #ifdef DEBUG_LOOP_SCHEDULER
     std::cerr << "\t\t\t\t\tunsetting jump guard from: "
               << mn.toString() << std::endl;
 #endif
     ddg().removeIncomingGuardEdges(mn);
     mn.move().setGuard(NULL);
 #ifdef DEBUG_BUBBLEFISH_SCHEDULER
     std::cerr << "\t\t\t\t\tunset jump guard: " << mn.toString() << std::endl;
 #endif
 }

References ddg(), MoveNode::move(), DataDependenceGraph::removeIncomingGuardEdges(), TTAProgram::Move::setGuard(), and MoveNode::toString().

Referenced by canAssign(), rmEC(), rmLC(), and unsetJumpGuardIfNeeded().

Here is the call graph for this function:

◆ unsetJumpGuardIfNeeded()

void BFOptimization::unsetJumpGuardIfNeeded	(	MoveNode &	mn,
		int	cycle
	)

private

Definition at line 912 of file BFOptimization.cc.

                                                                    {
     if (needJumpGuard(mn, cycle)) {
         unsetJumpGuard(mn);
     }
 }

References needJumpGuard(), and unsetJumpGuard().

Referenced by canAssign(), and unassign().

Here is the call graph for this function:

◆ usePrologMove()

bool BFOptimization::usePrologMove ( const MoveNode & mn )

protected

Definition at line 91 of file BFOptimization.cc.

                                                      {
     if (prologRM() == NULL) {
         return false;
     }
     // TODO: better way to no prolog move for lbufc op
     if (mn.move().isControlFlowMove() &&
         !mn.move().isJump()) {
         return false;
     }
     return true;
 }

References TTAProgram::Move::isControlFlowMove(), TTAProgram::Move::isJump(), MoveNode::move(), and prologRM().

Referenced by assign(), canAssign(), rmEC(), rmLC(), and unassign().

Here is the call graph for this function:

Member Data Documentation

◆ prologMoves_

std::map< MoveNode *, MoveNode *, MoveNode::Comparator > BFOptimization::prologMoves_

staticprotected

Definition at line 146 of file BFOptimization.hh.

Referenced by clearPrologMoves(), createCopyForPrologEpilog(), unassignCopyFromPrologEpilog(), and BFDRELoop::undoOnlyMe().

◆ sched_

BF2Scheduler& BFOptimization::sched_

protected

Definition at line 103 of file BFOptimization.hh.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ BFOptimization()

Member Function Documentation

◆ addJumpGuardIfNeeded()

◆ assign()

◆ assignCopyToPrologEpilog()

◆ canAssign()

◆ canBeScheduled()

◆ canBeSpeculated() [1/2]

◆ canBeSpeculated() [2/2]

◆ checkPrologDDG()

◆ clearPrologMoves()

◆ createCopyForPrologEpilog()

◆ ddg() [1/2]

◆ ddg() [2/2]

◆ destinationFU()

◆ duplicator()

◆ fuOfTerminal()

◆ getSisterTrigger()

◆ hasAmbiguousResources()

◆ ii()

◆ immCountPreventsScheduling()

◆ isFinishFront()

◆ jumpGuardAvailableCycle()

◆ mightBeReady()

◆ needJumpGuard()

◆ prologDDG()

◆ prologRM()

◆ putAlsoToPrologEpilog()

◆ RFReadPortCountPreventsScheduling()

◆ rm()

◆ rmEC()

◆ rmLC()

◆ rootDDG()

◆ selector()

◆ setJumpGuard()

◆ setPrologDstFUAnno()

◆ setPrologFUAnnos()

◆ setPrologSrcFUAnno()

◆ sourceFU()

◆ targetMachine()

◆ unassign()

◆ unassignCopyFromPrologEpilog()

◆ unsetJumpGuard()

◆ unsetJumpGuardIfNeeded()

◆ usePrologMove()

Member Data Documentation

◆ prologMoves_

◆ sched_