#include <UniversalFunctionUnit.hh>

Inheritance diagram for UniversalFunctionUnit:

Collaboration diagram for UniversalFunctionUnit:

Public Member Functions
	UniversalFunctionUnit (const std::string &name, OperationPool &opPool)

virtual	~UniversalFunctionUnit ()

virtual bool	hasOperation (const std::string &name) const

virtual TTAMachine::HWOperation *	operation (const std::string &name) const

virtual void	addPipelineElement (TTAMachine::PipelineElement &element)

virtual void	loadState (const ObjectState *state)

int	portCountWithWidth (int width) const

TTAMachine::FUPort &	portWithWidth (int index, int width) const

Public Member Functions inherited from TTAMachine::FunctionUnit
	FunctionUnit (const std::string &name)

	FunctionUnit (const ObjectState *state)

virtual	~FunctionUnit ()

virtual FunctionUnit *	copy () const

virtual void	setName (const std::string &name)

virtual BaseFUPort *	port (const std::string &name) const

virtual BaseFUPort *	port (int index) const

virtual int	operationPortCount () const

virtual bool	hasOperationPort (const std::string &name) const

virtual FUPort *	operationPort (const std::string &name) const

virtual FUPort *	operationPort (int index) const

virtual BaseFUPort *	triggerPort () const

virtual void	addOperation (HWOperation &operation)

virtual void	deleteOperation (HWOperation &operation)

virtual bool	hasOperationLowercase (const std::string &name) const

virtual HWOperation *	operationLowercase (const std::string &name) const

virtual HWOperation *	operation (int index) const

virtual int	operationCount () const

virtual void	operationNames (TCETools::CIStringSet &opNames) const

virtual int	maxLatency () const

virtual void	deletePipelineElement (PipelineElement &element)

virtual int	pipelineElementCount () const

virtual PipelineElement *	pipelineElement (int index) const

virtual bool	hasPipelineElement (const std::string &name) const

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

virtual AddressSpace *	addressSpace () const

virtual void	setAddressSpace (AddressSpace *as)

virtual bool	hasAddressSpace () const

virtual void	cleanup (const std::string &resource)

virtual void	unsetMachine ()

virtual ObjectState *	saveState () const

virtual bool	isArchitectureEqual (const FunctionUnit *fu, const bool checkPortWidths=true) const

bool	needsConflictDetection () const

virtual int	orderNumber () const

virtual void	setOrderNumber (int)

Public Member Functions inherited from TTAMachine::Unit
virtual	~Unit ()

virtual bool	hasPort (const std::string &name) const

virtual int	portCount () const

virtual int	outputPortCount (bool countBidir=false) const

virtual int	inputPortCount (bool countBidir=false) const

virtual int	bidirPortCount () const

virtual void	setMachine (Machine &mach)

Public Member Functions inherited from TTAMachine::Component
virtual	~Component ()

virtual TCEString	name () const

virtual Machine *	machine () const

virtual void	ensureRegistration (const Component &component) const

virtual bool	isRegistered () const

Public Member Functions inherited from Serializable
virtual	~Serializable ()

Static Public Member Functions
static bool	is32BitOperation (const std::string &opName)

Static Public Attributes
static const std::string	OC_SETTING_PORT_32 = "OCSetting32"
	Name of the 32 bit wide opcode setting port.

static const std::string	OC_SETTING_PORT_64 = "OCSetting64"
	Name of the 64 bit wide opcode setting port.

Static Public Attributes inherited from TTAMachine::FunctionUnit
static const std::string	OSNAME_FU = "fu"
	ObjectState name for function unit.

static const std::string	OSKEY_AS = "as"
	ObjectState attribute key for name of the address space.

static const std::string	OSKEY_ORDER_NUMBER = "order_no"
	ObjectState attribute key for FU order number name.

Static Public Attributes inherited from TTAMachine::Unit
static const std::string	OSNAME_UNIT = "unit"
	ObjectState name for Unit.

Static Public Attributes inherited from TTAMachine::Component
static const std::string	OSNAME_COMPONENT = "component"
	ObjectState name for component.

static const std::string	OSKEY_NAME = "name"
	ObjectState attribute key for the name of the component.

Private Member Functions
SmartHWOperation &	addSupportedOperation (const Operation &operation)

