torc::physical::ModuleTransformer Class Reference

Utility class to modularize/flatten designs. More...

#include <ModuleTransformer.hpp>

Collaboration diagram for torc::physical::ModuleTransformer:

Public Member Functions
	ModuleTransformer (DesignSharedPtr &inDesignPtr)
	Public constructor. More...
bool	modularize (const InstanceSharedPtrVector &inInstances, const string &inModuleDefinitionName, const string &inModuleInstanceName, bool inKeepPlacement=false, bool inKeepRouting=false)
	Group a set of instances into a module. More...
bool	flatten (const string &inModuleInstanceName, bool inKeepPlacement=false, bool inKeepRouting=false)
	Flatten a module instance in a design. More...

Protected Types
enum	ENetConnectivity { eNetConnectivityNotConnected = 0, eNetConnectivityInternal, eNetConnectivityExternal }
	Net connectivity with respect to module instance, either not connected to module, internal to module, or external to module. More...
typedef Design::InstanceSharedPtrConstIterator	InstanceSharedPtrConstIterator
	Imported type. More...
typedef Design::NetSharedPtrIterator	NetSharedPtrIterator
	Imported type. More...
typedef Design::ModuleSharedPtrIterator	ModuleSharedPtrIterator
	Imported type. More...
typedef Design::InstanceSharedPtrIterator	InstanceSharedPtrIterator
	Imported type. More...
typedef Module::PortSharedPtrConstIterator	PortSharedPtrConstIterator
	Imported type. More...
typedef Net::InstancePinSharedPtrIterator	InstancePinSharedPtrIterator
	Imported type. More...
typedef Net::InstancePinSharedPtrConstIterator	InstancePinSharedPtrConstIterator
	Imported type. More...
typedef Net::PipConstIterator	PipConstIterator
	Imported type. More...

Protected Attributes
DesignSharedPtr	mDesignPtr
	Design pointer. More...

Static Protected Attributes
static const string	sHierarchySeparator = "/"
	Hierarchy separator. More...
static const string	sPortIndexSeparator = "_"
	Port index separator. More...
static const boost::regex	sValidPinNameCharactersRegEx
	Valid characters in a pin name. More...
static const boost::regex	sInvalidPinNameFirstCharactersRegEx
	Invalid first characters in a pin name. More...

Private Member Functions
ENetConnectivity	getNetConnectivity (InstanceSharedPtrConstIterator inInstanceSharedPtrConstBegin, InstanceSharedPtrConstIterator inInstanceSharedPtrConstEnd, NetSharedPtr inNetPtr)
	Generate net connectivity type based on module boundary. More...
string	sanitizePinName (string inPinName)
	Sanitize a pin name. More...
InstanceSharedPtr	cloneInstance (InstanceSharedPtr inIntancePtr, const string &inCloneInstanceName)
	Clone an instance. More...
NetSharedPtr	cloneNet (NetSharedPtr inNetPtr, const string &inNetCloneName, const string &inModuleInstanceName)
	Clone a net. More...

Detailed Description

Utility class to modularize/flatten designs.

Definition at line 34 of file ModuleTransformer.hpp.

Member Typedef Documentation

typedef Net::InstancePinSharedPtrConstIterator torc::physical::ModuleTransformer::InstancePinSharedPtrConstIterator

protected

Imported type.

Definition at line 51 of file ModuleTransformer.hpp.

typedef Net::InstancePinSharedPtrIterator torc::physical::ModuleTransformer::InstancePinSharedPtrIterator

protected

Imported type.

Definition at line 49 of file ModuleTransformer.hpp.

typedef Design::InstanceSharedPtrConstIterator torc::physical::ModuleTransformer::InstanceSharedPtrConstIterator

protected

Imported type.

Definition at line 39 of file ModuleTransformer.hpp.

typedef Design::InstanceSharedPtrIterator torc::physical::ModuleTransformer::InstanceSharedPtrIterator

protected

Imported type.

Definition at line 45 of file ModuleTransformer.hpp.

typedef Design::ModuleSharedPtrIterator torc::physical::ModuleTransformer::ModuleSharedPtrIterator

protected

Imported type.

Definition at line 43 of file ModuleTransformer.hpp.

typedef Design::NetSharedPtrIterator torc::physical::ModuleTransformer::NetSharedPtrIterator

protected

Imported type.

Definition at line 41 of file ModuleTransformer.hpp.

typedef Net::PipConstIterator torc::physical::ModuleTransformer::PipConstIterator

protected

Imported type.

Definition at line 53 of file ModuleTransformer.hpp.

typedef Module::PortSharedPtrConstIterator torc::physical::ModuleTransformer::PortSharedPtrConstIterator

protected

Imported type.

Definition at line 47 of file ModuleTransformer.hpp.

Member Enumeration Documentation

enum torc::physical::ModuleTransformer::ENetConnectivity

protected

Net connectivity with respect to module instance, either not connected to module, internal to module, or external to module.

