FUState Class Reference

#include <FUState.hh>

Inheritance diagram for FUState:

Collaboration diagram for FUState:

Public Member Functions
	FUState ()
	FUState (const TCEString &name)
virtual	~FUState ()
void	setTriggered ()
void	setOperation (Operation &operation)
void	setOperation (Operation &operation, OperationExecutor &executor)
bool	isIdle ()
virtual void	endClock ()
virtual void	advanceClock ()
virtual void	addInputPortState (PortState &port)
virtual void	addOutputPortState (PortState &port)
virtual void	addOperationExecutor (OperationExecutor &opExec, Operation &op)
virtual void	setOperationSimulator (DetailedOperationSimulator &sim)
virtual void	replaceOperationExecutor (Operation &op, OperationExecutor *newExecutor)
virtual OperationExecutor *	executor (Operation &op)
virtual OperationContext &	context ()
virtual void	reset ()
	this is called at (re)initialization of the simulation
Public Member Functions inherited from ClockedState
	ClockedState ()
virtual	~ClockedState ()

Protected Attributes
bool	idle_
	The idle status of the FU. The derived classes should alway set this to true when possible to avoid unnecessary advanceClock() and endClock() calls.

Private Types
typedef std::map< Operation *, OperationExecutor * >	ExecutorContainer
	Maps operations to executors.
typedef std::vector< OperationExecutor * >	ExecutorList
	Contains all the different instances of executors.

Private Member Functions
	FUState (const FUState &)
	Copying not allowed.
FUState &	operator= (const FUState &)
	Assignment not allowed.
void	clearPorts ()
bool	sameBindings (OperationExecutor &exec1, OperationExecutor &exec2, Operation &op)
virtual void	setOperationSimulator (Operation &op, DetailedOperationSimulator &sim)

Private Attributes
bool	trigger_
	True if operation is triggered in current clock cycle.
Operation *	nextOperation_
	Operation to be triggered next.
OperationExecutor *	nextExecutor_
	OperationExecutor to be used for the next operation (an optimization).
OperationContext	operationContext_
	The operation context for this FU.
ExecutorContainer	executors_
	All operation executors.
ExecutorList	execList_
	All the different instances of OperationExecutors.
std::vector< PortState * >	inputPorts_
	Input ports of the function unit.
std::vector< PortState * >	outputPorts_
	Output ports of the function unit.
std::size_t	activeExecutors_
	Count of active executors (to allow returning instantly from advanceClock())
DetailedOperationSimulator *	detailedModel_
	Optional detailed operation simulation model. Assume there's one such model per FU or none at all for now (could be possible to be one model per Operation).

Detailed Description

Models the state of the function unit of a TTA processor.

Definition at line 58 of file FUState.hh.

Member Typedef Documentation

ExecutorContainer

typedef std::map<Operation*, OperationExecutor*> FUState::ExecutorContainer

private

Maps operations to executors.

Definition at line 114 of file FUState.hh.

ExecutorList

typedef std::vector<OperationExecutor*> FUState::ExecutorList

private

Contains all the different instances of executors.

Definition at line 116 of file FUState.hh.

Constructor & Destructor Documentation

FUState() [1/3]

FUState::FUState

(

)

Constructor (no explicitly given FU name).

Parameters

lock	Global lock signal.

Definition at line 67 of file FUState.cc.

                 :
    ClockedState(), idle_(false), trigger_(false),
    nextOperation_(NULL), nextExecutor_(NULL),
    operationContext_(DEFAULT_FU_NAME),
    activeExecutors_(0), detailedModel_(NULL) {
}

FUState() [2/3]

FUState::FUState

(

const TCEString &

name

)

Constructor (with explicitly given FU name).

Parameters

lock	Global lock signal.

Definition at line 79 of file FUState.cc.

                                      :
    ClockedState(), idle_(false), trigger_(false),
    nextOperation_(NULL), nextExecutor_(NULL), operationContext_(name),
    activeExecutors_(0), detailedModel_(NULL) {
}

~FUState()

FUState::~FUState ( )

virtual

Destructor.

Definition at line 88 of file FUState.cc.

                  {
    clearPorts();
    SequenceTools::deleteAllItems(execList_);
}

References clearPorts(), SequenceTools::deleteAllItems(), and execList_.

Here is the call graph for this function:

FUState() [3/3]

FUState::FUState ( const FUState &  )

private

Copying not allowed.

Member Function Documentation

addInputPortState()

void FUState::addInputPortState ( PortState &  port )

virtual

Adds new input port state.

Parameters

port	New input port state.

Reimplemented in NullFUState.

Definition at line 211 of file FUState.cc.

                                          {
    inputPorts_.push_back(&port);
}

References inputPorts_.

