PostpassOperandSharer Class Reference

#include <PostpassOperandSharer.hh>

Inheritance diagram for PostpassOperandSharer:

Collaboration diagram for PostpassOperandSharer:

Public Member Functions
	PostpassOperandSharer (InterPassData &ipd, TTAProgram::InstructionReferenceManager &irm)
virtual	~PostpassOperandSharer ()
virtual void	handleBasicBlock (TTAProgram::BasicBlock &basicBlock, const TTAMachine::Machine &targetMachine, TTAProgram::InstructionReferenceManager &irm, BasicBlockNode *bbn=NULL)
bool	tryRemoveOperandWrite (TTAProgram::BasicBlock &basicBlock, int insIndex, TTAProgram::Move &move)
virtual std::string	shortDescription () const
Public Member Functions inherited from BasicBlockPass
	BasicBlockPass (InterPassData &data)
virtual	~BasicBlockPass ()
virtual void	executeDDGPass (TTAProgram::BasicBlock &bb, const TTAMachine::Machine &targetMachine, TTAProgram::InstructionReferenceManager &irm, std::vector< DDGPass * > ddgPasses, BasicBlockNode *bbn=NULL)
virtual bool	executeLoopPass (TTAProgram::BasicBlock &bb, const TTAMachine::Machine &targetMachine, TTAProgram::InstructionReferenceManager &irm, std::vector< DDGPass * > ddgPasses, BasicBlockNode *bbn=NULL)
virtual DataDependenceGraphBuilder &	ddgBuilder ()
Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)
virtual	~SchedulerPass ()
InterPassData &	interPassData ()
virtual std::string	longDescription () const
Public Member Functions inherited from ControlFlowGraphPass
	ControlFlowGraphPass (InterPassData &data)
virtual	~ControlFlowGraphPass ()
virtual void	handleControlFlowGraph (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine)
void	executeBasicBlockPass (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine, BasicBlockPass &bbPass)

Static Public Member Functions
static void	printStats ()
Static Public Member Functions inherited from BasicBlockPass
static void	copyRMToBB (SimpleResourceManager &rm, TTAProgram::BasicBlock &bb, const TTAMachine::Machine &targetMachine, TTAProgram::InstructionReferenceManager &irm, int lastCycle=-1)

Private Attributes
TTAProgram::InstructionReferenceManager *	irm_

Static Private Attributes
static unsigned int	moveCount_ = 0
static unsigned int	operandCount_ = 0
static unsigned int	removedOperands_ = 0
static unsigned int	registerReads_ = 0
static unsigned int	triggerCannotRemove_ = 0

Additional Inherited Members
Protected Member Functions inherited from BasicBlockPass
void	ddgSnapshot (DataDependenceGraph *ddg, std::string &name, DataDependenceGraph::DumpFileFormat format, bool final)
virtual DataDependenceGraph *	createDDGFromBB (TTAProgram::BasicBlock &bb, const TTAMachine::Machine &mach)

Detailed Description

Definition at line 47 of file PostpassOperandSharer.hh.

Constructor & Destructor Documentation

PostpassOperandSharer()

PostpassOperandSharer::PostpassOperandSharer ( InterPassData &  ipd, TTAProgram::InstructionReferenceManager &  irm  )

inline

Definition at line 51 of file PostpassOperandSharer.hh.

                                                    : 
        BasicBlockPass(ipd), ControlFlowGraphPass(ipd), irm_(&irm) {}

~PostpassOperandSharer()

PostpassOperandSharer::~PostpassOperandSharer ( )

virtual

Definition at line 223 of file PostpassOperandSharer.cc.

{}

Member Function Documentation

handleBasicBlock()

void PostpassOperandSharer::handleBasicBlock ( TTAProgram::BasicBlock &  basicBlock, const TTAMachine::Machine &  targetMachine, TTAProgram::InstructionReferenceManager &  irm, BasicBlockNode *  bbn = NULL  )

virtual

Handles a single basic block.

Modifies the given basic block, so if the old one is to be preserved, client should copy the original. Does not restore the BB even though handling was not successful.

Todo:

: Why both BB and BBN as arguments? If BBN is needed then I think BB argument can be replaced with a BBN one. We always should have it anyways.

Parameters

basicBlock	The basic block to handle.
machine	The target machine if any. (NullMachine::instance() if target machine is irrelevant).

Exceptions

