Inheritance diagram for VectorLSGenerator:

Collaboration diagram for VectorLSGenerator:

Private Member Functions
	PLUGIN_DESCRIPTION ("Explorer plugin that creates wide load/store unit.")

	VectorLSGenerator ()

virtual bool	requiresStartingPointArchitecture () const

virtual bool	producesArchitecture () const

virtual bool	requiresHDB () const

virtual bool	requiresSimulationData () const

virtual bool	requiresApplication () const

virtual std::vector< RowID >	explore (const RowID &configurationID, const unsigned int &)

void	readParameters ()

void	addOperation (TTAMachine::FunctionUnit &lsUnit, Operation &op, bool scalar)

void	createVectorLSU (TTAMachine::FunctionUnit &lsUnit, TTAMachine::AddressSpace &addrSpace)

Private Attributes
ComponentImplementationSelector	selector_
	Selector used by the plugin.

int	nodeCount_

TCEString	addressSpaces_

Static Private Attributes
static const TCEString	NodeCountPN_

static const TCEString	AddressSpacesPN_

Additional Inherited Members
Public Types inherited from DesignSpaceExplorerPlugin
typedef std::pair< std::string, ExplorerPluginParameter >	Parameter

typedef std::map< std::string, ExplorerPluginParameter >	ParameterMap

typedef std::map< std::string, ExplorerPluginParameter >::iterator	PMIt

typedef std::map< std::string, ExplorerPluginParameter >::const_iterator	PMCIt

Public Member Functions inherited from DesignSpaceExplorerPlugin
virtual std::string	description () const

void	addParameter (TCEString name, ExplorerPluginParameterType type, bool compulsory=true, TCEString defaultValue="", TCEString description="")

template<typename T >
void	readCompulsoryParameter (const std::string paramName, T &param) const

template<typename T >
void	readOptionalParameter (const std::string paramName, T &param) const

template<typename RT >
RT	parameterValue (const std::string &paramName) const

virtual	~DesignSpaceExplorerPlugin ()

virtual void	giveParameter (const std::string &name, const std::string &value)

virtual std::string	name () const

virtual void	setPluginName (const std::string &pluginName)

virtual bool	hasParameter (const std::string &paramName) const

ParameterMap	parameters () const

virtual bool	booleanValue (const std::string &parameter) const

Public Member Functions inherited from DesignSpaceExplorer
	DesignSpaceExplorer ()

virtual	~DesignSpaceExplorer ()

virtual void	setDSDB (DSDBManager &dsdb)

virtual bool	evaluate (const DSDBManager::MachineConfiguration &configuration, CostEstimates &results=dummyEstimate_, bool estimate=false)

virtual DSDBManager &	db ()

std::vector< DesignSpaceExplorerPlugin * >	getPlugins ()