void	ensureInputPorts (int width, int count)

void	ensureOutputPorts (int width, int count)

Private Attributes
OperationPool &	opPool_
	Operation pool from which the operations are searched.

Static Private Attributes
static const std::string	OPERATIONS_OF_32_BITS []
	Table of names of 32 bit operations.

Additional Inherited Members
Protected Member Functions inherited from TTAMachine::FunctionUnit
void	unsetMachineDerived ()

Protected Member Functions inherited from TTAMachine::Unit
	Unit (const std::string &name)

	Unit (const ObjectState *state)

virtual void	removePort (Port &port)

Protected Member Functions inherited from TTAMachine::Component
	Component (const std::string &name)

	Component (const ObjectState *state)

void	internalSetMachine (Machine &machine)

void	internalUnsetMachine ()

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

virtual	~MachinePart ()

Detailed Description

UniversalFunctionUnit class represents a function unit which has all the operations of an operation pool. The operations are added on demand, not at construction.

Definition at line 50 of file UniversalFunctionUnit.hh.

Constructor & Destructor Documentation

◆ UniversalFunctionUnit()

UniversalFunctionUnit::UniversalFunctionUnit	(	const std::string &	name,
		OperationPool &	opPool
	)

The constructor.

Parameters

name	Name of the function unit.
opPool	The operation pool from which the operations are obtained on demand.

Exceptions

InvalidName If the given name is not a valid component name.

Definition at line 64 of file UniversalFunctionUnit.cc.

66 : FunctionUnit(name), opPool_(opPool) {}

TTAMachine::Component::name

virtual TCEString name() const

Definition MachinePart.cc:125

TTAMachine::FunctionUnit

Definition FunctionUnit.hh:55

UniversalFunctionUnit::opPool_

OperationPool & opPool_

Operation pool from which the operations are searched.

Definition UniversalFunctionUnit.hh:76

◆ ~UniversalFunctionUnit()

UniversalFunctionUnit::~UniversalFunctionUnit ( )

virtual

The destructor.

Definition at line 71 of file UniversalFunctionUnit.cc.

71 {

72}

Member Function Documentation

◆ addPipelineElement()

void UniversalFunctionUnit::addPipelineElement ( TTAMachine::PipelineElement & element )

virtual

Aborts the program. It should not be needed to add pipeline elements to universal function unit.

Parameters

element Never used.

Exceptions

ComponentAlreadyExists Never thrown.

Reimplemented from TTAMachine::FunctionUnit.

Definition at line 131 of file UniversalFunctionUnit.cc.

                                                          {
    const string procName = "UniversalFunctionUnit::addPipelineElement";
    const string errorMsg =
        "Tried to add pipeline element to UniversalFunctionUnit!";
    Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
    Application::abortProgram();
}

References Application::abortProgram(), and Application::writeToErrorLog().

Here is the call graph for this function:

◆ addSupportedOperation()

SmartHWOperation & UniversalFunctionUnit::addSupportedOperation ( const Operation & operation )

private

Adds the given operation to the function unit.

Adds input and/or output ports if there is not enough ports for the operands of the given operation. Operand bindings and pipeline are not created.

Parameters

operation The operation to be added.

Returns: The added operation.

Definition at line 228 of file UniversalFunctionUnit.cc.

                                                                       {
 
    int inputCount = operation.numberOfInputs();
    int outputCount = operation.numberOfOutputs();
 
    int operandWidth = is32BitOperation(operation.name()) ? 32 : 64;
 
    ensureInputPorts(operandWidth, inputCount);
    ensureOutputPorts(operandWidth, outputCount);
 
    // create the operation
    SmartHWOperation* hwOper = NULL;
    try {
        hwOper = new SmartHWOperation(operation, *this);
        return *hwOper;
    } catch (const InvalidName& exception) {
        const string procName = "UniversalFunctionUnit::addOperation";
        const string errorMsg =
            "Operation pool contained an operation with illegal"
            "name: " + string(operation.name());
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    } catch (...) {
        assert(false);
    }
 
    assert(false);
 
    // dummy return to avoid compilation warning
    return *hwOper;
}

