#include <BFLateBypass.hh>

Inheritance diagram for BFLateBypass:

Collaboration diagram for BFLateBypass:

Public Member Functions
	BFLateBypass (BF2Scheduler &sched, MoveNode &src, MoveNode &dst, int lc)

virtual bool	operator() ()

virtual void	undoOnlyMe ()

Public Member Functions inherited from BFOptimization
	BFOptimization (BF2Scheduler &sched)

virtual bool	isFinishFront ()

virtual void	mightBeReady (MoveNode &mn)

Public Member Functions inherited from Reversible
virtual void	undo ()

virtual	~Reversible ()

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

int	id ()

	Reversible ()

Protected Attributes
int	originalCycle_

MoveNode &	src_

MoveNode &	dst_

int	lc_

const TTAMachine::Bus *	originalBus_

const TTAMachine::Bus *	prologBus_

Protected Attributes inherited from BFOptimization
BF2Scheduler &	sched_

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

std::stack< Reversible * >	postChildren_

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

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

Protected Member Functions inherited from BFOptimization
DataDependenceGraph &	ddg ()

DataDependenceGraph *	rootDDG ()

const DataDependenceGraph &	ddg () const

DataDependenceGraph *	prologDDG ()

SimpleResourceManager &	rm () const

SimpleResourceManager *	prologRM () const

BUMoveNodeSelector &	selector ()

const TTAMachine::Machine &	targetMachine () const

unsigned int	ii () const

MoveNodeDuplicator &	duplicator () const

virtual bool	assign (int cycle, MoveNode &, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU_=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGuardWriteCycle=false)

virtual void	unassign (MoveNode &mn, bool disposePrologCopy=true)

virtual int	rmEC (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)

virtual int	rmLC (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)

virtual bool	canAssign (int cycle, MoveNode &mn, const TTAMachine::Bus bus=nullptr, const TTAMachine::FunctionUnit srcFU=nullptr, const TTAMachine::FunctionUnit dstFU=nullptr, const TTAMachine::Bus prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGWN=false)

bool	putAlsoToPrologEpilog (int cycle, MoveNode &mn)

void	setPrologSrcFUAnno (MoveNode &prologMN, MoveNode &loopMN)

void	setPrologDstFUAnno (MoveNode &prologMN, MoveNode &loopMN)

void	setJumpGuard (MoveNode &mn)

void	unsetJumpGuard (MoveNode &mn)

bool	needJumpGuard (const MoveNode &mn, int cycle)

int	jumpGuardAvailableCycle (const MoveNode &mn)

bool	canBeSpeculated (const Operation &op)

bool	canBeSpeculated (const MoveNode &mn)

bool	usePrologMove (const MoveNode &mn)

bool	canBeScheduled (const MoveNode &mn)

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

bool	immCountPreventsScheduling (const MoveNode &mn)

Protected Member Functions inherited from Reversible
bool	runPreChild (Reversible *preChild)

bool	runPostChild (Reversible *preChild)

bool	runChild (std::stack< Reversible * > &children, Reversible *child)

bool	runChild (Reversible *child, bool pre)

void	undoAndRemovePreChildren ()

void	undoAndRemovePostChildren ()

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

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

Detailed Description

Definition at line 47 of file BFLateBypass.hh.

Constructor & Destructor Documentation

◆ BFLateBypass()

BFLateBypass::BFLateBypass	(	BF2Scheduler &	sched,
		MoveNode &	src,
		MoveNode &	dst,
		int	lc
	)

inline

Definition at line 49 of file BFLateBypass.hh.

                                                                            :
        BFOptimization(sched),
        src_(src), dst_(dst), lc_(lc), prologBus_(NULL) {}

Member Function Documentation

◆ operator()()

bool BFLateBypass::operator() ( )

virtual

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

Implements Reversible.

Reimplemented in BFLateBypassGuard.