Enumerator
eNetConnectivityNotConnected
eNetConnectivityInternal
eNetConnectivityExternal

Definition at line 68 of file ModuleTransformer.hpp.

                              {
            eNetConnectivityNotConnected = 0, eNetConnectivityInternal, eNetConnectivityExternal
        };

Constructor & Destructor Documentation

torc::physical::ModuleTransformer::ModuleTransformer ( DesignSharedPtr &  inDesignPtr )

inline

Public constructor.

Parameters

inDesignPtr

Pointer to the design.

Definition at line 76 of file ModuleTransformer.hpp.

: mDesignPtr(inDesignPtr) {}

Member Function Documentation

InstanceSharedPtr torc::physical::ModuleTransformer::cloneInstance ( InstanceSharedPtr  inIntancePtr, const string &  inCloneInstanceName  )

inlineprivate

Clone an instance.

Parameters

inIntancePtr	A pointer to the instance to be cloned.
inCloneInstanceName	The name of the clone.

Clone an instance and its configuration. This function does not clone the instance pins. Instance pins are handled when cloning nets, in function cloneNet.

Definition at line 872 of file ModuleTransformer.hpp.

                                               {

            // Clone inInstancePtr
            InstanceSharedPtr inInstanceClonePtr = Factory::newInstancePtr(inCloneInstanceName,
                inIntancePtr->getType(), inIntancePtr->getTile(), inIntancePtr->getSite(),
                inIntancePtr->getBonding());

            // Begin clone inIntance configuration
            // Get a begin iterator to inIntance config
            ConfigMap::const_iterator instanceConfigBegin = inIntancePtr->configBegin();
            // Get an end iterator to inIntance config
            ConfigMap::const_iterator instanceConfigEnd = inIntancePtr->configEnd();
            // Configuration map
            ConfigMap configMap;

            // Iterate over all configuration
            while(instanceConfigBegin != instanceConfigEnd) {

                // Get current setting
                const string setting = instanceConfigBegin->first;
                // Get current configuration
                const Config config = instanceConfigBegin->second;
                // Add (setting,configuration) to configuration map
                configMap.setConfig(setting, config);
                // Move to the next configuration
                instanceConfigBegin++;

            }

            // Add configurations to instance clone
            inInstanceClonePtr->addConfigs(configMap);
            // End clone inInstance configuration

            // Return cloned instance
            return inInstanceClonePtr;
        }

Here is the call graph for this function:

NetSharedPtr torc::physical::ModuleTransformer::cloneNet ( NetSharedPtr  inNetPtr, const string &  inNetCloneName, const string &  inModuleInstanceName  )

inlineprivate

Clone a net.

Parameters

inNetPtr	A pointer to the net to be cloned.
inNetCloneName	The name of the clone.
inModuleInstanceName	The module instance name.

Clone a net, its configuration, its sources, sinks and pips. For pips, the routethrough instances are droppped and not cloned.

Todo:

We are dropping routethrough instances.

