#include <DesignSpaceExplorer.hh>

Inheritance diagram for DesignSpaceExplorer:

Collaboration diagram for DesignSpaceExplorer:

Public Member Functions
	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
static DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &pluginName, DSDBManager *dsdb=NULL)

Protected Member Functions
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)

Private Attributes
DSDBManager *	dsdb_
	Design space database where results are stored. More...

CostEstimator::Estimator	estimator_
	The estimator frontend. More...

std::ostringstream *	oStream_
	Output stream. More...

Static Private Attributes
static PluginTools	pluginTool_
	The plugin tool. More...

static CostEstimates	dummyEstimate_
	Used for the default evaluate() argument. More...

Detailed Description

Design space explorer interface provides methods to automatically evaluate machine configurations and select best implementations to the processor components according the test applications set in Design Space Database (DSDB).

Definition at line 70 of file DesignSpaceExplorer.hh.

Constructor & Destructor Documentation

◆ DesignSpaceExplorer()

DesignSpaceExplorer::DesignSpaceExplorer ( )

The constructor.

Definition at line 82 of file DesignSpaceExplorer.cc.

                                          {
     
     //schedulingPlan_ = 
     //    SchedulingPlan::loadFromFile(Environment::oldGccSchedulerConf());
     oStream_ = new std::ostringstream;
     OperationGlobals::setOutputStream(*oStream_);
 }

References OperationGlobals::setOutputStream().

Here is the call graph for this function:

◆ ~DesignSpaceExplorer()

DesignSpaceExplorer::~DesignSpaceExplorer ( )

virtual

The destructor.

Definition at line 93 of file DesignSpaceExplorer.cc.

                                           {
  
     //delete schedulingPlan_;
     //schedulingPlan_ = NULL;
     delete oStream_;
     oStream_ = NULL;
 }

Member Function Documentation

◆ addConfToDSDB()

RowID DesignSpaceExplorer::addConfToDSDB ( const DSDBManager::MachineConfiguration & conf )

Add given configuration to the database.

Parameters

conf	Configuration to be added to the database.
dsdb	Database where to add the configuration.

Returns: RowID Row ID of the config in the database. 0 if adding failed.

Definition at line 755 of file DesignSpaceExplorer.cc.

                                                  {
  
     try {
         return dsdb_->addConfiguration(conf);
     } catch (const Exception& e) {
         debugLog(e.errorMessage());
         return 0;
     }
 }

References debugLog, and Exception::errorMessage().

Here is the call graph for this function:

◆ createEstimateData()

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

creates estimate data for machine and idf.

Parameters

mach	Machine mathcing given idf.
idf	Implementation definition for given machine.
area	Estimated area cost.
longestPathDelay	Estimated longest path delay.

Definition at line 735 of file DesignSpaceExplorer.cc.

                                                        {
  
     area = estimator_.totalArea(mach, idf);
     longestPathDelay = estimator_.longestPath(mach, idf);                
 }

◆ createImplementation()

bool DesignSpaceExplorer::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"`
	)

Selects components for a machine and ands them to a given config.

Parameters

conf	MachineConfiguration of which architecture is used.
newConf	MachineConfiguration where idf is to be added.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
createEstimates	Boolean for creating estimates.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns: RowID of the new machine configuration having adf and idf.

Definition at line 650 of file DesignSpaceExplorer.cc.

                                {
  
     const TTAMachine::Machine* mach = dsdb_->architecture(conf.architectureID);
     IDF::MachineImplementation* idf = NULL;
  
     idf = selectComponents(*mach, frequency, maxArea, icDec, icDecHDB);
     if (!idf) {
         return false;
     }
  
     CostEstimator::AreaInGates area = 0;
     CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
     if (createEstimates) {
         createEstimateData(*mach, *idf, area, longestPathDelay);
     }
  
     delete mach;
     mach = NULL;
  
     newConf.architectureID = conf.architectureID;
     newConf.implementationID = dsdb_->addImplementation(*idf, longestPathDelay, area);
     newConf.hasImplementation = true;
     
     // idf written to the dsdb so it can be deleted
     delete idf;
     idf = NULL;
     return true;
 }