In	case handling is unsuccesful for any reason (basicBlock might still get modified).

Reimplemented from BasicBlockPass.

Definition at line 62 of file PostpassOperandSharer.cc.

                                                             {
    for (int i = basicBlock.instructionCount()-1; i >= 0; i--) {
        Instruction& ins = basicBlock.instructionAtIndex(i);
        for (int j = 0; j < ins.moveCount(); j++) {
            Move& move = ins.move(j);
            moveCount_++;
            if (tryRemoveOperandWrite(basicBlock, i, move)) {
                ins.removeMove(move);
                // TODO: make sure there is no movenode to this.
//                delete &move;
                j--;
            }
        }
    }
}

References TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), moveCount_, TTAProgram::Instruction::removeMove(), and tryRemoveOperandWrite().

Here is the call graph for this function:

printStats()

void PostpassOperandSharer::printStats ( )

static

Definition at line 225 of file PostpassOperandSharer.cc.

                                       {
    std::cerr << "PostpassOperandSharer statistics: " << std::endl 
              << "\tTotal moves: " << moveCount_ << std::endl
              << "\tTotal reg reads: " << registerReads_ << std::endl
              << "\tTotal operands: "<<operandCount_ 
              << std::endl
              << "\tRemoved operands: " << removedOperands_ << std::endl
              << "\tCannot share trigger count: " << triggerCannotRemove_ 
              << std::endl;
    
}

References moveCount_, operandCount_, registerReads_, removedOperands_, and triggerCannotRemove_.

shortDescription()

virtual std::string PostpassOperandSharer::shortDescription ( ) const

inlinevirtual

A short description of the pass, usually the optimization name, such as "basic block scheduler".

Returns

The description as a string.

Implements SchedulerPass.

Definition at line 71 of file PostpassOperandSharer.hh.

                                               {
        return "Post-pass that reduced redundant operand writes";
    }

tryRemoveOperandWrite()

bool PostpassOperandSharer::tryRemoveOperandWrite	(	TTAProgram::BasicBlock &	basicBlock,
		int	insIndex,
		TTAProgram::Move &	move
	)

Definition at line 83 of file PostpassOperandSharer.cc.

                                                                          {
 
    bool guardOK = false;
    Terminal& dest = move.destination();
    Terminal& src = move.source();
 
    if (src.isGPR()) {
        registerReads_++;
    }
 
#ifdef GET_BETTER_STATISTICS
    if (!dest.isFUPort())
    {
        return false;
    }
#else
 
    if (!dest.isFUPort() ||
        dest.isTriggering() ||
        dest.isOpcodeSetting()) {
        return false;
    }
#endif
 
    operandCount_++;
    if (src.isFUPort()) {
        return false;
    }
 
    if (src.isImmediateRegister()) {
        return false;
    }
 
    const TTAMachine::RegisterFile* guardRF = NULL;
    int guardIndex = -1;
    if (!move.isUnconditional()) {
        const TTAMachine::Guard& guard = move.guard().guard();
        const RegisterGuard* rg = dynamic_cast<const TTAMachine::RegisterGuard*>(&guard);
        if (rg) {
            guardRF = rg->registerFile();
            guardIndex = rg->registerIndex();
        }
    }
 
    int srcIndex = -1;
    const TTAMachine::RegisterFile* srcRF = NULL;
    if (src.isGPR()) {
        srcIndex = src.index();
        srcRF = &src.registerFile();
    }
 
    int glat = move.guardLatency();
    bool lastDueJump = false;
 
    for (int i = insIndex -1; i >= basicBlock.skippedFirstInstructions() && !lastDueJump; i--) {
 
        // first check guard writes..
        // if guard has longer latency than 1 , this has to go to previous
        // cycles.
        int k = i+1 - glat;
        if (k>= 0) {
            Instruction& gIns = basicBlock.instructionAtIndex(k);
            
            // check that does not overwrite the source
            for (int j = 0; j < gIns.moveCount(); j++) {
                Move& gMove = gIns.move(j);
                Terminal& gDst = gMove.destination();
                if (gDst.isGPR()) {
                    int pdIndex = gDst.index();
                    const RegisterFile* pdRF = &gDst.registerFile();
                    if (guardIndex == pdIndex && guardRF == pdRF) {
                        guardOK = false;
                    }
                }
            }
        }
 
        Instruction& prevIns = basicBlock.instructionAtIndex(i);
        if (irm_->hasReference(prevIns)) {
            lastDueJump = true;
        }
        // check that does not overwrite the source
        for (int j = 0; j < prevIns.moveCount(); j++) {
            Move& prevMove = prevIns.move(j);
            Terminal& prevDst = prevMove.destination();
 
            if (prevDst.isGPR()) {
                int pdIndex = prevDst.index();
                const RegisterFile* pdRF = &prevDst.registerFile();
                if ((srcIndex == pdIndex && srcRF == pdRF) &&
                    (!guardOK || prevMove.isUnconditional() ||
                     move.isUnconditional() || 
                     !prevMove.guard().guard().isOpposite(
                         move.guard().guard()))) {
                    return false;
                }
            }
        }
 
        // check if writes the same operand
        for (int j = 0; j < prevIns.moveCount(); j++) {
            Move& prevMove = prevIns.move(j);
            Terminal& prevDest = prevMove.destination();
 
            // write to same port..
            if (&prevDest.port() == &dest.port()) {
                // Check if previous move used narrower bus and
                // potentially cut  upper bits of the transported value.
                // This is possible is the value was previously used in
                // operation which used only the lower bits of the value
                // (see BusResource::canAssign()).
                if (move.source().equals(prevMove.source())
                    && move.bus().width() <= prevMove.bus().width()) {
 
                    // TODO: what if guard is conditional, ok or not?
                    if (!prevMove.isUnconditional() &&
                        (move.isUnconditional() || 
                         (!guardOK || !prevMove.guard().guard().isEqual(
                              move.guard().guard())))) {
                        continue;
                    }
                    
                    if (prevDest.isTriggering() ||
                        prevDest.isOpcodeSetting()) {
                        triggerCannotRemove_++;
                        return false;
                    }
                    
                    removedOperands_++;
                    return true;
                } else {
                    return false;
                }
            }
        }
    }
    return false;
}

