Inheritance diagram for RemoveUnconnectedComponents:

Collaboration diagram for RemoveUnconnectedComponents:

Private Member Functions
	PLUGIN_DESCRIPTION ("Removes unconnected components from a configuration.")

	RemoveUnconnectedComponents ()

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	removeUnconnectedFUs (TTAMachine::Machine &mach, std::vector< std::string > &removedFUNames)

void	checkFUPorts (TTAMachine::Machine &mach)

void	checkRFPorts (TTAMachine::Machine &mach, std::vector< std::string > &removedRFNames)

void	checkBuses (TTAMachine::Machine &mach)

void	removeSockets (TTAMachine::Machine &mach)

Private Attributes
bool	allowRemoval_
	parameter allow removal of unused ports and RFs without ports. More...

Static Private Attributes
static const std::string	allowRemovalPN_

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

ParameterMap	parameters_
	Parameters for the plugin. More...

Detailed Description

Explorer plugin that removes unconnected ports from units or creates connections to these ports in case of a FUs. Also removes unconnected buses. If all ports from a unit are removed, removes also the unit.

Definition at line 57 of file RemoveUnconnectedComponents.cc.

Constructor & Destructor Documentation

◆ RemoveUnconnectedComponents()

RemoveUnconnectedComponents::RemoveUnconnectedComponents ( )

inlineprivate

Definition at line 60 of file RemoveUnconnectedComponents.cc.

                                  : DesignSpaceExplorerPlugin(), 
         allowRemoval_(false) {
  
         // compulsory parameters
         // no compulsory parameters
  
         // parameters that have a default value
         addParameter(allowRemovalPN_, BOOL, false, 
             Conversion::toString(allowRemoval_));
     }

References BOOL, and Conversion::toString().

Here is the call graph for this function:

Member Function Documentation

◆ checkBuses()

void RemoveUnconnectedComponents::checkBuses ( TTAMachine::Machine & mach )

inlineprivate

Checks buses and removes the ones that have no connections to sockets.

Parameters

mach	Machine which buses are checked.

Definition at line 300 of file RemoveUnconnectedComponents.cc.

                                              {
         Machine::SocketNavigator socketNav = mach.socketNavigator();
         Machine::BusNavigator busNav = mach.busNavigator();
         for (int i = 0; i < busNav.count(); ++i) {
             bool isConnected = false;
             for (int j = 0; j < socketNav.count(); ++j) {
                 if ((busNav.item(i))->isConnectedTo(
                             *socketNav.item(j))) {
                     isConnected = true;
                 }
             }
             // if not connected to any socket remove bus
             if (!isConnected) {
                 mach.removeBus(*busNav.item(i));
             }
         }
     }

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::removeBus(), and TTAMachine::Machine::socketNavigator().

Here is the call graph for this function:

◆ checkFUPorts()

void RemoveUnconnectedComponents::checkFUPorts ( TTAMachine::Machine & mach )

inlineprivate

Checks that every FU port has at least one connection.

Adds an new connection to some available socket if port has no connections

Parameters

mach	Machine which FU ports are checked.

Definition at line 221 of file RemoveUnconnectedComponents.cc.

                                                {
         MachineTester& tester = mach.machineTester();
         Machine::SocketNavigator socketNav = mach.socketNavigator();
  
         Machine::FunctionUnitNavigator FUNav = mach.functionUnitNavigator();
         for (int i = 0; i < FUNav.count(); ++i) {
             FunctionUnit* FU = FUNav.item(i);
             for (int j = 0; j < FU->portCount(); ++j) {
                 Port* port = FU->port(j);
                 // if no connections, make a connection to some socket
                 if (port->socketCount() < 1) {
                     Socket* socket = NULL;
                     // find a socket where FU port can be connected
                     for (int soc = 0; i < socketNav.count(); ++soc) {
                         socket = socketNav.item(soc);
                         if (tester.canConnect(*socket, *port)) {
                             port->attachSocket(*socket);
                             break;
                         }
                     }
                 }
             }
         }
     }

