#include <MultiLatencyOperationExecutor.hh>

Inheritance diagram for MultiLatencyOperationExecutor:

Collaboration diagram for MultiLatencyOperationExecutor:

Public Member Functions
	MultiLatencyOperationExecutor (FUState &parent, TTAMachine::HWOperation &hwOp)

	MultiLatencyOperationExecutor ()

virtual	~MultiLatencyOperationExecutor ()

virtual void	startOperation (Operation &op)

virtual void	advanceClock ()

virtual OperationExecutor *	copy ()

virtual void	setContext (OperationContext &context)

virtual void	reset ()

virtual void	setOperationSimulator (DetailedOperationSimulator &sim)

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

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

ExecutingOperation &	findFreeExecutingOperation ()

Private Attributes
OperationContext *	context_
	Operation context.

TTAMachine::HWOperation *	hwOperation_
	The hardware operation this executor simulates.

Operation *	operation_
	The OSAL operation.

std::vector< ExecutingOperation >	executingOps_
	The operations "on flight" in this operation executor.

ExecutingOperation *	freeExecOp_
	If non-NULL, points to a known free ExecutingOperation slot.

bool	execOperationsInitialized_

DetailedOperationSimulator *	opSimulator_
	If non-NULL, points to a detailed cycle-by-cycle simulation model for the operation simulated by this executor.

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

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

Detailed Description

OperationExecutor that supports multi-output operation pipelines with different latencies for results.

Can be also used for cycle-accurate modeling of the operation pipeline. In addition to simulate the execution of operations with multiple outputs with different latencies in the standalone TTA simulation, this execution model is used in the SystemC TTA core function unit simulation model.

See also: tce_systemc.hh

Definition at line 61 of file MultiLatencyOperationExecutor.hh.

Constructor & Destructor Documentation

◆ MultiLatencyOperationExecutor() [1/2]

MultiLatencyOperationExecutor::MultiLatencyOperationExecutor	(	FUState &	parent,
		TTAMachine::HWOperation &	hwOp
	)

Constructor.

Parameters

parent	Parent of the OperationExecutor.
hwOp	The hardware operation to simulate.

Initialize a list of pending executing operations that is the size of the maximum on flight operations. Each element in the list is initialized to contain a large enough I/O vector for inputs and outputs. In addition, the models for simulating the output latencies are initialized so it's as fast as possible to trigger new operations.

Definition at line 54 of file MultiLatencyOperationExecutor.cc.

                                                  :
    OperationExecutor(parent), context_(NULL), hwOperation_(&hwOp),
    freeExecOp_(NULL), execOperationsInitialized_(false),
    opSimulator_(NULL) {
 
    OperationPool ops;
    operation_ = &ops.operation(hwOp.name().c_str());
    /**
     * Initialize a list of pending executing operations that is the
     * size of the maximum on flight operations. Each element in the
     * list is initialized to contain a large enough I/O vector for
     * inputs and outputs. In addition, the models for simulating the
     * output latencies are initialized so it's as fast as possible
     * to trigger new operations.
     */
    const std::size_t inputOperands = operation_->numberOfInputs();
    const std::size_t outputOperands = operation_->numberOfOutputs();
    const std::size_t operandCount = inputOperands + outputOperands;
 
    hasPendingOperations_ = true;
    ExecutingOperation eop(*operation_, hwOp.latency());
    eop.iostorage_.resize(operandCount);
    executingOps_.resize(hwOp.latency(), eop);
 
}

References executingOps_, OperationExecutor::hasPendingOperations_, ExecutingOperation::iostorage_, TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), Operation::numberOfInputs(), Operation::numberOfOutputs(), OperationPool::operation(), and operation_.

Here is the call graph for this function:

◆ MultiLatencyOperationExecutor() [2/2]

MultiLatencyOperationExecutor::MultiLatencyOperationExecutor ( )

inline

Definition at line 65 of file MultiLatencyOperationExecutor.hh.

65: hwOperation_(NULL) {}

Referenced by copy().

◆ ~MultiLatencyOperationExecutor()

MultiLatencyOperationExecutor::~MultiLatencyOperationExecutor ( )

virtual

Destructor.

Definition at line 84 of file MultiLatencyOperationExecutor.cc.

84 {

85}

Member Function Documentation

◆ advanceClock()

void MultiLatencyOperationExecutor::advanceClock ( )

virtual

Advances clock by one cycle.

Implements OperationExecutor.

Reimplemented in ConflictDetectingOperationExecutor.

Definition at line 168 of file MultiLatencyOperationExecutor.cc.

                                            {
 
    bool foundActiveOperation = false;
    size_t executingOpCount = executingOps_.size();
    for (std::size_t i = 0; i < executingOpCount; ++i) {
        ExecutingOperation& execOp = executingOps_[i];
        if (execOp.free_) {
            freeExecOp_ = &execOp;
            continue;
        }
 
        foundActiveOperation = true;
        bool customSimulated = 
            opSimulator_ != NULL && opSimulator_->simulateStage(execOp);
        if (execOp.stage_ == 0 && !customSimulated)
            operation_->simulateTrigger(&execOp.iovec_[0], *context_);
        execOp.advanceCycle();
        
        if (execOp.stage_ == hwOperation_->latency()) {
#ifdef DEBUG_OPERATION_SIMULATION
            Application::logStream()
                << &execOp << " (" << execOp.operation().name() 
                << ") finished" << std::endl;
#endif
            execOp.stop();
        }
    }
    hasPendingOperations_ = foundActiveOperation;
}