References Application::abortProgram(), assert, ensureInputPorts(), ensureOutputPorts(), is32BitOperation(), TTAMachine::HWOperation::name(), TTAMachine::HWOperation::numberOfInputs(), TTAMachine::HWOperation::numberOfOutputs(), operation(), and Application::writeToErrorLog().

Referenced by operation().

Here is the call graph for this function:

◆ ensureInputPorts()

void UniversalFunctionUnit::ensureInputPorts	(	int	width,
		int	count
	)

private

Ensures that there is at least the given number of input ports of the given width.

Adds input ports if there is not enough ports.

Parameters

width	Bit width of the ports to be ensured.
count	The number of ports to be ensured.

Definition at line 271 of file UniversalFunctionUnit.cc.

                                                            {
 
    assert(width == 32 || width == 64);
 
    Socket* inputSocket = machine()->socketNavigator().item(
        UM_INPUT_SOCKET_NAME);
 
    int portCount = this->portCountWithWidth(width);
 
    // create opcode setting port if there are no ports at all
    if (count > 0 && portCount == 0) {
        string portName =
            width == 32 ? OC_SETTING_PORT_32 : OC_SETTING_PORT_64;
        FUPort* ocPort = new UniversalFUPort(
            portName, width, *this, true, true);
        portCount++;
        ocPort->attachSocket(*inputSocket);
    }
 
    // check the amount of matches
    int matches(1);
    for (int i = 1; i < portCount; i++) {
        FUPort& port = this->portWithWidth(i, width);
        assert(port.width() == width);
        if (port.inputSocket() != NULL) {
            matches++;
        }
    }
 
    // create new ports as necessary
    while (matches < count) {
        string portName = "i" + Conversion::toString(width) + "_" +
            Conversion::toString(matches);
        FUPort* newPort = new UniversalFUPort(
            portName, width, *this, false, false);
        newPort->attachSocket(*inputSocket);
        matches++;
    }
}

References assert, TTAMachine::Port::attachSocket(), TTAMachine::Port::inputSocket(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), OC_SETTING_PORT_32, OC_SETTING_PORT_64, TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), portCountWithWidth(), portWithWidth(), TTAMachine::Machine::socketNavigator(), Conversion::toString(), UM_INPUT_SOCKET_NAME, and TTAMachine::BaseFUPort::width().

Referenced by addSupportedOperation().

Here is the call graph for this function:

◆ ensureOutputPorts()

void UniversalFunctionUnit::ensureOutputPorts	(	int	width,
		int	count
	)

private

Ensures that there is at least the given number of output ports of the given width.

Adds output ports if there is not enough ports.

Parameters

width	Bit width of the ports to be ensured.
count	The number of ports to be ensured.

Definition at line 322 of file UniversalFunctionUnit.cc.

                                                             {
 
    Socket* outputSocket = 
        machine()->socketNavigator().item(UM_OUTPUT_SOCKET_NAME);
 
    // check the amount of matches
    int matches(0);
    for (int i = 0; i < portCountWithWidth(width); i++) {
        FUPort& port = this->portWithWidth(i, width);
        assert(port.width() == width);
        if (port.outputSocket() != NULL) {
            matches++;
        }
    }
 
    // create new ports as necessary
    while (matches < count) {
        string portName = "output" + Conversion::toString(width) + "_" +
            Conversion::toString(matches + 1);
        FUPort* newPort = new UniversalFUPort(
            portName, width, *this, false, false);
        newPort->attachSocket(*outputSocket);
        matches++;
    }
}

References assert, TTAMachine::Port::attachSocket(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), TTAMachine::Port::outputSocket(), TTAMachine::FunctionUnit::port(), portCountWithWidth(), portWithWidth(), TTAMachine::Machine::socketNavigator(), Conversion::toString(), UM_OUTPUT_SOCKET_NAME, and TTAMachine::BaseFUPort::width().

Referenced by addSupportedOperation().

Here is the call graph for this function:

◆ hasOperation()

bool UniversalFunctionUnit::hasOperation ( const std::string & name ) const

virtual

Tells whether the universal function unit has an operation of the given name.

Returns true even if the operation is not loaded yet but it exists in the operation pool.

Parameters

name	Name of the operation.

Reimplemented from TTAMachine::FunctionUnit.

