HDB::FUArchitecture Class Reference

#include <FUArchitecture.hh>

Inheritance diagram for HDB::FUArchitecture:

Collaboration diagram for HDB::FUArchitecture:

Classes
struct	PipelineElementUsage
	Struct PipelineElementUsage. More...

Public Member Functions
	FUArchitecture (TTAMachine::FunctionUnit *fu)
	FUArchitecture (const FUArchitecture &o)
virtual	~FUArchitecture ()
bool	hasParameterizedWidth (const std::string &port) const
void	setParameterizedWidth (const std::string &port)
bool	hasGuardSupport (const std::string &port) const
void	setGuardSupport (const std::string &port)
TTAMachine::FunctionUnit &	architecture () const
HDB::Direction	portDirection (const std::string &port) const
bool	operator== (const FUArchitecture &rightHand) const
Public Member Functions inherited from HWBlockArchitecture
virtual	~HWBlockArchitecture ()
bool	hasID () const
void	setID (RowID id)
RowID	id () const

Private Types
typedef std::vector< PipelineElementUsage >	PipelineElementUsageTable
	typedef for PipelineElemetnUsageTable More...
typedef std::set< std::string >	PortSet
	Set type for port names. More...

Private Attributes
TTAMachine::FunctionUnit *	fu_
	The function unit. More...
PortSet	parameterizedPorts_
	Parameterized ports. More...
PortSet	guardedPorts_
	Port that support guard. More...

Additional Inherited Members
Protected Member Functions inherited from HWBlockArchitecture
	HWBlockArchitecture ()

Detailed Description

Represents architecture of an FU in HDB.

Definition at line 55 of file FUArchitecture.hh.

Member Typedef Documentation

PipelineElementUsageTable

typedef std::vector<PipelineElementUsage> HDB::FUArchitecture::PipelineElementUsageTable

private

typedef for PipelineElemetnUsageTable

Definition at line 78 of file FUArchitecture.hh.

PortSet

typedef std::set<std::string> HDB::FUArchitecture::PortSet

private

Set type for port names.

Definition at line 81 of file FUArchitecture.hh.

Constructor & Destructor Documentation

FUArchitecture() [1/2]

HDB::FUArchitecture::FUArchitecture

(

TTAMachine::FunctionUnit *

fu

)

The constructor.

Parameters

fu	The function unit of which architecture is represented. Becomes property of the FUArchitecture object.

Definition at line 55 of file FUArchitecture.cc.

                                                         : fu_(fu) {
}

FUArchitecture() [2/2]

HDB::FUArchitecture::FUArchitecture

(

const FUArchitecture &

original

)

Copy constructor.

Parameters

original

FUArchitecture to copy.

Definition at line 63 of file FUArchitecture.cc.

                                                             :
    HWBlockArchitecture(original) {
 
    fu_ = original.fu_->copy();
    parameterizedPorts_ = original.parameterizedPorts_;
    guardedPorts_ = original.guardedPorts_;
}

References TTAMachine::FunctionUnit::copy(), fu_, guardedPorts_, and parameterizedPorts_.

Here is the call graph for this function:

~FUArchitecture()

HDB::FUArchitecture::~FUArchitecture ( )

virtual

The destructor.

Definition at line 74 of file FUArchitecture.cc.

                                {
    delete fu_;
}

References fu_.

Member Function Documentation

architecture()

TTAMachine::FunctionUnit & HDB::FUArchitecture::architecture

(

)

const

Returns the FunctionUnit instance that represents the architecture.

Returns

The FunctionUnit instance.

Definition at line 131 of file FUArchitecture.cc.

                                   {
    return *fu_;
}

References fu_.