References TTAMachine::Port::attachSocket(), MachineTester::canConnect(), TTAMachine::Machine::Navigator< ComponentType >::count(), FU, TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::machineTester(), TTAMachine::Port::socketCount(), and TTAMachine::Machine::socketNavigator().

Here is the call graph for this function:

◆ checkRFPorts()

void RemoveUnconnectedComponents::checkRFPorts	(	TTAMachine::Machine &	mach,
		std::vector< std::string > &	removedRFNames
	)

inlineprivate

Checks that every RF port has connections.

Removes every port of a RF that has no connections to sockets if allowRemoval_ is true else makes connection to available socket. If RF ends up having no ports, removes the RF from machine.

Parameters

mach	Machine which RF ports are checked.
removedRFNames	Names of RF units that were removed from machine content only added not read in this function.

Definition at line 257 of file RemoveUnconnectedComponents.cc.

                                               {
  
         MachineTester& tester = mach.machineTester();
         Machine::SocketNavigator socketNav = mach.socketNavigator();
  
         Machine::RegisterFileNavigator RFNav = mach.registerFileNavigator();
         for (int i = 0; i < RFNav.count(); ++i) {
             RegisterFile* RF = RFNav.item(i);
             for (int j = 0; j < RF->portCount(); ++j) {
                 Port* port = RF->port(j);
                 // if no connections
                 if (port->socketCount() < 1) {
                     if (allowRemoval_) {
                         delete port;
                         port = NULL;
                         --j;
                         if (RF->portCount() < 1) {
                             mach.removeRegisterFile(*RF);
                             removedRFNames.push_back(RF->name());
                             --i;
                         } 
                     } else {
                         Socket* socket = NULL;
                         // find a socket where RF port can be connected
                         for (int soc = 0; i < socketNav.count(); ++soc) {
                             socket = socketNav.item(soc);
                             if (tester.canConnect(*socket, *port)) {
                                 port->attachSocket(*socket);
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }

References TTAMachine::Port::attachSocket(), MachineTester::canConnect(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::machineTester(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::Machine::removeRegisterFile(), RF, TTAMachine::Port::socketCount(), and TTAMachine::Machine::socketNavigator().

Here is the call graph for this function:

◆ explore()

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

inlineprivatevirtual

Removes unconnected components from a configuration.

Explorer plugin that removes unconnected ports from units or creates connections to these ports in case of a FUs. Also removes unconnected buses. If all ports from a unit are removed, removes also the unit. Removes also unconnected FUs. First unconnected sockets are removed.

Supported parameters:

allow_remove, Allows the RFs port removal and portless RFs removal.

Parameters

configurationID Configuration to optimize.

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 92 of file RemoveUnconnectedComponents.cc.

                                                                {
  
         std::vector<RowID> result;
  
         readParameters();
  
         try {
             DSDBManager& dsdb = db();
             DSDBManager::MachineConfiguration conf = 
                 dsdb.configuration(configurationID);
             
             // get the machine belonging to the configuration
             Machine* mach = NULL;
             try {
                 mach = dsdb.architecture(conf.architectureID);
             } catch (const Exception& e) {
                 return result;
             }
  
             // removes sockets not connected to any bus
             removeSockets(*mach);
  
             // removes FUs not connected to any socket by any port
             std::vector<std::string> removedFUNames;
             removeUnconnectedFUs(*mach, removedFUNames);
  
             // checks that every FU port is connected to a socket
             checkFUPorts(*mach);
  
             // register files are removed only if allow_remove parameter is
             // given, else connections to sockets are made for RFs
             std::vector<std::string> removedRFNames;
             checkRFPorts(*mach, removedRFNames);
  
             // removes buses that have no connections to any socket
             checkBuses(*mach);
  
             DSDBManager::MachineConfiguration newConf;
             if (conf.hasImplementation) {
                 newConf.hasImplementation = true;
                 IDF::MachineImplementation* idf = 
                     dsdb.implementation(conf.implementationID);
                 // removes removed RFs from idf
                 while (!removedRFNames.empty()) {
                     idf->removeRFImplementation(removedRFNames.at(
                         removedRFNames.size()-1));
                     removedRFNames.pop_back();
                 }
                 // removes removed FUs from idf
                 while (!removedFUNames.empty()) {
                     idf->removeFUImplementation(removedFUNames.at(
                         removedFUNames.size()-1));
                     removedFUNames.pop_back();
                 }
                 newConf.implementationID = 
                     dsdb.addImplementation(*idf, 0, 0);
             } else {
                 newConf.hasImplementation = false;
             }
             newConf.architectureID = dsdb.addArchitecture(*mach);
  
             RowID confID = dsdb.addConfiguration(newConf);
             result.push_back(confID);
  
         } catch (const Exception& e) {
             std::ostringstream msg(std::ostringstream::out);
             msg << "Error while using RemoveUnconnectedComponents:" 
                 << endl << e.errorMessage() << endl;
             verboseLog(msg.str());
             return result;
         }
         return result;
     }

References DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, DSDBManager::configuration(), Exception::errorMessage(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::implementation(), DSDBManager::MachineConfiguration::implementationID, IDF::MachineImplementation::removeFUImplementation(), IDF::MachineImplementation::removeRFImplementation(), and verboseLog.

Here is the call graph for this function:

◆ PLUGIN_DESCRIPTION()

RemoveUnconnectedComponents::PLUGIN_DESCRIPTION ( "Removes unconnected components from a configuration." )

private

◆ producesArchitecture()

virtual bool RemoveUnconnectedComponents::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 73 of file RemoveUnconnectedComponents.cc.

73 { return true; }

◆ readParameters()

void RemoveUnconnectedComponents::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 175 of file RemoveUnconnectedComponents.cc.

                           {
         readOptionalParameter(allowRemovalPN_, allowRemoval_);
     }

◆ removeSockets()

void RemoveUnconnectedComponents::removeSockets ( TTAMachine::Machine & mach )

inlineprivate

Removes sockets that are not needed in the machine.

Parameters

mach	Machine which extra sockets are removed.

Definition at line 323 of file RemoveUnconnectedComponents.cc.

                                                 {
         
         // remove not connected sockets
         MachineResourceModifier modifier;
         std::list<std::string> removedSocketNames;
         modifier.removeNotConnectedSockets(mach, removedSocketNames);
     }

References MachineResourceModifier::removeNotConnectedSockets().

Here is the call graph for this function:

◆ removeUnconnectedFUs()

void RemoveUnconnectedComponents::removeUnconnectedFUs	(	TTAMachine::Machine &	mach,
		std::vector< std::string > &	removedFUNames
	)

inlineprivate

Removes totally unconnected FUs.

Parameters

mach	Machine which unconnected FUs are removed.
removedFUNames	Names of FU units that were removed from machine

Definition at line 186 of file RemoveUnconnectedComponents.cc.

                                               {
  
         //MachineTester& tester = mach.machineTester();
         Machine::SocketNavigator socketNav = mach.socketNavigator();
  
         Machine::FunctionUnitNavigator FUNav = mach.functionUnitNavigator();
         for (int i = 0; i < FUNav.count(); ++i) {
             FunctionUnit* FU = FUNav.item(i);
             bool noConnections = true;
             for (int j = 0; j < FU->portCount(); ++j) {
                 Port* port = FU->port(j);
                 // if no connections
                 if (port->socketCount() > 0) {
                     noConnections = false;
                     break;
                 }
             }
             // remove FU if it did not have any connections
             if (noConnections) {
                 mach.removeFunctionUnit(*FU);
                 removedFUNames.push_back(FU->name());
                 --i;
             }
         }
     }