Definition at line 916 of file ModuleTransformer.hpp.

                                                {

            // Clone inNetPtr
            NetSharedPtr inNetClonePtr = Factory::newNetPtr(inNetCloneName, inNetPtr->getNetType());

            // Begin clone inNetPtr configuration
            // Get a begin iterator to net config
            ConfigMap::const_iterator netConfigBegin = inNetPtr->configBegin();
            // Get an end iterator to net config
            ConfigMap::const_iterator netConfigEnd = inNetPtr->configEnd();
            // Configuration map
            ConfigMap configMap;

            // Iterate over all configuration
            while(netConfigBegin != netConfigEnd) {

                // Get current setting
                const string setting = netConfigBegin->first;
                // Get current configuration
                const Config config = netConfigBegin->second;
                // Add (setting,configuration) to configuration map
                configMap.setConfig(setting, config);
                // Move to the next configuration
                netConfigBegin++;

            }

            // Add configurations to net clone
            inNetClonePtr->addConfigs(configMap);
            // End clone inNetPtr configuration

            // Begin clone inNetPtr sources
            // Get a begin iterator to net sources
            InstancePinSharedPtrConstIterator inNetSourcesBegin = inNetPtr->sourcesBegin();
            // Get an end iterator to net sources
            InstancePinSharedPtrConstIterator inNetSourcesEnd = inNetPtr->sourcesEnd();

            // Iterate over all source pins
            while(inNetSourcesBegin != inNetSourcesEnd) {

                // Get pointer to current net pin
                InstancePinSharedPtr instPinPtr = *inNetSourcesBegin;
                // Get net pin reference instance
                InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
                // Find the cloned instance that correspond to the pin reference instance
                InstanceSharedPtrIterator pinInstPtrCloneItr = mDesignPtr->findInstance(
                    inModuleInstanceName + sHierarchySeparator + pinInstPtr->getName());
                // Clone source pin
                InstancePinSharedPtr instPinPtrClone 
                    = Factory::newInstancePinPtr(*pinInstPtrCloneItr, instPinPtr->getPinName());
                // Add pin clone to the net clone
                inNetClonePtr->addSource(instPinPtrClone);
                // Move to next source
                inNetSourcesBegin++;

            }
            // End clone inNetPtr sources

            // Begin clone inNetPtr sinks
            // Get a begin iterator to net sinks
            InstancePinSharedPtrConstIterator inNetSinksBegin = inNetPtr->sinksBegin();
            // Get an end iterator to net sinks
            InstancePinSharedPtrConstIterator inNetSinksEnd = inNetPtr->sinksEnd();

            // Iterate over all sink pins
            while(inNetSinksBegin != inNetSinksEnd) {

                // Get pointer to current net pin
                InstancePinSharedPtr instPinPtr = *inNetSinksBegin;
                // Get net pin reference instance
                InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
                // Find the cloned instance that correspond to the pin reference instance
                InstanceSharedPtrIterator pinInstPtrCloneItr = mDesignPtr->findInstance(
                    inModuleInstanceName + sHierarchySeparator + pinInstPtr->getName());
                // Clone sink pin
                InstancePinSharedPtr instPinPtrClone 
                    = Factory::newInstancePinPtr(*pinInstPtrCloneItr, instPinPtr->getPinName());
                // Add pin clone to the net clone
                inNetClonePtr->addSink(instPinPtrClone);
                // Move to next sink
                inNetSinksBegin++;

            }
            // End clone inNetPtr sinks

            // Begin clone inNetPtr pips
            // Get a begin iterator to net pips
            PipConstIterator inNetPipsBegin = inNetPtr->pipsBegin();
            // Get an end iterator to net pips
            PipConstIterator inNetPipsEnd = inNetPtr->pipsEnd();

            // Iterate over all pips
            while(inNetPipsBegin != inNetPipsEnd) {

                // Get a pointer to the current pip
                Pip pipPtr = *inNetPipsBegin;
                /// \todo We are dropping routethrough instances.
                // Clone the pip
                Pip pipClone = Factory::newPip(pipPtr.getTileName(), pipPtr.getSourceWireName(),
                    pipPtr.getSinkWireName(), pipPtr.getDirection());
                // Add pip clone to cloned net
                inNetClonePtr->addPip(pipClone);
                // Move to next pip
                inNetPipsBegin++;

            }
            // End clone inNetPtr pips

            // Return cloned net
            return inNetClonePtr;
        }

Here is the call graph for this function:

bool torc::physical::ModuleTransformer::flatten ( const string &  inModuleInstanceName, bool  inKeepPlacement = false, bool  inKeepRouting = false  )

inline

Flatten a module instance in a design.

Parameters

inModuleInstanceName	The name of the module instance to be flattened.
inKeepPlacement	A flag specifying whether placement should be retained after flattening. Default to false.
inKeepRouting	A flag specifying whether routing should be retained afer flattening. Defaults to false.