References DSDBManager::MachineConfiguration::architectureID, DSDBManager::MachineConfiguration::hasImplementation, and DSDBManager::MachineConfiguration::implementationID.

◆ createImplementationAndStore()

RowID DesignSpaceExplorer::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"`
	)

Selects components for a machine and creates a new configuration.

Also stores the new configuration to the dsdb and returns it's rowID.

Parameters

conf	MachineConfiguration of which architecture is used.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
createEstimates	Boolean for creating estimates.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns: RowID of the new machine configuration having adf and idf.

Definition at line 597 of file DesignSpaceExplorer.cc.

                                {
  
     const TTAMachine::Machine* mach = dsdb_->architecture(conf.architectureID);
     IDF::MachineImplementation* idf = NULL;
  
     idf = selectComponents(*mach, frequency, maxArea, icDec, icDecHDB);
     if (!idf) {
         return 0;
     }
     
     CostEstimator::AreaInGates area = 0;
     CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
     if (createEstimates) {
         createEstimateData(*mach, *idf, area, longestPathDelay);
     }
  
     delete mach;
     mach = NULL;
  
     DSDBManager::MachineConfiguration newConf;
     newConf.architectureID = conf.architectureID;
  
     newConf.implementationID = 
         dsdb_->addImplementation(*idf, longestPathDelay, area);
     newConf.hasImplementation = true;
     
     // idf written to the dsdb so it can be deleted
     delete idf;
     idf = NULL;
  
     return addConfToDSDB(newConf);
 }

References DSDBManager::MachineConfiguration::architectureID, DSDBManager::MachineConfiguration::hasImplementation, and DSDBManager::MachineConfiguration::implementationID.

◆ db()

DSDBManager & DesignSpaceExplorer::db ( )

virtual

Returns the DSDBManager of the current exploration process.

Returns: The DSDBManager of the current exploration process.

Definition at line 300 of file DesignSpaceExplorer.cc.

                         {
  
     return *dsdb_;
 }

◆ evaluate()

bool DesignSpaceExplorer::evaluate	(	const DSDBManager::MachineConfiguration &	configuration,
		CostEstimates &	result = `dummyEstimate_`,
		bool	estimate = `false`
	)

virtual

Evaluates one processor configuration (architecture+implementation pair).

Evaluates the total area and the longest path delay of the current processor configuration (architecture+implementation pair) and also the energy consumed in each program in the DSDB with this processor configuration. Also configurations without implementation can be evaluated but no cost estimations are performed so the CostEstimate object won't include area, energy and longest path delay estimations. Estimation is not included either if the estimate flag is set to false.

Parameters

configuration	Machine configuration (architecture, implementation).
result	CostEstimates object where the configuration cost estimates are stored if the evaluation succeeds.
estimate	Flag indicating that the evaluate will also estimate the given configuration.

Exceptions

InvalidData thrown in case there are flaws in the application configuration which leads to evaluation failure.

Returns: Returns true if the evaluation succeeds false otherwise.

