Inheritance diagram for MinimizeMachine:

Collaboration diagram for MinimizeMachine:

Private Member Functions
	PLUGIN_DESCRIPTION ("Removes resources until the real time " "requirements of applications are not reached anymore.")

	MinimizeMachine ()

virtual bool	requiresStartingPointArchitecture () const

virtual bool	producesArchitecture () const

virtual bool	requiresHDB () const

virtual bool	requiresSimulationData () const

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

void	readParameters ()

RowID	minimizeMachine (RowID confToMinimize)

RowID	minimizeBuses (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)

RowID	minimizeRegisterFiles (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)

RowID	minimizeFunctionUnits (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)

bool	evalNewConfigWithoutImplementation (DesignSpaceExplorer &explorer, const TTAMachine::Machine &mach, DSDBManager &dsdb, DSDBManager::MachineConfiguration &newConfiguration, RowID &confID, CostEstimates &newEstimates)

bool	checkCycleCounts (const DSDBManager::MachineConfiguration &conf, const std::vector< ClockCycleCount > &maxCycleCounts)

Private Attributes
bool	minBus_
	minimize busses More...

bool	minFU_
	minimize function units More...

bool	minRF_
	minimize register files More...

unsigned int	frequency_
	running frequency in MHz for apps More...

Static Private Attributes
static const std::string	minBusPN_

static const std::string	minFUPN_

static const std::string	minRFPN_

static const std::string	frequencyPN_

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 bool	requiresApplication () const

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 More...

ParameterMap	parameters_
	Parameters for the plugin. More...

Detailed Description

Explorer plugin that removes resources until the real time requirements of applications are not reached anymore.

@TODO: maxRunTime parameter, which overrides app dir max runtime setting @TODO: if no maxRunTime then no frequency is needed == no cycle count limits

Supported parameters:

min_bus, boolean for do minimize busses minimization, default true.
min_fu, boolean for do minimize FUs minimization, default true.
min_rf, boolean for do minimize RFs minimization, default true.
frequency, running frequency for applications.

Definition at line 70 of file MinimizeMachine.cc.

Constructor & Destructor Documentation

◆ MinimizeMachine()

MinimizeMachine::MinimizeMachine ( )

inlineprivate

Definition at line 74 of file MinimizeMachine.cc.

                      : DesignSpaceExplorerPlugin(), 
         minBus_(true),
         minFU_(true),
         minRF_(true),
         frequency_(0) {
  
         // compulsory parameters
         addParameter(frequencyPN_, UINT);
  
         // parameters that have a default value
         addParameter(minBusPN_, BOOL, false, Conversion::toString(minBus_));
         addParameter(minFUPN_, BOOL, false, Conversion::toString(minFU_));
         addParameter(minRFPN_, BOOL, false, Conversion::toString(minRF_));
     }

References BOOL, Conversion::toString(), and UINT.

Here is the call graph for this function:

Member Function Documentation

◆ checkCycleCounts()

bool MinimizeMachine::checkCycleCounts	(	const DSDBManager::MachineConfiguration &	conf,
		const std::vector< ClockCycleCount > &	maxCycleCounts
	)

inlineprivate

Checks that max cycle counts are not exceeded.

Expects that maxCycleCount vector contains cycle counts for the matching programs in the same order as the estimates.

Parameters

estimates	Estimations that contain cycle counts.
maxCycleCounts	Maximum cycle counts of the applications.

Returns: true if maximum cycle counts are not exceeded, false otherwise.