Definition at line 85 of file UniversalFunctionUnit.cc.

                                                               {
    return &opPool_.operation(name.c_str()) != &NullOperation::instance();
}

References NullOperation::instance(), TTAMachine::Component::name(), OperationPool::operation(), and opPool_.

Referenced by llvm::LLVMTCEBuilder::emitOperationMacro().

Here is the call graph for this function:

◆ is32BitOperation()

bool UniversalFunctionUnit::is32BitOperation ( const std::string & opName )

static

Tells whether operation of the given name has 32 bits wide operands and return value.

Parameters

opName Name of the operation.

Returns: True if the operation has 32 bits wide operands and return value, otherwise false.

Definition at line 358 of file UniversalFunctionUnit.cc.

                                                               {
    int numberOfElements = sizeof(OPERATIONS_OF_32_BITS) / sizeof(string);
    for (int i = 0; i < numberOfElements; i++) {
        if (OPERATIONS_OF_32_BITS[i] == opName) {
            return true;
        }
    }
    return false;
}

References OPERATIONS_OF_32_BITS.

Referenced by addSupportedOperation(), and SmartHWOperation::SmartHWOperation().

◆ loadState()

void UniversalFunctionUnit::loadState ( const ObjectState * state )

virtual

Aborts the program. It is not allowed to load UniversalFunctionUnit from an ObjectState instance. DO NOT CALL THIS METHOD!

Parameters

state Never used.

Exceptions

ObjectStateLoadingException Never thrown.

Reimplemented from TTAMachine::FunctionUnit.

Definition at line 147 of file UniversalFunctionUnit.cc.

                                                   {
    const string procName = "UniversalFunctionUnit::loadState";
    const string errorMsg =
        "Tried to load state of UniversalFunctionUnit from an ObjectState "
        "tree!";
    Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
    Application::abortProgram();
}

References Application::abortProgram(), and Application::writeToErrorLog().

Here is the call graph for this function:

◆ operation()

TTAMachine::HWOperation * UniversalFunctionUnit::operation ( const std::string & name ) const

virtual

Returns an operation by the given name.

Adds the operation to the function unit if it doen't exist yet but exist in the operation pool.

Parameters

name	Name of the operation.

Exceptions

InstanceNotFound If an operation by the given name does not exist in the operation pool.

Returns: The operation.

Reimplemented from TTAMachine::FunctionUnit.

Definition at line 102 of file UniversalFunctionUnit.cc.

                                                            {
    const string procName = "UniversalFunctionUnit::operation";
 
    if (FunctionUnit::hasOperation(name)) {
        return FunctionUnit::operation(name);
    } else {
        Operation& oper = opPool_.operation(name.c_str());
 
        if (&oper == &NullOperation::instance()) {
            throw InstanceNotFound(__FILE__, __LINE__, procName);
        } else {
            // need to take non-const pointer of this FU to call non-const
            // method addOperation
            UniversalFunctionUnit* thisFU =
                const_cast<UniversalFunctionUnit*>(this);
            SmartHWOperation& hwOper = thisFU->addSupportedOperation(oper);
            return &hwOper;
        }
    }
}

References addSupportedOperation(), TTAMachine::FunctionUnit::hasOperation(), NullOperation::instance(), TTAMachine::Component::name(), OperationPool::operation(), TTAMachine::FunctionUnit::operation(), and opPool_.

Referenced by addSupportedOperation(), TTAProgram::CodeGenerator::createBreakOperation(), TTAProgram::CodeGenerator::createForLoopBufferInit(), TTAProgram::CodeGenerator::createTerminalFUPort(), TTAProgram::CodeGenerator::createWhileLoopBufferInit(), llvm::LLVMTCEBuilder::emitOperationMacro(), and CopyingDelaySlotFiller::getMove().

Here is the call graph for this function:

◆ portCountWithWidth()

int UniversalFunctionUnit::portCountWithWidth ( int width ) const

Returns the number of ports of the given bit width.

Parameters

width The bit width.

Returns: The number of ports of the given bit width.

Exceptions

OutOfRange If the given bit width is out of range.