Referenced by AddFUFromHDBDialog::acceptToList(), HDB::HDBManager::addFUArchitecture(), HDB::HDBManager::addFUImplementation(), ProGe::NetlistGenerator::addFUToNetlist(), HDB::HDBManager::addOperationPipelinesToFUArchitecture(), HDB::HDBManager::addPortsAndBindingsToFUArchitecture(), CostDatabase::buildFunctionUnits(), FUTestbenchGenerator::createMachineState(), FUTestbenchGenerator::createStimulus(), FUTestbenchGenerator::createStimulusArrays(), FUTestbenchGenerator::createTbCode(), FUTestbenchGenerator::createTbInstantiation(), AddFUImplementationCmd::Do(), HDBEditorModifyCmd::Do(), ComponentImplementationSelector::fuArchsByOpSetWithMinLatency(), HDBToHtml::fuArchToHtml(), ImplementationTester::fuFullyPipelined(), ImplementationTester::fuHasMemoryAccess(), HDB::HDBManager::isMatchingArchitecture(), AddFUFromHDBDialog::loadHDB(), AddFUFromHDBDialog::onAdd(), FUArchitectureDialog::onOK(), ProGe::NetlistGenerator::opcodePortWidth(), operator==(), FUTestbenchGenerator::parseFuPorts(), portDirection(), FUTestbenchGenerator::readValuesFromOutPorts(), HDB::HDBManager::resolveArchitecturePort(), FUArchitectureDialog::update(), HDBBrowserWindow::update(), and FUTestbenchGenerator::writeInputPortStimulus().

hasGuardSupport()

bool HDB::FUArchitecture::hasGuardSupport

(

const std::string &

port

)

const

Tells whether the given port is guarded.

Parameters

port	Name of the port.

Returns

True if the port is guarded, otherwise false.

Definition at line 109 of file FUArchitecture.cc.

                                                           {
    return AssocTools::containsKey(guardedPorts_, port);
}

References AssocTools::containsKey(), and guardedPorts_.

Referenced by HDB::HDBManager::addFUArchitecture(), HDBToHtml::fuArchToHtml(), and FUArchitectureDialog::update().

Here is the call graph for this function:

hasParameterizedWidth()

bool HDB::FUArchitecture::hasParameterizedWidth

(

const std::string &

port

)

const

Tells whether the given port has parameterized width.

Parameters

port	Name of the port.

Returns

True if the port is parameterized, otherwise false.

Definition at line 86 of file FUArchitecture.cc.

                                                                 {
    return AssocTools::containsKey(parameterizedPorts_, port);
}

References AssocTools::containsKey(), and parameterizedPorts_.

Referenced by HDB::HDBManager::addFUArchitecture(), CostDatabase::buildFunctionUnits(), HDBToHtml::fuArchToHtml(), HDB::HDBManager::isMatchingArchitecture(), ProGe::NetlistGenerator::isParameterizable(), BlockImplementationDialog::onHDBSelection(), operator==(), and FUArchitectureDialog::update().

Here is the call graph for this function:

operator==()

bool HDB::FUArchitecture::operator==

(

const FUArchitecture &

rightHand

)

const

Checks whether the given FU has a mathing architecture with the given FU architecture instance.

Parameters

rightHand

Right hand operand.

Returns

True if the architectures match, otherwise false.

