Inheritance diagram for ComponentAdder:

Collaboration diagram for ComponentAdder:

Private Member Functions
	PLUGIN_DESCRIPTION ("Explorer plugin that adds machine components to a " "given machine.")

	ComponentAdder ()

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	addComponents (TTAMachine::Machine *mach)

void	addRegisterFiles (TTAMachine::Machine *mach)

Private Attributes
ComponentImplementationSelector	selector_
	Selector used by the plugin.

std::string	RFName_

int	RFCount_

int	RFSize_

int	RFReadPorts_

int	RFWritePorts_

std::string	adf_
	name of the adf file if wanted to use idf generation

bool	buildIdf_
	do we build idf

Static Private Attributes
static const std::string	RFNamePN_

static const std::string	RFCountPN_

static const std::string	RFSizePN_

static const std::string	RFReadPortsPN_

static const std::string	RFWritePortsPN_

static const std::string	adfPN_

static const std::string	buildIdfPN_

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 adds machine components to a given machine.

Supported parameters:

rf_size, number of registers in one register file, default is 4
max_rfs, maximum number of register files in the machine, default is 16
rf_reads, number of register read ports in register files, default is 1
rf_writes, number of register write ports in register file, default is 1
build_idf, if parameter is set the idf file is built, not set as default
adf, if idf is wanted to generated to some arhitecture, no default value. If adf parameter is given the idf is built.

Definition at line 63 of file ComponentAdder.cc.

Constructor & Destructor Documentation

◆ ComponentAdder()

ComponentAdder::ComponentAdder ( )

inlineprivate

Definition at line 67 of file ComponentAdder.cc.

                    : DesignSpaceExplorerPlugin(), 
        RFName_("rf"),
        RFCount_(1),
        RFSize_(4),
        RFReadPorts_(1),
        RFWritePorts_(1),
        adf_(""),
        buildIdf_(false) {
 
        // compulsory parameters
        // no compulsory parameters
 
        // parameters that have a default value
        addParameter(RFNamePN_, STRING, false, RFName_);
        addParameter(RFCountPN_, UINT, false, Conversion::toString(RFCount_));
        addParameter(RFSizePN_, UINT, false, Conversion::toString(RFSize_));
        addParameter(RFReadPortsPN_, UINT, false, Conversion::toString(RFReadPorts_));
        addParameter(RFWritePortsPN_, UINT, false, Conversion::toString(RFWritePorts_));
        addParameter(adfPN_, STRING, false, adf_);
        addParameter(buildIdfPN_, BOOL, false, Conversion::toString(buildIdf_));
    }

References DesignSpaceExplorerPlugin::addParameter(), adf_, adfPN_, BOOL, buildIdf_, buildIdfPN_, RFCount_, RFCountPN_, RFName_, RFNamePN_, RFReadPorts_, RFReadPortsPN_, RFSize_, RFSizePN_, RFWritePorts_, RFWritePortsPN_, STRING, Conversion::toString(), and UINT.

Here is the call graph for this function:

Member Function Documentation

◆ addComponents()

void ComponentAdder::addComponents ( TTAMachine::Machine * mach )

inlineprivate

Builds the machine in basis of the analyzed data from the applications.

Returns: The initial machine of NULL if an error occurred.

Definition at line 204 of file ComponentAdder.cc.

                                                {
        // add register files
        addRegisterFiles(mach);
    }

References addRegisterFiles().

Referenced by explore().

Here is the call graph for this function:

◆ addRegisterFiles()

void ComponentAdder::addRegisterFiles ( TTAMachine::Machine * mach )

inlineprivate

Adds register file(s) to the machine

TODO: add type and guard latency setting

Returns: void

Definition at line 217 of file ComponentAdder.cc.

                                                   {
        for (int i = 0; i < RFCount_; i++) {
            std::string RFName = RFName_ + Conversion::toString(i);
 
            const TTAMachine::Machine::RegisterFileNavigator& RFNav = 
                mach->registerFileNavigator();
            if (RFNav.hasItem(RFName)) {
                RFName = RFName_ + Conversion::toString(i+RFNav.count());
            }
 
            TTAMachine::RegisterFile* rf = new TTAMachine::RegisterFile(
                    RFName, RFSize_, 32, RFReadPorts_, RFWritePorts_, 0,
                    TTAMachine::RegisterFile::NORMAL);
            for (int n = 0; n < RFReadPorts_; n++) {
                new TTAMachine::RFPort("read" + 
                        Conversion::toString( + 1), *rf);
            }
            for (int n = 0; n < RFWritePorts_; n++) {
                new TTAMachine::RFPort("write" + 
                        Conversion::toString(n + 1), *rf);
            }
            try {
                mach->addRegisterFile(*rf);
            } catch (const ComponentAlreadyExists& e) {
                verboseLog("ComponentAdder: Tried to add RF with a already"
                    "existing name (" + RFName)
                Application::exitProgram(1);
            }
        }
    }