Definition at line 481 of file ModuleTransformer.hpp.

                                        {

            // Flattened module source pins
            InstancePinSharedPtrVector flattenedModuleSourcePinPtrVector;
            // Flattened module sink pins
            InstancePinSharedPtrVector flattenedModuleSinkPinPtrVector;
            // Look for the module instance in the design
            InstanceSharedPtrConstIterator designModInstPtrConstIter 
                = mDesignPtr->findInstance(inModuleInstanceName);

            // Check for a non-existent module instance
            if(designModInstPtrConstIter == mDesignPtr->instancesEnd()) {

                // Warn the user that the module instance was not found in the design
                std::clog << "WARNING: Module instance of name " << inModuleInstanceName
                    << " was not found in design " << mDesignPtr->getName() << "." << std::endl;

                // Operation did not complete successfully
                return false;

            }

            // Get a pointer to the instance
            InstanceSharedPtr instPtr = *designModInstPtrConstIter;
            // Look for the module in the design
            ModuleSharedPtrIterator designModPtrConstIter 
                = mDesignPtr->findModule(instPtr->getType());

            // Check for a non-existent module
            if(designModPtrConstIter == mDesignPtr->modulesEnd()) {

                // Warn the user that the module was not found in the design
                std::clog << "WARNING: Module of name " << instPtr->getType()
                    << " was not found in design " << mDesignPtr->getName() << "." << std::endl;

                // Operation did not complete successfully
                return false;

            }

            // Current design module
            ModuleSharedPtr module = *designModPtrConstIter;

            // Check whether tile/site for module instance is same as tile/site for module def.
            // In case they don't match, the flattened module instance will be unplaced and any
            // external/internal nets to the module instance will be unrouted.
            InstanceSharedPtrIterator moduleAnchorInstIterator 
                = module->findInstance(module->getAnchor());
            InstanceSharedPtr moduleAnchorInst = *moduleAnchorInstIterator;
            // Begin handle instances inside module
            // Get a begin iterator to module instances
            InstanceSharedPtrIterator moduleInstancesIter = module->instancesBegin();
            // Get an end iterator to module instances
            InstanceSharedPtrIterator moduleInstancesEnd = module->instancesEnd();

            // Iterate over all instances hosted by the module
            while(moduleInstancesIter != moduleInstancesEnd) {

                // Get a pointer to the current instance hosted by the module
                InstanceSharedPtr modInstPtr = *moduleInstancesIter;
                // Clone the instance
                InstanceSharedPtr modInstPtrClone = cloneInstance(modInstPtr,
                    inModuleInstanceName + sHierarchySeparator + modInstPtr->getName());
                // Set clone instance reference
                modInstPtrClone->setInstanceReferencePtr(Factory::newInstanceReferencePtr(
                    inModuleInstanceName, module, modInstPtr));

                // Unplace the instance if so requested
                if(!inKeepPlacement) modInstPtrClone->unplace();

                // Add clone of instance to design
                mDesignPtr->addInstance(modInstPtrClone);

                // Next instance
                moduleInstancesIter++;

            } // while(moduleInstancesIter != moduleInstancesEnd)
            // End handle instances inside module

            // Begin handle internal module nets
            // Get a begin iterator to module nets
            NetSharedPtrIterator moduleNetsIter = module->netsBegin();
            // Get an end iterator to module nets
            NetSharedPtrIterator moduleNetsEnd = module->netsEnd();

            // Iterate over all nets inside module
            while(moduleNetsIter != moduleNetsEnd) {

                // Get a pointer to the current net
                NetSharedPtr moduleNetPtr = *moduleNetsIter;
                // Clone the net
                NetSharedPtr moduleNetPtrClone = cloneNet(moduleNetPtr, inModuleInstanceName
                    + sHierarchySeparator + moduleNetPtr->getName(), inModuleInstanceName);

                // Unroute the net if so requested
                if(!inKeepRouting) moduleNetPtrClone->unroute();

                // Add net to design
                mDesignPtr->addNet(moduleNetPtrClone);
                // Next net
                moduleNetsIter++;

            } // End handle internal module nets

            // Begin handle external module nets
            // Get a begin iterator to design nets
            NetSharedPtrIterator designNetsIter = mDesignPtr->netsBegin();
            // Get an end iterator to design nets
            NetSharedPtrIterator designNetsEnd = mDesignPtr->netsEnd();

            // Iterate over all nets connected to module and other instances outside module
            while(designNetsIter != designNetsEnd) {

                // Get a pointer to the current net
                NetSharedPtr designNetPtr = *designNetsIter;

                // Get a begin iterator to net sources
                InstancePinSharedPtrIterator designNetSourcesIter = designNetPtr->sourcesBegin();
                // Get an end iterator to net sources
                InstancePinSharedPtrIterator designNetSourcesEnd = designNetPtr->sourcesEnd();

                // Iterate over all net sources
                while(designNetSourcesIter != designNetSourcesEnd) {

                    // Net pin
                    InstancePinSharedPtr instPinPtr = *designNetSourcesIter;
                    // Pin instance
                    InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();

                    // Net connects to module instance
                    if(pinInstPtr == instPtr) {

                        // Unroute the net if so requested
                        if(!inKeepRouting) designNetPtr->unroute();

                        // Look for the port in the module
                        PortSharedPtrConstIterator modulePortConstIter 
                            = module->findPort(instPinPtr->getPinName());

                        // Check if port was found
                        if(modulePortConstIter != module->portsEnd()) {

                            // Get a pointer to the current port
                            PortSharedPtr modPortPtr = *modulePortConstIter;
                            // Get module port reference instance
                            InstanceSharedPtr portInstPtr = modPortPtr->getInstancePtr().lock();
                            // Find the cloned instance corresponding to the pin reference instance
                            InstanceSharedPtrIterator pinInstPtrCloneItr 
                                = mDesignPtr->findInstance(inModuleInstanceName
                                + sHierarchySeparator + portInstPtr->getName());
                            // Create new pin referencing the port reference instance
                            flattenedModuleSourcePinPtrVector.push_back(
                                Factory::newInstancePinPtr(*pinInstPtrCloneItr,
                                modPortPtr->getPinName()));
                            // Remove pin reference module instance
                            designNetPtr->removeSource(instPinPtr);
                            // Update designNetSourcesEnd iterator
                            designNetSourcesEnd = designNetPtr->sourcesEnd();

                        }

                    } else {

                        // Move to next source
                        designNetSourcesIter++;

                    }
                } // while(designNetSourcesIter != designNetSourcesEnd)

                // Get a begin iterator to flattened module source pins
                InstancePinSharedPtrIterator flattenedModuleSourcesIter 
                    = flattenedModuleSourcePinPtrVector.begin();
                // Get an end iterator to flattened module source pins
                InstancePinSharedPtrIterator flattenedModuleSourcesEnd 
                    = flattenedModuleSourcePinPtrVector.end();

                // Update net sources with new source pins
                while(flattenedModuleSourcesIter != flattenedModuleSourcesEnd) {

                    // Add source pin to net
                    designNetPtr->addSource(*flattenedModuleSourcesIter);
                    // Move to next source
                    flattenedModuleSourcesIter++;
                }

                // Reset vector
                flattenedModuleSourcePinPtrVector.clear();
                // Get a begin iterator to net sinks
                InstancePinSharedPtrIterator designNetSinksIter = designNetPtr->sinksBegin();
                // Get an end iterator to net sinks
                InstancePinSharedPtrIterator designNetSinksEnd = designNetPtr->sinksEnd();

                // Iterate over all net sinks
                while(designNetSinksIter != designNetSinksEnd) {

                    // Net pin
                    InstancePinSharedPtr instPinPtr = *designNetSinksIter;
                    // Pin instance
                    InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();

                    // Net connets to module instance
                    if(pinInstPtr == instPtr) {

                        // Unroute the net if so requested
                        if(!inKeepRouting) designNetPtr->unroute();

                        // Look for the port in the module
                        PortSharedPtrConstIterator modulePortConstIter 
                            = module->findPort(instPinPtr->getPinName());

                        // Check if port was found
                        if(modulePortConstIter != module->portsEnd()) {

                            // Get a pointer to the current port
                            PortSharedPtr modPortPtr = *modulePortConstIter;
                            // Get module port reference instance
                            InstanceSharedPtr portInstPtr = modPortPtr->getInstancePtr().lock();
                            // Find the cloned instance corresponding to the pin reference instance
                            InstanceSharedPtrIterator pinInstPtrCloneItr 
                                = mDesignPtr->findInstance(inModuleInstanceName
                                + sHierarchySeparator + portInstPtr->getName());
                            // Create new pin referencing the port reference instance
                            flattenedModuleSinkPinPtrVector.push_back(
                                Factory::newInstancePinPtr(*pinInstPtrCloneItr,
                                modPortPtr->getPinName()));
                            // Remove pin reference module instance
                            designNetPtr->removeSink(instPinPtr);
                            // Update designNetSinksEnd iterator
                            designNetSinksEnd = designNetPtr->sinksEnd();
                        }

                    } else {

                        // Move to next source
                        designNetSinksIter++;

                    }
                } // while(designNetSinksIter != designNetSinksEnd)

                // Get a begin iterator to flattened module sink pins
                InstancePinSharedPtrIterator flattenedModuleSinksBegin 
                    = flattenedModuleSinkPinPtrVector.begin();
                // Get an end iterator to flattened module sink pins
                InstancePinSharedPtrIterator flattenedModuleSinksEnd 
                    = flattenedModuleSinkPinPtrVector.end();

                // Update net sources with new source pins
                while(flattenedModuleSinksBegin != flattenedModuleSinksEnd) {

                    // Add sink pin to net
                    designNetPtr->addSink(*flattenedModuleSinksBegin);
                    // Move to next sink
                    flattenedModuleSinksBegin++;

                }

                // Reset vector
                flattenedModuleSinkPinPtrVector.clear();

                // Move to next net
                designNetsIter++;

            } // while(designNetsIter != designNetsEnd)
            // End handle external module nets

            // Remove module instance from design
            mDesignPtr->removeInstance(instPtr);

            // Operation successfully completed
            return true;
        }