Definition at line 701 of file MinimizeMachine.cc.

                                                           {
  
  
         std::vector<ClockCycleCount> cycleCounts;
         std::set<RowID> appIds = db().applicationIDs();
         for (std::set<RowID>::const_iterator appI = appIds.begin(); 
              appI != appIds.end(); ++appI) {
             RowID appID = *appI;
             if (!db().hasCycleCount(appID, conf.architectureID)) {
                 abortWithError("there was no cycle count?");
             }
             cycleCounts.push_back(
                 db().cycleCount(appID, conf.architectureID));
         }
  
         for (int i = 0; i < (int)cycleCounts.size(); i++) {
             // if no time constraints
             if (maxCycleCounts.at(i) < 1) {
                 continue;
             }
             // if some apps maxCycles was exceeded
             if (maxCycleCounts.at(i) < cycleCounts.at(i)) {
                 return false;
             }
         }
         return true;
     }

References abortWithError, and DSDBManager::MachineConfiguration::architectureID.

◆ evalNewConfigWithoutImplementation()

bool MinimizeMachine::evalNewConfigWithoutImplementation	(	DesignSpaceExplorer &	explorer,
		const TTAMachine::Machine &	mach,
		DSDBManager &	dsdb,
		DSDBManager::MachineConfiguration &	newConfiguration,
		RowID &	confID,
		CostEstimates &	newEstimates
	)

inlineprivate

Create, store and evaluate a new configuration without implementation.

Parameters

explorer	Design space explorer to use to evaluate.
mach	machine for the new configuration.
dsdb	Design space database to store the new configuration.
newConfiguration	New machine configuration.
confID	Row ID of the new configuration in the DSDB.
newEstimates	Estimates that are calculated during evaluation.

Returns: true if evaluation succeed, if not, return false.

Definition at line 669 of file MinimizeMachine.cc.

                                                     {
         try {
             newConfiguration.architectureID = dsdb.addArchitecture(mach);
         } catch (const RelationalDBException& e) {
             // Error occurred while adding adf to the dsdb, adf
             // probably too big
             throw e;
         }
         newConfiguration.hasImplementation = false;
  
         try {
             confID = dsdb.addConfiguration(newConfiguration);
         } catch (const KeyNotFound& e) {
             throw e;
         }
  
     return explorer.evaluate(newConfiguration, newEstimates, false);
     }

References DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::MachineConfiguration::architectureID, DesignSpaceExplorer::evaluate(), and DSDBManager::MachineConfiguration::hasImplementation.

Here is the call graph for this function:

◆ explore()

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

inlineprivatevirtual

Minimizes given configuration by not exceeding applications max runtime which depends on given frequncy

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 99 of file MinimizeMachine.cc.

                                                                {
         std::vector<RowID> result;
  
         readParameters();
  
         // TODO: make better parameter error function
         if (frequency_ < 1) {
             result.push_back(configurationID);
             return result;
         }
  
         RowID min = minimizeMachine(configurationID);
  
         result.push_back(min);
         return result;
     }

◆ minimizeBuses()

RowID MinimizeMachine::minimizeBuses	(	RowID	confToMinimize,
		std::vector< ClockCycleCount > &	maxCycleCounts
	)

inlineprivate

Reduces the number of buses in the machine as much as possible to still achieve the application run time requirements.

This function can handle implementations. Uses binary search to minimize the buses.

Parameters

confToMinimize	ID of the machine configuration which buses are reduced.
maxCycleCounts	Max cycle counts per program.

Returns: ID of the new congiguration where buses are reduced.

