BFMergeAndKeepUser Class Reference

#include <BFMergeAndKeepUser.hh>

Inheritance diagram for BFMergeAndKeepUser:

Collaboration diagram for BFMergeAndKeepUser:

Public Member Functions
	BFMergeAndKeepUser (BF2Scheduler &sched, MoveNode &src, MoveNode &mn, bool force=false, bool updatePrologMove=true)
bool	operator() () override
	~BFMergeAndKeepUser ()
Public Member Functions inherited from BFOptimization
	BFOptimization (BF2Scheduler &sched)
virtual bool	isFinishFront ()
virtual void	mightBeReady (MoveNode &mn)
Public Member Functions inherited from Reversible
virtual void	undo ()
virtual	~Reversible ()
void	deleteChildren (std::stack< Reversible * > &children)
int	id ()
	Reversible ()

Protected Member Functions
void	undoOnlyMe () override
bool	updateEdges (MoveNode *src, MoveNode *dst, bool loopBypass, bool pre)
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)

Private Attributes
MoveNode &	src_
MoveNode &	dst_
bool	force_
TCEString	reg_
bool	updatePrologMove_
bool	duplicatedSrc_

Additional Inherited Members
Static Public Member Functions inherited from BFOptimization
static void	clearPrologMoves ()
static MoveNode *	getSisterTrigger (const MoveNode &mn, const TTAMachine::Machine &mach)
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 41 of file BFMergeAndKeepUser.hh.

Constructor & Destructor Documentation

BFMergeAndKeepUser()

BFMergeAndKeepUser::BFMergeAndKeepUser ( BF2Scheduler &  sched, MoveNode &  src, MoveNode &  mn, bool  force = false, bool  updatePrologMove = true  )

inline

Definition at line 43 of file BFMergeAndKeepUser.hh.

                                                     :
                       BFOptimization(sched), src_(src), dst_(mn),
                       force_(force),
                       updatePrologMove_(updatePrologMove),
                       duplicatedSrc_(false) {}

~BFMergeAndKeepUser()

BFMergeAndKeepUser::~BFMergeAndKeepUser ( )

inline

Definition at line 53 of file BFMergeAndKeepUser.hh.

{}

Member Function Documentation

operator()()

bool BFMergeAndKeepUser::operator() ( )

overridevirtual

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

Implements Reversible.

Definition at line 150 of file BFMergeAndKeepUser.cc.

                               {
 
 
    if (!ddg().mergeAndKeepAllowed(src_, dst_)) {
        if (!force_) {
            return false;
        }
    }
 
    bool loopBypass = ddg().isLoopBypass(src_, dst_);
 
    // Cannot bypass over multiple loop iterations. even with force flag.
    if (loopBypass) {
        for (int i = 0; i < ddg().inDegree(src_); i++) {
            DataDependenceEdge& edge = ddg().inEdge(src_,i);
            if (!edge.isFalseDep() && edge.isBackEdge()) {
                return false;
            }
        }
    }
    runPreChild(new BFUpdateMoveOnBypass(sched_, src_, dst_));
 
    if (!updateEdges(&src_, &dst_, loopBypass, true)) {
        return false;
    }
 
 
    if (ii() && updatePrologMove_) {
        MoveNode* prologMove = duplicator().getMoveNode(dst_);
        if (prologMove != nullptr) {
            auto prologSrcMove =
                duplicator().duplicateMoveNode(src_,true, false);
            duplicatedSrc_ = prologSrcMove.second;
 
            runPostChild(
                new BFUpdateMoveOnBypass(
                    sched_, *prologSrcMove.first, *prologMove));
 
            updateEdges(
                prologSrcMove.first, prologMove, loopBypass, false);
 
        }
    }
    return true;
 
}

References BFOptimization::ddg(), dst_, duplicatedSrc_, MoveNodeDuplicator::duplicateMoveNode(), BFOptimization::duplicator(), force_, MoveNodeDuplicator::getMoveNode(), BFOptimization::ii(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), DataDependenceEdge::isBackEdge(), DataDependenceEdge::isFalseDep(), DataDependenceGraph::isLoopBypass(), Reversible::runPostChild(), Reversible::runPreChild(), BFOptimization::sched_, src_, updateEdges(), and updatePrologMove_.

Here is the call graph for this function:

undoOnlyMe()

void BFMergeAndKeepUser::undoOnlyMe ( )

overrideprotectedvirtual

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

Reimplemented from Reversible.

Definition at line 197 of file BFMergeAndKeepUser.cc.

                                    {
    if (duplicatedSrc_) {
        duplicator().disposeMoveNode(duplicator().getMoveNode(src_));
    }
}

References MoveNodeDuplicator::disposeMoveNode(), duplicatedSrc_, BFOptimization::duplicator(), and src_.

Here is the call graph for this function:

updateEdges()

bool BFMergeAndKeepUser::updateEdges ( MoveNode *  src, MoveNode *  dst, bool  loopBypass, bool  pre  )

protected

