#include <ExecutionPipeline.hh>

Inheritance diagram for TTAMachine::ExecutionPipeline:

Collaboration diagram for TTAMachine::ExecutionPipeline:

Public Types
typedef std::set< int >	OperandSet
	Set for operand indexes. More...

typedef std::set< PipelineElement *, PipelineElement::Comparator >	ResourceSet
	Set for pipeline elements. More...

Public Member Functions
	ExecutionPipeline (HWOperation &parentOperation)

virtual	~ExecutionPipeline ()

const HWOperation *	parentOperation () const

void	addResourceUse (const std::string &name, int start, int duration)

void	addPortRead (int operand, int start, int duration)

void	addPortWrite (int operand, int start, int duration)

void	removeResourceUse (const std::string &name)

void	removeResourceUse (const std::string &name, int cycle)

void	removeAllResourceUses ()

void	removeOperandUse (int operand, int cycle)

bool	isResourceUsed (const std::string &name, int cycle) const

ResourceSet	resourceUsages (int cycle) const

bool	isPortUsed (const FUPort &port, int cycle) const

bool	isPortRead (const FUPort &port, int cycle) const

bool	isPortWritten (const FUPort &port, int cycle) const

OperandSet	readOperands (int cycle) const

OperandSet	writtenOperands (int cycle) const

OperandSet	readOperands () const

OperandSet	writtenOperands () const

int	latency () const

int	latency (int output) const

int	slack (int input) const

ObjectState *	saveState () const

void	loadState (const ObjectState *state)

bool	isArchitectureEqual (const ExecutionPipeline *pipeline) const

Public Member Functions inherited from Serializable
virtual	~Serializable ()

Static Public Attributes
static const std::string	OSNAME_PIPELINE = "pipeline"
	ObjectState name for ExecutionPipeline. More...

static const std::string	OSNAME_RESOURCE_USAGE = "resource_usage"
	ObjectState name for pipeline resource usage. More...

static const std::string	OSNAME_OPERAND_READ = "op_read"
	ObjectState name for operand read. More...

static const std::string	OSNAME_OPERAND_WRITE = "op_write"
	ObjectState name for operand write. More...

static const std::string	OSKEY_RESOURCE_NAME = "res_name"
	ObjectState attribute key for name of resource. More...

static const std::string	OSKEY_OPERAND = "operand"
	ObjectState attribute key for operand number. More...

static const std::string	OSKEY_START_CYCLE = "start_cycle"
	ObjectState attribute key for start cycle of a resource usage. More...

static const std::string	OSKEY_CYCLES = "cycles"
	ObjectState attribute key for duration of a resource usage. More...

Private Types
typedef std::vector< const ObjectState * >	ObjectStateTable
	Vector for ObjectState pointers. More...

typedef std::vector< ResourceSet >	ResourceUsage
	Vector for resource sets. More...

typedef std::vector< OperandSet >	IOUsage
	Vector for operand sets. More...

Private Member Functions
void	checkStartCycle (int startCycle) const

void	checkInputOperand (int operand) const

void	checkOutputOperand (int operand) const

void	checkResourceAvailability (const std::string &resource, int start, int duration) const

void	checkOperandAvailability (int operand, int start, int duration) const

void	internalAddResourceUse (const std::string &name, int start, int duration)

void	internalAddPortUse (int operand, int start, int duration, IOUsage &toModify)

void	internalRemoveResourceUse (const std::string &name, int start, int duration)

void	internalRemoveOperandUse (int operand, int start, int duration)

void	adjustLatency (int newLatency)

bool	isOperandBound (const FUPort &port, const OperandSet &operands) const

bool	isOperandWritten (int operand) const

bool	isOperandRead (int operand) const

int	firstCycle () const

int	firstCycleWithoutResource (const std::string &resource) const

int	firstCycleWithoutResource (const std::string &resource, int cycle) const

int	firstCycleWithoutOperandUse (int operand, int cycle) const

ResourceSet	usedResources () const

PipelineElement *	pipelineElement (const std::string &name) const

PipelineElement *	addPipelineElement (const std::string &name) const

ObjectStateTable	sortResourceUsages (const ObjectState *pipelineState) const

void	addResourceUsage (ObjectStateTable &usages, const ObjectState *usageState) const

Static Private Member Functions
static void	checkDuration (int duration)

static void	checkResourceName (const std::string &name)

static void	saveResourceUse (const PipelineElement element, int cycleToSave, ObjectState pipelineState)

static void	saveOperandUse (int operand, int cycleToSave, ObjectState *pipelineState, const std::string &osName)

Private Attributes
ResourceUsage	resourceUsage_
	Resource usage. More...

IOUsage	opReads_
	Operand reads. More...

IOUsage	opWrites_
	Operand writes. More...

HWOperation *	parent_
	The parent operation. More...

Additional Inherited Members
Protected Member Functions inherited from TTAMachine::SubComponent
	SubComponent ()

virtual	~SubComponent ()

Protected Member Functions inherited from TTAMachine::MachinePart
	MachinePart ()

virtual	~MachinePart ()

Detailed Description

Represents an execution pipeline in function unit.

Definition at line 55 of file ExecutionPipeline.hh.

Member Typedef Documentation

◆ IOUsage

typedef std::vector<OperandSet> TTAMachine::ExecutionPipeline::IOUsage

private

Vector for operand sets.

Definition at line 120 of file ExecutionPipeline.hh.

◆ ObjectStateTable

typedef std::vector<const ObjectState*> TTAMachine::ExecutionPipeline::ObjectStateTable

private

Vector for ObjectState pointers.

Definition at line 115 of file ExecutionPipeline.hh.

◆ OperandSet

typedef std::set<int> TTAMachine::ExecutionPipeline::OperandSet

Set for operand indexes.

Definition at line 58 of file ExecutionPipeline.hh.

◆ ResourceSet

typedef std::set<PipelineElement*,PipelineElement::Comparator> TTAMachine::ExecutionPipeline::ResourceSet

Set for pipeline elements.

Definition at line 60 of file ExecutionPipeline.hh.

◆ ResourceUsage

typedef std::vector<ResourceSet> TTAMachine::ExecutionPipeline::ResourceUsage

private

Vector for resource sets.

Definition at line 118 of file ExecutionPipeline.hh.

Constructor & Destructor Documentation

◆ ExecutionPipeline()

TTAMachine::ExecutionPipeline::ExecutionPipeline ( HWOperation & parentOperation )

Constructor.

Parameters

parentOperation The parent operation which uses the pipeline.

Definition at line 68 of file ExecutionPipeline.cc.

                                                                  :
     SubComponent(), parent_(&parentOperation) {
  
     // run time sanity check
     assert(parentOperation.pipeline() == NULL);
 }

References assert, parentOperation(), and TTAMachine::HWOperation::pipeline().

Here is the call graph for this function:

◆ ~ExecutionPipeline()

TTAMachine::ExecutionPipeline::~ExecutionPipeline ( )

virtual

Destructor.

Definition at line 79 of file ExecutionPipeline.cc.

                                       {
     removeAllResourceUses();
 }

References removeAllResourceUses().

Here is the call graph for this function:

Member Function Documentation

◆ addPipelineElement()

PipelineElement * TTAMachine::ExecutionPipeline::addPipelineElement ( const std::string & name ) const

private

Creates a pipeline element by the given name.

Parameters

name	The name of the pipeline element.

Returns: The pipeline element that was created.

Definition at line 1272 of file ExecutionPipeline.cc.

                                                                  {
     FunctionUnit* fu = parent_->parentUnit();
     if (!fu->hasPipelineElement(name)) {
         new PipelineElement(name, *fu);
     }
     return fu->pipelineElement(name);
 }

References TTAMachine::FunctionUnit::hasPipelineElement(), parent_, TTAMachine::HWOperation::parentUnit(), and TTAMachine::FunctionUnit::pipelineElement().

Referenced by internalAddResourceUse().

Here is the call graph for this function:

◆ addPortRead()

void TTAMachine::ExecutionPipeline::addPortRead	(	int	operand,
		int	start,
		int	duration
	)

Adds read usage of an operand.

Parameters

operand	The operand to be read.
start	Start cycle of the usage.
duration	Duration of the usage.

Exceptions

OutOfRange	If the given cycle is less than 0 or if duration or operand is less than 1.
WrongOperandType	If the given operand is not an input operand, that is, if a port write is already added with the given operand.
StartTooLate	If the pipeline does not start by resource usage or operand read at cycle 0 or 1.
NotAvailable	If the given operand is already read at a cycle in the given time interval.