Definition at line 228 of file MinimizeMachine.cc.

                                                     {
         
         DSDBManager& dsdb = db();
  
         DSDBManager::MachineConfiguration configuration =
             dsdb.configuration(confToMinimize);
         
         TTAMachine::Machine* mach = NULL;
         try {
             mach = dsdb.architecture(configuration.architectureID);
         } catch (const Exception& e) {
             debugLog(std::string("No machine architecture found in config id "
                         "by MimimizeMachine plugin. "));
             delete mach;
             return confToMinimize;
         }
  
         TTAMachine::Machine::BusNavigator busNav = mach->busNavigator();
  
         // can't reduce buses from one
         int origBusCount = busNav.count();
         if (origBusCount < 2) {
             return confToMinimize;
         }
  
         DesignSpaceExplorer explorer;
         explorer.setDSDB(dsdb);
  
         CostEstimates estimates;
        
         // new configuration must be created
         DSDBManager::MachineConfiguration startConf;
         startConf.architectureID = dsdb.addArchitecture(*mach);
         startConf.hasImplementation = false;
  
         if (!explorer.evaluate(startConf, estimates, false)) {
             delete mach;
             mach = NULL;
             // return the original conf
             return confToMinimize;
         }
  
         // check if some apps maxCycles was exceeded
         if (!checkCycleCounts(startConf, maxCycleCounts)) {
             delete mach;
             mach = NULL;
             // return the original conf
             return confToMinimize;
         }
          
         MachineResourceModifier modifier;
  
         // variables for binary search    
         int busHigh = origBusCount;
         int busLow = 1;
         int busMid = (busLow + busHigh) /2;
  
         TTAMachine::Machine* newMach = NULL;
         RowID lastArchID = 0;
         RowID lastConfID = 0;
         RowID lastOKArchID = 0;
         RowID lastOKConfID = 0;
  
         std::list<std::string> removedBusNames;
  
         // use binary search to find out the bus count that can be removed
         // removes busses as long as each apps max cycle counts are not exceeded
         // if buses are not of equal value this doesn't really work.
         do {
             assert(newMach == NULL);
             newMach = new TTAMachine::Machine(*mach);
  
             int busesToRemove = (origBusCount - busMid);
  
             if (!modifier.removeBuses(busesToRemove, *newMach, removedBusNames)) {
                 // TODO: some good way to cope with non complete bus removal
             }
  
             DSDBManager::MachineConfiguration newConfiguration;
             try {
                 lastArchID = dsdb.addArchitecture(*newMach);
                 // machine stored to dsdb can be deleted
                 delete newMach;
                 newMach = NULL;
             } catch (const RelationalDBException& e) {
                 // Error occurred while adding adf to the dsdb, adf
                 // probably too big
                 delete newMach;
                 newMach = NULL;
                 break;
             }
  
             newConfiguration.architectureID = lastArchID;
             newConfiguration.hasImplementation = false;
             try {
                 lastConfID = dsdb.addConfiguration(newConfiguration);
             } catch (const KeyNotFound& e) {
                 break;
             }
             CostEstimates newEstimates;
  
             bool newConfigOK = false;
             if (explorer.evaluate(newConfiguration, newEstimates, false)) {
                 // goes through every apps new cycles
                 newConfigOK = 
                     checkCycleCounts(newConfiguration, maxCycleCounts);
             } 
  
             if (newConfigOK) {
                 busHigh = busMid - 1;
                 busMid = (busLow + busMid) / 2;
                 lastOKArchID = lastArchID;
                 lastOKConfID = lastConfID;
             } else {
                 busLow = busMid + 1;
                 busMid = (busMid + busHigh) / 2;
             }
         } while (busLow <= busHigh && busLow <= busMid);
  
         // these aren't needed anymore
         lastArchID = 0;
         lastConfID = 0;
  
         // delete old machine
         delete mach;
         mach = NULL;
         
         // check if no new architecture/config could be created
         if (lastOKArchID == 0) {
             return confToMinimize;
         }
         
         // create new idf for the new machine if needed
         if (configuration.hasImplementation) {
             IDF::MachineImplementation* idf =
                 dsdb.implementation(configuration.implementationID);
  
             // remove removed busses from orginal implementation file
             std::list<std::string>::const_iterator busNameIter = 
                 removedBusNames.begin();
             while (busNameIter != removedBusNames.end()) {
                 idf->removeBusImplementation(*busNameIter);
                 busNameIter++;
             }
  
             DSDBManager::MachineConfiguration newConfiguration;
             newConfiguration.architectureID = lastOKArchID;
  
             CostEstimates newEstimates;
             if (explorer.evaluate(newConfiguration, newEstimates, false)) {
                 newConfiguration.implementationID = 
                     dsdb.addImplementation(
                             *idf, newEstimates.longestPathDelay(),newEstimates.area());
  
                 delete idf;
                 idf = NULL;
  
                 newConfiguration.hasImplementation = true;
                 // add new configuration
                 RowID confID = dsdb.addConfiguration(newConfiguration);
                 return confID;
             } else {
                 return confToMinimize;
             }
         } else {
             return lastOKConfID;
         }
  
         assert(false);
         return 9999; 
     }

References DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, CostEstimates::area(), assert, TTAMachine::Machine::busNavigator(), DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), debugLog, DesignSpaceExplorer::evaluate(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::implementation(), DSDBManager::MachineConfiguration::implementationID, CostEstimates::longestPathDelay(), MachineResourceModifier::removeBuses(), IDF::MachineImplementation::removeBusImplementation(), and DesignSpaceExplorer::setDSDB().

Here is the call graph for this function:

◆ minimizeFunctionUnits()

RowID MinimizeMachine::minimizeFunctionUnits	(	RowID	confToMinimize,
		std::vector< ClockCycleCount > &	maxCycleCounts
	)

inlineprivate

Reduces the number of function units in the machine as much as possible to still achieve the application run time requirements.

This function won't handle implementations.

Parameters

confToMinimize	ID of the machine configuration which function units are reduced.
maxCycleCounts	Max cycle counts per program.

Returns: ID of the new congiguration where function units are reduced or same that was given if nothing was done.

Definition at line 544 of file MinimizeMachine.cc.

                                                         {
  
         DSDBManager& dsdb = db();
         RowID latestConfID = 0;
  
         MachineResourceModifier modifier;
         DesignSpaceExplorer explorer;
         explorer.setDSDB(dsdb);
  
         DSDBManager::MachineConfiguration configuration =
             dsdb.configuration(confToMinimize);
  
         const TTAMachine::Machine* origMach = NULL;
         try {
             origMach = dsdb.architecture(configuration.architectureID);
         } catch (const Exception& e) {
             debugLog(std::string("No machine architecture found in config id "
                         "by MimimizeMachine plugin. "));
             delete origMach;
             return confToMinimize;
         }
  
         MachineResourceModifier::FunctionUnitMap origFUMap;
         modifier.analyzeFunctionUnits(*origMach, origFUMap);
  
         CostEstimates estimates;
         DSDBManager::MachineConfiguration startConf;
         startConf.architectureID = dsdb.addArchitecture(*origMach);
         startConf.hasImplementation = false;
  
         if (!explorer.evaluate(startConf, estimates, false)) {
             // can't evaluate the given configuration
             delete origMach;
             origMach = NULL;
             return confToMinimize;
         }
  
         // check if some apps maxCycles was exceeded
         if (!checkCycleCounts(startConf, maxCycleCounts)) {
             delete origMach;
             origMach = NULL;
             return confToMinimize;
         }
  
         MachineResourceModifier::FunctionUnitMap::const_iterator fuMapIter =
             origFUMap.begin();
  
         ObjectState* currentState = origMach->saveState();
  
         // go through all different function unit types
         for (; fuMapIter != origFUMap.end(); fuMapIter++) {
             TTAMachine::Machine mach;
             mach.loadState(currentState);
             TTAMachine::Machine::FunctionUnitNavigator fuNav =
                 mach.functionUnitNavigator();
             int i = 0;
             // go through every function unit in the machine to find matching FU
             while (i < fuNav.count()) {
                 if (((*fuMapIter).second)->isArchitectureEqual(
                             fuNav.item(i), true)) {
  
                     mach.removeFunctionUnit(*fuNav.item(i));
                     std::list<std::string> socketList;
                     modifier.removeNotConnectedSockets(mach, socketList);
  
                     DSDBManager::MachineConfiguration newConfiguration;
                     RowID confID = 0;
                     CostEstimates newEstimates;
                     
                     // if the evaluation fails the removed FU is needed
                     // and the old machine state is loaded
                     if (!evalNewConfigWithoutImplementation(explorer, mach,
                             dsdb, newConfiguration, confID, newEstimates)) {
  
                         // continue with old machine state and
                         // try with next FU type
                         break;
                     }
  
                     // goes through every apps new cycles
                     if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
                         // continue with old machine state and
                         // try with next register file type
                         break;
                     }
                     latestConfID = confID;
  
                     // save the new machine state
                     delete currentState;
                     currentState = mach.saveState();
  
                     // continue removing same FU type
                     // no need to advance the FU navigator, 
                     // because of the removal
                     continue;
                 }
                 // if the units did not match, try next one in the machine
                 i++;
             }
         }
         delete origMach;
         origMach = NULL;
         if (latestConfID != 0) {
             return latestConfID;
         } else {
             // no new config could be created
             return confToMinimize; 
         }
     }

