BFOptimization Class Reference

#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 BFLateBypass::operator()(), BFLateBypassGuard::operator()(), BFPushAntidepDown::operator()(), BFPushMoveUp::operator()(), BFScheduleBU::operator()(), BFScheduleExact::operator()(), BFSchedule::operator()(), BFScheduleTD::operator()(), BFShareOperandLate::operator()(), BFShareOperandWithScheduled::operator()(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), BFLateBypass::undoOnlyMe(), BFLateBypassGuard::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(), BFDRELoop::operator()(), BFLateBypassGuard::operator()(), BFPushAntidepDown::operator()(), BFScheduleExact::operator()(), BFSchedule::operator()(), BFShareOperandLate::operator()(), BFAssignToBody::operator()(), BFPostpassLoopDRE::operator()(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), BFLateBypass::undoOnlyMe(), BFLateBypassGuard::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 BFScheduleBU::operator()(), BFScheduleExact::operator()(), and BFScheduleTD::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(), BFRemoveGuardsFromSuccs::operator()(), and BFTryRemoveGuard::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]

DataDependenceGraph & BFOptimization::ddg ( )

protected

Definition at line 70 of file BFOptimization.cc.

{ 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(), BFDREEarly::operator()(), BFDRELate::operator()(), BFDRELoop::operator()(), BFDropPreShared::operator()(), BFEarlyBypasser::operator()(), BFKillNode::operator()(), BFLateBypass::operator()(), BFLateBypasses::operator()(), BFLateBypassGuard::operator()(), BFPushAntidepDown::operator()(), BFPushAntidepsDown::operator()(), BFPushDepsUp::operator()(), BFPushMoveUp::operator()(), BFPushMoveUp2::operator()(), BFRegCopy::operator()(), BFRemoveLoopChecksAndJump::operator()(), BFRenameSource::operator()(), BFRescheduleSuccessorsClose::operator()(), BFScheduleBU::operator()(), BFScheduleExact::operator()(), BFScheduleTD::operator()(), BFShareOperandLate::operator()(), BFShareOperands::operator()(), BFShareOperandsLate::operator()(), BFShareOperandWithScheduled::operator()(), BFConnectNodes::operator()(), BFEarlyBypass::operator()(), BFEarlyGuardBypass::operator()(), BFMergeAndKeepUser::operator()(), BFPostpassBypass::operator()(), BFPostpassBypasser::operator()(), BFPostpassDRE::operator()(), BFPostpassLoopDRE::operator()(), BFRemoveEdge::operator()(), BFRemoveGuard::operator()(), BFRemoveGuardFromSucc::operator()(), BFRemoveGuardsFromSuccs::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(), BFDropPreShared::undoOnlyMe(), BFKillNode::undoOnlyMe(), BFLateBypass::undoOnlyMe(), BFLateBypassGuard::undoOnlyMe(), BFRemoveLoopChecksAndJump::undoOnlyMe(), BFShareOperandWithScheduled::undoOnlyMe(), BFConnectNodes::undoOnlyMe(), BFEarlyGuardBypass::undoOnlyMe(), BFPostpassLoopDRE::undoOnlyMe(), BFRemoveEdge::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

Definition at line 74 of file BFOptimization.cc.

{ return sched_.ddg();}

References BF2Scheduler::ddg(), and sched_.

Here is the call graph for this function:

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(), BFDRELoop::operator()(), BFLateBypass::operator()(), BFSchedulePreLoopShared::operator()(), BFShareOperand::operator()(), BFShareOperandLate::operator()(), BFShareOperandWithScheduled::operator()(), BFMergeAndKeepUser::operator()(), BFPostpassLoopDRE::operator()(), BFRemoveGuardFromSucc::operator()(), rmEC(), rmLC(), unassignCopyFromPrologEpilog(), BFDRELoop::undoOnlyMe(), BFSchedulePreLoopShared::undoOnlyMe(), BFShareOperand::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.

{ return 0; }

Referenced by assign(), canAssign(), jumpGuardAvailableCycle(), needJumpGuard(), BFDRELoop::operator()(), BFEarlyBypasser::operator()(), BFLateBypass::operator()(), BFPushDepsUp::operator()(), BFPushMoveUp::operator()(), BFPushMoveUp2::operator()(), BFRenameLiveRange::operator()(), BFRenameSource::operator()(), BFScheduleBU::operator()(), BFScheduleExact::operator()(), BFScheduleTD::operator()(), BFShareOperand::operator()(), BFShareOperandLate::operator()(), BFShareOperands::operator()(), BFShareOperandsLate::operator()(), BFShareOperandWithScheduled::operator()(), BFEarlyBypass::operator()(), BFMergeAndKeepUser::operator()(), BFPostpassBypass::operator()(), BFRemoveGuardFromSucc::operator()(), BFRemoveGuardsFromSuccs::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(), ProgramOperation::operation(), TTAMachine::FunctionUnit::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.

{ 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 BFDREEarly::operator()(), BFDRELate::operator()(), BFLateBypass::operator()(), and BFEarlyBypass::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.

{ 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(), BFDRELoop::operator()(), BFSchedulePreLoopShared::operator()(), BFShareOperandLate::operator()(), BFShareOperandWithScheduled::operator()(), BFPostpassLoopDRE::operator()(), rmEC(), rmLC(), BF2ScheduleFront::tryToScheduleMoveOuter(), unassignCopyFromPrologEpilog(), BFDRELoop::undoOnlyMe(), BFSchedulePreLoopShared::undoOnlyMe(), BFPostpassLoopDRE::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(), ProgramOperation::operation(), TTAMachine::FunctionUnit::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.

{ return sched_.rm(); }

References BF2Scheduler::rm(), and sched_.

Referenced by assign(), canAssign(), canBeScheduled(), BFLateBypasses::operator()(), BFSchedulePreLoopShared::operator()(), BFShareOperandLate::operator()(), BFShareOperandsLate::operator()(), BFShareOperandWithScheduled::operator()(), BFAssignToBody::operator()(), BFRemoveGuardsFromSuccs::operator()(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), BFShareOperandLate::revert(), rmEC(), rmLC(), BF2ScheduleFront::scheduleFrontFromMove(), unassign(), BFAssignToBody::undoOnlyMe(), BFUnscheduleFromBody::unscheduleOriginal(), and BFUnscheduleMove::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 BFPushAntidepDown::operator()(), and BFScheduleTD::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 BFPushAntidepDown::operator()(), BFPushMoveUp::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.

{ 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(), BFDREEarly::operator()(), BFDRELate::operator()(), BFDRELoop::operator()(), BFDropPreShared::operator()(), BFLateBypasses::operator()(), BFScheduleBU::operator()(), BFShareOperands::operator()(), BFEarlyBypass::operator()(), BFEarlyGuardBypass::operator()(), BFPostpassDRE::operator()(), BFTryRemoveGuard::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 BFLateBypass::operator()(), BFLateBypassGuard::operator()(), BFShareOperandLate::operator()(), BFShareOperandWithScheduled::operator()(), BFRescheduleMove::undoOnlyMe(), BFScheduleBU::undoOnlyMe(), BFScheduleExact::undoOnlyMe(), BFScheduleMove::undoOnlyMe(), BFScheduleTD::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.

Referenced by BFSwapOperands::BFSwapOperands(), BFEarlyBypasser::bypassSourceLatestCycle(), BFRegCopy::createAntidepsForReg(), ddg(), ddg(), duplicator(), BF2ScheduleFront::findInducingBypassSource(), BF2ScheduleFront::findInducingBypassSourceFromOperation(), BF2ScheduleFront::getMoveNodeFromFrontBU(), jumpGuardAvailableCycle(), mightBeReady(), BFRenameLiveRange::notifySelector(), BFDREEarly::operator()(), BFDRELate::operator()(), BFDRELoop::operator()(), BFDropPreShared::operator()(), BFEarlyBypasser::operator()(), BFKillNode::operator()(), BFLateBypass::operator()(), BFLateBypasses::operator()(), BFLateBypassGuard::operator()(), BFPushAntidepDown::operator()(), BFPushAntidepsDown::operator()(), BFPushDepsUp::operator()(), BFPushMoveUp::operator()(), BFPushMoveUp2::operator()(), BFRenameLiveRange::operator()(), BFRenameSource::operator()(), BFRescheduleResultClose::operator()(), BFRescheduleResultsClose::operator()(), BFRescheduleSuccessorsClose::operator()(), BFScheduleBU::operator()(), BFScheduleExact::operator()(), BFScheduleTD::operator()(), BFShareOperandLate::operator()(), BFShareOperands::operator()(), BFShareOperandsLate::operator()(), BFShareOperandWithScheduled::operator()(), BFEarlyBypass::operator()(), BFMergeAndKeepUser::operator()(), BFPostpassBypass::operator()(), BFPostpassDRE::operator()(), BFPostpassLoopDRE::operator()(), BFRemoveGuard::operator()(), BFRemoveGuardFromSucc::operator()(), BFRemoveGuardsFromSuccs::operator()(), BFTryRemoveGuard::operator()(), BF2ScheduleFront::printFront(), prologDDG(), prologRM(), BFRenameLiveRange::renameLiveRange(), BFShareOperandLate::revert(), rm(), BF2ScheduleFront::scheduleFrontFromMove(), BF2ScheduleFront::scheduleMove(), selector(), setJumpGuard(), BFRegCopyAfter::splitMove(), BFRegCopyBefore::splitMove(), targetMachine(), BFPostpassBypasser::tryBypassNode(), BF2ScheduleFront::tryRevertEarlierBypass(), BF2ScheduleFront::tryToScheduleMoveOuter(), BFRegCopy::undoDDG(), BFDropPreShared::undoOnlyMe(), BFKillNode::undoOnlyMe(), BFShareOperandWithScheduled::undoOnlyMe(), BFEarlyBypass::undoOnlyMe(), BFPostpassLoopDRE::undoOnlyMe(), BFRenameLiveRange::undoOnlyMe(), and BFMergeAndKeepUser::updateEdges().

---

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

• BFOptimization.hh
• BFOptimization.cc