Here is the caller graph for this function:

ENetConnectivity torc::physical::ModuleTransformer::getNetConnectivity ( InstanceSharedPtrConstIterator  inInstanceSharedPtrConstBegin, InstanceSharedPtrConstIterator  inInstanceSharedPtrConstEnd, NetSharedPtr  inNetPtr  )

inlineprivate

Generate net connectivity type based on module boundary.

Parameters

inInstanceSharedPtrConstBegin	A begin iterator to instances contained in module.
inInstanceSharedPtrConstEnd	An end iterator to instances contained in module.
inNetPtr	A pointer to a net.

Definition at line 760 of file ModuleTransformer.hpp.

                                                                                               {

            // Net connectivity type
            ENetConnectivity netConnectivity = eNetConnectivityNotConnected;
            // Is net connected to module?
            bool isNetConnectedToModule = false;
            // Is net crossing module boundary?
            bool isNetInterToModule = false;
            // Get a begin iterator to net sources
            InstancePinSharedPtrIterator sourcesBegin = inNetPtr->sourcesBegin();
            // Get an end iterator to net sources
            InstancePinSharedPtrIterator sourcesEnd = inNetPtr->sourcesEnd();

            // Iterate over all sources
            while(sourcesBegin != sourcesEnd) {

                // Get a pointer to the current source pin
                InstancePinSharedPtr instPinPtr = *sourcesBegin;
                // Get a pointer to the instance that hosts the pin
                InstanceSharedPtr pinInst = instPinPtr->getInstancePtr().lock();

                // Look for the instance in the vector of instances
                if((std::find(inInstanceSharedPtrConstBegin, inInstanceSharedPtrConstEnd, pinInst))
                    != inInstanceSharedPtrConstEnd) {

                    // Net connects to instance inside module boundary
                    isNetConnectedToModule = true;

                } else {

                    // Net connects to instance outside module boundary
                    isNetInterToModule = true;

                }

                // Move to next source
                sourcesBegin++;
            }

            // Get a begin iterator to net sinks
            InstancePinSharedPtrIterator sinksBegin = inNetPtr->sinksBegin();
            // Get an end iterator to net sinks
            InstancePinSharedPtrIterator sinksEnd = inNetPtr->sinksEnd();

            // Iterate over all sinks
            while(sinksBegin != sinksEnd) {

                // Get a pointer to the current sink pin
                InstancePinSharedPtr instPinPtr = *sinksBegin;
                // Get a pointer to the instance that hosts the pin
                InstanceSharedPtr pinInst = instPinPtr->getInstancePtr().lock();
                // Look for the instance in the vector of instances
                if((std::find(inInstanceSharedPtrConstBegin, inInstanceSharedPtrConstEnd, pinInst))
                    != inInstanceSharedPtrConstEnd) {
                    // Net connects to instance inside module boundary
                    isNetConnectedToModule = true;
                } else {
                    // Net connects to instance outside module boundary
                    isNetInterToModule = true;
                }
                // Move to the next sink
                sinksBegin++;
            }

            if(isNetConnectedToModule) { // Net connects to module
                if(isNetInterToModule) {
                    netConnectivity = eNetConnectivityExternal; // Net crosses module boundary
                } else {
                    netConnectivity = eNetConnectivityInternal; // Net lies within module boundary
                }
            }

            // Return net connectivity type
            return netConnectivity;
        }