Definition at line 196 of file FUArchitecture.cc.

                                                                {
 
    if (rightHand.architecture().operationCount() != 
        this->architecture().operationCount()) {
        return false;
    }
    
    std::map<const FUPort*, const FUPort*> portMap;
    for (int i = 0; i < rightHand.architecture().operationPortCount(); i++) {
        portMap.insert(
            std::pair<const FUPort*, const FUPort*>(
                rightHand.architecture().operationPort(i), NULL));
    }
    
    PipelineElementUsageTable plineElementUsages;
 
    for (int i = 0; i < rightHand.architecture().operationCount(); i++) {
        HWOperation* rightHandOp = rightHand.architecture().operation(i);
        if (!architecture().hasOperation(rightHandOp->name())) {
            return false;
        }
        HWOperation* thisOp = architecture().operation(
            rightHandOp->name());
        if (rightHandOp->latency() != thisOp->latency()) {
            return false;
        }
        
        // check operand bindings
        for (int i = 0;
             i < rightHand.architecture().operationPortCount();
             i++) {
            
            FUPort* port = rightHand.architecture().operationPort(i);
            if (rightHandOp->isBound(*port)) {
                int io = rightHandOp->io(*port);
                FUPort* samePort = thisOp->port(io);
                if (samePort == NULL) {
                    return false;
                }
                const FUPort* existingSamePort =
                    MapTools::valueForKey<const FUPort*>(portMap, port);
                if (existingSamePort != NULL &&
                    existingSamePort != samePort) {
                    return false;
                }
                
                // check the width of the ports
                // widths must equal
                if (hasParameterizedWidth(samePort->name()) !=
                    rightHand.hasParameterizedWidth(port->name())) {
                    return false;
                }
 
                // if the FUArchitectures have parameterized port width
                // those ports widths are not needed to check
                if (!hasParameterizedWidth(samePort->name()) &&
                    samePort->width() != port->width()) {
                    return false;
                }
                
                if (port->isOpcodeSetting() != samePort->isOpcodeSetting() ||
                    port->isTriggering() != samePort->isTriggering()) {
                    return false;
                }
                portMap.erase(port);
                portMap.insert(
                    std::pair<const FUPort*, const FUPort*>(port, samePort));
            }
        }
        
        // check operation pipeline
        ExecutionPipeline* opPipeline =  rightHandOp->pipeline();
        ExecutionPipeline* thisOpPipeline = thisOp->pipeline();
        for (int cycle = 0; cycle < rightHandOp->latency(); cycle++) {
            ExecutionPipeline::OperandSet written1 = 
                opPipeline->writtenOperands(cycle);
            ExecutionPipeline::OperandSet written2 = 
                thisOpPipeline->writtenOperands(cycle);
            if (written1 != written2) {
                return false;
            }
            ExecutionPipeline::OperandSet read1 = 
                opPipeline->readOperands(cycle);
            ExecutionPipeline::OperandSet read2 = 
                thisOpPipeline->readOperands(cycle);
            if (read1 != read2) {
                return false;
            }
            
            PipelineElementUsage usage;
            for (int i = 0;
                 i < rightHand.architecture().pipelineElementCount();
                 i++) {
                
                const PipelineElement* elem =
                    rightHand.architecture().pipelineElement(i);
                if (opPipeline->isResourceUsed(elem->name(),cycle)) {
                    usage.usage1.insert(elem);
                }
            }
            
            for (int i = 0; i < architecture().pipelineElementCount(); i++) {
                const PipelineElement* elem = 
                    architecture().pipelineElement(i);
                if (thisOpPipeline->isResourceUsed(elem->name(), cycle)) {
                    usage.usage2.insert(elem);
                }
            }
            plineElementUsages.push_back(usage);
        }
    }
 
    std::set<const TTAMachine::PipelineElement*> difference;
    for (size_t i = 0; i < plineElementUsages.size(); i++) {
        AssocTools::difference(plineElementUsages[i].usage1,
                               plineElementUsages[i].usage2,
                               difference);
    }
    if (!difference.empty()) {
        return false;
    }
    return true;
}

References architecture(), AssocTools::difference(), hasParameterizedWidth(), TTAMachine::HWOperation::io(), TTAMachine::HWOperation::isBound(), TTAMachine::FUPort::isOpcodeSetting(), TTAMachine::ExecutionPipeline::isResourceUsed(), TTAMachine::FUPort::isTriggering(), TTAMachine::HWOperation::latency(), TTAMachine::PipelineElement::name(), TTAMachine::HWOperation::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::HWOperation::pipeline(), TTAMachine::FunctionUnit::pipelineElement(), TTAMachine::FunctionUnit::pipelineElementCount(), TTAMachine::HWOperation::port(), TTAMachine::ExecutionPipeline::readOperands(), HDB::FUArchitecture::PipelineElementUsage::usage1, HDB::FUArchitecture::PipelineElementUsage::usage2, TTAMachine::BaseFUPort::width(), and TTAMachine::ExecutionPipeline::writtenOperands().