Definition at line 133 of file DesignSpaceExplorer.cc.

                                           {
  
     TTAMachine::Machine* adf = NULL;
     IDF::MachineImplementation* idf = NULL;
     if (configuration.hasImplementation) {
         adf = dsdb_->architecture(configuration.architectureID);
         idf = dsdb_->implementation(configuration.implementationID);
     } else {
         adf = dsdb_->architecture(configuration.architectureID);
     }
  
     try {
         // program independent estimations
         if (configuration.hasImplementation && estimate) {
  
             // estimate total area and longest path delay
             CostEstimator::AreaInGates totalArea = 0;
             CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
             createEstimateData(*adf, *idf, totalArea, longestPathDelay);
  
             dsdb_->setAreaEstimate(configuration.implementationID, totalArea);
             result.setArea(totalArea);
  
             dsdb_->setLongestPathDelayEstimate(
                 configuration.implementationID, longestPathDelay);
             result.setLongestPathDelay(longestPathDelay);
         }
        
         // get all programs from the dsdb
         set<RowID> applicationIDs = dsdb_->applicationIDs();
         for (set<RowID>::const_iterator i = applicationIDs.begin();
              i != applicationIDs.end(); i++) {
  
             if (dsdb_->isUnschedulable((*i), configuration.architectureID)) {
                 return false;
             }
  
             if (!estimate && 
                 dsdb_->hasCycleCount(*i, configuration.architectureID)) {
                 // this configuration has been compiled+simulated previously,
                 // the old cycle count can be reused for this app
                 continue; 
             }
  
             string applicationPath = dsdb_->applicationPath(*i);
             TestApplication testApplication(applicationPath);
             
             std::string applicationFile = testApplication.applicationPath();
  
             // test that program is found
             if (applicationFile.length() < 1) {
                 delete adf;
                 adf = NULL;
                 delete idf;
                 idf = NULL;
                 throw InvalidData(
                     __FILE__, __LINE__, __func__,
                     (boost::format(
                         "No program found from application dir '%s'") 
                      % applicationPath).str());
                 return false;
             }
             
 #if (!defined(HAVE_CXX11) && !defined(HAVE_CXX0X))
             std::auto_ptr<TTAProgram::Program> scheduledProgram(
                 schedule(applicationFile, *adf));
 #else
             std::unique_ptr<TTAProgram::Program> scheduledProgram(
                 schedule(applicationFile, *adf));
 #endif
  
             if (scheduledProgram.get() == NULL) {
                 dsdb_->setUnschedulable((*i), configuration.architectureID);
                 delete adf;
                 adf = NULL;
                 delete idf;
                 idf = NULL;
                 return false;
             }
  
             // simulate the scheduled program
             ClockCycleCount runnedCycles;
             const ExecutionTrace* traceDB = NULL;
             if (configuration.hasImplementation && estimate) {
                 traceDB = simulate(
                     *scheduledProgram, *adf, testApplication, 0, runnedCycles,
                     true);
             } else {
                 simulate(
                     *scheduledProgram, *adf, testApplication, 0, runnedCycles,
                     false);
             }
  
             //std::cerr << "DEBUG: simulated" << std::endl;
             // verify the simulation
             if (testApplication.hasCorrectOutput()) {
                 string correctResult = testApplication.correctOutput();
                 string resultString = oStream_->str();
                 if (resultString != correctResult) {
                     std::cerr << "Simulation FAILED, possible bug in scheduler!"
                               << std::endl;
                     std::cerr << "Architecture id in DSDB:" << std::endl;
                     std::cerr << configuration.architectureID << std::endl;
                     std::cerr << "use sqlite3 to find out which configuration "
                               << "has that id to get the machine written to "
                               << "ADF." << std::endl;
                     // @todo Do a method into DSDBManager to find out the
                     //       configuration ID.
                     std::cerr << "********** result found:" << std::endl;
                     std::cerr << resultString << std::endl;
                     std::cerr << "********** expected result:" << std::endl;
                     std::cerr << correctResult << std::endl;
                     std::cerr << "**********" << std::endl;
                     delete idf;
                     idf = NULL;
                     delete adf;
                     adf = NULL;
                     return false;
                 }
                 //std::cerr << "DEBUG: simulation OK" << std::endl;
                 // reset the stream pointer in to the beginning and empty the
                 // stream
                 oStream_->str("");
                 oStream_->seekp(0);
             }
  
             // add simulated cycle count to dsdb
             dsdb_->addCycleCount(
                     (*i), configuration.architectureID,
                     runnedCycles);
  
             if (configuration.hasImplementation && estimate) {
                 // energy estimate the simulated program
                 EnergyInMilliJoules programEnergy =
                     estimator_.totalEnergy(
                         *adf, *idf, *scheduledProgram, *traceDB);
                 dsdb_->addEnergyEstimate(
                     (*i), configuration.implementationID, programEnergy);
                 result.setEnergy(*scheduledProgram, programEnergy);
             }
             delete traceDB;
             traceDB = NULL;
         }
     } catch (const Exception& e) {
         delete adf;
         adf = NULL;
         delete idf;
         idf = NULL;
         debugLog(e.errorMessageStack());
         return false;
     }
     delete idf;
     idf = NULL;
     delete adf;
     adf = NULL;
     return true;
 }