bool torc::physical::ModuleTransformer::modularize ( const InstanceSharedPtrVector &  inInstances, const string &  inModuleDefinitionName, const string &  inModuleInstanceName, bool  inKeepPlacement = false, bool  inKeepRouting = false  )

inline

Group a set of instances into a module.

Parameters

inInstances	The vector of instances to group.
inModuleDefinitionName	The module definition name.
inModuleInstanceName	The module instance name.
inKeepPlacement	A flag specifying whether placement should be retained after modularization. Default to false.
inKeepRouting	A flag specifying whether routing should be retained afer modularization. Defaults to false.

Definition at line 147 of file ModuleTransformer.hpp.

                                                                      {

            // Get a current iterator to inInstances
            InstanceSharedPtrConstIterator inInstanceSharedPtrConstIter = inInstances.begin();
            // Get an end iterator to inInstances
            InstanceSharedPtrConstIterator inInstanceSharedPtrConstEnd = inInstances.end();

            // Check if inInstances is empty
            if(inInstanceSharedPtrConstIter == inInstanceSharedPtrConstEnd) {

                // Warn the user that none of the instances specified are found in the design
                std::clog << "WARNING: There were no instances specified to be modularized. "
                    << std::endl;

                // Operation did not complete successfully
                return false;

            }

            // Set the first returned instance as a reference point
            InstanceSharedPtr moduleReferenceInst = *inInstanceSharedPtrConstIter;
            // Create module definition
            ModuleSharedPtr moduleDefinition = Factory::newModulePtr(inModuleDefinitionName,
                moduleReferenceInst->getName());
            // Create module instance
            InstanceSharedPtr moduleInst = Factory::newInstancePtr(inModuleInstanceName,
                inModuleDefinitionName, moduleReferenceInst->getTile(),
                moduleReferenceInst->getSite());

            // Unplace module instance if so requested
            if(!inKeepPlacement) moduleInst->unplace();

            // Begin handle instances
            // Iterate over all instances in inInstances
            while(inInstanceSharedPtrConstIter != inInstanceSharedPtrConstEnd) {

                // Get a pointer to the current instance
                InstanceSharedPtr instPtr = *inInstanceSharedPtrConstIter;

                // Look for the current instance in the design
                InstanceSharedPtrConstIterator instPtrIter 
                    = mDesignPtr->findInstance(instPtr->getName());

                // Warn if the instance was not found
                if(instPtrIter == mDesignPtr->instancesEnd()) {

                    // Warn the user that the instance was not found in the design.
                    std::clog << "WARNING: Instance " << instPtr->getName()
                        << "was not found in design " << mDesignPtr->getName() << std::endl;
                    // Operation did not complete successfully
                    return false;

                }

                // Get a pointer to the looked up instance
                InstanceSharedPtr designInstPtr = *instPtrIter;

                // Unplace instance if so requested
                if(!inKeepPlacement) designInstPtr->unplace();

                // Add instance to module
                moduleDefinition->addInstance(designInstPtr);
                // Remove instance from design
                mDesignPtr->removeInstance(designInstPtr);

                // Move to next instance
                inInstanceSharedPtrConstIter++;

            } // while(inInstanceSharedPtrConstIter != inInstanceSharedPtrConstEnd)
            // End handle instances

            // Begin handle connectivity
            // Get a begin iterator to design nets
            NetSharedPtrIterator designNetsIter = mDesignPtr->netsBegin();
            // Get an end iterator to design nets
            NetSharedPtrIterator designNetsEnd = mDesignPtr->netsEnd();
            // Get a begin iterator to module hosted instances
            InstanceSharedPtrConstIterator modHostedInstPtrConstBegin 
                = moduleDefinition->instancesBegin();
            // Get an end iterator to module hosted instances
            InstanceSharedPtrConstIterator modHostedInstPtrConstEnd 
                = moduleDefinition->instancesEnd();
            // Module instance source pins
            InstancePinSharedPtrVector modInstSourcePinPtrVector;
            // Module instance sink pins
            InstancePinSharedPtrVector modInstSinkPinPtrVector;

            // Iterate over all design nets
            while(designNetsIter != designNetsEnd) {

                // Get a pointer to the current net
                NetSharedPtr designNetPtr = *designNetsIter;
                // Compute net connectivity type
                ENetConnectivity eNet = getNetConnectivity(modHostedInstPtrConstBegin,
                    modHostedInstPtrConstEnd, designNetPtr);

                // For internal nets, move net from design to module
                if(eNet == eNetConnectivityInternal) {

                    // Unroute the net if so requested
                    if(!inKeepRouting) designNetPtr->unroute();

                    // Add net to module
                    moduleDefinition->addNet(designNetPtr);
                    // Remove net from design
                    mDesignPtr->removeNet(designNetPtr);
                    // Update designNetsEnd iterator
                    designNetsEnd = mDesignPtr->netsEnd();

                } else {

                    // For unconnected nets, increment the iterator and continue looping
                    if(eNet == eNetConnectivityNotConnected) {

                        // Move to next net
                        designNetsIter++;
                        continue;

                    }

                    // For external nets, expose corresponding pins and update connectivity
                    // Unroute the net if so requested
                    if(!inKeepRouting) designNetPtr->unroute();

                    // Get a begin iterator to net sources
                    InstancePinSharedPtrIterator designNetSourcesIter 
                        = designNetPtr->sourcesBegin();
                    // Get an end iterator to net sources
                    InstancePinSharedPtrIterator designNetSourcesEnd = designNetPtr->sourcesEnd();
                    // Wire index used when creating ports
                    u_int32_t portIndex = 0;

                    // Iterate over all net sources
                    while(designNetSourcesIter != designNetSourcesEnd) {

                        // Get a pointer to the current net source pin
                        InstancePinSharedPtr instPinPtr = *designNetSourcesIter;
                        // Get a pointer to the instance hosting the net source pin
                        InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();

                        // Look for the instance in the vector of instances
                        if((std::find(modHostedInstPtrConstBegin, modHostedInstPtrConstEnd,
                            pinInstPtr)) != modHostedInstPtrConstEnd) {

                            // Build port name: netName_portIndex
                            string portName = sanitizePinName(designNetPtr->getName())
                                + sPortIndexSeparator 
                                + boost::lexical_cast<std::string>(portIndex++);
                            // Create port
                            PortSharedPtr portPtr = Factory::newPortPtr(portName, *(std::find(
                                modHostedInstPtrConstBegin, modHostedInstPtrConstEnd,
                                pinInstPtr)), instPinPtr->getPinName());
                            // Add port to module
                            moduleDefinition->addPort(portPtr);
                            // Create source pin from the module instance
                            modInstSourcePinPtrVector.push_back(
                                Factory::newInstancePinPtr(moduleInst, portName));
                            // Remove old source pin from net
                            designNetPtr->removeSource(instPinPtr);
                            // Update designNetSourcesEnd iterator
                            designNetSourcesEnd = designNetPtr->sourcesEnd();

                        } else {

                            // Move to next source
                            designNetSourcesIter++;

                        }
                    } // while(designNetSourcesIter != designNetSourcesEnd)

                    // Get a begin iterator to module source pins
                    InstancePinSharedPtrIterator modInstSourcesIter =
                        modInstSourcePinPtrVector.begin();
                    // Get an end iterator to module source pins
                    InstancePinSharedPtrIterator modInstSourcesEnd =
                        modInstSourcePinPtrVector.end();

                    // Update net sources with new source pins
                    while(modInstSourcesIter != modInstSourcesEnd) {

                        // Add source pin to net
                        designNetPtr->addSource(*modInstSourcesIter);
                        // Move to next source
                        modInstSourcesIter++;

                    }

                    // Reset module instance source pins vector
                    modInstSourcePinPtrVector.clear();
                    // Get a begin iterator to net sinks
                    InstancePinSharedPtrIterator designNetSinksIter = designNetPtr->sinksBegin();
                    // Get an end iterator to net sinks
                    InstancePinSharedPtrIterator designNetSinksEnd = designNetPtr->sinksEnd();

                    // Iterate over all net sinks
                    while(designNetSinksIter != designNetSinksEnd) {

                        // Get a pointer to the current net sink pin
                        InstancePinSharedPtr instPinPtr = *designNetSinksIter;
                        // Get a pointer to the instance hosting the net source pin
                        InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();

                        // Look for the instance in the vector of instances
                        if((std::find(modHostedInstPtrConstBegin, modHostedInstPtrConstEnd,
                            pinInstPtr)) != modHostedInstPtrConstEnd) {

                            // Build port name: netName_portIndex
                            string portName = sanitizePinName(designNetPtr->getName())
                                + sPortIndexSeparator + boost::lexical_cast<std::string>(
                                portIndex++);
                            // Create port
                            PortSharedPtr portPtr = Factory::newPortPtr(portName, *(std::find(
                                modHostedInstPtrConstBegin, modHostedInstPtrConstEnd,
                                pinInstPtr)), instPinPtr->getPinName());
                            // Add port to module
                            moduleDefinition->addPort(portPtr);
                            // Create sink pin to the module instance
                            modInstSinkPinPtrVector.push_back(Factory::newInstancePinPtr(
                                moduleInst, portName));
                            // Remove old sink pin from net
                            designNetPtr->removeSink(instPinPtr);
                            // Update designNetSinksEnd iterator
                            designNetSinksEnd = designNetPtr->sinksEnd();

                        } else {

                            // Move to next sink
                            designNetSinksIter++;

                        }
                    } // while(designNetSinksIter != designNetSinksEnd)

                    // Get a begin iterator to module sink pins
                    InstancePinSharedPtrIterator modInstSinksIter =
                        modInstSinkPinPtrVector.begin();
                    // Get an end iterator to module sink pins
                    InstancePinSharedPtrIterator modInstSinksEnd =
                        modInstSinkPinPtrVector.end();

                    // Update net sources with new source pins
                    while(modInstSinksIter != modInstSinksEnd) {

                        // Add sink pin to net
                        designNetPtr->addSink(*modInstSinksIter);
                        // Move to next sink
                        modInstSinksIter++;

                    }

                    // Reset module instance sink pins vector
                    modInstSinkPinPtrVector.clear();

                    // Move to next net
                    designNetsIter++;

                } // else
            } // while(designNetsIter != designNetsEnd)
            // End handle connectivity

            // Add module to design
            mDesignPtr->addModule(moduleDefinition);
            // Add module instance to design
            mDesignPtr->addInstance(moduleInst);

            // Operation successfully completed
            return true;
        }