References DSDBManager::addArchitecture(), MachineResourceModifier::analyzeFunctionUnits(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), debugLog, DesignSpaceExplorer::evaluate(), TTAMachine::Machine::functionUnitNavigator(), DSDBManager::MachineConfiguration::hasImplementation, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadState(), TTAMachine::Machine::removeFunctionUnit(), MachineResourceModifier::removeNotConnectedSockets(), TTAMachine::Machine::saveState(), and DesignSpaceExplorer::setDSDB().

Here is the call graph for this function:

◆ minimizeMachine()

RowID MinimizeMachine::minimizeMachine ( RowID confToMinimize )

inlineprivate

Minimizes the number of buses, function units and register files in the given configuration in that order.

This function minimizes the buses first, then function units and then register files. Removes also the extra sockets after minimization. Won't handle implementaions (IDF handling missing from fu and rf part).

Parameters

confToMinimize	Configuration to be minimized.
maxCycles	Maximum clock cycle count that won't be exceeded.

Returns: Minimized configuration id.

Definition at line 157 of file MinimizeMachine.cc.

                                                 {
  
         // calculate maxCycleCounts for all apps
         DSDBManager& dsdb = db();
         std::vector<ClockCycleCount> maxCycleCounts;
         std::set<RowID> applicationIDs = dsdb.applicationIDs();
         std::set<RowID>::const_iterator applicationIter;
         for (applicationIter = applicationIDs.begin();
                 applicationIter != applicationIDs.end();
                 applicationIter++) {
  
             TestApplication testApplication(
                     dsdb.applicationPath(*applicationIter));
  
             if (testApplication.maxRuntime() <= 0) {
                 maxCycleCounts.push_back(0);
             } else {
                 maxCycleCounts.push_back(
                     static_cast<ClockCycleCount>(
                         testApplication.maxRuntime() * 
                         static_cast<double>(frequency_) * 
                         static_cast<double>(1000000)));
             }
         }
     
         RowID orgConfToMinimize = confToMinimize;
         if (minBus_) {
             confToMinimize = minimizeBuses(confToMinimize, maxCycleCounts);
             CostEstimates res;
             evaluate(dsdb.configuration(confToMinimize), res, true);
         }
  
         if (minFU_) {
             confToMinimize = minimizeFunctionUnits(
                 confToMinimize, 
                 maxCycleCounts);
             CostEstimates res;            
             evaluate(dsdb.configuration(confToMinimize), res, true); 
         }
  
         if (minRF_) {
             confToMinimize = minimizeRegisterFiles(
                 confToMinimize, 
                 maxCycleCounts);
             CostEstimates res;            
             evaluate(dsdb.configuration(confToMinimize), res, true); 
         }
  
         if (orgConfToMinimize == confToMinimize) {
             debugLog(
                 std::string("No new config could be generated by "
                             "MinimizeMachine plugin."));
         }
         CostEstimates res;            
         evaluate(dsdb.configuration(confToMinimize), res, true); 
         return confToMinimize;
     }