References __func__, TestApplication::applicationPath(), DSDBManager::MachineConfiguration::architectureID, TestApplication::correctOutput(), debugLog, Exception::errorMessageStack(), TestApplication::hasCorrectOutput(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::MachineConfiguration::implementationID, CostEstimates::setArea(), CostEstimates::setEnergy(), and CostEstimates::setLongestPathDelay().

Referenced by MinimizeMachine::evalNewConfigWithoutImplementation(), GrowMachine::explore(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), and MinimizeMachine::minimizeRegisterFiles().

Here is the call graph for this function:

◆ getPlugins()

std::vector< DesignSpaceExplorerPlugin * > DesignSpaceExplorer::getPlugins ( )

Parses the plugin search directories and loads all available plugins

Definition at line 557 of file DesignSpaceExplorer.cc.

                                                                       {
     
     std::vector<DesignSpaceExplorerPlugin*> plugins;
     vector<string> found_plugins;
     vector<string> searchPaths = Environment::explorerPluginPaths();
     for (vector<string>::const_iterator iter = searchPaths.begin();
             iter != searchPaths.end(); iter++) {
  
         if (FileSystem::fileExists(*iter)) {
             FileSystem::findFromDirectory(".*\\.so$", *iter, found_plugins);
         }
     }
     for (unsigned int i = 0; i < found_plugins.size(); ++i) {
         std::string pluginName = FileSystem::fileNameBody(found_plugins[i]);
         DesignSpaceExplorerPlugin* plugin = loadExplorerPlugin(pluginName, NULL);
         if (!plugin) {
             continue;
         }
         
         plugins.push_back(plugin);
     }
     
     return plugins;
 }

References Environment::explorerPluginPaths(), FileSystem::fileExists(), FileSystem::fileNameBody(), FileSystem::findFromDirectory(), and loadExplorerPlugin().

Here is the call graph for this function:

◆ loadExplorerPlugin()

DesignSpaceExplorerPlugin * DesignSpaceExplorer::loadExplorerPlugin	(	const std::string &	pluginName,
		DSDBManager *	dsdb = `NULL`
	)

static

Loads the given explorer plugin from the default search pathes of the explorer plugins.

Searches for file named the plugin with an extension ".so". e.g. if the plugin is namen SimplePlugin is the file SimplePlugin.so loaded. Plugins are searched from the default search pathes of explorer plugins.

Parameters

pluginName	Name of the plugin to be loaded.
dsdb	DSDBManager to be used by the plugin.

Returns: Returns the loaded DesignSpacsExplorerPlugin instance.

Exceptions

FileNotFound	If the given plugin is not found from the search paths of explorer plugins.
DynamicLibraryException	If the dynamic library cannot be opened.

Definition at line 527 of file DesignSpaceExplorer.cc.

                                                     {
     string pluginFileName = pluginName + ".so";
     vector<string> searchPaths = Environment::explorerPluginPaths();
     for (vector<string>::const_iterator iter = searchPaths.begin();
          iter != searchPaths.end(); iter++) {
         
         if (FileSystem::fileExists(*iter)) {
             pluginTool_.addSearchPath(*iter);
         }
     }
     pluginTool_.registerModule(pluginFileName);
         DesignSpaceExplorerPlugin* (*pluginCreator)();
         pluginTool_.importSymbol(
                 "create_explorer_plugin_" + pluginName, pluginCreator, 
                 pluginFileName);
  
     DesignSpaceExplorerPlugin* plugin = pluginCreator();
     if (dsdb) {
         plugin->setDSDB(*dsdb);
     }
     return plugin;
 }

References Environment::explorerPluginPaths(), FileSystem::fileExists(), and setDSDB().

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), SimpleICOptimizer::explore(), ADFCombiner::explore(), FrequencySweepExplorer::explore(), and loadExplorerPlugin().