Here is the caller graph for this function:

string torc::physical::ModuleTransformer::sanitizePinName ( string  inPinName )

inlineprivate

Sanitize a pin name.

Parameters

inPinName

The pin name to be sanitized.

Definition at line 840 of file ModuleTransformer.hpp.

                                                 {

            // Sanitized pin name
            string sanitizedPinName;

            // Iterate over all characters in inString
            for(u_int32_t i = 0; i < inPinName.length(); i++) {

                // Match character against valid characters
                if(boost::regex_match(inPinName.substr(i, 1), sValidPinNameCharactersRegEx)) {
                    sanitizedPinName += inPinName.substr(i, 1);
                }
            }

            // Make sure sanitizedPinName does not start with an invalid first character
            while(sanitizedPinName.size() > 0 && boost::regex_match(sanitizedPinName.substr(0, 1),
                sInvalidPinNameFirstCharactersRegEx)) {

                // Remove invalid character
                sanitizedPinName = sanitizedPinName.substr(1, sanitizedPinName.size() - 1);

            }

            // Return sanitizedPinName
            return sanitizedPinName;
        }

Field Documentation

DesignSharedPtr torc::physical::ModuleTransformer::mDesignPtr

protected

Design pointer.

Definition at line 56 of file ModuleTransformer.hpp.

const std::string torc::physical::ModuleTransformer::sHierarchySeparator = "/"

staticprotected

Hierarchy separator.

Definition at line 58 of file ModuleTransformer.hpp.

const boost::regex torc::physical::ModuleTransformer::sInvalidPinNameFirstCharactersRegEx

staticprotected

Invalid first characters in a pin name.

Definition at line 64 of file ModuleTransformer.hpp.

const std::string torc::physical::ModuleTransformer::sPortIndexSeparator = "_"

staticprotected

Port index separator.

Definition at line 60 of file ModuleTransformer.hpp.

const boost::regex torc::physical::ModuleTransformer::sValidPinNameCharactersRegEx

staticprotected

Valid characters in a pin name.

Definition at line 62 of file ModuleTransformer.hpp.

---

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

• ModuleTransformer.hpp
• ModuleTransformer.cpp