Definition at line 141 of file ExecutionPipeline.cc.

                                                                    {
     const string procName = "ExecutionPipeline::addPortRead";
  
     checkStartCycle(start);
     checkDuration(duration);
     checkInputOperand(operand);
     checkOperandAvailability(operand, start, duration);
  
     internalAddPortUse(operand, start, duration, opReads_);
 }

References checkDuration(), checkInputOperand(), checkOperandAvailability(), checkStartCycle(), internalAddPortUse(), and opReads_.

Referenced by VectorLSGenerator::addOperation(), HDB::HDBManager::addOperationPipelinesToFUArchitecture(), BlocksMUL::ConfigurePipeline(), BlocksALU::ConfigurePipeline(), BlocksLSU::ConfigurePipeline(), BlocksGCU::ConfigurePipeline(), UniversalMachine::construct(), OpsetDialog::createOperation(), AddGCUCmd::Do(), CostEstimator::ICDecoderEstimatorPlugin::generateControlUnit(), loadState(), OperationDialog::onOperandLClick(), and SmartHWOperation::SmartHWOperation().

Here is the call graph for this function:

◆ addPortWrite()

void TTAMachine::ExecutionPipeline::addPortWrite	(	int	operand,
		int	start,
		int	duration
	)

Adds write usage of an operand.

Parameters

operand	The operand to be written.
start	Start cycle of the usage.
duration	Duration of the usage.

Exceptions

OutOfRange	If the given cycle is less than 0 or if duration or operand is less than 1.
WrongOperandType	If the given operand is not an output operand, that is, if a port read is already added with the given operand.
NotAvailable	If the given operand is already written at a cycle in the given time interval.

Definition at line 167 of file ExecutionPipeline.cc.

                                                                     {
     const string procName = "ExecutionPipeline::addPortWrite";
  
     if (start < 0) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     checkDuration(duration);
     checkOutputOperand(operand);
     checkOperandAvailability(operand, start, duration);
  
     internalAddPortUse(operand, start, duration, opWrites_);
 }

References checkDuration(), checkOperandAvailability(), checkOutputOperand(), internalAddPortUse(), and opWrites_.

Referenced by VectorLSGenerator::addOperation(), HDB::HDBManager::addOperationPipelinesToFUArchitecture(), BlocksALU::ConfigurePipeline(), BlocksMUL::ConfigurePipeline(), BlocksLSU::ConfigurePipeline(), OpsetDialog::createOperation(), loadState(), OperationDialog::onOperandLClick(), and SmartHWOperation::SmartHWOperation().

Here is the call graph for this function:

◆ addResourceUsage()

void TTAMachine::ExecutionPipeline::addResourceUsage	(	ObjectStateTable &	usages,
		const ObjectState *	usageState
	)		const

private

Adds the given ObjectState instance representing a resource usage to the given set of usages to correct position.

The correct position is determined by the start cycle of the resource usage.

Parameters

usages	The set of resource usages where to add the given usage.
usageState	The usageState to add.

Exceptions

ObjectStateLoadingException If the given ObjectState instance is invalid.

Definition at line 1401 of file ExecutionPipeline.cc.

                                                                    {
     try {
         int startCycle = usageState->intAttribute(OSKEY_START_CYCLE);
         for (ObjectStateTable::iterator iter = usages.begin();
              iter != usages.end(); iter++) {
             const ObjectState* usage = *iter;
             int usageStart = usage->intAttribute(OSKEY_START_CYCLE);
             if (startCycle < usageStart) {
                 usages.insert(iter, usageState);
                 return;
             }
         }
     } catch (const Exception& exception) {
         string procName = "ExecutionPipeline::addResourceUsage";
         throw ObjectStateLoadingException(
             __FILE__, __LINE__, procName, exception.errorMessage());
     }
  
     usages.push_back(usageState);
 }

References Exception::errorMessage(), ObjectState::intAttribute(), and OSKEY_START_CYCLE.

Referenced by sortResourceUsages().

Here is the call graph for this function:

◆ addResourceUse()

void TTAMachine::ExecutionPipeline::addResourceUse	(	const std::string &	name,
		int	start,
		int	duration
	)

Adds use for the given pipeline element.

If the function unit does not have a pipeline element by the given name the pipeline element is added to the function unit. Pipeline is valid only if it starts at cycle 0 or 1.

Parameters

name	Name of the pipeline element.
start	First cycle in which the element is used relative to operation start cycle.
duration	Number of cycles the element is used.

Exceptions

OutOfRange	If given start cycle or duration is out of range.
InvalidName	If the given name is not a valid component name.
StartTooLate	If the pipeline does not start by resource usage or operand read at cycle 0 or 1.
NotAvailable	If the given resource is already in use at a cycle in the given time interval.

Definition at line 112 of file ExecutionPipeline.cc.

                                                     {
     const string procName = "ExecutionPipeline::addResourceUse";
  
     checkStartCycle(start);
     checkDuration(duration);
     checkResourceName(name);
     checkResourceAvailability(name, start, duration);
  
     internalAddResourceUse(name, start, duration);
 }

References checkDuration(), checkResourceAvailability(), checkResourceName(), checkStartCycle(), and internalAddResourceUse().

Referenced by HDB::HDBManager::addOperationPipelinesToFUArchitecture(), loadState(), and OperationDialog::onResourceLClick().

Here is the call graph for this function:

◆ adjustLatency()

void TTAMachine::ExecutionPipeline::adjustLatency ( int newLatency )

private

Adjusts the size of usage vectors for the given latency.

If the given latency is greater than the current latency, sizes of the usage vectors are increased. If the given latency is smaller than the current latency (vector size), sizes of the vectors are tried to decrease to match with the given latency. However, if there are non-empty elements in the usage vectors, they are not removed.

Parameters

newLatency The new latency.

Definition at line 1003 of file ExecutionPipeline.cc.

                                                {
  
     if (newLatency > latency()) {
         resourceUsage_.resize(newLatency);
         opReads_.resize(newLatency);
         opWrites_.resize(newLatency);
  
     } else if (newLatency < latency()) {
         for (int cycle = latency() - 1; cycle >= newLatency; cycle--) {
             if (resourceUsage_[cycle].empty() && opReads_[cycle].empty() &&
                 opWrites_[cycle].empty()) {
                 resourceUsage_.resize(cycle);
                 opReads_.resize(cycle);
                 opWrites_.resize(cycle);
             } else {
                 break;
             }
         }
     }
 }

References latency(), opReads_, opWrites_, and resourceUsage_.

Referenced by internalAddPortUse(), internalAddResourceUse(), internalRemoveOperandUse(), and internalRemoveResourceUse().

Here is the call graph for this function:

◆ checkDuration()

void TTAMachine::ExecutionPipeline::checkDuration ( int duration )

staticprivate

Checks whether the given value is valid for duration of resource usage.

Parameters

duration The duration value.

Exceptions

OutOfRange If the value is not in a valid range.

