Encapsulation of the site index, pin name, and pin flags for a package. More...

#include <PrimitiveStructure.hpp>

Inheritance diagram for torc::packer::PrimitiveStructure:

Collaboration diagram for torc::packer::PrimitiveStructure:

Public Member Functions
	PrimitiveStructure (const PrimitiveDef *inPrimitiveDefPtr)
	Default constructor. More...

	PrimitiveStructure (void)
	Null constructor. More...

virtual	~PrimitiveStructure (void)
	Virtual destructor. More...

void	debug (const PrimitiveElement &inPrimitiveElement)
	Prints out debugging information for the specified element. More...

virtual bool	isPreclassified (const PrimitiveElement &inElement)
	Return true if the element has been preclassified (typically by a subclass). More...

virtual bool	isPrincipal (const PrimitiveElement &inElement)
	Return true if the element is the principal element (a parent to the orphans). More...

virtual bool	isTerminal (const PrimitiveElement &inElement)
	Return true if the element is a terminal. More...

virtual bool	isOrphan (const PrimitiveElement &inElement)
	Return true if the element is an orphan. More...

virtual bool	isMux (const PrimitiveElement &inElement, bool &outIsSwitch)
	Return true if the element is a configurable mux. More...

virtual bool	isPower (const PrimitiveElement &inElement)
	Return true if the element is a power source. More...

virtual bool	isGround (const PrimitiveElement &inElement)
	Return true if the element is a ground source. More...

virtual bool	isLUT (const PrimitiveElement &inElement, const string &inConfig)
	Return true if the element is a LUT. More...

virtual bool	isFlop (const PrimitiveElement &inElement, const string &inConfig)
	Return true if the element is a flop. More...

virtual bool	isRoutethrough (const PrimitiveElement &inElementPtr)
	Return true if the element is a routethrough. More...

const PrimitiveDef *	getPrimitiveDefPtr (void) const
	Returns a pointer to the associated primitive definition. More...

Protected Types
typedef std::string	string
	Imported type name. More...

typedef torc::architecture::PrimitiveDef	PrimitiveDef
	Imported type name. More...

typedef torc::architecture::PrimitiveElement	PrimitiveElement
	Imported type name. More...

typedef std::map< string, const PrimitiveElement * >	NameToElementPtrMap
	Mapping from element name to element pointer. More...

typedef std::map< string, std::vector< const PrimitiveElement * > >	PrincipalToOrphanPtrMap
	Mapping from principal element name to an orphan element pointer vector. More...

typedef std::set< const torc::architecture::PrimitiveElementPin * >	ElementPinPtrSet
	A set of configuration values. More...

Protected Member Functions
virtual void	initialize (void)
	Initialize this object based on the PrimitiveDef information. More...

Protected Attributes
const PrimitiveDef *	mPrimitiveDefPtr
	Pointer to the associated primitive definition. More...

ElementPinPtrSet	mInvertedInputs
	Set of inverted element input pins. More...

NameToElementPtrMap	mUnprocessed
	Map of unprocessed elements. More...

NameToElementPtrMap	mPreclassified
	Map of pre-classified elements (typically by a subclass). More...

NameToElementPtrMap	mElements
	Map of all elements. More...

NameToElementPtrMap	mPrincipals
	Map of all principals. More...

NameToElementPtrMap	mTerminals
	Map of all terminals. More...

NameToElementPtrMap	mMuxes
	Map of all configurable muxes (including switches and inverters). More...

NameToElementPtrMap	mOrphans
	Map of all Orphans. More...

NameToElementPtrMap	mSwitches
	Map of all switches. More...

NameToElementPtrMap	mLUTs
	Map of all LUTs. More...

NameToElementPtrMap	mFlops
	Map of all flops. More...

NameToElementPtrMap	mPower
	Map of all power sources. More...

NameToElementPtrMap	mGround
	Map of all ground sources. More...

NameToElementPtrMap	mRoutethroughs
	Map of all routethroughs. More...

PrincipalToOrphanPtrMap	mPrincipalsToOrphans
	Map of principals to orphans. More...

