#include <BFEarlyBypasser.hh>

Inheritance diagram for BFEarlyBypasser:

Collaboration diagram for BFEarlyBypasser:

Public Member Functions
	BFEarlyBypasser (BF2Scheduler &sched, MoveNode &mn)

bool	operator() ()

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 ()

Private Member Functions
int	bypassSourceLatestCycle (MoveNode &bypassSrc, MoveNode &bypassDst)

Private Attributes
MoveNode &	dst_

int	bypassDistance_ = 5

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)

virtual void	undoOnlyMe ()

Protected Attributes inherited from BFOptimization
BF2Scheduler &	sched_

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

std::stack< Reversible * >	postChildren_

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

Detailed Description

Definition at line 42 of file BFEarlyBypasser.hh.

Constructor & Destructor Documentation

◆ BFEarlyBypasser()

BFEarlyBypasser::BFEarlyBypasser	(	BF2Scheduler &	sched,
		MoveNode &	mn
	)

Definition at line 141 of file BFEarlyBypasser.cc.

                                                                  :
    BFOptimization(sched),  dst_(mn) {
    SchedulerCmdLineOptions* opts =
        dynamic_cast<SchedulerCmdLineOptions*>(Application::cmdLineOptions());
    if (opts != NULL && opts->bypassDistance() > -1) {
        bypassDistance_ = opts->bypassDistance();
    }
}

References SchedulerCmdLineOptions::bypassDistance(), bypassDistance_, and Application::cmdLineOptions().

Here is the call graph for this function:

Member Function Documentation

◆ bypassSourceLatestCycle()

int BFEarlyBypasser::bypassSourceLatestCycle	(	MoveNode &	bypassSrc,
		MoveNode &	bypassDst
	)

private

Checks that bypass source does not WHAT???

Definition at line 91 of file BFEarlyBypasser.cc.

                                              {
    DataDependenceGraph::NodeSet nodes;
 
    int lc = INT_MAX;
 
    if (bypassSrc.isSourceOperation()) {
        ProgramOperation& po = bypassSrc.sourceOperation();
        for (int j = 0; j < po.inputMoveCount(); j++) {
            MoveNode& inputMove = po.inputMove(j);
            // may also be a shared operand
            if (!sched_.isPreLoopSharedOperand(inputMove)) {
                nodes.insert(&inputMove);
            }
        }
 
        for (int j = 0; j < po.outputMoveCount(); j++) {
            MoveNode& outputMove = po.outputMove(j);
            if (!sched_.isDeadResult(outputMove)) {
                nodes.insert(&outputMove);
            }
        }
    } else {
        nodes.insert(&bypassSrc);
    }
 
    for (auto mn : nodes) {
        DataDependenceGraph::EdgeSet edges = ddg().outEdges(*mn);
        for (auto e : edges) {
            MoveNode& head = ddg().headNode(*e);
            if (head.isScheduled()) {
                lc = std::min(lc, head.cycle());
                continue;
            }
            if (&head == &bypassDst || head.isInFrontier() ||
                e->isBackEdge() || nodes.count(&head)) {
                continue;
            }
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
            std::cerr << "\t\t\t\tEdge almost preventing bypass from: "
                      << bypassSrc.toString() << "to: " <<bypassDst.toString()
                      << ": " << e->toString() << " dst: "
                      << head.toString() << std::endl;
#endif
            return -1;
        }
    }
    return lc;
}

References MoveNode::cycle(), BFOptimization::ddg(), BoostGraph< GraphNode, GraphEdge >::headNode(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), BF2Scheduler::isDeadResult(), MoveNode::isInFrontier(), BF2Scheduler::isPreLoopSharedOperand(), MoveNode::isScheduled(), MoveNode::isSourceOperation(), BoostGraph< GraphNode, GraphEdge >::outEdges(), ProgramOperation::outputMove(), ProgramOperation::outputMoveCount(), BFOptimization::sched_, MoveNode::sourceOperation(), and MoveNode::toString().

Referenced by operator()().

Here is the call graph for this function:

◆ operator()()

bool BFEarlyBypasser::operator() ( )

virtual

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

Implements Reversible.

Definition at line 48 of file BFEarlyBypasser.cc.

                            {
 
    if (bypassDistance_ == 0) return false;
 
    DataDependenceEdge* bypassEdge = sched_.findBypassEdge(dst_);
    if (bypassEdge == NULL) {
        return false;
    }
    MoveNode& src = ddg().tailNode(*bypassEdge);
 
    if (sched_.currentFront()->illegalBypassSources_.count(&src)) {
#ifdef DEBUG_BUBBLEFISH_SCHEDULER
        std::cerr << "Bypass source illegal: " << src.toString() << std::endl;
#endif
        return 0;
    }
 
    if (!ddg().guardsAllowBypass(src, dst_, bypassEdge->isBackEdge())) {
        return false;
    }
 
    if (!MachineConnectivityCheck::canBypass(
            src, dst_, sched_.targetMachine())) {
        return false;
    }
 
    int bypassSourceLC = bypassSourceLatestCycle(src, dst_);
    if (bypassSourceLC == -1) {
        return false;
    }
 
    if (bypassEdge->isBackEdge()) {
        if (!src.isScheduled() || src.cycle() < (int)ii()) {
            return false;
        }
    } else {
        return runPreChild(new BFEarlyBypass(sched_, src, dst_));
    }
    return false;
}

References bypassDistance_, bypassSourceLatestCycle(), MachineConnectivityCheck::canBypass(), BF2Scheduler::currentFront(), MoveNode::cycle(), BFOptimization::ddg(), dst_, BF2Scheduler::findBypassEdge(), BFOptimization::ii(), BF2ScheduleFront::illegalBypassSources_, DataDependenceEdge::isBackEdge(), MoveNode::isScheduled(), Reversible::runPreChild(), BFOptimization::sched_, BoostGraph< GraphNode, GraphEdge >::tailNode(), BF2Scheduler::targetMachine(), and MoveNode::toString().

Here is the call graph for this function:

Member Data Documentation

◆ bypassDistance_

int BFEarlyBypasser::bypassDistance_ = 5

private

Definition at line 50 of file BFEarlyBypasser.hh.

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

◆ dst_

MoveNode& BFEarlyBypasser::dst_

private

Definition at line 49 of file BFEarlyBypasser.hh.

Referenced by operator()().

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BFEarlyBypasser()

Member Function Documentation

◆ bypassSourceLatestCycle()

◆ operator()()

Member Data Documentation

◆ bypassDistance_

◆ dst_