References ExecutingOperation::advanceCycle(), context_, executingOps_, ExecutingOperation::free_, freeExecOp_, OperationExecutor::hasPendingOperations_, hwOperation_, ExecutingOperation::iovec_, TTAMachine::HWOperation::latency(), Application::logStream(), Operation::name(), ExecutingOperation::operation(), operation_, opSimulator_, DetailedOperationSimulator::simulateStage(), Operation::simulateTrigger(), ExecutingOperation::stage_, and ExecutingOperation::stop().

Referenced by ConflictDetectingOperationExecutor::advanceClock().

Here is the call graph for this function:

◆ copy()

OperationExecutor * MultiLatencyOperationExecutor::copy ( )

virtual

Copies OperationExecutor.

Returns: The copied OperationExecutor.

Implements OperationExecutor.

Reimplemented in ConflictDetectingOperationExecutor.

Definition at line 204 of file MultiLatencyOperationExecutor.cc.

                                    {
    return new MultiLatencyOperationExecutor(*this);
}

References MultiLatencyOperationExecutor().

Here is the call graph for this function:

◆ findFreeExecutingOperation()

ExecutingOperation & MultiLatencyOperationExecutor::findFreeExecutingOperation ( )

private

Definition at line 89 of file MultiLatencyOperationExecutor.cc.

                                                          {
    ExecutingOperation* execOp = NULL;
    if (freeExecOp_ != NULL) {
        execOp = freeExecOp_;
        freeExecOp_ = NULL;
    } else {
        for (std::size_t i = 0; i < executingOps_.size(); ++i) {
            execOp = &executingOps_[i];
            if (execOp->free_) {
                break;
            }
        }
    }
    assert(execOp != NULL &&
           "Did not find a free ExecutingOperation.");
    return *execOp;
}

References assert, executingOps_, ExecutingOperation::free_, and freeExecOp_.

Referenced by startOperation().

◆ operator=()

MultiLatencyOperationExecutor & MultiLatencyOperationExecutor::operator= ( const MultiLatencyOperationExecutor & )

private

Assignment not allowed.

◆ reset()

void MultiLatencyOperationExecutor::reset ( )

virtual

Resets the state to allow simulation restart. hasPendingOperations_ is resetted because otherwise some operations could be left in middle of execution if there was a runtime error during operation.

Reimplemented from OperationExecutor.

Definition at line 225 of file MultiLatencyOperationExecutor.cc.

                                     {
    hasPendingOperations_ = false;
}

References OperationExecutor::hasPendingOperations_.

◆ setContext()

void MultiLatencyOperationExecutor::setContext ( OperationContext & context )

virtual

Sets the OperationContext for the OperationExecutor.

Parameters

context New OperationContext.

Implements OperationExecutor.

Definition at line 214 of file MultiLatencyOperationExecutor.cc.

                                                                   {
    context_ = &context;
}

References context_.

◆ setOperationSimulator()

virtual void MultiLatencyOperationExecutor::setOperationSimulator ( DetailedOperationSimulator & sim )

inlinevirtual

Definition at line 74 of file MultiLatencyOperationExecutor.hh.

                                         {
        opSimulator_ = &sim;
    }

References opSimulator_.

Referenced by FUState::setOperationSimulator().

◆ startOperation()

void MultiLatencyOperationExecutor::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.

Implements OperationExecutor.

Reimplemented in ConflictDetectingOperationExecutor.

Definition at line 118 of file MultiLatencyOperationExecutor.cc.

                                                        {
 
    const std::size_t inputOperands = operation_->numberOfInputs();
    const std::size_t outputOperands = operation_->numberOfOutputs();
    const std::size_t operandCount = inputOperands + outputOperands;
    ExecutingOperation& execOp = findFreeExecutingOperation();
 
    if (!execOperationsInitialized_) {
        // cannot initialize in the constructor as the
        // FUPort -> operand bindings have not been initialized at
        // that point
        for (std::size_t i = 0; i < executingOps_.size(); ++i) {
            ExecutingOperation& execOp = executingOps_[i];
            execOp.initIOVec();
            // set the widths of the storage values to enforce correct 
            // clipping of values
            for (std::size_t o = 1; o <= operandCount; ++o) {
                execOp.iostorage_[o - 1].setBitWidth(
                    binding(o).value().width());
            }
            // set operation output storages to point to the corresponding 
            // output ports and setup their delayed appearance 
            for (std::size_t o = inputOperands + 1; o <= operandCount; ++o) {
                PortState& port = binding(o);
                const int resultLatency = hwOperation_->latency(o);
 
                ExecutingOperation::PendingResult res(
                    execOp.iostorage_[o - 1], port, resultLatency);
                execOp.pendingResults_.push_back(res);
            }
        }
        execOperationsInitialized_ = true;
    }
    // copy the input values to the on flight operation executor model
    for (std::size_t i = 1; i <= inputOperands; ++i) {
        execOp.iostorage_[i - 1] = binding(i).value();
    }
#ifdef DEBUG_OPERATION_SIMULATION
    Application::logStream()
        << &execOp << " (" << execOp.operation().name() 
        << ") started" << std::endl;
#endif
    execOp.start();
    hasPendingOperations_ = true;
}