Here is the call graph for this function:

◆ schedule()

TTAProgram::Program * DesignSpaceExplorer::schedule	(	const std::string	bytecodeFile,
		TTAMachine::Machine &	target,
		TCEString	paramOptions = `"-O3"`
	)

protected

Compiles the given application bytecode file on the given target machine.

Parameters

bytecodeFile	Bytecode filename with path.
target	The machine to compile the sequential program against.
paramOptions	Compiler options (if cmdline options are not given)

Returns: Scheduled parallel program or NULL if scheduler produced exeption.

Definition at line 315 of file DesignSpaceExplorer.cc.

                             {
  
     TCEString compilerOptions;
     
     ExplorerCmdLineOptions* options = 
         dynamic_cast<ExplorerCmdLineOptions*>(Application::cmdLineOptions());
     if (options != NULL) {
         if (options->compilerOptions()) {
             compilerOptions = options->compilerOptionsString();
         // use compiler options given by method parameters (-O3 by default)
         } else {
             compilerOptions = paramOptions;
         }
     }
     // If compiler options did not provide optimization, we use default.
     if (compilerOptions.find("-O") == std::string::npos) {
         compilerOptions += " -O3";        
     }
     static const std::string DS = FileSystem::DIRECTORY_SEPARATOR;
     
     // create temp directory for the target machine
     std::string tmpDir = FileSystem::createTempDirectory();
  
     // write machine to a file for tcecc
     std::string adf = tmpDir + DS + "mach.adf";
     std::string tpef = tmpDir + DS + "program.tpef";
     ADFSerializer serializer;
     serializer.setDestinationFile(adf);
     try {
         serializer.writeMachine(target);
     } catch (const SerializerException& exception) {
         FileSystem::removeFileOrDirectory(tmpDir);
         throw IOException(
             __FILE__, __LINE__, __func__, exception.errorMessage());
     }     
     // call tcecc to compile, link and schedule the program
     std::vector<std::string> tceccOutputLines;
     std::string tceccPath = Environment::tceCompiler();
     std::string tceccCommand = tceccPath + " "  
         + compilerOptions + " --no-link -a " + adf + " -o " 
         + tpef + " " + bytecodeFile + " --no-plugin-cache 2>&1";
  
     const bool debug = Application::verboseLevel() > 0;
  
     Application::runShellCommandAndGetOutput(tceccCommand, tceccOutputLines);
  
     if (debug && tceccOutputLines.size() > 0) {
         for (unsigned int i = 0; i < tceccOutputLines.size(); ++i) {
             std::cout << tceccOutputLines.at(i) << std::endl;
         }
     }
     
     // check if tcecc produced any tpef output
     if (!(FileSystem::fileExists(tpef) && FileSystem::fileIsReadable(tpef))) {
         if (debug) {
             std::cout << "failed command: " << tceccCommand << std::endl
                       << "temporary directory left for inspection at: " 
                       << tmpDir << std::endl;
         } else {
             FileSystem::removeFileOrDirectory(tmpDir);            
         }
         return NULL;    
     } 
     
     TTAProgram::Program* prog = NULL;
     try {
         prog = TTAProgram::Program::loadFromTPEF(tpef, target);
     } catch (const Exception& e) {
         FileSystem::removeFileOrDirectory(tmpDir);
         IOException error(__FILE__, __LINE__,__func__, e.errorMessage());
         error.setCause(e);
         throw error;
     }
     FileSystem::removeFileOrDirectory(tmpDir);    
     return prog;        
 }