Definition at line 164 of file UniversalFunctionUnit.cc.

                                                         {
    if (width < 1) {
        const string procName = "UniversalFunctionUnit::portCount";
        throw OutOfRange(__FILE__, __LINE__, procName);
    }
 
    int count(0);
 
    for (int i = 0; i < FunctionUnit::portCount(); i++) {
        if (FunctionUnit::port(i)->width() == width) {
            count++;
        }
    }
 
    return count;
}

References TTAMachine::FunctionUnit::port(), and TTAMachine::BaseFUPort::width().

Referenced by ensureInputPorts(), ensureOutputPorts(), SmartHWOperation::port(), and portWithWidth().

Here is the call graph for this function:

◆ portWithWidth()

FUPort & UniversalFunctionUnit::portWithWidth	(	int	index,
		int	width
	)		const

By the given index, returns a port which has the given bit width.

Parameters

index	The index.
width	The bit width.

Returns: A port of the given bit width.

Exceptions

OutOfRange If the given bit width or index is out of range.

Definition at line 190 of file UniversalFunctionUnit.cc.

                                                               {
    if (width < 1 || index >= portCountWithWidth(width)) {
        const string procName = "UniversalFunctionUnit::port";
        throw OutOfRange(__FILE__, __LINE__, procName);
    }
 
    int count(0);
    int portC = portCount();
    for (int i = 0; i < portC; i++) {
        auto p = port(i);
        TTAMachine::FUPort* port =
            dynamic_cast<FUPort*>(p);
        if (p != nullptr && port->width() == width) {
            count++;
            if (count > index) {
                return *port;
            }
        }
    }
 
    assert(false);
 
    // dummy return to avoid compilation warning
    FUPort* port = NULL;
    return *port;
}

References assert, TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), portCountWithWidth(), and TTAMachine::BaseFUPort::width().

Referenced by ensureInputPorts(), ensureOutputPorts(), and SmartHWOperation::port().

Here is the call graph for this function:

Member Data Documentation

◆ OC_SETTING_PORT_32

const string UniversalFunctionUnit::OC_SETTING_PORT_32 = "OCSetting32"

static

Name of the 32 bit wide opcode setting port.

Definition at line 66 of file UniversalFunctionUnit.hh.

Referenced by ensureInputPorts(), and SmartHWOperation::port().

◆ OC_SETTING_PORT_64

const string UniversalFunctionUnit::OC_SETTING_PORT_64 = "OCSetting64"

static

Name of the 64 bit wide opcode setting port.

Definition at line 68 of file UniversalFunctionUnit.hh.

Referenced by ensureInputPorts(), and SmartHWOperation::port().

◆ OPERATIONS_OF_32_BITS

const string UniversalFunctionUnit::OPERATIONS_OF_32_BITS

staticprivate

Initial value:

= {
    "ADD", "SUB", "LDW", "LDQ", "LDH", "STW", "STQ", "STH", "EQ", "GT",
    "GTU", "SHL", "SHR", "SHRU", "AND", "IOR", "XOR", "SYS", "JUMP", "CALL",
    "MIN", "MAX", "MINU", "MAXU", "SXQW", "SXHW", "NEG", "MUL", "DIV",
    "DIVU", "CFI", "CIF", "ROTL", "ROTR", "ABS", "LDQU", "LDHU"}

Table of names of 32 bit operations.

Definition at line 49 of file UniversalFunctionUnit.hh.

                            : public TTAMachine::FunctionUnit {
public:
    UniversalFunctionUnit(const std::string& name, OperationPool& opPool);
    virtual ~UniversalFunctionUnit();

Referenced by is32BitOperation().

◆ opPool_

OperationPool& UniversalFunctionUnit::opPool_

private

Operation pool from which the operations are searched.

Definition at line 76 of file UniversalFunctionUnit.hh.

Referenced by hasOperation(), and operation().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ UniversalFunctionUnit()

◆ ~UniversalFunctionUnit()

Member Function Documentation

◆ addPipelineElement()

◆ addSupportedOperation()

◆ ensureInputPorts()

◆ ensureOutputPorts()

◆ hasOperation()

◆ is32BitOperation()

◆ loadState()

◆ operation()

◆ portCountWithWidth()

◆ portWithWidth()

Member Data Documentation

◆ OC_SETTING_PORT_32

◆ OC_SETTING_PORT_64

◆ OPERATIONS_OF_32_BITS

◆ opPool_