Definition at line 59 of file BFLateBypass.cc.

                         {
    // if already has guard operation, cannot have source operation.
    if (dst_.isGuardOperation()) {
        return false;
    }
 
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
   std::cerr << "\t\tPerforming late bypass: " << dst_.toString() <<std::endl;
#else
#ifdef DEBUG_LOOP_SCHEDULER
    if (ii() != 0) {
        std::cerr << "\t\tPerforming late bypass, dst: "
                  << dst_.toString() << std::endl;
    }
#endif
#endif
    originalCycle_ = dst_.cycle();
    originalBus_ = &dst_.move().bus();
    MoveNode* prologMN = ii() ?  duplicator().getMoveNode(dst_) : NULL;
    if (prologMN != NULL) {
        prologBus_ = &prologMN->move().bus();
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\t\tProlog move: " << prologMN->toString()
                  << std::endl;
        std::cerr << "\t\t\t\tLate bypass saving prolog bus: "
                  << prologBus_->name() << std::endl;
#endif
    }
 
    bool dstTriggering = dst_.move().isTriggering();
    // this one did not create the prolog copy so do not remove it here.
    unassign(dst_, false);
 
    // Take the predecssors so that they can be notified because their
    // antideps may change
    // makes compiling too slow, disabled for now
    DataDependenceGraph::NodeSet pred = ddg().predecessors(dst_);
 
    if (!runPostChild(new BFMergeAndKeepUser(sched_, src_, dst_))) {
        assign(originalCycle_, dst_, originalBus_, NULL, NULL, prologBus_);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\t\tMerge and keep fail!" << std::endl;
#endif
        return false;
    }
 
    // TODO: this does too much optimizations?
 
    BFOptimization* sched = NULL;
    if ((dst_.move().isControlFlowMove() && dstTriggering) ||
        (ii() != 0 &&
         static_cast<DataDependenceGraph*>(ddg().rootGraph())->
         writesJumpGuard(dst_))) {
        if (lc_ < originalCycle_) {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
            std::cerr << "Late bypass fail: must use originalcycle "
                "which is too late!!!" << std::endl;
#endif
            undo();
            return false;
        }
        sched = new BFScheduleExact(sched_, dst_, originalCycle_);
    } else {
        sched = new BFScheduleBU(sched_, dst_, lc_, false, false, false);
    }
    if ((*sched)()) {
        // TODO: get this from bypass distance setting?
        if (dst_.cycle() + 3 < originalCycle_) {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
            std::cerr << "\t\t\tToo long bypass dist, fail late bypass!"
                      << std::endl;
#endif
            sched->undo();
            delete sched;
            undo();
            return false;
        }
 
        postChildren_.push(sched);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\tLate bypass ok: " << dst_.toString() << std::endl;
#endif
 
        // now notify antideps sources
        for (auto i : pred) {
            mightBeReady(*i);
        }
 
        return true;
    } else {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "\t\tLate bypass sched fail.: " << dst_.toString()
                  << std::endl;
#endif
        delete sched;
        undo();
        return false;
    }
}

References BFOptimization::assign(), TTAProgram::Move::bus(), MoveNode::cycle(), BFOptimization::ddg(), dst_, BFOptimization::duplicator(), MoveNodeDuplicator::getMoveNode(), BFOptimization::ii(), TTAProgram::Move::isControlFlowMove(), MoveNode::isGuardOperation(), TTAProgram::Move::isTriggering(), lc_, BFOptimization::mightBeReady(), MoveNode::move(), TTAMachine::Component::name(), originalBus_, originalCycle_, Reversible::postChildren_, BoostGraph< GraphNode, GraphEdge >::predecessors(), prologBus_, Reversible::runPostChild(), BFOptimization::sched_, src_, MoveNode::toString(), BFOptimization::unassign(), and Reversible::undo().

Here is the call graph for this function:

◆ undoOnlyMe()

void BFLateBypass::undoOnlyMe ( )

virtual

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

Reimplemented from Reversible.

Reimplemented in BFLateBypassGuard.

Definition at line 161 of file BFLateBypass.cc.

                         {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
    std::cerr << "\t\t\tUndoing late bypass: " << dst_.toString() << std::endl;
#endif
 
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
    std::cerr << "\t\t\tReassigning move: " << dst_.toString() <<" to cycle: "
          << originalCycle_ << " bus: " << originalBus_->name() << std::endl;
    if (!canAssign(
            originalCycle_, dst_, originalBus_, NULL, NULL, prologBus_)) {
        std::cerr << "assign to original cycle fail, cycle: "
                  << originalCycle_ << " movenode: "
                  << dst_.toString() << std::endl;
        for (int unsigned i = 0; i < dst_.destinationOperationCount(); i++) {
            std::cerr << "\tDestination op: "
                      << dst_.destinationOperation(i).toString() << std::endl;
        }
        ddg().writeToDotFile("late_bypass_undo_fail.dot");
        assert(false);
    }
#endif
    assign(originalCycle_, dst_, originalBus_, NULL, NULL, prologBus_);
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
    std::cerr << "\t\tReassigned move:" << dst_.toString() << std::endl;
#endif
}