#include <SimpleOperationExecutor.hh>

Inheritance diagram for SimpleOperationExecutor:

Collaboration diagram for SimpleOperationExecutor:

Classes
struct	BufferCell

Public Member Functions
	SimpleOperationExecutor (int latency, FUState &parent)

virtual	~SimpleOperationExecutor ()

virtual int	latency () const

virtual void	startOperation (Operation &op)

virtual void	advanceClock ()

virtual OperationExecutor *	copy ()

virtual void	setContext (OperationContext &context)

Public Member Functions inherited from OperationExecutor
	OperationExecutor ()

	OperationExecutor (FUState &parent)

virtual	~OperationExecutor ()

FUState &	parent () const

void	setParent (FUState &parent)

void	addBinding (int io, PortState &port)

PortState &	binding (int io) const

bool	hasPendingOperations () const

virtual void	reset ()

Private Types
typedef std::vector< BufferCell >	Buffer
	Ring buffer type for the pipeline slots. More...

Private Member Functions
SimpleOperationExecutor &	operator= (const SimpleOperationExecutor &)
	Assignment not allowed. More...

Private Attributes
int	nextSlot_
	Position of the ring buffer where to put the next triggered operation. More...

Buffer	buffer_
	Ring buffer for the pipeline slots. More...

OperationContext *	context_
	Operation context. More...

std::size_t	pendingOperations_
	Count of pending operations in the pipeline. More...

Additional Inherited Members
Protected Attributes inherited from OperationExecutor
std::vector< PortState * >	bindings_
	PortStates that are bound to a certain input or output operand. More...

bool	hasPendingOperations_
	This is set to true if the OperationExecutor is not in 'idle' mode. More...

Detailed Description

Simple implementation of OperationExecutor.

Definition at line 48 of file SimpleOperationExecutor.hh.

Member Typedef Documentation

◆ Buffer

typedef std::vector<BufferCell> SimpleOperationExecutor::Buffer

private

Ring buffer type for the pipeline slots.

Definition at line 93 of file SimpleOperationExecutor.hh.

Constructor & Destructor Documentation

◆ SimpleOperationExecutor()

SimpleOperationExecutor::SimpleOperationExecutor	(	int	latency,
		FUState &	parent
	)

Constructor.

Parameters

latency	Latency of the operation.
parent	Parent of the OperationExecutor.

Definition at line 54 of file SimpleOperationExecutor.cc.

                      : 
     OperationExecutor(parent), nextSlot_(0), context_(NULL), 
     pendingOperations_(0) {
     
     for (int i = 0; i < latency; i++) {
         BufferCell cell;
         buffer_.push_back(cell);
     }
     hasPendingOperations_ = true;
 }

References buffer_, OperationExecutor::hasPendingOperations_, and latency().

Referenced by copy().

Here is the call graph for this function:

◆ ~SimpleOperationExecutor()

SimpleOperationExecutor::~SimpleOperationExecutor ( )

virtual

Destructor.

Definition at line 70 of file SimpleOperationExecutor.cc.

70 {

71 }

Member Function Documentation

◆ advanceClock()

void SimpleOperationExecutor::advanceClock ( )

virtual

Advances clock by one cycle.

Takes the oldest result in the pipeline and makes it visible in the function unit's ports.

Implements OperationExecutor.

Definition at line 138 of file SimpleOperationExecutor.cc.

                                       {
  
     int index = (nextSlot_ + 1) % buffer_.size();
     
     BufferCell& oldestEntry = buffer_[index];
     Operation* oldestOperation = oldestEntry.operation_;
     if (oldestOperation != NULL) {
  
         const std::size_t inputOperands = oldestOperation->numberOfInputs();
         const std::size_t outputOperands = oldestOperation->numberOfOutputs();
         const std::size_t operandCount = inputOperands + outputOperands;
         for (std::size_t i = inputOperands + 1; i <= operandCount; ++i) {
             PortState& port = binding(i);
             port.setValue(*oldestEntry.io_[i - 1]);
         }
         // results now moved to the FU output ports, "lifetime" of this
         // operation execution ends in this FU
         oldestEntry.operation_ = NULL;
         --pendingOperations_;
         hasPendingOperations_ = (pendingOperations_ > 0);
     }
     nextSlot_++;
     nextSlot_ = nextSlot_ % buffer_.size();
 }