References TTAProgram::Move::bus(), TTAProgram::Move::destination(), TTAProgram::Terminal::equals(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), TTAProgram::Move::guardLatency(), TTAProgram::InstructionReferenceManager::hasReference(), TTAProgram::Terminal::index(), TTAProgram::CodeSnippet::instructionAtIndex(), irm_, TTAMachine::Guard::isEqual(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), TTAProgram::Terminal::isOpcodeSetting(), TTAMachine::Guard::isOpposite(), TTAProgram::Terminal::isTriggering(), TTAProgram::Move::isUnconditional(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), operandCount_, TTAProgram::Terminal::port(), TTAMachine::RegisterGuard::registerFile(), TTAProgram::Terminal::registerFile(), TTAMachine::RegisterGuard::registerIndex(), registerReads_, removedOperands_, TTAProgram::BasicBlock::skippedFirstInstructions(), TTAProgram::Move::source(), triggerCannotRemove_, and TTAMachine::Bus::width().

Referenced by handleBasicBlock().

Here is the call graph for this function:

Member Data Documentation

irm_

TTAProgram::InstructionReferenceManager* PostpassOperandSharer::irm_

private

Definition at line 75 of file PostpassOperandSharer.hh.

Referenced by tryRemoveOperandWrite().

moveCount_

unsigned int PostpassOperandSharer::moveCount_ = 0

staticprivate

Definition at line 76 of file PostpassOperandSharer.hh.

Referenced by handleBasicBlock(), and printStats().

operandCount_

unsigned int PostpassOperandSharer::operandCount_ = 0

staticprivate

Definition at line 77 of file PostpassOperandSharer.hh.

Referenced by printStats(), and tryRemoveOperandWrite().

registerReads_

unsigned int PostpassOperandSharer::registerReads_ = 0

staticprivate

Definition at line 79 of file PostpassOperandSharer.hh.

Referenced by printStats(), and tryRemoveOperandWrite().

removedOperands_

unsigned int PostpassOperandSharer::removedOperands_ = 0

staticprivate

Definition at line 78 of file PostpassOperandSharer.hh.

Referenced by printStats(), and tryRemoveOperandWrite().

triggerCannotRemove_

unsigned int PostpassOperandSharer::triggerCannotRemove_ = 0

staticprivate

Definition at line 80 of file PostpassOperandSharer.hh.

Referenced by printStats(), and tryRemoveOperandWrite().

---

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

• PostpassOperandSharer.hh
• PostpassOperandSharer.cc