#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.

53 :

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

◆ ~PostpassOperandSharer()

PostpassOperandSharer::~PostpassOperandSharer ( )

virtual

Definition at line 223 of file PostpassOperandSharer.cc.

223 {}

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;
 }