Referenced by MachineStateBuilder::addPortToFU(), and MachineStateBuilder::addVirtualOpcodeSettingPortsToFU().

addOperationExecutor()

void FUState::addOperationExecutor ( OperationExecutor &  opExec, Operation &  op  )

virtual

Adds operation executor for a given operation.

Parameters

opExec	Operation executor to be added.
op	Operation which executor is added.

Reimplemented in NullFUState.

Definition at line 232 of file FUState.cc.

                                                                      {
 
    op.createState(context());
 
    // do not use same operation executor even if the latency and operand
    // bindings are equal between the operations, because the executor
    // properties can be different (especially, one of the executors can
    // have conflict detection)
    OperationExecutor* newExecutor = opExec.copy();
    execList_.push_back(newExecutor);
    newExecutor->setContext(context());
    executors_[&op] = newExecutor;
}

References context(), OperationExecutor::copy(), Operation::createState(), execList_, executors_, and OperationExecutor::setContext().

Referenced by MachineStateBuilder::addVirtualOpcodeSettingPortsToFU().

Here is the call graph for this function:

addOutputPortState()

void FUState::addOutputPortState ( PortState &  port )

virtual

Adds new output port state.

Parameters

port	New output port state.

Reimplemented in NullFUState.

Definition at line 221 of file FUState.cc.

                                           {
    outputPorts_.push_back(&port);
}

References outputPorts_.

Referenced by MachineStateBuilder::addPortToFU().

advanceClock()

void FUState::advanceClock ( )

virtual

Handles actions that take place while clock cycle changes.

advanceClock() of all active operation executors are called.

Todo:

detect if there are clocked state objects

Todo:

detect if there are clocked state objects

Implements ClockedState.

Reimplemented in NullFUState, and GCUState.

Definition at line 152 of file FUState.cc.

                      {
 
    if (detailedModel_ != NULL)
        detailedModel_->simulateCycleStart();
 
    // in case there are no active operations and there are no states
    // which need clock advancing, the FU is in idle state
    if (activeExecutors_ == 0 && context().isEmpty()) {
        idle_ = true;
        return;
    } else if (activeExecutors_ == 1 && nextExecutor_ != NULL &&
               nextExecutor_->hasPendingOperations()) {
        // a special case for sequential simulation:
        // if there's only one active executor, and it's the one
        // triggered previously in endClock(), we can use 
        // nextExecutor_ and avoid traversing the whole list of executors
        nextExecutor_->advanceClock();
        if (nextExecutor_->hasPendingOperations()) {
            activeExecutors_ = 1;
            idle_ = false;
        } else {
            activeExecutors_ = 0;
            idle_ = true;
        }
        // advance clock of all operations with state
        /// @todo detect if there are *clocked* state objects
        if (!context().isEmpty()) {
            context().advanceClock();
        } 
        return;
    }
 
    activeExecutors_ = 0;
    size_t execListSize = execList_.size();
    for (size_t i = 0; i < execListSize; ++i) {
        OperationExecutor* opexec = execList_[i];
        if (opexec->hasPendingOperations()) {            
            opexec->advanceClock();
            // check if it's still active
            if (opexec->hasPendingOperations()) {
                ++activeExecutors_;
            } 
        }
    }
    // advance clock of all operations with state
    /// @todo detect if there are *clocked* state objects
    if (!context().isEmpty()) {
        context().advanceClock();
    } 
 
    idle_ = (activeExecutors_ == 0 && context().isEmpty());
}

References activeExecutors_, OperationContext::advanceClock(), OperationExecutor::advanceClock(), context(), detailedModel_, execList_, OperationExecutor::hasPendingOperations(), idle_, OperationContext::isEmpty(), nextExecutor_, and DetailedOperationSimulator::simulateCycleStart().

Referenced by FUTestbenchGenerator::createStimulus().

Here is the call graph for this function:

clearPorts()

void FUState::clearPorts ( )

private

Clears input and output ports.

Definition at line 97 of file FUState.cc.

                    {
    inputPorts_.clear();
    outputPorts_.clear();
}

References inputPorts_, and outputPorts_.

Referenced by ~FUState().

context()

OperationContext & FUState::context ( )

virtual

Returns the operation context.

This is a "template method" to allow differently initialized OperationContext-classes in FUState subclasses.

Returns

The operation context for the FU.

Reimplemented in GCUState, and MemoryAccessingFUState.

Definition at line 376 of file FUState.cc.

                 {
    return operationContext_;
}

References operationContext_.

Referenced by addOperationExecutor(), advanceClock(), replaceOperationExecutor(), reset(), SimulationController::SimulationController(), and TransportPipeline::TransportPipeline().

endClock()

void FUState::endClock ( )

virtual

Handles actions that take place in the end of the clock cycle.