Static Protected Attributes
static boost::regex	sRoutethroughRegEx
	Regular expression for routethroughs. More...

static boost::regex	sPrincipalRegEx
	Regular expression for additional principal elements. More...

static boost::regex	sLUTRegEx
	Regular expression for LUTs. More...

static boost::regex	sFlopRegEx
	Regular expression for flops. More...

static boost::regex	sPowerRegEx
	Regular expression for power sources. More...

static boost::regex	sGroundRegEx
	Regular expression for ground sources. More...

static boost::regex	sInvertingInputRegEx
	Regular expression for inverting input pins. More...

Friends
class	torc::packer::packer::PrimitiveStructureUnitTest
	Our unit test class has access to our internals. More...

class	Unpacker

Detailed Description

Encapsulation of the site index, pin name, and pin flags for a package.

Definition at line 50 of file PrimitiveStructure.hpp.

Member Typedef Documentation

typedef std::set<const torc::architecture::PrimitiveElementPin*> torc::packer::PrimitiveStructure::ElementPinPtrSet

protected

A set of configuration values.

Definition at line 68 of file PrimitiveStructure.hpp.

typedef std::map<string, const PrimitiveElement*> torc::packer::PrimitiveStructure::NameToElementPtrMap

protected

Mapping from element name to element pointer.

Definition at line 64 of file PrimitiveStructure.hpp.

typedef torc::architecture::PrimitiveDef torc::packer::PrimitiveStructure::PrimitiveDef

protected

Imported type name.

Definition at line 60 of file PrimitiveStructure.hpp.

typedef torc::architecture::PrimitiveElement torc::packer::PrimitiveStructure::PrimitiveElement

protected

Imported type name.

Definition at line 62 of file PrimitiveStructure.hpp.

typedef std::map<string, std::vector<const PrimitiveElement*> > torc::packer::PrimitiveStructure::PrincipalToOrphanPtrMap

protected

Mapping from principal element name to an orphan element pointer vector.

Definition at line 66 of file PrimitiveStructure.hpp.

typedef std::string torc::packer::PrimitiveStructure::string

protected

Imported type name.

Definition at line 58 of file PrimitiveStructure.hpp.

Constructor & Destructor Documentation

torc::packer::PrimitiveStructure::PrimitiveStructure ( const PrimitiveDef * inPrimitiveDefPtr )

inline

Default constructor.

Definition at line 132 of file PrimitiveStructure.hpp.

             : mPrimitiveDefPtr(inPrimitiveDefPtr) {
             initialize();
         }

torc::packer::PrimitiveStructure::PrimitiveStructure ( void )

inline

Null constructor.

Definition at line 137 of file PrimitiveStructure.hpp.

137 : mPrimitiveDefPtr(0) {};

torc::packer::PrimitiveStructure::mPrimitiveDefPtr

const PrimitiveDef * mPrimitiveDefPtr

Pointer to the associated primitive definition.

Definition: PrimitiveStructure.hpp:71

virtual torc::packer::PrimitiveStructure::~PrimitiveStructure ( void )

inlinevirtual

Virtual destructor.

Definition at line 139 of file PrimitiveStructure.hpp.

139 {}

Member Function Documentation

void torc::packer::PrimitiveStructure::debug ( const PrimitiveElement & inPrimitiveElement )

Prints out debugging information for the specified element.

Definition at line 224 of file PrimitiveStructure.cpp.

                                                                              {
         const PrimitiveElementPinArray& elementPins = inPrimitiveElement.getPins();
         PrimitiveElementPinArray::const_iterator pp = elementPins.begin();
         PrimitiveElementPinArray::const_iterator pe = elementPins.end();
         //std::cout << "        pins: ";
         while(pp < pe) {
             break;//std::cout << (*pp++).getName() << " ";
         }
         //std::cout << std::endl;
 
         const PrimitiveElement::StringSet& cfgs = inPrimitiveElement.getCfgs();
         PrimitiveElement::StringSet::const_iterator cp = cfgs.begin();
         PrimitiveElement::StringSet::const_iterator ce = cfgs.end();
         //std::cout << "        configs: ";
         while(cp != ce) {
             break;//std::cout << *cp++ << " ";
         }
         //std::cout << std::endl;
     }