Definition at line 751 of file ExecutionPipeline.cc.

                                              {
     if (duration < 1) {
         const string procName = "ExecutionPipeline::checkDuration";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
 }

Referenced by addPortRead(), addPortWrite(), and addResourceUse().

◆ checkInputOperand()

void TTAMachine::ExecutionPipeline::checkInputOperand ( int operand ) const

private

Checks whether the given operand is an input operand.

The operand is an input operand if it is read by the pipeline already.

Parameters

operand The operand.

Exceptions

OutOfRange	If the given operand is smaller than 1.
WrongOperandType	If the operand is written by the pipeline.

Definition at line 782 of file ExecutionPipeline.cc.

                                                       {
     const string procName = "ExecutionPipeline::checkInputOperand";
  
     if (operand < 1) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (isOperandWritten(operand)) {
         throw WrongOperandType(__FILE__, __LINE__, procName);
     }
 }

References isOperandWritten().

Referenced by addPortRead().

Here is the call graph for this function:

◆ checkOperandAvailability()

void TTAMachine::ExecutionPipeline::checkOperandAvailability	(	int	operand,
		int	start,
		int	duration
	)		const

private

Checks whether the given operand is not read or written at the given time interval.

Parameters

operand	The operand.
start	The start cycle.
duration	Duration of the usage.

Exceptions

NotAvailable If the given operand is used at the given time interval.

Definition at line 858 of file ExecutionPipeline.cc.

                                                 {
     int end = start + duration - 1;
     if (end >= latency()) {
         end = latency() - 1;
     }
  
     for (int cycle = start; cycle <= end; cycle++) {
         if (AssocTools::containsKey(opReads_[cycle], operand) ||
             AssocTools::containsKey(opWrites_[cycle], operand)) {
             const string procName =
                 "ExecutionPipeline::checkOperandAvailability";
             throw NotAvailable(__FILE__, __LINE__, procName);
         }
     }
 }

References AssocTools::containsKey(), latency(), opReads_, and opWrites_.

Referenced by addPortRead(), and addPortWrite().

Here is the call graph for this function:

◆ checkOutputOperand()

void TTAMachine::ExecutionPipeline::checkOutputOperand ( int operand ) const

private

Checks whether the given operand is an output operand.

The operand is an output operand if it is written by the pipeline already.

Parameters

operand The operand.

Exceptions

OutOfRange	If the given operand is smaller than 1.
WrongOperandType	If the operand is read by the pipeline.

Definition at line 804 of file ExecutionPipeline.cc.

                                                        {
     const string procName = "ExecutionPipeline::checkOutputOperand";
  
     if (operand < 1) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (isOperandRead(operand)) {
         throw WrongOperandType(__FILE__, __LINE__, procName);
     }
 }

References isOperandRead().

Referenced by addPortWrite().

Here is the call graph for this function:

◆ checkResourceAvailability()

void TTAMachine::ExecutionPipeline::checkResourceAvailability	(	const std::string &	resource,
		int	start,
		int	duration
	)		const

private

Checks whether the given resource is available all the time of the given time interval.

Parameters

resource	Name of the pipeline resource.
start	The start cycle.
duration	Duration of the usage.

Exceptions

NotAvailable If the given resource is not available.

Definition at line 826 of file ExecutionPipeline.cc.

                                                               {
     PipelineElement* element = pipelineElement(resource);
     if (element == NULL) {
         return;
     }
  
     int end = start + duration - 1;
     if (end >= latency()) {
         end = latency() - 1;
     }
  
     for (int cycle = start; cycle <= end; cycle++) {
         if (AssocTools::containsKey(resourceUsage_[cycle], element)) {
             const string procName =
                 "ExecutionPipeline::checkResourceAvailability";
             throw NotAvailable(__FILE__, __LINE__, procName);
         }
     }
 }

References AssocTools::containsKey(), latency(), pipelineElement(), and resourceUsage_.

Referenced by addResourceUse().

Here is the call graph for this function:

◆ checkResourceName()

void TTAMachine::ExecutionPipeline::checkResourceName ( const std::string & name )

staticprivate

Checks whether the given name is valid for pipeline resource.

Parameters

name The name.

Exceptions

InvalidName If the name is not valid for pipeline resource.

Definition at line 765 of file ExecutionPipeline.cc.

                                                           {
     if (!MachineTester::isValidComponentName(name)) {
         const string procName = "ExecutionPipeline::checkResourceName";
         throw InvalidName(__FILE__, __LINE__, procName);
     }
 }

References MachineTester::isValidComponentName().

Referenced by addResourceUse().

Here is the call graph for this function:

◆ checkStartCycle()

void TTAMachine::ExecutionPipeline::checkStartCycle ( int startCycle ) const

private

Checks whether the pipeline would start too late if a new resource usage or operand read was added starting at given cycle.

Parameters

startCycle The start cycle.

Exceptions

OutOfRange	If the given cycle is negative.
StartTooLate	If the pipeline would start too late.

Definition at line 723 of file ExecutionPipeline.cc.

                                                        {
     const string procName = "ExecutionPipeline::checkStartCycle";
  
     if (startCycle < 0) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (startCycle > 1) {
         if (latency() == 0) {
             throw StartTooLate(__FILE__, __LINE__, procName);
         } else if (latency() == 1 && resourceUsage_[0].empty() &&
                    opReads_[0].empty()) {
             throw StartTooLate(__FILE__, __LINE__, procName);
         } else if (latency() >= 2 && resourceUsage_[0].empty() && 
                    resourceUsage_[1].empty() && opReads_[0].empty() &&
                    opReads_[1].empty()) {
             throw StartTooLate(__FILE__, __LINE__, procName);
         }
     }
 }

References latency(), opReads_, and resourceUsage_.

Referenced by addPortRead(), and addResourceUse().

Here is the call graph for this function:

◆ firstCycle()

int TTAMachine::ExecutionPipeline::firstCycle ( ) const

private

Returns the first cycle when a resource is used or a port read by this pipeline.

Returns -1 if no resource is used or port read by this pipeline.

Returns: The first cycle or -1.

Definition at line 1097 of file ExecutionPipeline.cc.

                                     {
  
     int latency = this->latency();
  
     for (int cycle = 0; cycle < latency; cycle++) {
         if (!resourceUsage_[cycle].empty() || !opReads_[cycle].empty()) {
             return cycle;
         }
     }
  
     return -1;
 }

References latency(), opReads_, and resourceUsage_.

Referenced by firstCycleWithoutOperandUse(), and firstCycleWithoutResource().

Here is the call graph for this function:

◆ firstCycleWithoutOperandUse()

int TTAMachine::ExecutionPipeline::firstCycleWithoutOperandUse	(	int	operand,
		int	cycle
	)		const

private

Returns the first cycle when a resource is used or port read if usage of the given operand is removed from the given cycle.

Returns -1 if no resource is used.

Parameters

operand	The operand.
cycle	The cycle.

Returns: The first cycle or -1.

Definition at line 1201 of file ExecutionPipeline.cc.

                      {
  
     int currentFirstCycle = firstCycle();
     if (currentFirstCycle != cycle) {
         return currentFirstCycle;
     }
  
  
     if (opReads_[cycle].size() > 1 ||
         (opReads_[cycle].size() == 1 &&
          !AssocTools::containsKey(opReads_[cycle], operand))) {
         return cycle;
     }
  
     if (!resourceUsage_[cycle].empty()) {
         return cycle;
     }
  
     int latency = this->latency();
     for (int i = cycle + 1; i < latency; i++) {
         if (!resourceUsage_[i].empty() || !opReads_[i].empty()) {
             return i;
         }
     }
  
     return -1;
 }

References AssocTools::containsKey(), firstCycle(), latency(), opReads_, and resourceUsage_.

Referenced by removeOperandUse().

Here is the call graph for this function:

◆ firstCycleWithoutResource() [1/2]

int TTAMachine::ExecutionPipeline::firstCycleWithoutResource ( const std::string & resource ) const

private

Returns the first cycle when a resource is used or port read by this pipeline if the given pipeline resource is not used.

Returns -1 if no resource is used or port read.

Parameters

resource Name of the pipeline resource.

Returns: The first cycle or -1.

Definition at line 1121 of file ExecutionPipeline.cc.

                                      {
  
     PipelineElement* element = pipelineElement(resource);
     if (element == NULL) {
         return firstCycle();
     }
  
     int latency = this->latency();
     for (int i = 0; i < latency; i++) {
         if (!opReads_[i].empty()) {
             return i;
         }
         if (resourceUsage_[i].size() > 1 ||
             (resourceUsage_[i].size() == 1 &&
              !AssocTools::containsKey(resourceUsage_[i], element))) {
             return i;
         }
     }
  
     return -1;
 }

References AssocTools::containsKey(), firstCycle(), latency(), opReads_, pipelineElement(), and resourceUsage_.

Referenced by removeResourceUse().

Here is the call graph for this function:

◆ firstCycleWithoutResource() [2/2]

int TTAMachine::ExecutionPipeline::firstCycleWithoutResource	(	const std::string &	resource,
		int	cycle
	)		const

private

Returns the first cycle when a resource is used or port read if usage of the given resource is removed from the given cycle.

Returns -1 if no resource is used or port read.

Parameters

resource	Name of the pipeline resource.
cycle	The cycle when the pipeline resource is not used.

Returns: The first cycle or -1.

Definition at line 1156 of file ExecutionPipeline.cc.

                      {
  
     int currentFirstCycle = firstCycle();
     if (currentFirstCycle != cycle) {
         return currentFirstCycle;
     }
  
     PipelineElement* element = pipelineElement(resource);
     if (element == NULL) {
         return currentFirstCycle;
     }
  
     if (!opReads_[cycle].empty()) {
         return cycle;
     }
     if (resourceUsage_[cycle].size() > 1 ||
         (resourceUsage_[cycle].size() == 1 &&
          !AssocTools::containsKey(resourceUsage_[cycle], element))) {
         return cycle;
     }
  
     int latency = this->latency();
     for (int i = cycle + 1; i < latency; i++) {
         if (!opReads_[i].empty() || !resourceUsage_[i].empty()) {
             return i;
         }
     }
  
     return -1;
 }

References AssocTools::containsKey(), firstCycle(), latency(), opReads_, pipelineElement(), and resourceUsage_.

Here is the call graph for this function:

◆ internalAddPortUse()

void TTAMachine::ExecutionPipeline::internalAddPortUse	(	int	operand,
		int	start,
		int	duration,
		IOUsage &	toModify
	)

private

Internally adds use of the given operand.

Parameters

operand	The operand to add the usage for.
start	The start cycle of the operand usage.
duration	Duration of the operand usage.
toModify	The IOUsage to modify.

Definition at line 911 of file ExecutionPipeline.cc.

                        {
  
     if (start + duration > latency()) {
         adjustLatency(start + duration);
     }
  
     for (int cycle = start; cycle < start + duration; cycle++) {
         toModify[cycle].insert(operand);
     }
 }

References adjustLatency(), and latency().

Referenced by addPortRead(), and addPortWrite().

Here is the call graph for this function:

◆ internalAddResourceUse()

void TTAMachine::ExecutionPipeline::internalAddResourceUse	(	const std::string &	name,
		int	start,
		int	duration
	)

private

Internally adds the resource usage of the given resource at the given time interval.

Parameters

name	Name of the resource.
start	The start cycle.
duration	The duration of the usage.

Definition at line 884 of file ExecutionPipeline.cc.

                   {
  
     PipelineElement* used = pipelineElement(name);
     if (used == NULL) {
         used = addPipelineElement(name);
     }
  
     adjustLatency(start + duration);
  
     for (int cycle = start; cycle < start + duration; cycle++) {
         resourceUsage_[cycle].insert(used);
     }
 }

References addPipelineElement(), adjustLatency(), pipelineElement(), and resourceUsage_.

Referenced by addResourceUse().

Here is the call graph for this function:

◆ internalRemoveOperandUse()

void TTAMachine::ExecutionPipeline::internalRemoveOperandUse	(	int	operand,
		int	start,
		int	duration
	)

private

Internally removes the operand usage of the given operand at the given time interval.

Parameters

operand	The operand.
start	The start cycle.
duration	The duration of the usage to be removed.

Definition at line 971 of file ExecutionPipeline.cc.

                   {
  
     int end = start + duration - 1;
     if (end >= latency()) {
         end = latency() - 1;
     }
  
     for (int cycle = start; cycle <= end; cycle++) {
         ContainerTools::removeValueIfExists(opReads_[cycle], operand);
         ContainerTools::removeValueIfExists(opWrites_[cycle], operand);
     }
  
     adjustLatency(0);
 }

References adjustLatency(), latency(), opReads_, opWrites_, and ContainerTools::removeValueIfExists().

Referenced by removeOperandUse().

Here is the call graph for this function:

◆ internalRemoveResourceUse()

void TTAMachine::ExecutionPipeline::internalRemoveResourceUse	(	const std::string &	name,
		int	start,
		int	duration
	)

private

Internally removes the resource usage of the given resource at the given time interval.

Parameters

name	Name of the resource.
start	The start cycle.
duration	The duration of the usage to be removed.

Definition at line 936 of file ExecutionPipeline.cc.

                   {
  
     PipelineElement* toRemove = pipelineElement(name);
     if (toRemove == NULL) {
         return;
     }
  
     int end = start + duration - 1;
     if (end >= latency()) {
         end = latency() - 1;
     }
  
     for (int cycle = start; cycle <= end; cycle++) {
         ContainerTools::removeValueIfExists(resourceUsage_[cycle], toRemove);
     }
  
     adjustLatency(0);
  
     FunctionUnit* fu = parent_->parentUnit();
     fu->cleanup(name);
 }

References adjustLatency(), TTAMachine::FunctionUnit::cleanup(), latency(), parent_, TTAMachine::HWOperation::parentUnit(), pipelineElement(), ContainerTools::removeValueIfExists(), and resourceUsage_.

Referenced by removeResourceUse().

Here is the call graph for this function:

◆ isArchitectureEqual()

bool TTAMachine::ExecutionPipeline::isArchitectureEqual ( const ExecutionPipeline * pipeline ) const

Compares two ExecutionPipeline architectures.

Parameters

pipeline ExecutionPipeline to compare with.

Returns: True if the two ExecutionPipeline architectures are equal.

Definition at line 693 of file ExecutionPipeline.cc.

                                              {
     
     for (unsigned int i = 0; i < resourceUsage_.size(); i++) {
         ResourceSet::const_iterator iter = resourceUsage_[i].begin();
         for (; iter != resourceUsage_[i].end(); iter++) {
             if (!pipeline->isResourceUsed((*iter)->name(), i)) {
                 return false;
             }
         }
     }
     if (readOperands() != pipeline->readOperands()) {
         return false;
     }
     if (writtenOperands() != pipeline->writtenOperands()) {
         return false;
     }
     return true;
 }

References isResourceUsed(), readOperands(), resourceUsage_, and writtenOperands().

Here is the call graph for this function:

◆ isOperandBound()

bool TTAMachine::ExecutionPipeline::isOperandBound	(	const FUPort &	port,
		const OperandSet &	operands
	)		const

private

Checks whether the given port is bound to one of the operands in the given operand set.

Parameters

port	The port.
operands	The operands.

Returns: True if at least one of the operands is bound to the given port, otherwise false.

Definition at line 1035 of file ExecutionPipeline.cc.

                                       {
  
     for (OperandSet::const_iterator iter = operands.begin();
          iter != operands.end(); iter++) {
         if (parent_->port(*iter) == &port) {
             return true;
         }
     }
  
     return false;
 }

References parent_, and TTAMachine::HWOperation::port().

Referenced by isPortRead(), and isPortWritten().

Here is the call graph for this function:

◆ isOperandRead()

bool TTAMachine::ExecutionPipeline::isOperandRead ( int operand ) const

private

Checks whether the given operand is read by the pipeline.

Parameters

operand The operand.

Returns: True if the operand is read, otherwise false.

Definition at line 1076 of file ExecutionPipeline.cc.

                                                   {
     int latency = this->latency();
     for (int cycle = 0; cycle < latency; cycle++) {
         OperandSet cycleReads = opReads_[cycle];
         if (AssocTools::containsKey(cycleReads, operand)) {
             return true;
         }
     }
     return false;
 }

References AssocTools::containsKey(), latency(), and opReads_.

Referenced by checkOutputOperand().

Here is the call graph for this function:

◆ isOperandWritten()

bool TTAMachine::ExecutionPipeline::isOperandWritten ( int operand ) const

private

Checks whether the given operand is written by the pipeline.

Parameters

operand The operand.

Returns: True if the operand is written, otherwise false.

Definition at line 1057 of file ExecutionPipeline.cc.

                                                      {
     int latency = this->latency();
     for (int cycle = 0; cycle < latency; cycle++) {
         OperandSet cycleWrites = opWrites_[cycle];
         if (AssocTools::containsKey(cycleWrites, operand)) {
             return true;
         }
     }
     return false;
 }

References AssocTools::containsKey(), latency(), and opWrites_.

Referenced by checkInputOperand().

Here is the call graph for this function:

◆ isPortRead()

bool TTAMachine::ExecutionPipeline::isPortRead	(	const FUPort &	port,
		int	cycle
	)		const

Checks whether the given port is read at the given cycle by the pipeline.

Parameters

port	The port.
cycle	The cycle.

Returns: True if the port is read, otherwise false.

Exceptions

OutOfRange If the given cycle is negative.

Definition at line 362 of file ExecutionPipeline.cc.

                                                                  {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::isPortRead";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (cycle >= latency()) {
         return false;
     }
  
     OperandSet readOperands = opReads_[cycle];
     return (isOperandBound(port, readOperands));
 }

References isOperandBound(), latency(), opReads_, and readOperands().

Referenced by MachineStateBuilder::addPortToFU(), FullyConnectedCheck::connectFUPort(), ExecutionPipelineResourceTable::ExecutionPipelineResourceTable(), isPortUsed(), AddFUFromHDBDialog::onAdd(), HDB::FUArchitecture::portDirection(), and FUPortImplementationDialog::TransferDataToWindow().

Here is the call graph for this function:

◆ isPortUsed()

bool TTAMachine::ExecutionPipeline::isPortUsed	(	const FUPort &	port,
		int	cycle
	)		const

Checks whether the given port is used at the given cycle by the pipeline.

Parameters

port	The port.
cycle	The cycle.

Returns: True if the port is used, otherwise false.

Exceptions

OutOfRange If the given cycle is negative.

Definition at line 349 of file ExecutionPipeline.cc.

                                                                  {
     return isPortRead(port, cycle) || isPortWritten(port, cycle);
 }

References isPortRead(), and isPortWritten().

Referenced by ReservationTable::ReservationTable().

Here is the call graph for this function:

◆ isPortWritten()

bool TTAMachine::ExecutionPipeline::isPortWritten	(	const FUPort &	port,
		int	cycle
	)		const

Checks whether the given port is written at the given cycle by the pipeline.

Parameters

port	The port.
cycle	The cycle.

Returns: True if the port is written, otherwise false.

Exceptions

OutOfRange If the given cycle is negative.

Definition at line 386 of file ExecutionPipeline.cc.

                                                                     {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::isPortRead";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (cycle >= latency()) {
         return false;
     }
  
     OperandSet writtenOperands = opWrites_[cycle];
     return (isOperandBound(port, writtenOperands));
 }

References isOperandBound(), latency(), opWrites_, and writtenOperands().

Referenced by MachineStateBuilder::addPortToFU(), FullyConnectedCheck::connectFUPort(), ExecutionPipelineResourceTable::ExecutionPipelineResourceTable(), isPortUsed(), AddFUFromHDBDialog::onAdd(), HDB::FUArchitecture::portDirection(), and FUPortImplementationDialog::TransferDataToWindow().

Here is the call graph for this function:

◆ isResourceUsed()

bool TTAMachine::ExecutionPipeline::isResourceUsed	(	const std::string &	name,
		int	cycle
	)		const

Tells whether a given pipeline element is used in the given cycle by this pipeline.

Parameters

name	Name of the pipeline element.
cycle	Cycle in which element use is to be tested.

Returns: True if the element is in use in the given cycle.

Exceptions

OutOfRange If the given cycle is negative.

Definition at line 300 of file ExecutionPipeline.cc.

                                                                         {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::isResourceUsed";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (latency() <= cycle) {
         return false;
     }
  
     PipelineElement* resource = pipelineElement(name);
     if (resource == NULL) {
         return false;
     }
  
     ResourceSet usedResources = resourceUsage_[cycle];
     return (AssocTools::containsKey(usedResources, resource));
 }

References AssocTools::containsKey(), latency(), pipelineElement(), resourceUsage_, and usedResources().

Referenced by HDB::HDBManager::addFUArchitecture(), TTAMachine::FunctionUnit::cleanup(), ExecutionPipelineResourceTable::ExecutionPipelineResourceTable(), HDBToHtml::fuArchToHtml(), isArchitectureEqual(), HDB::HDBManager::isMatchingArchitecture(), HDB::FUArchitecture::operator==(), ReservationTable::ReservationTable(), OperationDialog::updateResourceGrid(), and OperationDialog::warnOnResourcesWithoutUsages().

Here is the call graph for this function:

◆ latency() [1/2]

int TTAMachine::ExecutionPipeline::latency ( ) const

Returns the latency of the pipeline.

If the pipeline is totally empty, returns 0.

Returns: The latency of the pipeline.

Definition at line 482 of file ExecutionPipeline.cc.

                                  {
     assert(resourceUsage_.size() == opReads_.size());
     assert(resourceUsage_.size() == opWrites_.size());
     return resourceUsage_.size();
 }

References assert, opReads_, opWrites_, and resourceUsage_.

Referenced by HDB::HDBManager::addFUArchitecture(), MachineStateBuilder::addPortToFU(), adjustLatency(), checkOperandAvailability(), FUValidator::checkOperandBindings(), FUValidator::checkOperations(), checkResourceAvailability(), checkStartCycle(), TTAMachine::FunctionUnit::cleanup(), ExecutionPipelineResourceTable::ExecutionPipelineResourceTable(), firstCycle(), firstCycleWithoutOperandUse(), firstCycleWithoutResource(), internalAddPortUse(), internalRemoveOperandUse(), internalRemoveResourceUse(), isOperandRead(), isOperandWritten(), isPortRead(), isPortWritten(), isResourceUsed(), TTAMachine::HWOperation::latency(), latency(), OperationDialog::onDeleteOperand(), readOperands(), removeOperandUse(), removeResourceUse(), resourceUsages(), TTAMachine::ResourceVector::ResourceVector(), OperationDialog::updateOperandList(), OperationDialog::updateResourceGrid(), OperationDialog::updateUsageGrid(), usedResources(), OperationDialog::warnOnResourcesWithoutUsages(), and writtenOperands().

◆ latency() [2/2]

int TTAMachine::ExecutionPipeline::latency ( int output ) const

Returns the latency for the given output.

Parameters

output The number of the output.

Returns: The latency for the given output.

Exceptions

IllegalParameters If the given output is not written in the pipeline.

Definition at line 498 of file ExecutionPipeline.cc.

                                            {
     int cycle = latency();
     for (IOUsage::const_reverse_iterator iter = opWrites_.rbegin(); 
          iter != opWrites_.rend(); iter++) {
         if (AssocTools::containsKey(*iter, output)) {
             return cycle;
         }
         cycle--;
     }
  
     const string msg =
         (boost::format("Latency for operand index %d was not found for "
             "operation '%s' on unit '%s'!") % output % parent_->name()
             % parent_->parentUnit()->name()).str();
     throw IllegalParameters(__FILE__, __LINE__, __func__, msg);
 }

References __func__, AssocTools::containsKey(), latency(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), opWrites_, parent_, and TTAMachine::HWOperation::parentUnit().

Here is the call graph for this function:

◆ loadState()

void TTAMachine::ExecutionPipeline::loadState ( const ObjectState * pipelineState )

virtual

Loads the state of pipeline from the given ObjectState tree.

Parameters

pipelineState An ObjectState tree representing state of a pipeline.

Exceptions

ObjectStateLoadingException If an error occurs while loading state.

Implements Serializable.

Definition at line 611 of file ExecutionPipeline.cc.

                                                              {
     const string procName = "ExecutionPipeline::loadState";
  
     if (pipelineState->name() != OSNAME_PIPELINE) {
         throw ObjectStateLoadingException(__FILE__, __LINE__, procName);
     }
  
     removeAllResourceUses();
     ObjectStateTable childTable = sortResourceUsages(pipelineState);
     MOMTextGenerator textGen;
  
     try {
         for (ObjectStateTable::const_iterator iter = childTable.begin();
              iter != childTable.end(); iter++) {
             const ObjectState* usage = *iter;
             int startCycle = usage->intAttribute(OSKEY_START_CYCLE);
             int cycles = usage->intAttribute(OSKEY_CYCLES);
             int operand = 0;
             string resourceName;
  
             try {
  
                 if (usage->name() == OSNAME_RESOURCE_USAGE) {
                     resourceName = usage->stringAttribute(
                         OSKEY_RESOURCE_NAME);
                     addResourceUse(resourceName, startCycle, cycles);
                 } else if (usage->name() == OSNAME_OPERAND_READ) {
                     operand = usage->intAttribute(OSKEY_OPERAND);
                     addPortRead(operand, startCycle, cycles);
                 } else if (usage->name() == OSNAME_OPERAND_WRITE) {
                     operand = usage->intAttribute(OSKEY_OPERAND);
                     addPortWrite(operand, startCycle, cycles);
                 } else {
                     throw ObjectStateLoadingException(
                         __FILE__, __LINE__, procName);
                 }
  
             } catch (const WrongOperandType&) {
                 format errorMsg = textGen.text(
                     MOMTextGenerator::TXT_PORT_READ_AND_WRITTEN_BY_PIPELINE);
                 errorMsg % operand % parent_->name() %
                     parent_->parentUnit()->name();
                 throw ObjectStateLoadingException(
                     __FILE__, __LINE__, procName, errorMsg.str());
  
             } catch (const InvalidName&) {
                 format errorMsg = textGen.text(
                     MOMTextGenerator::TXT_INVALID_NAME);
                 errorMsg % resourceName;
                 throw ObjectStateLoadingException(
                     __FILE__, __LINE__, procName, errorMsg.str());
  
             } catch (const StartTooLate&) {
                 format errorMsg = textGen.text(
                     MOMTextGenerator::TXT_PIPELINE_START_TOO_LATE);
                 errorMsg % parent_->name() % parent_->parentUnit()->name() %
                     startCycle;
                 throw ObjectStateLoadingException(
                     __FILE__, __LINE__, procName, errorMsg.str());
  
             } catch (const NotAvailable&) {
                 format errorMsg = textGen.text(
                     MOMTextGenerator::TXT_PIPELINE_NOT_CANONICAL);
                 errorMsg % parent_->name() % parent_->parentUnit()->name();
                 throw ObjectStateLoadingException(
                     __FILE__, __LINE__, errorMsg.str());
             }
         }
  
     } catch (const Exception& exception) {
         throw ObjectStateLoadingException(
             __FILE__, __LINE__, procName, exception.errorMessage());
     }
 }