References DSDBManager::applicationIDs(), DSDBManager::applicationPath(), DSDBManager::configuration(), debugLog, and TestApplication::maxRuntime().

Here is the call graph for this function:

◆ minimizeRegisterFiles()

RowID MinimizeMachine::minimizeRegisterFiles	(	RowID	confToMinimize,
		std::vector< ClockCycleCount > &	maxCycleCounts
	)

inlineprivate

Reduces the number of register files in the machine as much as possible to still achieve the application run time requirements.

This function won't handle implementations.

Parameters

confToMinimize	ID of the machine configuration which register files are reduced.
maxCycleCounts	Max cycle counts per program.

Returns: ID of the new congiguration where register files are reduced or same that was given if nothing was done.

Definition at line 414 of file MinimizeMachine.cc.

                                                         {
  
         DSDBManager& dsdb = db();
         RowID latestConfID = 0;
  
         MachineResourceModifier modifier;
         DesignSpaceExplorer explorer;
         explorer.setDSDB(dsdb);
  
         DSDBManager::MachineConfiguration configuration =
             dsdb.configuration(confToMinimize);
  
         const TTAMachine::Machine* origMach = NULL;
         try {
             origMach = dsdb.architecture(configuration.architectureID);
         } catch (const Exception& e) {
             debugLog(std::string("No machine architecture found in config id "
                         "by MimimizeMachine plugin. "));
             delete origMach;
             return confToMinimize;
         }
  
         MachineResourceModifier::RegisterMap origRegisterMap;
         modifier.analyzeRegisters(*origMach, origRegisterMap);
  
         CostEstimates estimates;
  
         DSDBManager::MachineConfiguration startConf;
         startConf.architectureID = dsdb.addArchitecture(*origMach);
         startConf.hasImplementation = false;
  
         // evaluates the desing with all dsdb apps
         if (!explorer.evaluate(startConf, estimates, false)) {
             // can't evaluate the given configuration
             delete origMach;
             origMach = NULL;
             return confToMinimize;
         }
         
         // check if some apps maxCycles was exceeded
         if (!checkCycleCounts(startConf, maxCycleCounts)) {
             delete origMach;
             origMach = NULL;
             return confToMinimize;
         }
  
         MachineResourceModifier::RegisterMap::const_iterator registerMapIter =
             origRegisterMap.begin();
  
         ObjectState* currentState = origMach->saveState();
         // go through all different register file types
         for (; registerMapIter != origRegisterMap.end(); registerMapIter++) {
             TTAMachine::Machine mach;
             mach.loadState(currentState);
             TTAMachine::Machine::RegisterFileNavigator rfNav =
                 mach.registerFileNavigator();
  
             int i = 0;
             rfNav = mach.registerFileNavigator();
             // go through every register file in the machine to find matching RF
             while (i < rfNav.count()) {
                 if (((*registerMapIter).second)->isArchitectureEqual(
                             *rfNav.item(i))) {
  
                     // remove the register file
                     mach.removeRegisterFile(*rfNav.item(i));
                     std::list<std::string> socketList;
                     modifier.removeNotConnectedSockets(mach, socketList);
  
                     DSDBManager::MachineConfiguration newConfiguration;
                     RowID confID = 0;
                     CostEstimates newEstimates;
                     
                     // if the evaluation fails the removed RF is needed
                     // and the old machine state is loaded
                     if (!evalNewConfigWithoutImplementation(explorer, mach,
                             dsdb, newConfiguration, confID, newEstimates)) {
  
                         // continue with old machine state and
                         // try with next register file type
                         break;
                     }
  
                     // check every apps new cycle counts against
                     // maxCycleCounts
                     if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
                         // continue with old machine state and
                         // try with next register file type
                         break;
                     }
                     latestConfID = confID;
  
                     // save the new machine state
                     delete currentState;
                     currentState = mach.saveState();
  
                     // else continue removing same register types
                     // no need to advance the rf navigator, 
                     // because of the removal
                     continue;
                 }
                 // if the registers did not match, try next one in the machine
                 i++;
             }
         }
  
         delete origMach;
         origMach = NULL;
         if (latestConfID != 0) {
             return latestConfID;
         } else {
             // no new config could be created
             return confToMinimize; 
         }
     }