References TTAMachine::Machine::addRegisterFile(), TTAMachine::Machine::Navigator< ComponentType >::count(), Application::exitProgram(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::RegisterFile::NORMAL, TTAMachine::Machine::registerFileNavigator(), RFCount_, RFName_, RFReadPorts_, RFSize_, RFWritePorts_, Conversion::toString(), and verboseLog.

Referenced by addComponents().

Here is the call graph for this function:

◆ explore()

virtual std::vector< RowID > ComponentAdder::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 100 of file ComponentAdder.cc.

                                                               {
        readParameters();
        std::vector<RowID> result;
 
        // check if adf given
        if (configurationID == 0 && adf_ == "") {
            std::ostringstream msg(std::ostringstream::out);
            msg << "No configuration nor adf defined. Use -s <confID> to "
                << "define the configuration to be optimized or give adf "
                << "as plugin parameter." << endl;
            verboseLog(msg.str());
            return result;
        }
 
        DSDBManager& dsdb = db();
        DSDBManager::MachineConfiguration conf;
        conf.hasImplementation = false;
        TTAMachine::Machine* mach = NULL;
 
        // load the adf from file or from dsdb
        try {
            if (adf_ != "") {
                mach = TTAMachine::Machine::loadFromADF(adf_);
            } else {
                conf = dsdb.configuration(configurationID);
                mach = dsdb.architecture(conf.architectureID);
            }
        } catch (const Exception& e) {
            std::ostringstream msg(std::ostringstream::out);
            msg << "Error loading the adf." << std::endl;
            verboseLog(msg.str());
            return result;
        }
        assert(mach != NULL);
 
        // add components
        addComponents(mach);
 
        if (buildIdf_) {
            try {
                // add idf to configuration
                selector_.selectComponentsToConf(conf, dsdb, mach);
            } catch (const Exception& e) {
                std::ostringstream msg(std::ostringstream::out);
                msg << e.errorMessage() 
                    << " " << e.fileName() 
                    << " " << e.lineNum() << std::endl;
                verboseLog(msg.str());
            }
        } else {
            conf.hasImplementation = false;
        }
 
        // add machine to configuration
        conf.architectureID = dsdb.addArchitecture(*mach);
 
        // add new configuration to dsdb
        RowID confID = dsdb.addConfiguration(conf);
        result.push_back(confID);
        return result;
    }

References DSDBManager::addArchitecture(), addComponents(), DSDBManager::addConfiguration(), adf_, DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, assert, buildIdf_, DSDBManager::configuration(), DesignSpaceExplorer::db(), Exception::errorMessage(), Exception::fileName(), DSDBManager::MachineConfiguration::hasImplementation, Exception::lineNum(), TTAMachine::Machine::loadFromADF(), readParameters(), ComponentImplementationSelector::selectComponentsToConf(), selector_, and verboseLog.

Here is the call graph for this function:

◆ PLUGIN_DESCRIPTION()

ComponentAdder::PLUGIN_DESCRIPTION ( "Explorer plugin that adds machine components to a " "given machine." )

private

◆ producesArchitecture()

virtual bool ComponentAdder::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 90 of file ComponentAdder.cc.

90{ return true; }

◆ readParameters()

void ComponentAdder::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 188 of file ComponentAdder.cc.

                          {
        readOptionalParameter(RFNamePN_, RFName_);
        readOptionalParameter(RFCountPN_, RFCount_);
        readOptionalParameter(RFSizePN_, RFSize_);
        readOptionalParameter(RFReadPortsPN_, RFReadPorts_);
        readOptionalParameter(RFWritePortsPN_, RFWritePorts_);
        readOptionalParameter(adfPN_, adf_);
        readOptionalParameter(buildIdfPN_, buildIdf_);
    }