References addPortRead(), addPortWrite(), addResourceUse(), Exception::errorMessage(), ObjectState::intAttribute(), TTAMachine::HWOperation::name(), ObjectState::name(), TTAMachine::Component::name(), OSKEY_CYCLES, OSKEY_OPERAND, OSKEY_RESOURCE_NAME, OSKEY_START_CYCLE, OSNAME_OPERAND_READ, OSNAME_OPERAND_WRITE, OSNAME_PIPELINE, OSNAME_RESOURCE_USAGE, parent_, TTAMachine::HWOperation::parentUnit(), removeAllResourceUses(), sortResourceUsages(), ObjectState::stringAttribute(), Texts::TextGenerator::text(), MOMTextGenerator::TXT_INVALID_NAME, MOMTextGenerator::TXT_PIPELINE_NOT_CANONICAL, MOMTextGenerator::TXT_PIPELINE_START_TOO_LATE, and MOMTextGenerator::TXT_PORT_READ_AND_WRITTEN_BY_PIPELINE.

Referenced by TTAMachine::HWOperation::loadState().

Here is the call graph for this function:

◆ parentOperation()

const HWOperation * TTAMachine::ExecutionPipeline::parentOperation ( ) const

Returns the parent HWOperation.

Returns: The parent.

Definition at line 89 of file ExecutionPipeline.cc.

                                          {
     return parent_;
 }

References parent_.

Referenced by ExecutionPipeline(), and TTAMachine::ResourceVector::ResourceVector().

◆ pipelineElement()

PipelineElement * TTAMachine::ExecutionPipeline::pipelineElement ( const std::string & name ) const

private

Returns the pipeline element by the given name.

Parameters

name The name.

Returns: The pipeline element or NULL if there is no such pipeline element.

Definition at line 1259 of file ExecutionPipeline.cc.

                                                               {
     FunctionUnit* fu = parent_->parentUnit();
     return fu->pipelineElement(name);
 }

References parent_, TTAMachine::HWOperation::parentUnit(), and TTAMachine::FunctionUnit::pipelineElement().

Referenced by checkResourceAvailability(), firstCycleWithoutResource(), internalAddResourceUse(), internalRemoveResourceUse(), isResourceUsed(), and removeResourceUse().

Here is the call graph for this function:

◆ readOperands() [1/2]

ExecutionPipeline::OperandSet TTAMachine::ExecutionPipeline::readOperands ( ) const

Returns a set of operands that are read by this pipeline.

Returns: The operand set.

Definition at line 448 of file ExecutionPipeline.cc.

                                       {
     OperandSet operands;
     for (int i = 0; i < latency(); i++) {
         OperandSet cycleOperands = readOperands(i);
         operands.insert(cycleOperands.begin(), cycleOperands.end());
     }
     return operands;
 }

References latency().

Referenced by isArchitectureEqual(), and isPortRead().

Here is the call graph for this function:

◆ readOperands() [2/2]

ExecutionPipeline::OperandSet TTAMachine::ExecutionPipeline::readOperands ( int cycle ) const

Returns the operands that are read at the given cycle.

Parameters

cycle The cycle.

Returns: Set of operand indexes.

Exceptions

OutOfRange If the cycle is smaller than 0.

Definition at line 408 of file ExecutionPipeline.cc.

                                                {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::readOperands";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (cycle >= latency()) {
         return OperandSet();
     }
  
     return opReads_[cycle];
 }

References latency(), and opReads_.

Referenced by HDB::HDBManager::addFUArchitecture(), OperationBindingCheck::check(), FUValidator::checkOperandBindings(), FUValidator::checkOperations(), ADFCombiner::connectVectorLSU(), llvm::LLVMTCEBuilder::emitOperationMacro(), HDBToHtml::fuArchToHtml(), isArchitectureEqual(), HDB::HDBManager::isMatchingArchitecture(), OperationDialog::onDeleteOperand(), OperationDialog::onOperandLClick(), HDB::FUArchitecture::operator==(), TTAMachine::ResourceVector::ResourceVector(), OperationDialog::updateOperandList(), and OperationDialog::updateUsageGrid().

Here is the call graph for this function:

◆ removeAllResourceUses()

void TTAMachine::ExecutionPipeline::removeAllResourceUses ( )

Removes the all the usages of resources.

Definition at line 243 of file ExecutionPipeline.cc.

                                          {
  
     ResourceSet usedResources = this->usedResources();
  
     resourceUsage_.clear();
     opWrites_.clear();
     opReads_.clear();
  
     FunctionUnit* parent = parent_->parentUnit();
  
     // clean up pipeline elements
     for (ResourceSet::const_iterator iter = usedResources.begin();
          iter != usedResources.end(); iter++) {
         parent->cleanup((*iter)->name());
     }
 }

References TTAMachine::FunctionUnit::cleanup(), opReads_, opWrites_, parent_, TTAMachine::HWOperation::parentUnit(), resourceUsage_, and usedResources().

Referenced by loadState(), and ~ExecutionPipeline().

Here is the call graph for this function:

◆ removeOperandUse()

void TTAMachine::ExecutionPipeline::removeOperandUse	(	int	operand,
		int	cycle
	)

Removes reads and writes of the given operand at the given cycle.

Parameters

operand	The operand.
cycle	The cycle.

Exceptions

OutOfRange	If the given cycle is less than 0 or the given operand is smaller than 1.
StartTooLate	If the pipeline does not start by resource usage or operand read at cycle 0 or 1.

Definition at line 272 of file ExecutionPipeline.cc.

                                                           {
     const string procName = "ExecutionPipeline::removeOperandUse";
  
     if (cycle < 0 || operand < 1) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (latency() <= cycle) {
         return;
     }
  
     if (firstCycleWithoutOperandUse(operand, cycle) > 1) {
         throw StartTooLate(__FILE__, __LINE__, procName);
     }
  
     internalRemoveOperandUse(operand, cycle, 1);
 }

References firstCycleWithoutOperandUse(), internalRemoveOperandUse(), and latency().

Referenced by OperationDialog::onDeleteOperand(), and OperationDialog::onOperandLClick().

Here is the call graph for this function:

◆ removeResourceUse() [1/2]

void TTAMachine::ExecutionPipeline::removeResourceUse ( const std::string & name )

Removes any usage of given pipeline element in the pipeline.

Parameters

name	Name of the pipeline element.

Exceptions

StartTooLate If the pipeline does not start by resource usage or operand read at cycle 0 or 1.

Definition at line 189 of file ExecutionPipeline.cc.

                                                           {
     const string procName = "ExecutionPipeline::removeResourceUse";
  
     FunctionUnit* fu = parent_->parentUnit();
     if (!fu->hasPipelineElement(name)) {
         return;
     }
  
     if (firstCycleWithoutResource(name) > 1) {
         throw StartTooLate(__FILE__, __LINE__, procName);
     }
  
     internalRemoveResourceUse(name, 0, latency());
 }

References firstCycleWithoutResource(), TTAMachine::FunctionUnit::hasPipelineElement(), internalRemoveResourceUse(), latency(), parent_, and TTAMachine::HWOperation::parentUnit().

Referenced by OperationDialog::onResourceLClick(), and TTAMachine::PipelineElement::~PipelineElement().

Here is the call graph for this function:

◆ removeResourceUse() [2/2]

void TTAMachine::ExecutionPipeline::removeResourceUse	(	const std::string &	name,
		int	cycle
	)

Removes any usage of given pipeline element in given cycle from the pipeline.

Parameters

name	Name of the pipeline element.
cycle	Cycle in which element use is to be removed.

Exceptions

OutOfRange	If the given cycle is negative.
StartTooLate	If the pipeline does not start by resource usage or operand read at cycle 0 or 1.

Definition at line 215 of file ExecutionPipeline.cc.

                                                                      {
     const string procName = "ExecutionPipeline::removeResourceUse";
  
     if (pipelineElement(name) == NULL) {
         return;
     }
  
     if (cycle < 0) {
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (latency() <= cycle) {
         return;
     }
  
     if (cycle == 0 || cycle == 1) {
         if (firstCycleWithoutResource(name, cycle) > 1) {
             throw StartTooLate(__FILE__, __LINE__, procName);
         }
     }
  
     internalRemoveResourceUse(name, cycle, 1);
 }

References firstCycleWithoutResource(), internalRemoveResourceUse(), latency(), and pipelineElement().

Here is the call graph for this function:

◆ resourceUsages()

ExecutionPipeline::ResourceSet TTAMachine::ExecutionPipeline::resourceUsages ( int cycle ) const

Returns the resource usages in the given cycle.

Parameters

cycle Cycle of which resource usages to return.

Returns: True if the element is in use in the given cycle.

Exceptions

OutOfRange If the given cycle is negative.

Definition at line 327 of file ExecutionPipeline.cc.

                                                  {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::isResourceUsed";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (latency() <= cycle) {
         return ResourceSet();
     }
  
     return resourceUsage_[cycle];
 }

References latency(), and resourceUsage_.

Referenced by TTAMachine::ResourceVector::ResourceVector().