Definition at line 47 of file BFMergeAndKeepUser.cc.

                                                             {
 
    bool sourceIsRegToItselfCopy = false;
 
    if (src != nullptr && dst != nullptr &&
        ddg().rootGraph()->hasNode(*dst) &
        ddg().rootGraph()->hasNode(*src)) {
        bool removedRawEdge = false;
        auto edges = ddg().rootGraph()->connectingEdges(*src, *dst);
        for (auto e: edges) {
            if (e->isRAW()) {
                removedRawEdge = true;
                runChild(new BFRemoveEdge(sched_, *src, *dst, *e), pre);
                reg_ = e->data();
            }
        }
        if (!removedRawEdge) {
            undo();
            return false;
        }
 
        TTAProgram::Move& sm = src->move();
        sourceIsRegToItselfCopy = sm.source().equals(sm.destination());
 
        // if we are bypassing from a register-to-register copy, we'll have to
        // copy incoming raw edges also in rootgraph level to preserve inter-bb
        // -dependencies.
        for (int i = 0; i < ddg().rootGraphInDegree(*src); i++) {
            DataDependenceEdge& edge = ddg().rootGraphInEdge(*src,i);
 
            // skip antidependencies due bypassed register.. these are no more
            if (edge.edgeReason() == DataDependenceEdge::EDGE_REGISTER &&
                edge.data() == reg_) {
                if (edge.dependenceType() == DataDependenceEdge::DEP_WAW ||
                    edge.dependenceType() == DataDependenceEdge::DEP_WAR) {
                    continue;
                }
            }
 
            // do not copy guard use edges - the user already ahs them.
            // copying them leads to exponential increase in guard ege counts.
            if (edge.guardUse()) {
                continue;
            }
 
            // copy other edges.
            MoveNode& source = ddg().rootGraph()->tailNode(edge);
            DataDependenceEdge* newEdge =
                new DataDependenceEdge(edge, loopBypass);
            runChild(new BFConnectNodes(sched_, source, *dst, newEdge), pre);
        }
 
        if (src->isSourceVariable() || src->isSourceRA()) {
            // if bypassing reg-to-reg this copy anti edges resulting from the
            // read of the other register.
            for (int i = 0; i < ddg().rootGraphOutDegree(*src); i++) {
                DataDependenceEdge& edge = ddg().rootGraphOutEdge(*src,i);
                if ((edge.edgeReason() == DataDependenceEdge::EDGE_REGISTER||
                     edge.edgeReason() == DataDependenceEdge::EDGE_RA) &&
                    edge.dependenceType() == DataDependenceEdge::DEP_WAR &&
                    !edge.tailPseudo()) {
 
                    MoveNode& target = ddg().rootGraph()->headNode(edge);
 
                    if (!(static_cast<DataDependenceGraph*>(ddg().rootGraph()))
                        ->exclusingGuards(*dst, target) &&
                        dst != &target) {
 
                        DataDependenceEdge* newEdge =
                            new DataDependenceEdge(edge, loopBypass);
                        // TODO: loop here!
                        runChild(new BFConnectNodes(
                                     sched_, *dst, target, newEdge), pre);
                    }
                }
            }
        }
    }
 
 
    if (dst != nullptr && ddg().rootGraph()->hasNode(*dst)) {
        // fix WAR antidependencies to WaW
        for (int i = 0; i < ddg().rootGraphOutDegree(*dst); i++) {
            DataDependenceEdge& edge = ddg().rootGraphOutEdge(*dst,i);
            if (edge.edgeReason() == DataDependenceEdge::EDGE_REGISTER &&
                edge.dependenceType() == DataDependenceEdge::DEP_WAR &&
                edge.data() == reg_) {
                // if stupid reg to itself copy, keep to in edges..
                if (!sourceIsRegToItselfCopy) {
                    runChild(
                        new BFRemoveEdge(
                            sched_, *dst,
                            ddg().rootGraph()->headNode(edge), edge), pre);
                   i--; // don't skip one edge here!
                }
            }
        }
    }
    return true;
}

References BoostGraph< GraphNode, GraphEdge >::connectingEdges(), DataDependenceEdge::data(), BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceEdge::dependenceType(), TTAProgram::Move::destination(), DataDependenceEdge::EDGE_RA, DataDependenceEdge::EDGE_REGISTER, DataDependenceEdge::edgeReason(), TTAProgram::Terminal::equals(), DataDependenceEdge::guardUse(), BoostGraph< GraphNode, GraphEdge >::headNode(), MoveNode::isSourceRA(), MoveNode::isSourceVariable(), MoveNode::move(), reg_, BoostGraph< GraphNode, GraphEdge >::rootGraph(), BoostGraph< GraphNode, GraphEdge >::rootGraphInDegree(), BoostGraph< GraphNode, GraphEdge >::rootGraphInEdge(), BoostGraph< GraphNode, GraphEdge >::rootGraphOutDegree(), BoostGraph< GraphNode, GraphEdge >::rootGraphOutEdge(), Reversible::runChild(), BFOptimization::sched_, TTAProgram::Move::source(), BoostGraph< GraphNode, GraphEdge >::tailNode(), DataDependenceEdge::tailPseudo(), and Reversible::undo().

Referenced by operator()().

Here is the call graph for this function:

Member Data Documentation

dst_

MoveNode& BFMergeAndKeepUser::dst_

private

Definition at line 61 of file BFMergeAndKeepUser.hh.

Referenced by operator()().

duplicatedSrc_

bool BFMergeAndKeepUser::duplicatedSrc_

private

Definition at line 65 of file BFMergeAndKeepUser.hh.

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

force_

bool BFMergeAndKeepUser::force_

private

Definition at line 62 of file BFMergeAndKeepUser.hh.

Referenced by operator()().

reg_

TCEString BFMergeAndKeepUser::reg_

private

Definition at line 63 of file BFMergeAndKeepUser.hh.

Referenced by updateEdges().

src_

MoveNode& BFMergeAndKeepUser::src_

private

Definition at line 60 of file BFMergeAndKeepUser.hh.

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

updatePrologMove_

bool BFMergeAndKeepUser::updatePrologMove_

private

Definition at line 64 of file BFMergeAndKeepUser.hh.

Referenced by operator()().

---

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

• BFMergeAndKeepUser.hh
• BFMergeAndKeepUser.cc