Here is the call graph for this function:

portDirection()

HDB::Direction HDB::FUArchitecture::portDirection

(

const std::string &

portName

)

const

Tells the direction of the given port.

Parameters

portName

Name of the port in the FU architecture.

Exceptions

InstanceNotFound	If the FU architecture does not have the given port.
InvalidData	If the given port is not used by any pipeline.

Definition at line 145 of file FUArchitecture.cc.

                                                             {
    FunctionUnit& fu = architecture();
    if (!fu.hasOperationPort(portName)) {
        throw InstanceNotFound(__FILE__, __LINE__, __func__);
    }
 
    FUPort* port = fu.operationPort(portName);
    bool read = false;
    bool written = false;
    
    int operationCount = fu.operationCount();
    for (int i = 0; i < operationCount; i++) {
        HWOperation* operation = fu.operation(i);
        ExecutionPipeline* pLine = operation->pipeline();
        int latency = operation->latency();
        for (int cycle = 0; cycle < latency; cycle++) {
            if (!read) {
                if (pLine->isPortRead(*port, cycle)) {
                    read = true;
                }
            }
            if (!written) {
                if (pLine->isPortWritten(*port, cycle)) {
                    written = true;
                }
            }
        }
        if (read && written) {
            break;
        }
    }
 
    if (read && written) {
        return HDB::BIDIR;
    } else if (read) {
        return HDB::IN;
    } else if (written) {
        return HDB::OUT;
    } else {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
}

References __func__, architecture(), HDB::BIDIR, TTAMachine::FunctionUnit::hasOperationPort(), HDB::IN, TTAMachine::ExecutionPipeline::isPortRead(), TTAMachine::ExecutionPipeline::isPortWritten(), TTAMachine::HWOperation::latency(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), HDB::OUT, and TTAMachine::HWOperation::pipeline().

Referenced by ProGe::NetlistGenerator::addFUToNetlist().

Here is the call graph for this function:

setGuardSupport()

void HDB::FUArchitecture::setGuardSupport

(

const std::string &

port

)

Sets guard support for the given port.

Parameters

port	Name of the port.

Definition at line 120 of file FUArchitecture.cc.

                                                     {
    guardedPorts_.insert(port);
}

References guardedPorts_.

Referenced by HDB::HDBManager::addPortsAndBindingsToFUArchitecture(), and FUArchitectureDialog::onOK().

setParameterizedWidth()

void HDB::FUArchitecture::setParameterizedWidth

(

const std::string &

port

)

Sets parameterized width for the given port.

Parameters

port	Name of the port.

Definition at line 97 of file FUArchitecture.cc.

                                                           {
    parameterizedPorts_.insert(port);
}

References parameterizedPorts_.

Referenced by HDB::HDBManager::addPortsAndBindingsToFUArchitecture(), and FUArchitectureDialog::onOK().

Member Data Documentation

fu_

TTAMachine::FunctionUnit* HDB::FUArchitecture::fu_

private

The function unit.

Definition at line 84 of file FUArchitecture.hh.

Referenced by architecture(), FUArchitecture(), and ~FUArchitecture().

guardedPorts_

PortSet HDB::FUArchitecture::guardedPorts_

private

Port that support guard.

Definition at line 88 of file FUArchitecture.hh.

Referenced by FUArchitecture(), hasGuardSupport(), and setGuardSupport().

parameterizedPorts_

PortSet HDB::FUArchitecture::parameterizedPorts_

private

Parameterized ports.

Definition at line 86 of file FUArchitecture.hh.

Referenced by FUArchitecture(), hasParameterizedWidth(), and setParameterizedWidth().

---

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

• FUArchitecture.hh
• FUArchitecture.cc