Here is the call graph for this function:

◆ saveOperandUse()

void TTAMachine::ExecutionPipeline::saveOperandUse	(	int	operand,
		int	cycleToSave,
		ObjectState *	pipelineState,
		const std::string &	osName
	)

staticprivate

Saves use of an operand to ObjectState tree.

Parameters

operand	The operand.
cycleToSave	The cycle to save.
pipelineState	ObjectState instance representing the state of the pipeline.
osName	Name of the ObjectState instance in which to save the operand use.

Definition at line 1334 of file ExecutionPipeline.cc.

                              {
  
     bool found = false;
  
     for (int i = 0; i < pipelineState->childCount(); i++) {
         ObjectState* child = pipelineState->child(i);
         if (child->name() == osName &&
             child->intAttribute(OSKEY_OPERAND) == operand) {
  
             int cycles = child->intAttribute(OSKEY_CYCLES);
             if (child->intAttribute(OSKEY_START_CYCLE) + cycles ==
                 cycleToSave) {
                 child->setAttribute(OSKEY_CYCLES, cycles + 1);
                 found = true;
                 break;
             }
         }
     }
  
     if (!found) {
         ObjectState* operandUsage = new ObjectState(osName);
         pipelineState->addChild(operandUsage);
         operandUsage->setAttribute(OSKEY_OPERAND, operand);
         operandUsage->setAttribute(OSKEY_START_CYCLE, cycleToSave);
         operandUsage->setAttribute(OSKEY_CYCLES, 1);
     }
 }

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), ObjectState::intAttribute(), ObjectState::name(), OSKEY_CYCLES, OSKEY_OPERAND, OSKEY_START_CYCLE, and ObjectState::setAttribute().

Referenced by saveState().

Here is the call graph for this function:

◆ saveResourceUse()

void TTAMachine::ExecutionPipeline::saveResourceUse	(	const PipelineElement *	element,
		int	cycleToSave,
		ObjectState *	pipelineState
	)

staticprivate

Saves usage of a pipeline element to ObjectState tree.

Parameters

element	The pipelineElement used.
cycleToSave	The cycle to save.
pipelineState	ObjectState instance representing the state of the pipeline.

Definition at line 1290 of file ExecutionPipeline.cc.

                                 {
  
     string elementName = element->name();
     bool resourceFound = false;
  
     for (int i = 0; i < pipelineState->childCount(); i++) {
         ObjectState* child = pipelineState->child(i);
         if (child->name() == OSNAME_RESOURCE_USAGE &&
             child->stringAttribute(OSKEY_RESOURCE_NAME) == elementName) {
  
             int cycles = child->intAttribute(OSKEY_CYCLES);
             if (child->intAttribute(OSKEY_START_CYCLE) + cycles ==
                 cycleToSave) {
                 child->setAttribute(OSKEY_CYCLES, cycles + 1);
                 resourceFound = true;
                 break;
             }
         }
     }
  
     if (!resourceFound) {
         ObjectState* resource = new ObjectState(OSNAME_RESOURCE_USAGE);
         pipelineState->addChild(resource);
         resource->setAttribute(OSKEY_RESOURCE_NAME, elementName);
         resource->setAttribute(OSKEY_START_CYCLE, cycleToSave);
         resource->setAttribute(OSKEY_CYCLES, 1);
     }
 }

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), ObjectState::intAttribute(), TTAMachine::PipelineElement::name(), ObjectState::name(), OSKEY_CYCLES, OSKEY_RESOURCE_NAME, OSKEY_START_CYCLE, OSNAME_RESOURCE_USAGE, ObjectState::setAttribute(), and ObjectState::stringAttribute().

Referenced by saveState().

Here is the call graph for this function:

◆ saveState()

ObjectState * TTAMachine::ExecutionPipeline::saveState ( ) const

virtual

Saves the pipeline to ObjectState tree.

Returns: The newly created ObjectState tree.

Implements Serializable.

Definition at line 551 of file ExecutionPipeline.cc.

                                    {
  
     ObjectState* pipelineState = new ObjectState(OSNAME_PIPELINE);
  
     // save resources usages in different ObjectState instances
     int cycle = 0;
     for (ResourceUsage::const_iterator resUsageIter = resourceUsage_.begin();
          resUsageIter != resourceUsage_.end(); resUsageIter++) {
  
         ResourceSet cycleUsage = *resUsageIter;
         for (ResourceSet::const_iterator cycleUsageIter = cycleUsage.begin();
              cycleUsageIter != cycleUsage.end(); cycleUsageIter++) {
             PipelineElement* element = *cycleUsageIter;
             saveResourceUse(element, cycle, pipelineState);
         }
         cycle++;
     }
  
     // save operand reads in different ObjectState instances
     cycle = 0;
     for (IOUsage::const_iterator readsIter = opReads_.begin();
          readsIter != opReads_.end(); readsIter++) {
  
         OperandSet operands = *readsIter;
         for (OperandSet::const_iterator opIter = operands.begin();
              opIter != operands.end(); opIter++) {
             int operand = *opIter;
             saveOperandUse(
                 operand, cycle, pipelineState, OSNAME_OPERAND_READ);
         }
         cycle++;
     }
  
     // save operand writes in different ObjectState instances
     cycle = 0;
     for (IOUsage::const_iterator writesIter = opWrites_.begin();
          writesIter != opWrites_.end(); writesIter++) {
  
         OperandSet operands = *writesIter;
         for (OperandSet::const_iterator opIter = operands.begin();
              opIter != operands.end(); opIter++) {
             int operand = *opIter;
             saveOperandUse(
                 operand, cycle, pipelineState, OSNAME_OPERAND_WRITE);
         }
         cycle++;
     }
  
     return pipelineState;
 }

References opReads_, opWrites_, OSNAME_OPERAND_READ, OSNAME_OPERAND_WRITE, OSNAME_PIPELINE, resourceUsage_, saveOperandUse(), and saveResourceUse().

Referenced by TTAMachine::HWOperation::saveState().

Here is the call graph for this function:

◆ slack()

int TTAMachine::ExecutionPipeline::slack ( int input ) const

Returns the slack of the given input.

The slack tells how many cycles AFTER the trigger, opcode-setting move is scheduled, can the operand be scheduled (and still affect correctly the result of the operation).

Parameters

input The number of the input.

Returns: The slack of the given input.

Exceptions

IllegalParameters If the given input is not read in the pipeline.

Definition at line 528 of file ExecutionPipeline.cc.

                                         {
     int slack(0);
     for (IOUsage::const_iterator iter = opReads_.begin();
          iter != opReads_.end(); iter++) {
         if (AssocTools::containsKey(*iter, input)) {
             return slack;
         }
         slack++;
     }
  
     const string errMessage = "Propably broken operand binding in operation:"
     + parent_->name() + " in FU: " + parent_->parentUnit()->name();
  
     const string procName = "ExecutionPipeline::slack";
     throw IllegalParameters(__FILE__, __LINE__, procName, errMessage);
 }

References AssocTools::containsKey(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), opReads_, parent_, and TTAMachine::HWOperation::parentUnit().

Referenced by TTAMachine::HWOperation::slack().

Here is the call graph for this function:

◆ sortResourceUsages()

ExecutionPipeline::ObjectStateTable TTAMachine::ExecutionPipeline::sortResourceUsages ( const ObjectState * pipelineState ) const

private

Sorts the resource and operand usages by the start cycle of the usage.

Parameters

pipelineState An ObjectState instance representing an execution pipeline.

Returns: A vector of ObjectState instances each of them representing a resource or operand usage.

Exceptions

ObjectStateLoadingException If the given ObjectState instance is invalid.

Definition at line 1378 of file ExecutionPipeline.cc.

                                                                             {
     ObjectStateTable usages;
     for (int i = 0; i < pipelineState->childCount(); i++) {
         ObjectState* usageState = pipelineState->child(i);
         addResourceUsage(usages, usageState);
     }
  
     return usages;
 }

References addResourceUsage(), ObjectState::child(), and ObjectState::childCount().

Referenced by loadState().

Here is the call graph for this function:

◆ usedResources()

ExecutionPipeline::ResourceSet TTAMachine::ExecutionPipeline::usedResources ( ) const

private

Returns the pipeline resources used by this pipeline.

Returns: The pipeline resources used by this pipeline.

Definition at line 1238 of file ExecutionPipeline.cc.

                                        {
  
     ResourceSet resources;
     int latency = this->latency();
  
     for (int cycle = 0; cycle < latency; cycle++) {
         ResourceSet cycleResources = resourceUsage_[cycle];
         resources.insert(cycleResources.begin(), cycleResources.end());
     }
  
     return resources;
 }

References latency(), and resourceUsage_.

Referenced by isResourceUsed(), and removeAllResourceUses().

Here is the call graph for this function:

◆ writtenOperands() [1/2]

ExecutionPipeline::OperandSet TTAMachine::ExecutionPipeline::writtenOperands ( ) const

Returns a set of operands that are written by this pipeline.

Returns: The operand set.

Definition at line 464 of file ExecutionPipeline.cc.

                                          {
     OperandSet operands;
     for (int i = 0; i < latency(); i++) {
         OperandSet cycleOperands = writtenOperands(i);
         operands.insert(cycleOperands.begin(), cycleOperands.end());
     }
     return operands;
 }

References latency().

Referenced by isArchitectureEqual(), and isPortWritten().

Here is the call graph for this function:

◆ writtenOperands() [2/2]

ExecutionPipeline::OperandSet TTAMachine::ExecutionPipeline::writtenOperands ( int cycle ) const

Returns the operands that are written at the given cycle.

Parameters

cycle The cycle.

Returns: Set of operand indexes.

Exceptions

OutOfRange If the given cycle is smaller than 0.

Definition at line 429 of file ExecutionPipeline.cc.

                                                   {
     if (cycle < 0) {
         const string procName = "ExecutionPipeline::readOperands";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     if (cycle >= latency()) {
         return OperandSet();
     }
  
     return opWrites_[cycle];
 }

References latency(), and opWrites_.

Referenced by HDB::HDBManager::addFUArchitecture(), OperationBindingCheck::check(), FUValidator::checkOperandBindings(), ADFCombiner::connectVectorLSU(), llvm::LLVMTCEBuilder::emitOperationMacro(), ExecutionPipelineResourceTable::ExecutionPipelineResourceTable(), HDBToHtml::fuArchToHtml(), isArchitectureEqual(), HDB::HDBManager::isMatchingArchitecture(), OperationDialog::onDeleteOperand(), OperationDialog::onOperandLClick(), HDB::FUArchitecture::operator==(), TTAMachine::ResourceVector::ResourceVector(), OperationDialog::updateOperandList(), and OperationDialog::updateUsageGrid().

Here is the call graph for this function:

Member Data Documentation

◆ opReads_

IOUsage TTAMachine::ExecutionPipeline::opReads_

private

Operand reads.

Definition at line 176 of file ExecutionPipeline.hh.

Referenced by addPortRead(), adjustLatency(), checkOperandAvailability(), checkStartCycle(), firstCycle(), firstCycleWithoutOperandUse(), firstCycleWithoutResource(), internalRemoveOperandUse(), isOperandRead(), isPortRead(), latency(), readOperands(), removeAllResourceUses(), saveState(), and slack().

◆ opWrites_

IOUsage TTAMachine::ExecutionPipeline::opWrites_

private

Operand writes.

Definition at line 178 of file ExecutionPipeline.hh.

Referenced by addPortWrite(), adjustLatency(), checkOperandAvailability(), internalRemoveOperandUse(), isOperandWritten(), isPortWritten(), latency(), removeAllResourceUses(), saveState(), and writtenOperands().

◆ OSKEY_CYCLES

const string TTAMachine::ExecutionPipeline::OSKEY_CYCLES = "cycles"

static

ObjectState attribute key for duration of a resource usage.

Definition at line 111 of file ExecutionPipeline.hh.

Referenced by loadState(), saveOperandUse(), and saveResourceUse().

◆ OSKEY_OPERAND

const string TTAMachine::ExecutionPipeline::OSKEY_OPERAND = "operand"

static

ObjectState attribute key for operand number.

Definition at line 107 of file ExecutionPipeline.hh.

Referenced by loadState(), and saveOperandUse().

◆ OSKEY_RESOURCE_NAME

const string TTAMachine::ExecutionPipeline::OSKEY_RESOURCE_NAME = "res_name"

static

ObjectState attribute key for name of resource.

Definition at line 105 of file ExecutionPipeline.hh.

Referenced by loadState(), and saveResourceUse().

◆ OSKEY_START_CYCLE

const string TTAMachine::ExecutionPipeline::OSKEY_START_CYCLE = "start_cycle"

static

ObjectState attribute key for start cycle of a resource usage.

Definition at line 109 of file ExecutionPipeline.hh.

Referenced by addResourceUsage(), loadState(), saveOperandUse(), and saveResourceUse().

◆ OSNAME_OPERAND_READ

const string TTAMachine::ExecutionPipeline::OSNAME_OPERAND_READ = "op_read"

static

ObjectState name for operand read.

Definition at line 101 of file ExecutionPipeline.hh.

Referenced by loadState(), and saveState().

◆ OSNAME_OPERAND_WRITE

const string TTAMachine::ExecutionPipeline::OSNAME_OPERAND_WRITE = "op_write"

static

ObjectState name for operand write.

Definition at line 103 of file ExecutionPipeline.hh.

Referenced by loadState(), and saveState().

◆ OSNAME_PIPELINE

const string TTAMachine::ExecutionPipeline::OSNAME_PIPELINE = "pipeline"

static

ObjectState name for ExecutionPipeline.

Definition at line 97 of file ExecutionPipeline.hh.

Referenced by TTAMachine::HWOperation::loadState(), loadState(), and saveState().

◆ OSNAME_RESOURCE_USAGE

const string TTAMachine::ExecutionPipeline::OSNAME_RESOURCE_USAGE = "resource_usage"

static

ObjectState name for pipeline resource usage.

Definition at line 99 of file ExecutionPipeline.hh.

Referenced by loadState(), and saveResourceUse().

◆ parent_

HWOperation* TTAMachine::ExecutionPipeline::parent_

private

The parent operation.

Definition at line 180 of file ExecutionPipeline.hh.

Referenced by addPipelineElement(), internalRemoveResourceUse(), isOperandBound(), latency(), loadState(), parentOperation(), pipelineElement(), removeAllResourceUses(), removeResourceUse(), and slack().

◆ resourceUsage_

ResourceUsage TTAMachine::ExecutionPipeline::resourceUsage_

private

Resource usage.

Definition at line 174 of file ExecutionPipeline.hh.

Referenced by adjustLatency(), checkResourceAvailability(), checkStartCycle(), firstCycle(), firstCycleWithoutOperandUse(), firstCycleWithoutResource(), internalAddResourceUse(), internalRemoveResourceUse(), isArchitectureEqual(), isResourceUsed(), latency(), removeAllResourceUses(), resourceUsages(), saveState(), and usedResources().

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

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ IOUsage

◆ ObjectStateTable

◆ OperandSet

◆ ResourceSet

◆ ResourceUsage

Constructor & Destructor Documentation

◆ ExecutionPipeline()

◆ ~ExecutionPipeline()

Member Function Documentation

◆ addPipelineElement()

◆ addPortRead()

◆ addPortWrite()

◆ addResourceUsage()

◆ addResourceUse()

◆ adjustLatency()

◆ checkDuration()

◆ checkInputOperand()

◆ checkOperandAvailability()

◆ checkOutputOperand()

◆ checkResourceAvailability()

◆ checkResourceName()

◆ checkStartCycle()

◆ firstCycle()

◆ firstCycleWithoutOperandUse()

◆ firstCycleWithoutResource() [1/2]

◆ firstCycleWithoutResource() [2/2]

◆ internalAddPortUse()

◆ internalAddResourceUse()

◆ internalRemoveOperandUse()

◆ internalRemoveResourceUse()

◆ isArchitectureEqual()

◆ isOperandBound()

◆ isOperandRead()

◆ isOperandWritten()

◆ isPortRead()

◆ isPortUsed()

◆ isPortWritten()

◆ isResourceUsed()

◆ latency() [1/2]

◆ latency() [2/2]

◆ loadState()

◆ parentOperation()

◆ pipelineElement()

◆ readOperands() [1/2]

◆ readOperands() [2/2]

◆ removeAllResourceUses()

◆ removeOperandUse()

◆ removeResourceUse() [1/2]

◆ removeResourceUse() [2/2]

◆ resourceUsages()

◆ saveOperandUse()

◆ saveResourceUse()

◆ saveState()

◆ slack()

◆ sortResourceUsages()

◆ usedResources()

◆ writtenOperands() [1/2]

◆ writtenOperands() [2/2]

Member Data Documentation

◆ opReads_

◆ opWrites_

◆ OSKEY_CYCLES

◆ OSKEY_OPERAND

◆ OSKEY_RESOURCE_NAME

◆ OSKEY_START_CYCLE

◆ OSNAME_OPERAND_READ

◆ OSNAME_OPERAND_WRITE

◆ OSNAME_PIPELINE

◆ OSNAME_RESOURCE_USAGE

◆ parent_