References __func__, Application::cmdLineOptions(), FileSystem::createTempDirectory(), FileSystem::DIRECTORY_SEPARATOR, DS, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileIsReadable(), TTAProgram::Program::loadFromTPEF(), options, FileSystem::removeFileOrDirectory(), Application::runShellCommandAndGetOutput(), Exception::setCause(), XMLSerializer::setDestinationFile(), Environment::tceCompiler(), Application::verboseLevel(), and ADFSerializer::writeMachine().

Referenced by SimpleICOptimizer::explore().

Here is the call graph for this function:

◆ selectComponents()

IDF::MachineImplementation * DesignSpaceExplorer::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

Selects components for a machine, creates a idf.

Parameters

mach	Target machine for which components are selected.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns: Machine Implementation pointer if ok, else NULL.

Definition at line 698 of file DesignSpaceExplorer.cc.

                                      {
  
     ComponentImplementationSelector impSelector;
     IDF::MachineImplementation* idf = NULL;
  
     try {
         // TODO: check that idf is deleted when it has been written to the
         // dsdb, and not in use anymore (selectComponents reserves it with
         // new)
         idf = impSelector.selectComponents(&mach, icDec,
                 icDecHDB, frequency, maxArea);
     } catch (const Exception& e) {
         debugLog(e.errorMessage());
         if (idf != NULL) {
             delete idf;
             idf = NULL;
         }
     }
  
     return idf;
 }

References debugLog, Exception::errorMessage(), and ComponentImplementationSelector::selectComponents().

Here is the call graph for this function:

◆ setDSDB()

void DesignSpaceExplorer::setDSDB ( DSDBManager & dsdb )

virtual

Sets new design space database.

Parameters

dsdb	Design space database to be used with the explorer.

Definition at line 107 of file DesignSpaceExplorer.cc.

                                               {
  
     dsdb_ = &dsdb;
 }

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), GrowMachine::explore(), loadExplorerPlugin(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), and MinimizeMachine::minimizeRegisterFiles().

◆ simulate()

const ExecutionTrace * DesignSpaceExplorer::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

Simulates the parallel program.

Simulates the target machine as long as the program runs or the maximum cycle count is reached. If maximum cycle count is reached an exception is thrown.

Parameters

program	Sequential program.
machine	Target machine.
testApplication	Test application directory.
maxCycles	Maximum amount of clock cycles that program is allowed to run. Not used by this implementation.
runnedCycles	Simulated cycle amount is stored here.
tracing	Flag indicating is the tracing used.

Returns: Execution trace of the program.

Exceptions

Exception All exceptions produced by simulator engine except SimulationCycleLimitReached in case of max cycles are reached without program finishing and SimulationTimeOut in case of simulation is killed after simulating maximum time that is currently 10h.