If operation is triggered, startOperation() of the executor of the operation is called.

Implements ClockedState.

Reimplemented in NullFUState.

Definition at line 122 of file FUState.cc.

                  {
    if (trigger_) {
        if (nextOperation_ == NULL) {
            throw Exception(
                __FILE__, __LINE__, __func__,
                "Tried to trigger FU without operation code.");
        }
        if (nextExecutor_ == NULL) {
            ExecutorContainer::iterator iter = executors_.find(nextOperation_);
            assert(iter != executors_.end());
            nextExecutor_ = (*iter).second;
        }
        // set this flag to false before actually handling the trigger
        // condition because startOperation() can cause a runtime error
        // exception
        trigger_ = false;
        nextExecutor_->startOperation(*nextOperation_);
        if (nextExecutor_->hasPendingOperations()) {
            ++activeExecutors_;
            idle_ = false;
        }
    }
}

References __func__, activeExecutors_, assert, executors_, OperationExecutor::hasPendingOperations(), idle_, nextExecutor_, nextOperation_, OperationExecutor::startOperation(), and trigger_.

Referenced by OTASimulationController::advanceMachineCycle(), FUTestbenchGenerator::createStimulus(), and SimulationController::simulateCycle().

Here is the call graph for this function:

executor()

OperationExecutor * FUState::executor ( Operation &  op )

virtual

Returns OperationExecutor for the given operation.

Parameters

op	The operation of the wanted OperationExecutor.

Reimplemented in NullFUState.

Definition at line 358 of file FUState.cc.

                               {
    ExecutorContainer::iterator iter = executors_.find(&op);
    if (iter == executors_.end()) {
        return NULL;
    } else {
        return (*iter).second;
    }
}

References executors_.

Referenced by MachineStateBuilder::addVirtualOpcodeSettingPortsToFU(), and setOperationSimulator().

isIdle()

bool FUState::isIdle

(

)

Referenced by OTASimulationController::advanceMachineCycle(), and SimulationController::simulateCycle().

operator=()

FUState & FUState::operator= ( const FUState &  )

private

Assignment not allowed.

replaceOperationExecutor()

void FUState::replaceOperationExecutor ( Operation &  op, OperationExecutor *  newExecutor  )

virtual

Replaces the operation executor model for an operation.

Does not copy the operation executor but uses the given instance. The method copies the I/O bindings and sets the parent FUState from the old model.

Parameters

op	Operation of which executor is added.
newExecutor	Operation executor to be set.

Definition at line 257 of file FUState.cc.

                                    {
 
    op.createState(context());
    newExecutor->setContext(context());
 
    OperationExecutor* oldExecutor = executors_[&op];
    newExecutor->setParent(oldExecutor->parent());
 
    /* Copy the operand-port bindings. */
    for (int ioId = 1; 
         ioId <= op.numberOfInputs() + op.numberOfOutputs(); ++ioId) {
        newExecutor->addBinding(ioId, oldExecutor->binding(ioId));
    }
    assert(sameBindings(*oldExecutor, *newExecutor, op));
 
    /* Replace the executor in the execution list. */
    for (std::size_t i = 0; i < execList_.size(); ++i) {
        if (execList_.at(i) == oldExecutor) {
            execList_[i] = newExecutor;
            break;
        }
    }
    executors_[&op] = newExecutor;
    delete oldExecutor;
}

References OperationExecutor::addBinding(), assert, OperationExecutor::binding(), context(), Operation::createState(), execList_, executors_, Operation::numberOfInputs(), Operation::numberOfOutputs(), OperationExecutor::parent(), sameBindings(), OperationExecutor::setContext(), and OperationExecutor::setParent().

Here is the call graph for this function:

reset()

void FUState::reset ( )

virtual

this is called at (re)initialization of the simulation

Reimplemented from ClockedState.

Reimplemented in GCUState.

Definition at line 103 of file FUState.cc.

               {
    for (ExecutorContainer::iterator i = executors_.begin();
         i != executors_.end(); ++i) {
        Operation* op = (*i).first;
        // Ensure the init state is called again.
        op->deleteState(context());
        op->createState(context());
        // Reset the internal state of executor
        (*i).second->reset();
    }
}

References context(), Operation::createState(), Operation::deleteState(), and executors_.

Here is the call graph for this function:

sameBindings()

bool FUState::sameBindings ( OperationExecutor &  exec1, OperationExecutor &  exec2, Operation &  op  )

private

Returns true if the two OperationExecutors have the same bindings.

Parameters

exec1	First OperationExecutor.
exec2	Second OperationExecutor.
op	Operation to be executed with executors.

Returns

True if the two executors have same bindings.