References OperationExecutor::binding(), buffer_, OperationExecutor::hasPendingOperations_, SimpleOperationExecutor::BufferCell::io_, nextSlot_, Operation::numberOfInputs(), Operation::numberOfOutputs(), SimpleOperationExecutor::BufferCell::operation_, pendingOperations_, and RegisterState::setValue().

Here is the call graph for this function:

◆ copy()

OperationExecutor * SimpleOperationExecutor::copy ( )

virtual

Copies OperationExecutor.

Returns: The copied OperationExecutor.

Implements OperationExecutor.

Definition at line 169 of file SimpleOperationExecutor.cc.

                               {
     return new SimpleOperationExecutor(*this);
 }

References SimpleOperationExecutor().

Here is the call graph for this function:

◆ latency()

int SimpleOperationExecutor::latency ( ) const

virtual

Returns the latency of the executor.

Returns: The latency of the executor.

Definition at line 79 of file SimpleOperationExecutor.cc.

                                        {
     return buffer_.size();
 }

References buffer_.

Referenced by SimpleOperationExecutor().

◆ operator=()

SimpleOperationExecutor& SimpleOperationExecutor::operator= ( const SimpleOperationExecutor & )

private

Assignment not allowed.

◆ setContext()

void SimpleOperationExecutor::setContext ( OperationContext & context )

virtual

Sets the OperationContext for the OperationExecutor.

Parameters

context New OperationContext.

Implements OperationExecutor.

Definition at line 179 of file SimpleOperationExecutor.cc.

                                                              {
     context_ = &context;
 }

References context_.

◆ startOperation()

void SimpleOperationExecutor::startOperation ( Operation & op )

virtual

Starts new operation.

First original inputs and outputs are stored. Then outputs of the operation are stored. Then operation is triggered.

Parameters

op	Operation to be triggered.

Todo:: This can be optimized a lot: try to initialize the vector as rarely as possible.

Todo:: create valueConst() and value() to avoid these uglies

Todo:: Fix! This should not probably be assumed, or at least user should be notified if his operand ids are not what are expected.

Implements OperationExecutor.

Definition at line 94 of file SimpleOperationExecutor.cc.

                                                      {
  
     BufferCell& nextSlot = buffer_[nextSlot_];
  
     const bool reuseBindings = 
         nextSlot.boundOperation_ != NULL && nextSlot.boundOperation_ == &op;
  
     if (!reuseBindings) {
         const std::size_t inputOperands = op.numberOfInputs();
         const std::size_t outputOperands = op.numberOfOutputs();
         const std::size_t operandCount = inputOperands + outputOperands;
  
         assert(operandCount <= EXECUTOR_MAX_OPERAND_COUNT);
         // let the operation access the input port values directly,
         for (std::size_t i = 1; i <= inputOperands; ++i) {
             /// @todo create valueConst() and value() to avoid these uglies
             nextSlot.io_[i - 1] = &(const_cast<SimValue&>(binding(i).value()));
         }
  
         // create new temporary SimValues for the outputs, assume
         // indexing of outputs starts after inputs 
         /// @todo Fix! This should not probably be assumed, or at least
         /// user should be notified if his operand ids are not what
         /// are expected.
         for (std::size_t i = inputOperands + 1; i <= operandCount; ++i) {
             nextSlot.ioOrig_[i - 1].setBitWidth(op.operand(i).width());  
             nextSlot.io_[i - 1] = &nextSlot.ioOrig_[i - 1];
         }
         nextSlot.boundOperation_ = &op;
     }
  
     nextSlot.operation_ = &op;
     nextSlot.ready_ = op.simulateTrigger(nextSlot.io_, *context_);
     ++pendingOperations_;
     hasPendingOperations_ = true;
 }