Definition at line 416 of file DesignSpaceExplorer.cc.

                                                  {
     // initialize the simulator
     SimulatorFrontend simulator(
         useCompiledSimulation ? 
         SimulatorFrontend::SIM_COMPILED : 
         SimulatorFrontend::SIM_NORMAL);
     
     // setting simulator timeout in seconds
     simulator.setTimeout(480);
  
     // use memory file in sqlite
     // TODO: should use a tmp dir as now TraceDB produces multiple
     // text files, thus only the SQL part goes to memory
     const string traceFile = ":memory:";
     simulator.forceTraceDBFileName(traceFile);
     if (!useCompiledSimulation)
         simulator.setRFAccessTracing(tracing);
     simulator.setUtilizationDataSaving(tracing);
     simulator.setExecutionTracing(tracing);
  
     simulator.loadMachine(machine);
     simulator.loadProgram(program);
     // run the 'setup.sh' in the test application directory
     testApplication.setupSimulation();
     // if there is 'simulate.ttasim' file in the application dir we use that
     if (testApplication.hasSimulateTTASim()) {
         std::string command = "";
         std::istream* input = testApplication.simulateTTASim();
         BaseLineReader reader(*input, *oStream_);
         reader.initialize();
         reader.setPromptPrinting(false);
         SimulatorInterpreterContext interpreterContext(simulator);
         SimulatorInterpreter interpreter(0, NULL, interpreterContext, reader);
         while (!interpreter.isQuitCommandGiven()) {
             try {
                 command = reader.readLine();
             } catch (const EndOfFile&) {
                 interpreter.interpret(SIM_INTERP_QUIT_COMMAND);
                 if (interpreter.result().size() > 0) {
                     *oStream_ << interpreter.result() << std::endl;
                 }
                 break;
             }
             command = StringTools::trim(command);
             if (command == "") {
                 continue;
             }
             interpreter.interpret(command);
             if (interpreter.result().size() > 0) {
                 *oStream_ << interpreter.result() << std::endl;
             }
         }
         delete input;
         input = NULL;
     } else {
         // no 'simulate.ttasim' file
         BaseLineReader reader(std::cin, *oStream_);
         reader.initialize();
         SimulatorInterpreterContext interpreterContext(simulator);
         SimulatorInterpreter interpreter(0, NULL, interpreterContext, reader);
         simulator.run();
         if (interpreter.result().size() > 0) {
             *oStream_ << interpreter.result() << std::endl;
         }
     }
  
     runnedCycles = simulator.cycleCount();
     
     int instructionCount = program.instructionVector().size();
     if (executionCounts) {
         executionCounts->resize(instructionCount, 0);
         for (int i=0; i<instructionCount; ++i) {
             (*executionCounts)[i] = simulator.executableInstructionAt(i)
                 .executionCount();
         }
     }
  
     // Flush data collected during simulation to the trace file.
     const ExecutionTrace* db = NULL;
     if (tracing) {
         db = simulator.lastTraceDB();
     }
     
     simulator.killSimulation();
     
     return db;
 }

Here is the call graph for this function:

Member Data Documentation

◆ dsdb_

DSDBManager* DesignSpaceExplorer::dsdb_

private

Design space database where results are stored.

Definition at line 131 of file DesignSpaceExplorer.hh.

◆ dummyEstimate_

CostEstimates DesignSpaceExplorer::dummyEstimate_

staticprivate

Used for the default evaluate() argument.

Definition at line 139 of file DesignSpaceExplorer.hh.

◆ estimator_

CostEstimator::Estimator DesignSpaceExplorer::estimator_

private

The estimator frontend.

Definition at line 135 of file DesignSpaceExplorer.hh.

◆ oStream_

std::ostringstream* DesignSpaceExplorer::oStream_

private

Output stream.

Definition at line 137 of file DesignSpaceExplorer.hh.

◆ pluginTool_

PluginTools DesignSpaceExplorer::pluginTool_

staticprivate

The plugin tool.

Definition at line 133 of file DesignSpaceExplorer.hh.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DesignSpaceExplorer()

◆ ~DesignSpaceExplorer()

Member Function Documentation

◆ addConfToDSDB()

◆ createEstimateData()

◆ createImplementation()

◆ createImplementationAndStore()

◆ db()

◆ evaluate()

◆ getPlugins()

◆ loadExplorerPlugin()

◆ schedule()

◆ selectComponents()

◆ setDSDB()

◆ simulate()

Member Data Documentation

◆ dsdb_

◆ dummyEstimate_

◆ estimator_

◆ oStream_

◆ pluginTool_