References DSDBManager::addArchitecture(), MachineResourceModifier::analyzeRegisters(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), debugLog, DesignSpaceExplorer::evaluate(), DSDBManager::MachineConfiguration::hasImplementation, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadState(), TTAMachine::Machine::registerFileNavigator(), MachineResourceModifier::removeNotConnectedSockets(), TTAMachine::Machine::removeRegisterFile(), TTAMachine::Machine::saveState(), and DesignSpaceExplorer::setDSDB().

Here is the call graph for this function:

◆ PLUGIN_DESCRIPTION()

MinimizeMachine::PLUGIN_DESCRIPTION ( "Removes resources until the real time " "requirements of applications are not reached anymore." )

private

◆ producesArchitecture()

virtual bool MinimizeMachine::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 90 of file MinimizeMachine.cc.

90 { return true; }

◆ readParameters()

void MinimizeMachine::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 135 of file MinimizeMachine.cc.

                           {
         readCompulsoryParameter(frequencyPN_, frequency_);
  
         readOptionalParameter(minBusPN_, minBus_);
         readOptionalParameter(minFUPN_, minFU_);
         readOptionalParameter(minRFPN_, minRF_);
     }

◆ requiresHDB()

virtual bool MinimizeMachine::requiresHDB ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 91 of file MinimizeMachine.cc.

91 { return true; }

◆ requiresSimulationData()

virtual bool MinimizeMachine::requiresSimulationData ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 92 of file MinimizeMachine.cc.

92 { return false; }

◆ requiresStartingPointArchitecture()

virtual bool MinimizeMachine::requiresStartingPointArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 89 of file MinimizeMachine.cc.

89 { return true; }

Member Data Documentation

◆ frequency_

unsigned int MinimizeMachine::frequency_

private

running frequency in MHz for apps

Definition at line 130 of file MinimizeMachine.cc.

◆ frequencyPN_

const std::string MinimizeMachine::frequencyPN_

staticprivate

Definition at line 121 of file MinimizeMachine.cc.

◆ minBus_

bool MinimizeMachine::minBus_

private

minimize busses

Definition at line 124 of file MinimizeMachine.cc.

◆ minBusPN_

const std::string MinimizeMachine::minBusPN_

staticprivate

Definition at line 118 of file MinimizeMachine.cc.

◆ minFU_

bool MinimizeMachine::minFU_

private

minimize function units

Definition at line 126 of file MinimizeMachine.cc.

◆ minFUPN_

const std::string MinimizeMachine::minFUPN_

staticprivate

Definition at line 119 of file MinimizeMachine.cc.

◆ minRF_

bool MinimizeMachine::minRF_

private

minimize register files

Definition at line 128 of file MinimizeMachine.cc.

◆ minRFPN_

const std::string MinimizeMachine::minRFPN_

staticprivate

Definition at line 120 of file MinimizeMachine.cc.

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

MinimizeMachine.cc

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MinimizeMachine()

Member Function Documentation

◆ checkCycleCounts()

◆ evalNewConfigWithoutImplementation()

◆ explore()

◆ minimizeBuses()

◆ minimizeFunctionUnits()

◆ minimizeMachine()

◆ minimizeRegisterFiles()

◆ PLUGIN_DESCRIPTION()

◆ producesArchitecture()

◆ readParameters()

◆ requiresHDB()

◆ requiresSimulationData()

◆ requiresStartingPointArchitecture()

Member Data Documentation

◆ frequency_

◆ frequencyPN_

◆ minBus_

◆ minBusPN_

◆ minFU_

◆ minFUPN_

◆ minRF_

◆ minRFPN_