Definition at line 324 of file FUState.cc.

                   {
 
    for (int i = 1; i <= op.numberOfInputs() + op.numberOfOutputs(); i++) {
 
        PortState* port1 = NULL;
        try {
            port1 = &exec1.binding(i);
        } catch (const OutOfRange& o) {
            return false;
        }
 
        PortState* port2 = NULL;
        try {
            port2 = &exec2.binding(i);
        } catch (const OutOfRange& o) {
            return false;
        }
 
        if (port1 != port2) {
            return false;
        }
    }
    return true;
}

References OperationExecutor::binding(), Operation::numberOfInputs(), and Operation::numberOfOutputs().

Referenced by replaceOperationExecutor().

Here is the call graph for this function:

setOperation() [1/2]

void FUState::setOperation

(

Operation &

operation

)

Referenced by OpcodeSettingVirtualInputPortState::setValue().

setOperation() [2/2]

void FUState::setOperation	(	Operation &	operation,
		OperationExecutor &	executor
	)

setOperationSimulator() [1/2]

void FUState::setOperationSimulator ( DetailedOperationSimulator &  sim )

virtual

Sets a detailed operation simulation model for all operations in the FU.

Definition at line 304 of file FUState.cc.

                                                              {
 
    for (ExecutorContainer::iterator i = executors_.begin();
         i != executors_.end(); ++i) {
        Operation* op = (*i).first;
        setOperationSimulator(*op, sim);
    }
    detailedModel_ = ∼
}

References detailedModel_, executors_, and setOperationSimulator().

Referenced by setOperationSimulator().

Here is the call graph for this function:

setOperationSimulator() [2/2]

void FUState::setOperationSimulator ( Operation &  op, DetailedOperationSimulator &  sim  )

privatevirtual

Sets a detailed operation simulation model for all operations in the FU.

Definition at line 290 of file FUState.cc.

                                     {
 
    MultiLatencyOperationExecutor* oe = 
        dynamic_cast<MultiLatencyOperationExecutor*>(executor(op));  
    assert (oe != NULL && "Can only add details to a complex executor.");
    oe->setOperationSimulator(sim);
}

References assert, executor(), and MultiLatencyOperationExecutor::setOperationSimulator().

Here is the call graph for this function:

setTriggered()

void FUState::setTriggered

(

)

Referenced by OpcodeSettingVirtualInputPortState::setValue(), and TriggeringInputPortState::setValue().

Member Data Documentation

activeExecutors_

std::size_t FUState::activeExecutors_

private

Count of active executors (to allow returning instantly from advanceClock())

Definition at line 136 of file FUState.hh.

Referenced by advanceClock(), and endClock().

detailedModel_

DetailedOperationSimulator* FUState::detailedModel_

private

Optional detailed operation simulation model. Assume there's one such model per FU or none at all for now (could be possible to be one model per Operation).

Definition at line 140 of file FUState.hh.

Referenced by advanceClock(), and setOperationSimulator().

execList_

ExecutorList FUState::execList_

private

All the different instances of OperationExecutors.

Definition at line 129 of file FUState.hh.

Referenced by addOperationExecutor(), advanceClock(), replaceOperationExecutor(), and ~FUState().

executors_

ExecutorContainer FUState::executors_

private

All operation executors.

Definition at line 127 of file FUState.hh.

Referenced by addOperationExecutor(), endClock(), executor(), replaceOperationExecutor(), reset(), and setOperationSimulator().

idle_

bool FUState::idle_

protected

The idle status of the FU. The derived classes should alway set this to true when possible to avoid unnecessary advanceClock() and endClock() calls.

Definition at line 95 of file FUState.hh.

Referenced by advanceClock(), GCUState::advanceClock(), and endClock().

inputPorts_

std::vector<PortState*> FUState::inputPorts_

private

Input ports of the function unit.

Definition at line 131 of file FUState.hh.

Referenced by addInputPortState(), and clearPorts().

nextExecutor_

OperationExecutor* FUState::nextExecutor_

private

OperationExecutor to be used for the next operation (an optimization).

Definition at line 123 of file FUState.hh.

Referenced by advanceClock(), and endClock().

nextOperation_

Operation* FUState::nextOperation_

private

Operation to be triggered next.

Definition at line 121 of file FUState.hh.

Referenced by endClock().

operationContext_

OperationContext FUState::operationContext_

private

The operation context for this FU.

Definition at line 125 of file FUState.hh.

Referenced by context().

outputPorts_

std::vector<PortState*> FUState::outputPorts_

private

Output ports of the function unit.

Definition at line 133 of file FUState.hh.

Referenced by addOutputPortState(), and clearPorts().

trigger_

bool FUState::trigger_

private

True if operation is triggered in current clock cycle.

Definition at line 119 of file FUState.hh.

Referenced by endClock().

---

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

• FUState.hh
• FUState.cc