RowID	createImplementationAndStore (const DSDBManager::MachineConfiguration &conf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")

bool	createImplementation (const DSDBManager::MachineConfiguration &conf, DSDBManager::MachineConfiguration &newConf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")

IDF::MachineImplementation *	selectComponents (const TTAMachine::Machine &mach, const double &frequency=0.0, const double &maxArea=0.0, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb") const

void	createEstimateData (const TTAMachine::Machine &mach, const IDF::MachineImplementation &idf, CostEstimator::AreaInGates &area, CostEstimator::DelayInNanoSeconds &longestPathDelay)

RowID	addConfToDSDB (const DSDBManager::MachineConfiguration &conf)

Static Public Member Functions inherited from DesignSpaceExplorer
static DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &pluginName, DSDBManager *dsdb=NULL)

Protected Member Functions inherited from DesignSpaceExplorerPlugin
	DesignSpaceExplorerPlugin ()

void	checkParameters () const

Protected Member Functions inherited from DesignSpaceExplorer
TTAProgram::Program *	schedule (const std::string applicationFile, TTAMachine::Machine &machine, TCEString paramOptions="-O3")

const ExecutionTrace *	simulate (const TTAProgram::Program &program, const TTAMachine::Machine &machine, const TestApplication &testApplication, const ClockCycleCount &maxCycles, ClockCycleCount &runnedCycles, const bool tracing, const bool useCompiledSimulation=false, std::vector< ClockCycleCount > *executionCounts=NULL)

Protected Attributes inherited from DesignSpaceExplorerPlugin
std::string	pluginName_
	the name of the explorer plugin

ParameterMap	parameters_
	Parameters for the plugin.

Detailed Description

Explorer plugin that creates wide load store unit.

Supported parameters:

node_count, number of times the input architecture is copied to new one, default is 4.
address_spaces, semicolon separated names of the address spaces for which the LSUs will be created, default is 'data'

Definition at line 68 of file VectorLSGenerator.cc.

Constructor & Destructor Documentation

◆ VectorLSGenerator()

VectorLSGenerator::VectorLSGenerator ( )

inlineprivate

Definition at line 71 of file VectorLSGenerator.cc.

                       : DesignSpaceExplorerPlugin(), 
        nodeCount_(4),
        addressSpaces_("data") {
 
 
        // parameters that have a default value
        addParameter(NodeCountPN_, UINT, false, 
            Conversion::toString(nodeCount_));        
        addParameter(AddressSpacesPN_, STRING, false, 
            addressSpaces_);        
        
    }

References DesignSpaceExplorerPlugin::addParameter(), addressSpaces_, AddressSpacesPN_, nodeCount_, NodeCountPN_, STRING, Conversion::toString(), and UINT.

Here is the call graph for this function:

Member Function Documentation

◆ addOperation()

void VectorLSGenerator::addOperation	(	TTAMachine::FunctionUnit &	lsUnit,
		Operation &	op,
		bool	scalar
	)

inlineprivate

Adds operation to function unit, sets the port bindings and pipeline parameters.

Definition at line 185 of file VectorLSGenerator.cc.

                                                                    {
        
        TTAMachine::HWOperation* hwOp = 
            new TTAMachine::HWOperation(op.name(), lsUnit); 
        TTAMachine::ExecutionPipeline* pipeline = hwOp->pipeline();
        
        // Specificly define the triggering port
        hwOp->bindPort(1, *lsUnit.operationPort("in1t"));          
        pipeline->addPortRead(1,0,1);
        if (scalar) {
            if (op.numberOfInputs() == 2) {
                // this is stw operation
                hwOp->bindPort(2, *lsUnit.operationPort("in_extra2"));
                pipeline->addPortRead(2, 0, 1);
            }
            if (op.numberOfOutputs() == 1) {
                // this is ldw operation
                hwOp->bindPort(2, *lsUnit.operationPort("out_extra1"));
                pipeline->addPortWrite(2, 2, 1);
            }
            assert(hwOp->isBound(*lsUnit.operationPort("in1t")));            
            return;
        }
        // Add other inputs, after triggering port.
        for (int i = 1; i < op.numberOfInputs(); i++) {
            hwOp->bindPort(
                i+1, *lsUnit.operationPort("in" + Conversion::toString(i+1)));
            pipeline->addPortRead(i+1,0,1);            
        }
        // Add other outputs, after triggering port.        
        for (int i = 1; i <= op.numberOfOutputs(); i++) {
            hwOp->bindPort(
                i+1, *lsUnit.operationPort("out" + Conversion::toString(i)));
            pipeline->addPortWrite(i+1,2,1);                        
        }
        assert(hwOp->isBound(*lsUnit.operationPort("in1t")));
    }

References TTAMachine::ExecutionPipeline::addPortRead(), TTAMachine::ExecutionPipeline::addPortWrite(), assert, TTAMachine::HWOperation::bindPort(), TTAMachine::HWOperation::isBound(), Operation::name(), Operation::numberOfInputs(), Operation::numberOfOutputs(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::HWOperation::pipeline(), and Conversion::toString().

Referenced by createVectorLSU().

Here is the call graph for this function:

◆ createVectorLSU()

void VectorLSGenerator::createVectorLSU	(	TTAMachine::FunctionUnit &	lsUnit,
		TTAMachine::AddressSpace &	addrSpace
	)

inlineprivate

Create single instance of vector load store unit, starting from empty unit.

Definition at line 228 of file VectorLSGenerator.cc.

                                           {
        
        TTAMachine::FUPort* trigger = 
            new TTAMachine::FUPort("in1t", 
                MathTools::requiredBits(addrSpace.end()), 
                lsUnit, true, true);
        assert(trigger->isTriggering());
        int width = (nodeCount_ >= 8) ? 8 : 
            (nodeCount_ >= 4) ? 4 : 
            (nodeCount_ >= 2) ? 2 : 0;
        if (width == 0) {
            TCEString msg = "No reason for creating wide LSU since number" 
                " of nodes in cluster is just " + Conversion::toString(nodeCount_);
            throw Exception(
                __FILE__, __LINE__, __func__, msg);                                    
        }
        for (int i = 1; i <= width; i++) {
            TTAMachine::FUPort* inPort =
                new TTAMachine::FUPort(
                    "in" + Conversion::toString(i+1), 32, lsUnit, false, false);
            assert(inPort->isOpcodeSetting() == false);
            TTAMachine::FUPort* outPort =
                new TTAMachine::FUPort(
                    "out" + Conversion::toString(i), 32, lsUnit, false, false);                
            assert(outPort->isOpcodeSetting() == false);                
        }
        TTAMachine::FUPort* inPort =
            new TTAMachine::FUPort(
               "in_extra" + Conversion::toString(2), 32, lsUnit, false, false);
        assert(inPort->isOpcodeSetting() == false);
        TTAMachine::FUPort* outPort =
            new TTAMachine::FUPort(
               "out_extra" + Conversion::toString(1), 32, lsUnit, false, false);                
        assert(outPort->isOpcodeSetting() == false);                
        
        // Adds aditional read and write port for use with scalar load
        // and stores from the extras
        
        OperationPool pool;
        OperationIndex& index = pool.index();    
        for (int m = 0; m < index.moduleCount(); m++) {        
            OperationModule& module = index.module(m);        
            for (int i = 0; i < index.operationCount(module); i++) {
                TCEString opName = index.operationName(i, module);            
                Operation& op = pool.operation(opName.c_str());
                // Creates HWOperations for memory access operations with
                // number as suffix. ATM this means vector operation.
                if (op.usesMemory() && 
                    (opName.endsWith("2") ||
                    opName.endsWith("4") ||
                    opName.endsWith("8"))) {
                    if (!lsUnit.hasOperation(opName) && 
                        op.numberOfInputs() <= nodeCount_ +1 &&
                        op.numberOfOutputs() <= nodeCount_) {
                        addOperation(lsUnit, op, false);
                    }
                }
                if (op.usesMemory() && 
                    opName.startsWith("LD") &&
                    op.numberOfInputs() == 1 &&
                    op.numberOfOutputs() == 1 &&
                    !lsUnit.hasOperation(opName)) {
                    addOperation(lsUnit, op, true);                    
                }
                if (op.usesMemory() && 
                    opName.startsWith("ST") &&
                    op.numberOfInputs() == 2 &&
                    op.numberOfOutputs() == 0 &&
                    !lsUnit.hasOperation(opName)) {                
                    addOperation(lsUnit, op, true);                    
                }                
            }
        }
        
    }

References __func__, addOperation(), assert, TTAMachine::AddressSpace::end(), TCEString::endsWith(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::FUPort::isOpcodeSetting(), TTAMachine::FUPort::isTriggering(), OperationIndex::moduleCount(), nodeCount_, Operation::numberOfInputs(), Operation::numberOfOutputs(), OperationIndex::operationCount(), OperationIndex::operationName(), MathTools::requiredBits(), TCEString::startsWith(), Conversion::toString(), and Operation::usesMemory().

Referenced by explore().

Here is the call graph for this function:

◆ explore()

virtual std::vector< RowID > VectorLSGenerator::explore	(	const RowID &	configurationID,
		const unsigned int &
	)

inlineprivatevirtual

Explorer plugin that adds machine components to a given machine with adf parameter or with configuration id in dsdb.

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 95 of file VectorLSGenerator.cc.

                                                               {
        readParameters();
        std::vector<RowID> result;
 
        DSDBManager& dsdb = db();
        DSDBManager::MachineConfiguration conf = 
            dsdb.configuration(configurationID);
        TTAMachine::Machine* mach = NULL;
        try {
            mach = dsdb.architecture(conf.architectureID);
        } catch (const Exception& e) {
            throw Exception(
                __FILE__, __LINE__, __func__, e.errorMessageStack());            
        }
        
        const TTAMachine::Machine::AddressSpaceNavigator& addrNav = 
            mach->addressSpaceNavigator();
        TTAMachine::AddressSpace* addrSpace = NULL;
        std::vector<TCEString> addressSpaces = 
            StringTools::chopString(addressSpaces_, ";");
        for (unsigned int i = 0; i < addressSpaces.size(); i++) {
            if (!addrNav.hasItem(addressSpaces[i])) {
                TCEString msg = "Original architecture does not have \"" 
                    + addressSpaces[i] +"\" address space. Not adding Vector LSU.";
                throw Exception(
                    __FILE__, __LINE__, __func__, msg);                        
            }
 
            addrSpace = addrNav.item(addressSpaces[i]);
            
            if (addrSpace == NULL) {
            }
            TTAMachine::FunctionUnit* lsUnit = 
                new TTAMachine::FunctionUnit("VectorLSU_" + addrSpace->name());
 
            createVectorLSU(*lsUnit, *addrSpace);
            
            try {
                mach->addFunctionUnit(*lsUnit);
            } catch (const Exception& e) {
                throw Exception(
                    __FILE__, __LINE__, __func__, e.errorMessageStack());                                    
            }
            try {
                lsUnit->setAddressSpace(addrSpace);
            } catch (const Exception& e) {
                throw Exception(
                    __FILE__, __LINE__, __func__, e.errorMessageStack());                                                
            }
        }
        
        DSDBManager::MachineConfiguration tempConf;
        try {
            tempConf.architectureID = dsdb.addArchitecture(*mach);
            tempConf.hasImplementation = false;
        } catch (const RelationalDBException& e) {
            TCEString msg = "Error while adding ADF to the dsdb. "
                "ADF probably too big.";
            throw Exception(
                __FILE__, __LINE__, __func__, msg);                                                
        }        
        // add config to database to pass it to
        // RemoveUnconnectedComponents plugin
        RowID tempConfID = dsdb.addConfiguration(tempConf);
        result.push_back(tempConfID);
        return result;
        
    }

References __func__, DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), TTAMachine::Machine::addFunctionUnit(), TTAMachine::Machine::addressSpaceNavigator(), addressSpaces_, DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, StringTools::chopString(), DSDBManager::configuration(), createVectorLSU(), DesignSpaceExplorer::db(), Exception::errorMessageStack(), DSDBManager::MachineConfiguration::hasImplementation, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), readParameters(), and TTAMachine::FunctionUnit::setAddressSpace().

Here is the call graph for this function:

◆ PLUGIN_DESCRIPTION()

VectorLSGenerator::PLUGIN_DESCRIPTION ( "Explorer plugin that creates wide load/store unit." )

private

◆ producesArchitecture()

virtual bool VectorLSGenerator::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 85 of file VectorLSGenerator.cc.

85{ return true; }

◆ readParameters()

void VectorLSGenerator::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 177 of file VectorLSGenerator.cc.

                          {
        readOptionalParameter(NodeCountPN_, nodeCount_);
        readOptionalParameter(AddressSpacesPN_, addressSpaces_);                
    }