Here is the call graph for this function:

const PrimitiveDef* torc::packer::PrimitiveStructure::getPrimitiveDefPtr ( void ) const

inline

Returns a pointer to the associated primitive definition.

Definition at line 165 of file PrimitiveStructure.hpp.

165 { return mPrimitiveDefPtr; }

torc::packer::PrimitiveStructure::mPrimitiveDefPtr

const PrimitiveDef * mPrimitiveDefPtr

Pointer to the associated primitive definition.

Definition: PrimitiveStructure.hpp:71

Here is the caller graph for this function:

void torc::packer::PrimitiveStructure::initialize ( void )

protectedvirtual

Initialize this object based on the PrimitiveDef information.

Reimplemented in torc::packer::Virtex2PrimitiveStructure, torc::packer::Virtex5PrimitiveStructure, and torc::packer::Virtex7PrimitiveStructure.

Definition at line 119 of file PrimitiveStructure.cpp.

                                             {
         // look up the primitive's pins
         const PrimitivePinArray& primitivePins = mPrimitiveDefPtr->getPins();
         const std::string& primitiveDefName = mPrimitiveDefPtr->getName();
         (void) primitivePins;
         (void) primitiveDefName;
 //std::cout << primitiveDefName << ": " << primitivePins.getSize() << " pins" << std::endl;
 
         // iterate over the elements
         const PrimitiveElementArray& elements = mPrimitiveDefPtr->getElements();    
         PrimitiveElementArray::const_iterator ep = elements.begin();    
         PrimitiveElementArray::const_iterator ee = elements.end();
         while(ep < ee) {
 
             // look up the current element
             const PrimitiveElement& primitiveElement = *ep++;
             const std::string& elementName = primitiveElement.getName();
 
             // add the element to the comprehensive list
             mElements[elementName] = &primitiveElement;
 
             // skip elements that have been preclassified
             if(isPreclassified(primitiveElement)) {
                 continue;
             }
 
             // identify principals
             if(isPrincipal(primitiveElement)) {
                 mPrincipals[elementName] = &primitiveElement;
                 continue;
             }
 
             // identify terminals
             if(isTerminal(primitiveElement)) {
                 mTerminals[elementName] = &primitiveElement;
                 continue;
             }
 
             // identify orphans
             if(isOrphan(primitiveElement)) {
                 mOrphans[elementName] = &primitiveElement;
                 continue;
             }
 
             // for all remaining elements, it's easier to track status with a flag
             bool processed = false;
 
             // identify muxes
             bool isSwitch = false;
             if(isMux(primitiveElement, isSwitch)) {
                 // mark this element as a mux (and also as a switch if it has a single input)
                 mMuxes[elementName] = &primitiveElement;
                 if(isSwitch) mSwitches[elementName] = &primitiveElement;
                 processed = true;
                 continue;
             }
 
             // identify power sources
             if(isPower(primitiveElement)) {
                 mPower[elementName] = &primitiveElement;
                 processed = true;
                 continue;
             }
             // identify ground sources
             if(isGround(primitiveElement)) {
                 mGround[elementName] = &primitiveElement;
                 processed = true;
                 continue;
             }
 
             // identify LUTs and flops
             const PrimitiveElement::StringSet& cfgs = primitiveElement.getCfgs();
             PrimitiveElement::StringSet::const_iterator cp = cfgs.begin();
             PrimitiveElement::StringSet::const_iterator ce = cfgs.end();
             while(cp != ce) {
                 const std::string& config = *cp++;
                 // identify LUTs
                 if(regex_match(config, sLUTRegEx)) {
                     mLUTs[elementName] = &primitiveElement;
                     processed = true;
                     break;
                 }
                 // identify flops
                 if(isFlop(primitiveElement, config)) {
                     mFlops[elementName] = &primitiveElement;
                     processed = true;
                     break;
                 }
             }
             if(processed) continue;
 
             // ignore routethroughs
             if(isRoutethrough(primitiveElement)) {
                 mRoutethroughs[elementName] = &primitiveElement;
                 processed = true;
                 continue;
             }
 
             // note all unprocessed elements
             mUnprocessed[elementName] = &primitiveElement;
 //std::cout << "    Unprocessed element " << elementName << std::endl;
 debug(primitiveElement);
         }
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isFlop	(	const PrimitiveElement &	inElement,
		const string &	inConfig
	)

virtual

Return true if the element is a flop.

Definition at line 111 of file PrimitiveStructure.cpp.

                                                                                              {
         return regex_match(inConfig, sFlopRegEx);
     }

bool torc::packer::PrimitiveStructure::isGround ( const PrimitiveElement & inElement )

virtual

Return true if the element is a ground source.

Definition at line 101 of file PrimitiveStructure.cpp.

                                                                        {
         const PrimitiveElementPinArray& elementPins = inElement.getPins();
         return elementPins.getSize() == 1 && elementPins[0].getName() == "0" 
             && regex_match(inElement.getName(), sGroundRegEx);
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isLUT	(	const PrimitiveElement &	inElement,
		const string &	inConfig
	)

virtual

Return true if the element is a LUT.

Definition at line 107 of file PrimitiveStructure.cpp.

                                                                                             {
         return regex_match(inConfig, sLUTRegEx);
     }

bool torc::packer::PrimitiveStructure::isMux	(	const PrimitiveElement &	inElement,
		bool &	outIsSwitch
	)

virtual

Return true if the element is a configurable mux.

Definition at line 54 of file PrimitiveStructure.cpp.

                                                                                        {
         outIsSwitch = false;
         // look up information about the primitive
         const PrimitiveElement::StringSet& cfgs = inElement.getCfgs();
         PrimitiveElement::StringSet::size_type cfgsCount = cfgs.size();
         const PrimitiveElementPinArray& elementPins = inElement.getPins();
         boost::uint32_t elementPinsCount = elementPins.getSize();
 
         // if the configuration set is empty, this cannot be a mux
         if(cfgsCount == 0) return false;
 
         // configurable muxes will have cfgsCount input pins plus one output pin
         if(elementPinsCount != cfgsCount + 1) return false;
         // copy the input pins into a set
         PrimitiveElement::StringSet inputs;
         PrimitiveElementPinArray::const_iterator pp = elementPins.begin();
         PrimitiveElementPinArray::const_iterator pe = elementPins.end();
         while(pp < pe) { if(pp->isInput()) inputs.insert(pp->getName()); pp++; }
         PrimitiveElement::StringSet::size_type inputCount = inputs.size();
 
         // compare the implicitly sorted cfgs and input pins sets for equality
         PrimitiveElement::StringSet::const_iterator ip = inputs.begin();
         PrimitiveElement::StringSet::const_iterator ie = inputs.end();
         PrimitiveElement::StringSet::const_iterator cp = cfgs.begin();
         while(ip != ie) if(*ip++ != *cp++) return false;
 
         // now that we know this is a mux, make note of all the inverting inputs
         ip = inputs.begin();
         while(ip != ie) {
             const std::string& input = *ip++;
             if(regex_match(input, sInvertingInputRegEx)) {
                 torc::architecture::xilinx::PinIndex pinIndex = inElement.findPinIndexByName(input);
                 mInvertedInputs.insert(&elementPins[pinIndex]);
             }
         }
 
         // if we got this far, the element is a mux (and it may also be a switch)
         if(inputCount == 1) outIsSwitch = true;
         return true;
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isOrphan ( const PrimitiveElement & inElement )

virtual

Return true if the element is an orphan.

Definition at line 50 of file PrimitiveStructure.cpp.

                                                                        {
         return inElement.getPins().getSize() == 0;
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isPower ( const PrimitiveElement & inElement )

virtual

Return true if the element is a power source.

Definition at line 95 of file PrimitiveStructure.cpp.

                                                                       {
         const PrimitiveElementPinArray& elementPins = inElement.getPins();
         return elementPins.getSize() == 1 && elementPins[0].getName() == "1" 
             && regex_match(inElement.getName(), sPowerRegEx);
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isPreclassified ( const PrimitiveElement & inElement )

virtual

Return true if the element has been preclassified (typically by a subclass).

Definition at line 36 of file PrimitiveStructure.cpp.

                                                                               {
         return mPreclassified.find(inElement.getName()) != mPreclassified.end();
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isPrincipal ( const PrimitiveElement & inElement )

virtual

Return true if the element is the principal element (a parent to the orphans).

Definition at line 40 of file PrimitiveStructure.cpp.

                                                                           {
         return inElement.getName() == mPrimitiveDefPtr->getName() 
             || regex_match(inElement.getName(), sPrincipalRegEx);
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isRoutethrough ( const PrimitiveElement & inElementPtr )

virtual

Return true if the element is a routethrough.

Definition at line 115 of file PrimitiveStructure.cpp.

                                                                              {
         return regex_match(inElement.getName(), sRoutethroughRegEx);
     }

Here is the call graph for this function:

bool torc::packer::PrimitiveStructure::isTerminal ( const PrimitiveElement & inElement )

virtual

Return true if the element is a terminal.

Definition at line 45 of file PrimitiveStructure.cpp.

                                                                          {
         if(inElement.getPins().getSize() != 1) return false;
         return !mPrimitiveDefPtr->findPinIndexByName(inElement.getName()).isUndefined();
     }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class torc::packer::packer::PrimitiveStructureUnitTest

friend

Our unit test class has access to our internals.

Definition at line 53 of file PrimitiveStructure.hpp.

friend class Unpacker

friend

Definition at line 54 of file PrimitiveStructure.hpp.

Field Documentation

NameToElementPtrMap torc::packer::PrimitiveStructure::mElements

protected

Map of all elements.

Definition at line 80 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mFlops

protected

Map of all flops.

Definition at line 99 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mGround

protected

Map of all ground sources.

Definition at line 106 of file PrimitiveStructure.hpp.

ElementPinPtrSet torc::packer::PrimitiveStructure::mInvertedInputs

protected

Set of inverted element input pins.

Definition at line 74 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mLUTs

protected

Map of all LUTs.

Definition at line 97 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mMuxes

protected

Map of all configurable muxes (including switches and inverters).

Definition at line 86 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mOrphans

protected

Map of all Orphans.

Definition at line 88 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mPower

protected

Map of all power sources.

Definition at line 104 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mPreclassified

protected

Map of pre-classified elements (typically by a subclass).

Definition at line 78 of file PrimitiveStructure.hpp.

const PrimitiveDef* torc::packer::PrimitiveStructure::mPrimitiveDefPtr

protected

Pointer to the associated primitive definition.

Definition at line 71 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mPrincipals

protected

Map of all principals.

Definition at line 82 of file PrimitiveStructure.hpp.

PrincipalToOrphanPtrMap torc::packer::PrimitiveStructure::mPrincipalsToOrphans

protected

Map of principals to orphans.

Definition at line 110 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mRoutethroughs

protected

Map of all routethroughs.

Definition at line 108 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mSwitches

protected

Map of all switches.

Definition at line 91 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mTerminals

protected

Map of all terminals.

Definition at line 84 of file PrimitiveStructure.hpp.

NameToElementPtrMap torc::packer::PrimitiveStructure::mUnprocessed

protected

Map of unprocessed elements.

Definition at line 76 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sFlopRegEx

staticprotected

Regular expression for flops.

Definition at line 119 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sGroundRegEx

staticprotected

Regular expression for ground sources.

Definition at line 123 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sInvertingInputRegEx

staticprotected

Regular expression for inverting input pins.

Definition at line 125 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sLUTRegEx

staticprotected

Regular expression for LUTs.

Definition at line 117 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sPowerRegEx

staticprotected

Regular expression for power sources.

Definition at line 121 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sPrincipalRegEx

staticprotected

Regular expression for additional principal elements.

Definition at line 115 of file PrimitiveStructure.hpp.

boost::regex torc::packer::PrimitiveStructure::sRoutethroughRegEx

staticprotected

Regular expression for routethroughs.

Definition at line 113 of file PrimitiveStructure.hpp.

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

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation