torc::physical Namespace Reference

Namespace for the Torc physical netlist, including the XDL importer, exporter, placer, router, unpacker, and packer. More...

Namespaces
	physical

Data Structures
class	CombinationalPath
	Routing net. More...
class	Component
	Hierarchical componenet. More...
class	Connection
	Hierarchical componenet. More...
class	ConnectionPin
	Physical design connection-pin pair, suitable for specifying a net endpoint. More...
class	Element
	Element composed of connections and pins. More...
class	ParsePrimitive
	Pare Primitives. More...
class	Primitive
	primitive. More...
class	PrimitivePin
	Physical design primitive-pin. More...
class	PrimitiveSet
	PrimitiveSet. More...
class	RcFactory
	RcFactory class for physical netlist elements. More...
class	RoutingNet
	Routing net. More...
class	WritePrimitive
	Pare Primitives. More...
class	XdlUnpack
class	Circuit
	Circuit composed of instances and nets. More...
class	RenamableInstance
class	Config
	Configuration. A {name:value} pair. More...
class	ConfigMap
	Configuration setting map. More...
class	Design
	Physical netlist design. More...
class	Factory
	Factory class for physical netlist elements. More...
class	Instance
	Physical design instance. More...
class	InstancePinBase
	Physical design instance-pin pair, suitable for specifying a net endpoint. More...
class	InstancePin
	Physical design instance-pin pair, suitable for specifying a net endpoint. More...
class	InstanceReference
	Instantiation of a module instance. More...
class	Module
	Hierarchical module. More...
class	ModuleTransformer
	Utility class to modularize/flatten designs. More...
class	Named
	Concept for any object that can be named. More...
class	NameComparator
	Comparator class to serve as a predicate when searching for names. More...
class	Net
	Physical design net. More...
class	Pip
	Physical design programmable interconnect point. More...
class	Port
	Module input or output port. More...
class	PortTemp
	Temporary module port. More...
class	Progenitor
	Concept for any object that may have children. More...
class	Progeny
	Concept for any object that may have a parent. More...
class	Renamable
	Concept for any object that can be renamed. More...
class	Routethrough
	Pip routethrough. More...
class	TilewirePlaceholder
	Drop-in placeholder for a Tilewire with no torc::architecture dependencies. More...
class	XdlExporter
	Physical design exporter for XDL. More...
class	XdlImporter
	Importer from XDL format into a physical design. More...
class	WireName
	Encapsulation of a wire name. More...
class	TileName
	Encapsulation of a tile name. More...
class	TileTypeName
	Encapsulation of a tile type name. More...
class	InstanceName
	Encapsulation of an instance name. More...
class	SiteName
	Encapsulation of a site name. More...
class	SiteTypeName
	Encapsulation of a site type name. More...
class	PinName
	Encapsulation of a site pin name. More...

Typedefs
typedef boost::shared_ptr < CombinationalPath >	CombinationalPathSharedPtr
	Shared pointer encapsulation of a CombinationalPath. More...
typedef std::vector < CombinationalPathSharedPtr >	CombinationalPathSharedPtrVector
	Vector of CombinationalPath shared pointers. More...
typedef boost::shared_ptr < Component >	ComponentSharedPtr
	Shared pointer encapsulation of a componenet. More...
typedef boost::weak_ptr < Component >	ComponentWeakPtr
	Weak pointer encapsulation of a componenet. More...
typedef std::vector < ComponentSharedPtr >	ComponentSharedPtrVector
	Vector of componenet shared pointers. More...
typedef boost::shared_ptr < Connection >	ConnectionSharedPtr
	Shared pointer encapsulation of a componenet. More...
typedef boost::weak_ptr < Connection >	ConnectionWeakPtr
	Weak pointer encapsulation of a componenet. More...
typedef std::vector < ConnectionSharedPtr >	ConnectionSharedPtrVector
	Vector of componenet shared pointers. More...
typedef std::vector < ConnectionPin >	ConnectionPinVector
	Vector of connection pins. More...
typedef vector< string >	ConfigVector
typedef boost::shared_ptr < Element >	ElementSharedPtr
	Shared pointer encapsulation of a element. More...
typedef boost::weak_ptr< Element >	ElementWeakPtr
	Weak pointer encapsulation of a element. More...
typedef std::vector < ElementSharedPtr >	ElementSharedPtrVector
	Vector of element shared pointers. More...
typedef boost::shared_ptr < Primitive >	PrimitiveSharedPtr
	Shared pointer encapsulation of a Primitive. More...
typedef std::vector < PrimitiveSharedPtr >	PrimitiveSharedPtrVector
	Vector of Primitive shared pointers. More...
typedef std::vector< PrimitivePin >	PrimitivePinVector
	Vector of primitive pins. More...
typedef boost::shared_ptr < PrimitivePin >	PrimitivePinSharedPtr
	Shared pointer encapsulation of a componenet. More...
typedef boost::weak_ptr < PrimitivePin >	PrimitivePinWeakPtr
	Weak pointer encapsulation of a componenet. More...
typedef std::vector < PrimitivePinSharedPtr >	PrimitivePinSharedPtrVector
	Vector of componenet shared pointers. More...
typedef boost::shared_ptr < PrimitiveSet >	PrimitiveSetSharedPtr
	Shared pointer encapsulation of a PrimitiveSet. More...
typedef boost::weak_ptr < PrimitiveSet >	PrimitiveSetWeakPtr
	Shared pointer encapsulation of a PrimitiveSet. More...
typedef std::vector < PrimitiveSetSharedPtr >	PrimitiveSetSharedPtrVector
	Vector of PrimitiveSet shared pointers. More...
typedef boost::shared_ptr < RoutingNet >	RoutingNetSharedPtr
	Shared pointer encapsulation of a RoutingNet. More...
typedef std::vector < RoutingNetSharedPtr >	RoutingNetSharedPtrVector
	Vector of RoutingNet shared pointers. More...
typedef boost::shared_ptr < Circuit >	CircuitSharedPtr
	Shared pointer encapsulation of a Circuit. More...
typedef boost::weak_ptr< Circuit >	CircuitWeakPtr
	Weak pointer encapsulation of a Circuit. More...
typedef std::vector < CircuitSharedPtr >	CircuitSharedPtrVector
	Vector of Circuit shared pointers. More...
typedef boost::shared_ptr < class RenamableInstance >	RenamableInstanceSharedPtr
typedef boost::shared_ptr< Design >	DesignSharedPtr
	Shared pointer encapsulation of a Design. More...
typedef std::vector < DesignSharedPtr >	DesignSharedPtrVector
	Vector of Design shared pointers. More...
typedef boost::shared_ptr < class InstancePin >	InstancePinSharedPtr
	Shared pointer encapsulation of an InstancePin. More...
typedef boost::weak_ptr< class InstancePin >	InstancePinWeakPtr
	Weak pointer encapsulation of an InstancePin. More...
typedef std::vector < InstancePinSharedPtr >	InstancePinSharedPtrVector
	Vector of InstancePin shared pointers. More...
typedef boost::shared_ptr < Instance >	InstanceSharedPtr
	Shared pointer encapsulation of an Instance. More...
typedef boost::weak_ptr< Instance >	InstanceWeakPtr
	Weak pointer encapsulation of an Instance. More...
typedef std::vector < InstanceSharedPtr >	InstanceSharedPtrVector
	Vector of Instance shared pointers. More...
typedef boost::shared_ptr < InstanceReference >	InstanceReferenceSharedPtr
	Shared pointer encapsulation of an InstanceReference. More...
typedef boost::weak_ptr < InstanceReference >	InstanceReferenceWeakPtr
	Weak pointer encapsulation of an InstanceReference. More...
typedef boost::shared_ptr< Module >	ModuleSharedPtr
	Shared pointer encapsulation of a Module. More...
typedef boost::weak_ptr< Module >	ModuleWeakPtr
	Weak pointer encapsulation of a Module. More...
typedef std::vector < ModuleSharedPtr >	ModuleSharedPtrVector
	Vector of Module shared pointers. More...
typedef boost::shared_ptr< Named >	NamedSharedPtr
	Shared pointer encapsulation of a Named object. More...
typedef boost::shared_ptr< Net >	NetSharedPtr
	Shared pointer encapsulation of a Net. More...
typedef boost::weak_ptr< Net >	NetWeakPtr
	Weak pointer encapsulation of a Net. More...
typedef std::vector< NetSharedPtr >	NetSharedPtrVector
	Vector of Net shared pointers. More...
typedef std::vector< Pip >	PipVector
	Vector of pips. More...
typedef boost::shared_ptr< Pip >	PipSharedPtr
	Shared pointer encapsulation of a Pip. More...
typedef boost::weak_ptr< Pip >	PipWeakPtr
	Weak pointer encapsulation of a Pip. More...
typedef std::vector< PipSharedPtr >	PipSharedPtrVector
	Vector of Pip shared pointers. More...
typedef boost::shared_ptr< Port >	PortSharedPtr
	Shared pointer encapsulation of a Port. More...
typedef boost::weak_ptr< Port >	PortWeakPtr
	Weak pointer encapsulation of a Port. More...
typedef std::vector < PortSharedPtr >	PortSharedPtrVector
	Vector of Port shared pointers. More...
typedef std::vector< PortTemp >	PortTempVector
	Vector. More...
typedef boost::shared_ptr < Routethrough >	RoutethroughSharedPtr
	Shared pointer encapsulation of a Routethrough. More...
typedef boost::weak_ptr < Routethrough >	RoutethroughWeakPtr
	Weak pointer encapsulation of a Routethrough. More...
typedef boost::uint64_t	SequenceIndex
	Typedef for generic sequences. More...

Enumerations
enum	PinType { Unknown, InputP, OutputP }
enum	EInstanceBonding { eInstanceBondingUnbonded = 0, eInstanceBondingBonded, eInstanceBondingUnknown, eInstanceBondingCount }
	Enumeration of pad bonding types. More...
enum	EPinDirection { ePinDirectionInpin = 0, ePinDirectionOutpin, ePinDirectionUnknown, ePinDirectionCount }
	Enumeration of instance pin directionality. More...
enum	EPipDirection {   ePipBidirectionalUnbuffered = 0, ePipBidirectionalUnidirectionallyBuffered, ePipBidirectionalBidirectionallyBuffered, ePipUnidirectionalBuffered,   ePipDirectionCount }
	Enumeration of pip directionality. More...
enum	ENetType { eNetTypeNormal = 0, eNetTypePower, eNetTypeGround, eNetTypeCount }
	Enumeration of net power types. More...
enum	ESequenceIndex { eSequenceIndexNone = 0, eSequenceIndexFirst }
	Enumeration of sequence indexes. More...

Functions
	BOOST_AUTO_TEST_CASE (XdlUnpackUnitTest)
	Unit test for the XdlUnpack class. More...
	BOOST_AUTO_TEST_CASE (CircuitUnitTest)
	Unit test for the Circuit class. More...
	BOOST_AUTO_TEST_CASE (ConfigMapUnitTest)
	Unit test for the ConfigMap class. More...
	BOOST_AUTO_TEST_CASE (ConfigUnitTest)
	Unit test for the Config class. More...
	BOOST_AUTO_TEST_CASE (DesignRegressionTest)
	Basic regression test for the entire XDL infrastructure. More...
	BOOST_AUTO_TEST_CASE (DesignUnitTest)
	Unit test for the Design class. More...
	BOOST_AUTO_TEST_CASE (FactoryUnitTest)
	Unit test for the Factory class. More...
	BOOST_AUTO_TEST_CASE (InstancePinUnitTest)
	Unit test for the InstancePin class. More...
	BOOST_AUTO_TEST_CASE (InstanceReferenceUnitTest)
	Unit test for the InstanceReference class. More...
	BOOST_AUTO_TEST_CASE (InstanceUnitTest)
	Unit test for the Instance class. More...
DesignSharedPtr	verifyDesignOpenedSuccessfully (const string &inDesignFileName)
	Verify that the design file opened successfully. More...
InstanceSharedPtrVector	getInstancesToModularize (DesignSharedPtr inDesignPtr)
	Retrieve the instances to modularize from the design and return them in a vector. More...
void	preModularizationVerifications (DesignSharedPtr inDesignPtr)
	Perform pre-modularization tests on a design. More...
void	postModularizationVerifications (DesignSharedPtr inDesignPtr, InstanceSharedPtrVector inInstanceVector, bool inKeepPlacement, bool inKeepRouting)
	Perform post-modularization tests on a design. More...
void	preFlatteningVerifications (DesignSharedPtr inDesignPtr)
	Perform pre-flattening tests on a design. More...
void	postFlatteningVerifications (DesignSharedPtr inDesignPtr, bool inKeepPlacement, bool inKeepRouting)
	Perform post-flattening tests on a design. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithIntraNetUnitTest)
	Unit test for modularizing two instances with intra net. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithInputInterNetUnitTest)
	Unit test for modularizing two instances with input inter net. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithInputFanoutInterNetUnitTest)
	Unit test for modularizing two instances with input fanout input net. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithOutputInterNetUnitTest)
	Unit test for modularizing two instances with output inter net. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithOutputFanoutInterNetUnitTest)
	Unit test for modularizing two instances with output fanout inter net. More...
	BOOST_AUTO_TEST_CASE (ModularizeWithIntraAndInterNetUnitTest)
	Unit test for modularizing two instances with fanout intra and inter net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithIntraNetUnitTest)
	Unit test for flattening a module with two instances and an intra net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithInputInterNetUnitTest)
	Unit test for flattening two instances with input inter net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithInputFanoutInterNetUnitTest)
	Unit test for flattening two instances with input fanout input net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithOutputInterNetUnitTest)
	Unit test for flattening two instances with output inter net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithOutputFanoutInterNetUnitTest)
	Unit test for flattening two instances with output fanout inter net. More...
	BOOST_AUTO_TEST_CASE (FlattenWithIntraAndInterNetUnitTest)
	Unit test for flattening two instances with fanout intra and inter net. More...
	BOOST_AUTO_TEST_CASE (ModuleUnitTest)
	Unit test for the Module class. More...
	BOOST_AUTO_TEST_CASE (NamedUnitTest)
	Unit test for the Named class. More...
	BOOST_AUTO_TEST_CASE (NetUnitTest)
	Unit test for the Net class. More...
std::ostream &	operator<< (std::ostream &os, const Design &rhs)
	Design stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Module &rhs)
	Module stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Instance &rhs)
	Instance stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Net &rhs)
	Net stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const InstancePin &rhs)
	InstancePin stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Pip &rhs)
	Pip stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Config &rhs)
	Config iterator stream inserter. More...
	BOOST_AUTO_TEST_CASE (OutputStreamHelpersUnitTest)
	Unit test for the output stream helpers. More...
	BOOST_AUTO_TEST_CASE (PipUnitTest)
	Unit test for the Pip class. More...
	BOOST_AUTO_TEST_CASE (PortUnitTest)
	Unit test for the Port class. More...
	BOOST_AUTO_TEST_CASE (ProgenitorUnitTest)
	Unit test for the Progenitor class. More...
	BOOST_AUTO_TEST_CASE (ProgenyUnitTest)
	Unit test for the Progeny class. More...
	BOOST_AUTO_TEST_CASE (RenamableUnitTest)
	Unit test for the Renamable class. More...
	BOOST_AUTO_TEST_CASE (RouteThroughUnitTest)
	Unit test for the Routethrough class. More...
	BOOST_AUTO_TEST_CASE (SampleCodeUnitTest)
	Unit test demonstrating some sample code. More...
	BOOST_AUTO_TEST_CASE (TilewirePlaceholderUnitTest)
	Unit test for the TilewirePlaceholder class. More...
	BOOST_AUTO_TEST_CASE (XdlExporterUnitTest)
	Unit test for the XdlExporter class. More...
	BOOST_AUTO_TEST_CASE (XdlImporterUnitTest)
	Unit test for the XdlImporter class. More...

Variables
static const char	delimiters [] = " \n\t\f"
const string	elementNames = "SRUSED REVUSED PRECYINIT DUSED CUSED COUTUSED CEUSED BUSED AUSED DCY0 CCY0 BCY0 ACY0 END"
const string	extraMuxNames = "CY0G CY0F GYMUX DYMUX FXMUX DXMUX CYINIT DIG_MUX DIF_MUX XBMUX DOUTMUX COUTMUX BOUTMUX AOUTMUX DFFMUX CFFMUX BFFMUX AFFMUX ACY0 BCY0 CCY0 DCY0 PRECYINIT CDI1MUX BDI1MUX ADI1MUX WEMUX TMUX OMUX IDELMUX D2OBYP_SEL IFFDELMUX IFFMUX END"
const string	extraInvNames = "CLKINV T1INV T2INV D1INV D2INV END"
static const string	sInstanceOneName = "c1"
static const string	sInstanceTwoName = "c2"
static const string	sModuleDefinition = "aModule"
static const string	sModuleInstanceName = "aModuleInstance"
static const string	sHierarchySeparator = "/"

Detailed Description

Namespace for the Torc physical netlist, including the XDL importer, exporter, placer, router, unpacker, and packer.

Typedef Documentation

typedef boost::shared_ptr<Circuit> torc::physical::CircuitSharedPtr

Shared pointer encapsulation of a Circuit.

Definition at line 219 of file Circuit.hpp.

typedef std::vector<CircuitSharedPtr> torc::physical::CircuitSharedPtrVector

Vector of Circuit shared pointers.

Definition at line 225 of file Circuit.hpp.

typedef boost::weak_ptr<Circuit> torc::physical::CircuitWeakPtr

Weak pointer encapsulation of a Circuit.

Definition at line 222 of file Circuit.hpp.

typedef boost::shared_ptr<CombinationalPath> torc::physical::CombinationalPathSharedPtr

Shared pointer encapsulation of a CombinationalPath.

Definition at line 303 of file CombinationalPath.hpp.

typedef std::vector<CombinationalPathSharedPtr> torc::physical::CombinationalPathSharedPtrVector

Vector of CombinationalPath shared pointers.

Definition at line 306 of file CombinationalPath.hpp.

typedef boost::shared_ptr<Component> torc::physical::ComponentSharedPtr

Shared pointer encapsulation of a componenet.

Definition at line 76 of file Component.hpp.

typedef std::vector<ComponentSharedPtr> torc::physical::ComponentSharedPtrVector

Vector of componenet shared pointers.

Definition at line 82 of file Component.hpp.

typedef boost::weak_ptr<Component> torc::physical::ComponentWeakPtr

Weak pointer encapsulation of a componenet.

Definition at line 79 of file Component.hpp.

typedef vector<string> torc::physical::ConfigVector

Definition at line 36 of file Element.hpp.

typedef std::vector<ConnectionPin> torc::physical::ConnectionPinVector

Vector of connection pins.

Definition at line 60 of file ConnectionPin.hpp.

typedef boost::shared_ptr<Connection> torc::physical::ConnectionSharedPtr

Shared pointer encapsulation of a componenet.

Definition at line 82 of file Connection.hpp.

typedef std::vector<ConnectionSharedPtr> torc::physical::ConnectionSharedPtrVector

Vector of componenet shared pointers.

Definition at line 88 of file Connection.hpp.

typedef boost::weak_ptr<Connection> torc::physical::ConnectionWeakPtr

Weak pointer encapsulation of a componenet.

Definition at line 85 of file Connection.hpp.

typedef boost::shared_ptr<Design> torc::physical::DesignSharedPtr

Shared pointer encapsulation of a Design.

Definition at line 134 of file physical/Design.hpp.

typedef std::vector<DesignSharedPtr> torc::physical::DesignSharedPtrVector

Vector of Design shared pointers.

Definition at line 137 of file physical/Design.hpp.

typedef boost::shared_ptr<Element> torc::physical::ElementSharedPtr

Shared pointer encapsulation of a element.

Definition at line 119 of file Element.hpp.

typedef std::vector<ElementSharedPtr> torc::physical::ElementSharedPtrVector

Vector of element shared pointers.

Definition at line 125 of file Element.hpp.

typedef boost::weak_ptr<Element> torc::physical::ElementWeakPtr

Weak pointer encapsulation of a element.

Definition at line 122 of file Element.hpp.

typedef boost::shared_ptr< InstancePin > torc::physical::InstancePinSharedPtr

Shared pointer encapsulation of an InstancePin.

Definition at line 39 of file physical/Instance.hpp.

typedef std::vector< InstancePinSharedPtr > torc::physical::InstancePinSharedPtrVector

Vector of InstancePin shared pointers.

Definition at line 45 of file physical/Instance.hpp.

typedef boost::weak_ptr< InstancePin > torc::physical::InstancePinWeakPtr

Weak pointer encapsulation of an InstancePin.

Definition at line 42 of file physical/Instance.hpp.

typedef boost::shared_ptr<InstanceReference> torc::physical::InstanceReferenceSharedPtr

Shared pointer encapsulation of an InstanceReference.

Definition at line 84 of file InstanceReference.hpp.

typedef boost::weak_ptr<InstanceReference> torc::physical::InstanceReferenceWeakPtr

Weak pointer encapsulation of an InstanceReference.

Definition at line 87 of file InstanceReference.hpp.

typedef boost::shared_ptr<Instance> torc::physical::InstanceSharedPtr

Shared pointer encapsulation of an Instance.

Definition at line 188 of file physical/Instance.hpp.

typedef std::vector<InstanceSharedPtr> torc::physical::InstanceSharedPtrVector

Vector of Instance shared pointers.

Definition at line 194 of file physical/Instance.hpp.

typedef boost::weak_ptr<Instance> torc::physical::InstanceWeakPtr

Weak pointer encapsulation of an Instance.

Definition at line 191 of file physical/Instance.hpp.

typedef boost::shared_ptr<Module> torc::physical::ModuleSharedPtr

Shared pointer encapsulation of a Module.

Definition at line 114 of file Module.hpp.

typedef std::vector<ModuleSharedPtr> torc::physical::ModuleSharedPtrVector

Vector of Module shared pointers.

Definition at line 120 of file Module.hpp.

typedef boost::weak_ptr<Module> torc::physical::ModuleWeakPtr

Weak pointer encapsulation of a Module.

Definition at line 117 of file Module.hpp.

typedef boost::shared_ptr<Named> torc::physical::NamedSharedPtr

Shared pointer encapsulation of a Named object.

Definition at line 58 of file Named.hpp.

typedef boost::shared_ptr<Net> torc::physical::NetSharedPtr

Shared pointer encapsulation of a Net.

Definition at line 229 of file physical/Net.hpp.

typedef std::vector<NetSharedPtr> torc::physical::NetSharedPtrVector

Vector of Net shared pointers.

Definition at line 235 of file physical/Net.hpp.

typedef boost::weak_ptr<Net> torc::physical::NetWeakPtr

Weak pointer encapsulation of a Net.

Definition at line 232 of file physical/Net.hpp.

typedef boost::shared_ptr<Pip> torc::physical::PipSharedPtr

Shared pointer encapsulation of a Pip.

Definition at line 98 of file Pip.hpp.

typedef std::vector<PipSharedPtr> torc::physical::PipSharedPtrVector

Vector of Pip shared pointers.

Definition at line 104 of file Pip.hpp.

typedef std::vector<Pip> torc::physical::PipVector

Vector of pips.

Definition at line 95 of file Pip.hpp.

typedef boost::weak_ptr<Pip> torc::physical::PipWeakPtr

Weak pointer encapsulation of a Pip.

Definition at line 101 of file Pip.hpp.

typedef boost::shared_ptr<Port> torc::physical::PortSharedPtr

Shared pointer encapsulation of a Port.

Definition at line 71 of file physical/Port.hpp.

typedef std::vector<PortSharedPtr> torc::physical::PortSharedPtrVector

Vector of Port shared pointers.

Definition at line 77 of file physical/Port.hpp.

typedef std::vector<PortTemp> torc::physical::PortTempVector

Vector.

Definition at line 112 of file physical/Port.hpp.

typedef boost::weak_ptr<Port> torc::physical::PortWeakPtr

Weak pointer encapsulation of a Port.

Definition at line 74 of file physical/Port.hpp.

typedef boost::shared_ptr<PrimitivePin> torc::physical::PrimitivePinSharedPtr

Shared pointer encapsulation of a componenet.

Definition at line 73 of file packer/PrimitivePin.hpp.

typedef std::vector<PrimitivePinSharedPtr> torc::physical::PrimitivePinSharedPtrVector

Vector of componenet shared pointers.

Definition at line 79 of file packer/PrimitivePin.hpp.

typedef std::vector<PrimitivePin> torc::physical::PrimitivePinVector

Vector of primitive pins.

Definition at line 70 of file packer/PrimitivePin.hpp.

typedef boost::weak_ptr<PrimitivePin> torc::physical::PrimitivePinWeakPtr

Weak pointer encapsulation of a componenet.

Definition at line 76 of file packer/PrimitivePin.hpp.

typedef boost::shared_ptr<PrimitiveSet> torc::physical::PrimitiveSetSharedPtr

Shared pointer encapsulation of a PrimitiveSet.

Definition at line 105 of file PrimitiveSet.hpp.

typedef std::vector<PrimitiveSetSharedPtr> torc::physical::PrimitiveSetSharedPtrVector

Vector of PrimitiveSet shared pointers.

Definition at line 111 of file PrimitiveSet.hpp.

typedef boost::weak_ptr<PrimitiveSet> torc::physical::PrimitiveSetWeakPtr

Shared pointer encapsulation of a PrimitiveSet.

Definition at line 108 of file PrimitiveSet.hpp.

typedef boost::shared_ptr<Primitive> torc::physical::PrimitiveSharedPtr

Shared pointer encapsulation of a Primitive.

Definition at line 171 of file Primitive.hpp.

typedef std::vector<PrimitiveSharedPtr> torc::physical::PrimitiveSharedPtrVector

Vector of Primitive shared pointers.

Definition at line 174 of file Primitive.hpp.

typedef boost::shared_ptr<class RenamableInstance> torc::physical::RenamableInstanceSharedPtr

Definition at line 28 of file CircuitUnitTest.cpp.

typedef boost::shared_ptr<Routethrough> torc::physical::RoutethroughSharedPtr

Shared pointer encapsulation of a Routethrough.

Definition at line 72 of file Routethrough.hpp.

typedef boost::weak_ptr<Routethrough> torc::physical::RoutethroughWeakPtr

Weak pointer encapsulation of a Routethrough.

Definition at line 75 of file Routethrough.hpp.

typedef boost::shared_ptr<RoutingNet> torc::physical::RoutingNetSharedPtr

Shared pointer encapsulation of a RoutingNet.

Definition at line 131 of file RoutingNet.hpp.

typedef std::vector<RoutingNetSharedPtr> torc::physical::RoutingNetSharedPtrVector

Vector of RoutingNet shared pointers.

Definition at line 134 of file RoutingNet.hpp.

typedef boost::uint64_t torc::physical::SequenceIndex

Typedef for generic sequences.

Definition at line 144 of file XilinxPhysicalTypes.hpp.

Enumeration Type Documentation

enum torc::physical::EInstanceBonding

Enumeration of pad bonding types.

Enumerator
eInstanceBondingUnbonded
eInstanceBondingBonded
eInstanceBondingUnknown
eInstanceBondingCount

Definition at line 69 of file XilinxPhysicalTypes.hpp.

                          {
        eInstanceBondingUnbonded = 0,
        eInstanceBondingBonded,
        eInstanceBondingUnknown,
        eInstanceBondingCount
    };

enum torc::physical::ENetType

Enumeration of net power types.

Enumerator
eNetTypeNormal
eNetTypePower
eNetTypeGround
eNetTypeCount

Definition at line 132 of file XilinxPhysicalTypes.hpp.

                  {
        eNetTypeNormal = 0,
        eNetTypePower,
        eNetTypeGround,
        eNetTypeCount
    };

enum torc::physical::EPinDirection

Enumeration of instance pin directionality.

Enumerator
ePinDirectionInpin
ePinDirectionOutpin
ePinDirectionUnknown
ePinDirectionCount

Definition at line 107 of file XilinxPhysicalTypes.hpp.

                       {
        ePinDirectionInpin = 0,
        ePinDirectionOutpin,
        ePinDirectionUnknown,
        ePinDirectionCount
    };

enum torc::physical::EPipDirection

Enumeration of pip directionality.

Enumerator
ePipBidirectionalUnbuffered
ePipBidirectionalUnidirectionallyBuffered
ePipBidirectionalBidirectionallyBuffered
ePipUnidirectionalBuffered
ePipDirectionCount

Definition at line 119 of file XilinxPhysicalTypes.hpp.

                       {
        ePipBidirectionalUnbuffered = 0,
        ePipBidirectionalUnidirectionallyBuffered,
        ePipBidirectionalBidirectionallyBuffered,
        ePipUnidirectionalBuffered,
        ePipDirectionCount
    };

enum torc::physical::ESequenceIndex

Enumeration of sequence indexes.

A sequence index is just a number, so we only need to capture the number to use when there is no sequence defined, and the number with which to begin actual sequences. Note that this should probably be pulled into a higher-level part of the code, since it may be used in multiple cases.

Enumerator
eSequenceIndexNone
eSequenceIndexFirst

Definition at line 150 of file XilinxPhysicalTypes.hpp.

                        {
        eSequenceIndexNone = 0,
        eSequenceIndexFirst
    };

enum torc::physical::PinType

Enumerator
Unknown
InputP
OutputP

Definition at line 31 of file packer/PrimitivePin.hpp.

{ Unknown, InputP, OutputP } PinType;

Function Documentation

torc::physical::BOOST_AUTO_TEST_CASE

(

ConfigUnitTest

)

Unit test for the Config class.

Definition at line 28 of file ConfigUnitTest.cpp.

                                     {
    // functions tested:
    //      Config(const string& inName, const string& inValue);
    //      Config(const string& inName, const string& inValue, SequenceIndex inOrder);
    //      Config(void);
    // create a config
    std::string name1 = "name1";
    std::string name2 = "name2";
    std::string name3 = "name3";
    std::string value1 = "value1";
    std::string value2 = "value2";
    std::string value3 = "value3";
    SequenceIndex order1(0);
    SequenceIndex order2(9);
    SequenceIndex order3(10);
    Config config1(name1, value1);
    Config config2("name3", "value3", order2);
    Config config3;

    // functions tested:
    //      const string& Named::getName(void) const;
    //      const string& getValue(void) const;
    //      SequenceIndex getOrder(void) const;
    //      void setOrder(SequenceIndex inOrder);
    BOOST_CHECK_EQUAL(config1.getName(), name1);
    BOOST_CHECK_EQUAL(config1.getValue(), value1);
    config3.setOrder(order3);
    BOOST_CHECK(config1.getOrder() == order1);
    BOOST_CHECK(config2.getOrder() == order2);
    BOOST_CHECK(config3.getOrder() == order3);

    // functions tested:
    //      void setValue(const string& inValue);
    //      void setName(const string& inName);
    //      const string& Named::getName(void) const;
    //      const string& getValue(void) const;
    config1.setName(name2);
    config1.setValue(value2);
    BOOST_CHECK_EQUAL(config1.getName(), name2);
    BOOST_CHECK_EQUAL(config1.getValue(), value2);

    // functions tested:
    //      bool operator ==(const Config& rhs) const;
    BOOST_CHECK((config1 == config2) == false);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

RenamableUnitTest

)

Unit test for the Renamable class.

Definition at line 28 of file RenamableUnitTest.cpp.

                                        {
}

torc::physical::BOOST_AUTO_TEST_CASE

(

FactoryUnitTest

)

Unit test for the Factory class.

Definition at line 28 of file physical/FactoryUnitTest.cpp.

                                      {
    // functions tested:
    //  static DesignSharedPtr newDesignPtr(const string& inName, const string& inDevice, 
    //      const string& inPackage, const string& inSpeedGrade, const string& inXdlVersion);
    DesignSharedPtr designPtr = Factory::newDesignPtr("design", "device", "package", "speed", 
        "version");
    BOOST_REQUIRE(designPtr.get() != 0);

    // functions tested:
    //  static ModuleSharedPtr newModulePtr(const string& inName, const string& inAnchor);
    ModuleSharedPtr modulePtr = Factory::newModulePtr("name", "anchor");
    BOOST_REQUIRE(modulePtr.get() != 0);

    // functions tested:
    //  static InstanceSharedPtr newInstancePtr(const string& inName, const string& inType, 
    //      const string& inTile, const string& inSite, EInstanceBonding inBonding, 
    //      InstanceReferenceSharedPtr inInstanceReferencePtr);
    InstanceSharedPtr instance1Ptr = Factory::newInstancePtr("name", "type", "tile", "site");
    BOOST_REQUIRE(instance1Ptr.get() != 0);

    // functions tested:
    //  static PortSharedPtr newPortPtr(const string& inName, InstanceSharedPtr inInstancePtr, 
    //      const string& inPinName);
    PortSharedPtr portPtr = Factory::newPortPtr("name", instance1Ptr, "pin");
    BOOST_REQUIRE(portPtr.get() != 0);

    // functions tested:
    //  static NetSharedPtr newNetPtr(const string& inName, ENetType inNetType = eNetTypeNormal);
    NetSharedPtr net1Ptr = Factory::newNetPtr("name");
    BOOST_REQUIRE(net1Ptr.get() != 0);

    // functions tested:
    //  static InstanceReferenceSharedPtr newInstanceReferencePtr(const string& inInstantiationName, 
    //      ModuleSharedPtr inModulePtr, InstanceSharedPtr inInstancePtr);
    InstanceReferenceSharedPtr instanceReferencePtr = Factory::newInstanceReferencePtr("name", 
        modulePtr, instance1Ptr);
    BOOST_REQUIRE(instanceReferencePtr.get() != 0);

    // functions tested:
    InstanceSharedPtr instance2Ptr = Factory::newInstancePtr("name", "type", "tile", "site", 
        eInstanceBondingUnknown, instanceReferencePtr);
    BOOST_REQUIRE(instance2Ptr.get() != 0);

    // functions tested:
    //  static torc::physical::InstancePin newInstancePinPtr(InstanceSharedPtr inInstancePtr, 
    //      const string& inPinName);
    InstancePinSharedPtr instancePinPtr = Factory::newInstancePinPtr(instance2Ptr, "pin");
    BOOST_REQUIRE(instancePinPtr->getInstancePtr().lock() == instance2Ptr);

    // functions tested:
    //  static RoutethroughSharedPtr newRoutethroughPtr(const string& inSetting, 
    //      const string& inName, const string& inValue, const InstanceWeakPtr& inInstancePtr, 
    //      const string& inSourceWireName, const string& inSinkWireName);
    RoutethroughSharedPtr routethroughPtr = Factory::newRoutethroughPtr("setting", "name", "value", 
        instance2Ptr, "source", "sink");
    BOOST_REQUIRE(routethroughPtr.get() != 0);

    // functions tested:
    //  static torc::physical::Pip newPip(const string& inTileName, const string& inSourceWireName, 
    //      const string& inSinkWireName, EPipDirection inPipDirection, 
    //      RoutethroughSharedPtr inRoutethroughPtr);
    Pip pip = Factory::newPip("tile", "source", "sink", ePipUnidirectionalBuffered, 
        routethroughPtr);
    BOOST_REQUIRE(pip.getRoutethroughPtr() == routethroughPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

NamedUnitTest

)

Unit test for the Named class.

Definition at line 28 of file NamedUnitTest.cpp.

                                    {
    // functions tested:
    //      Named(const string& inName);
    //      const string& getName(void) const;
    //      bool operator ==(const Named& rhs) const;
    // create two Named objects
    std::string name1 = "name1";
    std::string name2 = "name2";
    Named named1(name1);
    Named named2(name2);
    BOOST_CHECK(named1.getName() == name1);
    BOOST_CHECK_EQUAL(named1 == named2, false);

    // functions tested:
    //      NameComparator(const string& inName);
    //      bool operator() (const Named& inNamed) const;
    //      bool operator() (const NamedSharedPtr& inNamedPtr) const;
    // compare Named objects with a comparator
    NameComparator comparator(name1);
    NamedSharedPtr named1Ptr = NamedSharedPtr(new Named(name1));
    BOOST_CHECK_EQUAL(comparator(named1Ptr), true);
    BOOST_CHECK_EQUAL(comparator(named1), true);
    BOOST_CHECK_EQUAL(comparator(named2), false);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

InstancePinUnitTest

)

Unit test for the InstancePin class.

Definition at line 29 of file physical/InstancePinUnitTest.cpp.

                                          {
    // create an accessory instance
    InstanceSharedPtr instance1Ptr = Factory::newInstancePtr("name1", "type", "tile", "site");
    InstanceSharedPtr instance2Ptr = Factory::newInstancePtr("name2", "type", "tile", "site");

    // functions tested:
    //      InstancePin(InstanceSharedPtr inInstancePtr, const string& inPinName);
    // create an instance pin and verify that we can recover what we put into it
    std::string pinName = "pin";
    InstancePinSharedPtr instancePin1Ptr = Factory::newInstancePinPtr(instance1Ptr, "");
    InstancePinSharedPtr instancePin2Ptr = Factory::newInstancePinPtr(instance2Ptr, pinName);

    // functions tested:
    //      const InstanceWeakPtr& getInstancePtr(void) const;
    //      const PinName& getPinName(void) const;
    //      void setInstancePtr(const InstanceWeakPtr& inInstancePtr);
    //      void setPinName(const string& inPinName);
    BOOST_CHECK(*(instancePin1Ptr->getInstancePtr().lock()) == *instance1Ptr);
    BOOST_CHECK(instancePin1Ptr->getPinName().empty());
    instancePin1Ptr->setInstancePtr(instance2Ptr);
    instancePin1Ptr->setPinName(pinName);
    BOOST_CHECK(*(instancePin1Ptr->getInstancePtr().lock()) == *instance2Ptr);
    BOOST_CHECK(instancePin1Ptr->getPinName() == pinName);

    // functions tested:
    //      bool operator ==(const InstancePin& rhs) const;
    BOOST_CHECK(*instancePin1Ptr == *instancePin2Ptr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

InstanceReferenceUnitTest

)

Unit test for the InstanceReference class.

Definition at line 29 of file InstanceReferenceUnitTest.cpp.

                                                {
    // create the accessory instance and module
    ModuleSharedPtr modulePtr = Factory::newModulePtr("name", "anchor");
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site");

    // functions tested:
    //      InstanceReference(const string& inInstantiationName, ModuleSharedPtr inModulePtr, 
    //          InstanceSharedPtr inInstancePtr);
    // create an instance reference and verify that we can recover what we put into it
    std::string name = "name";
    InstanceReferenceSharedPtr instanceReference1Ptr = Factory::newInstanceReferencePtr(name, 
        modulePtr, instancePtr);
    InstanceReferenceSharedPtr instanceReference2Ptr = Factory::newInstanceReferencePtr(name, 
        modulePtr, instancePtr);
    BOOST_REQUIRE(instanceReference1Ptr != 0);
    BOOST_REQUIRE(instanceReference2Ptr != 0);

    // functions tested:
    //      const ModuleWeakPtr& getModulePtr(void) const;
    //      const InstanceWeakPtr& getInstancePtr(void) const;
    //      const string& getInstantiationName(void) const;
    BOOST_CHECK(*(instanceReference1Ptr->getInstancePtr().lock()) == *instancePtr);
    BOOST_CHECK(*(instanceReference1Ptr->getModulePtr().lock()) == *modulePtr);
    BOOST_CHECK(instanceReference1Ptr->getInstantiationName() == name);

    // functions tested:
    //      bool operator ==(const InstanceReference& rhs) const;
    BOOST_CHECK(*instanceReference1Ptr == *instanceReference2Ptr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ConfigMapUnitTest

)

Unit test for the ConfigMap class.

Definition at line 29 of file ConfigMapUnitTest.cpp.

                                        {
    // create some configuration entries
    Config config1("name1", "value1");
    Config config2("name2", "value2");
    Config config3("name3", "value3");
    Config config4("name4", "value4");

    // functions tested:
    //      ConfigMap(void);
    //      void setConfig(const string& inSetting, const Config& inConfig);
    //      static bool allowConfigDuplicates(const string& inSetting);
    // create a configuration map and add the configuration entries to it
    ConfigMap configMap1;
    configMap1.setConfig("config", config1);
    configMap1.setConfig("config", config2);
    configMap1.setConfig("_config", config3);
    configMap1.setConfig("_config", config4);
    ConfigMap configMap2;

    // functions tested:
    //      bool getConfig(const string& inSetting, string& outName, string& outValue);
    //      void setConfig(const string& inSetting, const string& inName, const string& inValue);
    std::string name;
    std::string value;
    configMap1.getConfig("config", name, value);
    configMap2.setConfig("ending", name, value);

    // functions tested:
    //      bool hasConfig(const string& inSetting) const;
    //      size_type getMultiConfigCount(const string& inSetting);
    //      size_t getConfigCount(void) const;
    //      bool configIsEmpty(void) const;
    // verify that the configuration entries exist in the proper quantities
    // (settings prefixed with an underscore can exist multiple times, while other settings cannot)
    BOOST_CHECK(configMap1.hasConfig("config"));
    BOOST_CHECK(configMap1.hasConfig("_config"));
    BOOST_CHECK_EQUAL((size_t) 1, configMap1.getMultiConfigCount("config"));
    BOOST_CHECK_EQUAL((size_t) 2, configMap1.getMultiConfigCount("_config"));
    BOOST_CHECK(configMap1.getConfigCount() == 3);
    BOOST_CHECK(configMap1.configIsEmpty() == false);

    // functions tested:
    //      bool getConfig(const string& inSetting, Config& outConfig);
    //      const_iterator configBegin(void) const;
    //      const_iterator configEnd(void) const;
    // read out and check expected settings
    Config config5;
    configMap1.getConfig("config", config5);
    BOOST_CHECK_EQUAL(config2, config5);
    // verify the expected iterator behavior
    ConfigMap::const_iterator p = configMap1.configBegin();
    ConfigMap::const_iterator e = configMap1.configEnd();
    BOOST_CHECK_EQUAL(config3, p->second); p++;
    BOOST_CHECK_EQUAL(config4, p->second); p++;
    BOOST_CHECK_EQUAL(config2, p->second); p++;

    // functions tested:
    //      std::pair<iterator, iterator> getMultiConfigValues(const string& inSetting);
    std::pair<ConfigMap::const_iterator, ConfigMap::const_iterator> range 
        = configMap1.getMultiConfigValues("_config");
    p = range.first;
    e = range.second;
    BOOST_CHECK_EQUAL(config3, p->second); p++;
    BOOST_CHECK_EQUAL(config4, p->second); p++;
    BOOST_CHECK(p == e);
    //  p = configMap1.configBegin();
    //  e = configMap1.configEnd();
    //  while(p != e) {
    //      std::cout << p->first << ":" << p->second.getName() << ":" << p->second.getValue() << std::endl;
    //      p++;
    //  }

    // functions tested:
    //      void clearConfig(void);
    //      void addConfigs(const ConfigMap& inConfigMap);
    //      size_t getConfigCount(void) const;
    //      bool configIsEmpty(void) const;
    configMap2.addConfigs(configMap1);
    configMap1.clearConfig();
    BOOST_CHECK(configMap1.getConfigCount() == 0);
    BOOST_CHECK(configMap1.configIsEmpty() == true);
    BOOST_CHECK(configMap2.getConfigCount() == 4);
    BOOST_CHECK(configMap2.configIsEmpty() == false);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

PipUnitTest

)

Unit test for the Pip class.

Definition at line 29 of file PipUnitTest.cpp.

                                  {
    // create an accessory instance and routethrough
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site", 
        eInstanceBondingUnknown);
    BOOST_REQUIRE(instancePtr.get() != 0);
    RoutethroughSharedPtr routethroughPtr = Factory::newRoutethroughPtr("setting", "name", "value", 
        instancePtr, "source", "sink");
    BOOST_REQUIRE(routethroughPtr.get() != 0);

    // functions tested:
    //      Pip(const string& inTileName, const string& inSourceWireName, 
    //          const string& inSinkWireName, EPipDirection inPipDirection, 
    //          RoutethroughSharedPtr inRoutethroughPtr);
    std::string tile = "tile";
    std::string source = "source";
    std::string sink = "sink";
    EPipDirection direction = ePipUnidirectionalBuffered;
    Pip pip1 = Factory::newPip(tile, source, sink, direction, routethroughPtr);
    Pip pip2 = Factory::newPip(tile, source, sink, direction, routethroughPtr);

    // functions tested:
    //      const TileName& getTileName(void) const;
    //      const WireName& getSourceWireName(void) const;
    //      const WireName& getSinkWireName(void) const;
    //      EPipDirection getDirection(void) const;
    //      const char* getDirectionString(void) const;
    //      static const char* getDirectionString(EPipDirection inPipDirection);
    BOOST_CHECK_EQUAL(pip1.getTileName(), tile);
    BOOST_CHECK_EQUAL(pip1.getSourceWireName(), source);
    BOOST_CHECK_EQUAL(pip1.getSinkWireName(), sink);
    BOOST_CHECK(pip1.getDirection() == direction);
    BOOST_CHECK(pip1.getDirectionString() == Pip::getDirectionString(direction));
    BOOST_CHECK_EQUAL("==", Pip::getDirectionString(ePipBidirectionalUnbuffered));
    BOOST_CHECK_EQUAL("=>", Pip::getDirectionString(ePipBidirectionalUnidirectionallyBuffered));
    BOOST_CHECK_EQUAL("=-", Pip::getDirectionString(ePipBidirectionalBidirectionallyBuffered));
    BOOST_CHECK_EQUAL("->", Pip::getDirectionString(ePipUnidirectionalBuffered));

    // functions tested:
    //      RoutethroughSharedPtr getRoutethroughPtr(void) const;
    //      bool isRoutethrough(void) const;
    BOOST_CHECK(pip1.isRoutethrough());
    BOOST_CHECK(pip1.getRoutethroughPtr() == routethroughPtr);

    // functions tested:
    //      bool operator ==(const Pip& rhs) const;
    BOOST_CHECK(pip1 == pip1); // name based comparison
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

PortUnitTest

)

Unit test for the Port class.

Definition at line 29 of file PortUnitTest.cpp.

                                   {
    // create an accessory instance
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site", 
        eInstanceBondingUnknown);
    BOOST_REQUIRE(instancePtr.get() != 0);

    // functions tested:
    //      Port(const string& inName, InstanceSharedPtr inInstancePtr, const string& inPinName);
    std::string name = "name";
    std::string pin = "pin";
    PortSharedPtr port1Ptr = Factory::newPortPtr(name, instancePtr, pin);
    PortSharedPtr port2Ptr = Factory::newPortPtr(name, instancePtr, pin);
    BOOST_REQUIRE(port1Ptr.get() != 0);
    BOOST_REQUIRE(port2Ptr.get() != 0);

    // functions tested:
    //      const InstanceWeakPtr& getInstancePtr(void) const;
    //      const PinName& getPinName(void) const;
    BOOST_CHECK(port1Ptr->getInstancePtr().lock() == instancePtr);
    BOOST_CHECK(port1Ptr->getPinName() == pin);

    // functions tested:
    //      bool operator ==(const Port& rhs) const;
    BOOST_CHECK(*port1Ptr == *port2Ptr); // name based comparison
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

InstanceUnitTest

)

Unit test for the Instance class.

Definition at line 29 of file InstanceUnitTest.cpp.

                                       {
    // create accessory instances and module
    std::string name = "name";
    std::string type = "type";
    std::string tile = "tile";
    std::string site = "site";
    ModuleSharedPtr modulePtr = Factory::newModulePtr("name", "anchor");
    InstanceSharedPtr instance2Ptr = Factory::newInstancePtr(name, "type", "tile", "site");
    InstanceReferenceSharedPtr instanceReferencePtr = Factory::newInstanceReferencePtr("name", 
        modulePtr, instance2Ptr);

    // functions tested:
    //      Instance(const string& inName, const string& inType, const string& inTile, 
    //          const string& inSite, EInstanceBonding inBonding, 
    //          InstanceReferenceSharedPtr& inInstanceReferencePtr);
    // create an instance
    EInstanceBonding bonding = eInstanceBondingBonded;
    InstanceSharedPtr instance1Ptr = Factory::newInstancePtr(name, "", "", "");
    BOOST_REQUIRE(instance1Ptr != 0);

    // functions tested:
    //      void setType(const string& inType);
    //      void setTile(const string& inTile);
    //      void setSite(const string& inSite);
    //      void setBonding(EInstanceBonding inBonding);
    //      void setInstanceReferencePtr(InstanceReferenceSharedPtr inInstanceReferenceSharedPtr);
    //      const string& getType(void) const;
    //      const string& getTile(void) const;
    //      const string& getSite(void) const;
    //      EInstanceBonding getBonding(void) const;
    //      InstanceReferenceSharedPtr getInstanceReferencePtr(void) const;
    BOOST_CHECK(instance1Ptr->getType().empty());
    BOOST_CHECK(instance1Ptr->getTile().empty());
    BOOST_CHECK(instance1Ptr->getSite().empty());
    BOOST_CHECK(instance1Ptr->getBonding() == eInstanceBondingUnknown);
    instance1Ptr->setType(type);
    instance1Ptr->setTile(tile);
    instance1Ptr->setSite(site);
    instance1Ptr->setBonding(bonding);
    instance1Ptr->setInstanceReferencePtr(instanceReferencePtr);
    BOOST_CHECK(instance1Ptr->getType() == type);
    BOOST_CHECK(instance1Ptr->getTile() == tile);
    BOOST_CHECK(instance1Ptr->getSite() == site);
    BOOST_CHECK(instance1Ptr->getBonding() == bonding);
    BOOST_CHECK(instance1Ptr->getInstanceReferencePtr() == instanceReferencePtr);

    // functions tested:
    //      bool operator ==(const Instance& rhs) const;
    BOOST_CHECK(*instance1Ptr == *instance2Ptr); // comparison based on instance names only

    // functions tested:
    //      void unplace(void);
    instance1Ptr->unplace();
    BOOST_CHECK(instance1Ptr->getTile().empty());
    BOOST_CHECK(instance1Ptr->getSite().empty());

    // functions tested:
    //      void addPin(const InstancePinWeakPtr& inInstancePinPtr);
    //      void removePin(const InstancePinWeakPtr& inInstancePinPtr);
    //      const InstancePinSharedPtrConstIterator findPin(const PinName& inPinName);
    PinName pinName1("name1");
    PinName pinName2("name2");
    InstancePinSharedPtr instancePin1Ptr = Factory::newInstancePinPtr(instance1Ptr, pinName1);
    InstancePinSharedPtr instancePin2Ptr = Factory::newInstancePinPtr(instance1Ptr, pinName1);
    InstancePinSharedPtr instancePin3Ptr = Factory::newInstancePinPtr(instance1Ptr, pinName2);
    NetSharedPtr netPtr = Factory::newNetPtr("name");
    netPtr->addSource(instancePin1Ptr);
    netPtr->addSource(instancePin2Ptr);
    netPtr->addSink(instancePin3Ptr);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(), 3u);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(pinName1), 2u);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(pinName2), 1u);
    Instance::InstancePinSharedPtrConstIterator ipp = instance1Ptr->findPin(pinName1);
    Instance::InstancePinSharedPtrConstIterator ipe = instance1Ptr->pinsEnd();
    BOOST_REQUIRE(ipp != ipe);
    BOOST_CHECK(ipp->second == instancePin1Ptr);
    BOOST_CHECK_EQUAL(ipp->second->getPinName(), pinName1);
    BOOST_CHECK_EQUAL(ipp->second->getPinName(), ipp->first);
    BOOST_CHECK(ipp->second->getParentWeakPtr().lock() == netPtr);
    std::pair<Instance::InstancePinSharedPtrConstIterator, 
        Instance::InstancePinSharedPtrConstIterator> range = instance1Ptr->findPinRange(pinName1);
    BOOST_REQUIRE(range.first != range.second);
    BOOST_CHECK_EQUAL(range.first->second->getPinName(), pinName1); range.first++;
    BOOST_CHECK_EQUAL(range.first->second->getPinName(), pinName1); range.first++;
    BOOST_CHECK(range.first == range.second);
    netPtr->removeSource(instancePin2Ptr);
    netPtr->removeSink(instancePin3Ptr);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(), 1u);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(pinName1), 1u);
    BOOST_CHECK_EQUAL(instance1Ptr->getPinCount(pinName2), 0u);
    ipp = instance1Ptr->findPin(pinName1);
    ipe = instance1Ptr->pinsEnd();
    BOOST_REQUIRE(ipp != ipe);
    BOOST_CHECK(ipp->second == instancePin1Ptr);
    BOOST_CHECK_EQUAL(ipp->second->getPinName(), pinName1);
    BOOST_CHECK_EQUAL(ipp->second->getPinName(), ipp->first);
    BOOST_CHECK(ipp->second->getParentWeakPtr().lock() == netPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

RouteThroughUnitTest

)

Unit test for the Routethrough class.

Definition at line 29 of file RoutethroughUnitTest.cpp.

                                           {
    // create an accessory instance
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site", 
        eInstanceBondingUnknown);
    BOOST_REQUIRE(instancePtr.get() != 0);

    // functions tested:
    //      Routethrough(const string& inSetting, const string& inName, const string& inValue, 
    //          const InstanceWeakPtr& inInstancePtr, const string& inSourceWireName, 
    //          const string& inSinkWireName);
    std::string setting = "_ROUTETHROUGH";
    std::string name = "name";
    std::string value = "value";
    std::string source = "source";
    std::string sink = "sink";
    Routethrough routethrough(setting, name, value, instancePtr, source, sink);

    // functions tested:
    //      const string& getSetting(void) const;
    //      const InstanceWeakPtr& getInstancePtr(void) const;
    //      const WireName& getSourceWireName(void) const;
    //      const WireName& getSinkWireName(void) const;
    BOOST_CHECK_EQUAL(routethrough.getSetting(), setting);
    BOOST_CHECK_EQUAL(routethrough.getSourceWireName(), source);
    BOOST_CHECK_EQUAL(routethrough.getSinkWireName(), sink);
    BOOST_CHECK(routethrough.getInstancePtr().lock() == instancePtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

TilewirePlaceholderUnitTest

)

Unit test for the TilewirePlaceholder class.

Definition at line 29 of file TilewirePlaceholderUnitTest.cpp.

                                                  {
    // features tested:
    //      sizeof(TilewirePlaceholder)
    BOOST_CHECK_EQUAL(sizeof(torc::architecture::Tilewire), sizeof(TilewirePlaceholder));
}

torc::physical::BOOST_AUTO_TEST_CASE

(

ModuleUnitTest

)

Unit test for the Module class.

Definition at line 29 of file ModuleUnitTest.cpp.

                                     {
    std::string port = "name1";
    // create accessory instance and ports
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site");
    PortSharedPtr port1Ptr = Factory::newPortPtr(port, instancePtr, "pin");
    PortSharedPtr port2aPtr = Factory::newPortPtr("name2", instancePtr, "pin");
    PortSharedPtr port2bPtr = Factory::newPortPtr("name2", instancePtr, "pin");
    // functions tested:
    //      Module(const string& inName, const string& inAnchor);
    // create two modules
    std::string name = "name";
    std::string anchor = "anchor";
    ModuleSharedPtr module1Ptr = Factory::newModulePtr(name, "");
    ModuleSharedPtr module2Ptr = Factory::newModulePtr(name, anchor);
    BOOST_REQUIRE(module1Ptr != 0);
    BOOST_REQUIRE(module2Ptr != 0);

    // functions tested:
    //      const string& getAnchor(void) const;
    //      void setAnchor(const string& inAnchor);
    BOOST_CHECK(module1Ptr->getAnchor().empty());
    module1Ptr->setAnchor(anchor);
    BOOST_CHECK(module1Ptr->getAnchor() == anchor);

    // functions tested:
    //      PortSharedPtrIterator findPort(const string& inName);
    //      bool addPort(PortSharedPtr& inPortPtr);
    //      size_t getPortCount(void) const;
    BOOST_CHECK_EQUAL(module1Ptr->addPort(port1Ptr), true);
    BOOST_CHECK_EQUAL(module1Ptr->addPort(port2aPtr), true);
    BOOST_CHECK_EQUAL(module1Ptr->addPort(port2bPtr), false); // port name already exists
    BOOST_CHECK(module1Ptr->getPortCount() == 2);

    // functions tested:
    //      PortSharedPtrConstIterator portsBegin(void) const;
    //      PortSharedPtrConstIterator portsEnd(void) const;
    //      PortSharedPtrIterator portsBegin(void);
    //      PortSharedPtrIterator portsEnd(void);
    Module::PortSharedPtrConstIterator p = module1Ptr->portsBegin();
    Module::PortSharedPtrConstIterator e = module1Ptr->portsEnd();
    BOOST_CHECK(*p++ == port1Ptr);
    BOOST_CHECK(*p++ == port2aPtr);
    BOOST_CHECK(p == e);
    BOOST_CHECK(*(module1Ptr->findPort(port)) == port1Ptr);

    // functions tested:
    //      PortSharedPtrIterator findPort(const string& inName);
    //      bool removePort(PortSharedPtr& inPortPtr);
    //      size_t getPortCount(void) const;
    BOOST_CHECK_EQUAL(module1Ptr->removePort(port1Ptr), true);
    BOOST_CHECK_EQUAL(module1Ptr->removePort(port2aPtr), true);
    BOOST_CHECK_EQUAL(module1Ptr->removePort(port2bPtr), false);
    BOOST_CHECK(module1Ptr->getPortCount() == 0);

    // functions tested:
    //      bool operator ==(const Module& rhs) const;
    BOOST_CHECK(*module1Ptr == *module2Ptr); // comparison based on module names only
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

NetUnitTest

)

Unit test for the Net class.

Definition at line 29 of file NetUnitTest.cpp.

                                  {
    // accessory instance and pins
    std::string name = "name";
    // create accessory instance, pins, and pips
    InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site");
    InstancePinSharedPtr pin1Ptr = Factory::newInstancePinPtr(instancePtr, "pin1");
    InstancePinSharedPtr pin2Ptr = Factory::newInstancePinPtr(instancePtr, "pin2");
    InstancePinSharedPtr pin3Ptr = Factory::newInstancePinPtr(instancePtr, "pin3");
    InstancePinSharedPtr pin4Ptr = Factory::newInstancePinPtr(instancePtr, "pin4");
    Pip pip1 = Factory::newPip("tile", "source1", "sink1", ePipUnidirectionalBuffered);
    Pip pip2 = Factory::newPip("tile", "source2", "sink2", ePipUnidirectionalBuffered);
    Pip pip3 = Factory::newPip("tile", "source3", "sink3", ePipUnidirectionalBuffered);

    // functions tested:
    //      Net(const string& inName, ENetType inNetType);
    ENetType normal = eNetTypeNormal;
    ENetType power = eNetTypePower;
    ENetType ground = eNetTypeGround;
    NetSharedPtr net1Ptr = Factory::newNetPtr(name);
    NetSharedPtr net2Ptr = Factory::newNetPtr(name, power);
    BOOST_REQUIRE(net1Ptr != 0);
    BOOST_REQUIRE(net2Ptr != 0);

    // functions tested:
    //      ENetType getNetType(void) const;
    //      void setNetType(ENetType inNetType);
    BOOST_CHECK(net1Ptr->getNetType() == normal);
    BOOST_CHECK(net2Ptr->getNetType() == power);
    net2Ptr->setNetType(ground);
    BOOST_CHECK(net2Ptr->getNetType() == ground);

    // functions tested:
    //      void addSource(const InstancePin& inInstancePin);
    //      void addSink(const InstancePin& inInstancePin);
    //      bool containsSource(const InstancePin& inInstancePin) const;
    //      bool containsSink(const InstancePin& inInstancePin) const;
    //      bool hasAnySources(void) const;
    //      bool hasOneSource(void) const;
    //      bool hasMultipleSources(void) const;
    //      size_t getSourceCount(void) const;
    //      bool hasAnySinks(void) const;
    //      bool hasOneSink(void) const;
    //      bool hasMultipleSinks(void) const;
    //      size_t getSinkCount(void) const;
    net1Ptr->addSource(pin1Ptr);
    net1Ptr->addSink(pin2Ptr);
    net1Ptr->addSink(pin3Ptr);
    net1Ptr->addSink(pin4Ptr);
    BOOST_CHECK_EQUAL(net1Ptr->containsSource(pin1Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin1Ptr), false);
    BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin2Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin3Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin4Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->hasAnySources(), true);
    BOOST_CHECK_EQUAL(net1Ptr->hasOneSource(), true);
    BOOST_CHECK_EQUAL(net1Ptr->hasMultipleSources(), false);
    BOOST_CHECK(net1Ptr->getSourceCount() == 1);
    BOOST_CHECK_EQUAL(net1Ptr->hasAnySinks(), true);
    BOOST_CHECK_EQUAL(net1Ptr->hasOneSink(), false);
    BOOST_CHECK_EQUAL(net1Ptr->hasMultipleSinks(), true);
    BOOST_CHECK(net1Ptr->getSinkCount() == 3);

    // functions tested:
    //      bool removeSource(const InstancePin& inInstancePin);
    //      bool removeSink(const InstancePin& inInstancePin);
    //      InstancePinConstIterator sourcesBegin(void) const;
    //      InstancePinConstIterator sourcesEnd(void) const;
    //      InstancePinConstIterator sinksBegin(void) const;
    //      InstancePinConstIterator sinksEnd(void) const;
    Net::InstancePinSharedPtrConstIterator op = net1Ptr->sourcesBegin();
    Net::InstancePinSharedPtrConstIterator oe = net1Ptr->sourcesEnd();
    BOOST_CHECK(*op++ == pin1Ptr);
    BOOST_CHECK(op == oe);
    BOOST_CHECK_EQUAL(net1Ptr->removeSource(pin1Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->removeSource(pin2Ptr), false);
    BOOST_CHECK(net1Ptr->getSourceCount() == 0);
    Net::InstancePinSharedPtrConstIterator ip = net1Ptr->sinksBegin();
    Net::InstancePinSharedPtrConstIterator ie = net1Ptr->sinksEnd();
    BOOST_CHECK(*ip++ == pin2Ptr);
    BOOST_CHECK(*ip++ == pin3Ptr);
    BOOST_CHECK(*ip++ == pin4Ptr);
    BOOST_CHECK(ip == ie);
    BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin1Ptr), false);
    BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin2Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin3Ptr), true);
    BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin4Ptr), true);
    BOOST_CHECK(net1Ptr->getSinkCount() == 0);

    // functions tested:
    //      void addPip(const Pip& inPip);
    //      bool containsPip(const Pip& inPip) const;
    //      bool hasAnyPips(void) const;
    //      size_t getPipCount(void) const;
    //      bool isRouted(void) const;
    //      bool isUnrouted(void) const;
    net1Ptr->addPip(pip1);
    net1Ptr->addPip(pip2);
    net1Ptr->addPip(pip3);
    BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip1), true);
    BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip2), true);
    BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip3), true);
    BOOST_CHECK_EQUAL(net1Ptr->hasAnyPips(), true);
    BOOST_CHECK_EQUAL(net1Ptr->isRouted(), true);
    BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), false);
    BOOST_CHECK(net1Ptr->getPipCount() == 3);

    // functions tested:
    //      bool removePip(const Pip& inPip);
    //      void unroute(void);
    //      PipConstIterator pipsBegin(void) const;
    //      PipConstIterator pipsEnd(void) const;
    //      size_t getPipCount(void) const;
    //      bool isRouted(void) const;
    //      bool isUnrouted(void) const;
    Net::PipConstIterator pp = net1Ptr->pipsBegin();
    Net::PipConstIterator pe = net1Ptr->pipsEnd();
    BOOST_CHECK(*pp++ == pip1);
    BOOST_CHECK(*pp++ == pip2);
    BOOST_CHECK(*pp++ == pip3);
    BOOST_CHECK(pp == pe);
    BOOST_CHECK_EQUAL(net1Ptr->removePip(pip1), true);
    BOOST_CHECK_EQUAL(net1Ptr->removePip(pip1), false);
    BOOST_CHECK_EQUAL(net1Ptr->isRouted(), true);
    BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), false);
    BOOST_CHECK(net1Ptr->getPipCount() == 2);
    net1Ptr->unroute();
    BOOST_CHECK_EQUAL(net1Ptr->isRouted(), false);
    BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), true);
    BOOST_CHECK(net1Ptr->getPipCount() == 0);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

DesignUnitTest

)

Unit test for the Design class.

Todo:

Verify that all children can trace their lineage all the way up to the design.

Definition at line 30 of file DesignUnitTest.cpp.

                                     {
    // functions tested:
    //      Design(const string& inName, const string& inDevice, const string& inPackage, 
    //          const string& inSpeedGrade, const string& inXdlVersion);
    // create a design
    std::string designName = "design";
    std::string deviceName = "device";
    std::string devicePackage = "package";
    std::string deviceSpeedGrade = "speed_grade";
    std::string xdlVersion = "xdl_version";
    std::string moduleName = "module1";
    DesignSharedPtr designPtr = Factory::newDesignPtr(designName, "", "", "", "");
    BOOST_REQUIRE(designPtr.get() != 0);

    // functions tested:
    //      const string& getDevice(void) const;
    //      const string& getPackage(void) const;
    //      const string& getSpeedGrade(void) const;
    //      const string& getXdlVersion(void) const;
    //      void setDevice(const string& inDevice);
    //      void setPackage(const string& inPackage);
    //      void setSpeedGrade(const string& inSpeedGrade);
    //      void setXdlVersion(const string& inXdlVersion);
    BOOST_CHECK(designPtr->getDevice().empty());
    BOOST_CHECK(designPtr->getPackage().empty());
    BOOST_CHECK(designPtr->getSpeedGrade().empty());
    BOOST_CHECK(designPtr->getXdlVersion().empty());
    designPtr->setDevice(deviceName);
    designPtr->setPackage(devicePackage);
    designPtr->setSpeedGrade(deviceSpeedGrade);
    designPtr->setXdlVersion(xdlVersion);
    BOOST_CHECK_EQUAL(designPtr->getName(), designName);
    BOOST_CHECK_EQUAL(designPtr->getDevice(), deviceName);
    BOOST_CHECK_EQUAL(designPtr->getPackage(), devicePackage);
    BOOST_CHECK_EQUAL(designPtr->getSpeedGrade(), deviceSpeedGrade);
    BOOST_CHECK_EQUAL(designPtr->getXdlVersion(), xdlVersion);

    // functions tested:
    //      ModuleSharedPtrIterator findModule(const string& inName);
    //      bool addModule(ModuleSharedPtr& inModulePtr);
    //      size_t getModuleCount(void) const;
    // create and add some modules to the design
    ModuleSharedPtr module1Ptr = Factory::newModulePtr(moduleName, "anchor1");
    ModuleSharedPtr module2aPtr = Factory::newModulePtr("module2", "anchor2");
    ModuleSharedPtr module2bPtr = Factory::newModulePtr("module2", "anchor2");
    BOOST_CHECK_EQUAL(designPtr->addModule(module1Ptr), true);
    BOOST_CHECK_EQUAL(designPtr->addModule(module2aPtr), true);
    BOOST_CHECK_EQUAL(designPtr->addModule(module2bPtr), false);
    BOOST_CHECK(designPtr->getModuleCount() == 2);

    // functions tested:
    //      ModuleSharedPtrIterator findModule(const string& inName);
    //      ModuleSharedPtrConstIterator modulesBegin(void) const;
    //      ModuleSharedPtrConstIterator modulesEnd(void) const;
    //      ModuleSharedPtrIterator modulesBegin(void);
    //      ModuleSharedPtrIterator modulesEnd(void);
    Design::ModuleSharedPtrConstIterator p = designPtr->modulesBegin();
    Design::ModuleSharedPtrConstIterator e = designPtr->modulesEnd();
    BOOST_CHECK(*p++ == module1Ptr);
    BOOST_CHECK(*p++ == module2aPtr);
    BOOST_CHECK(p == e);
    BOOST_CHECK(*(designPtr->findModule(moduleName)) == module1Ptr);

    // functions tested:
    //      ModuleSharedPtrIterator findModule(const string& inName);
    //      bool removeModule(ModuleSharedPtr& inModulePtr);
    //      size_t getModuleCount(void) const;
    // remove the modules
    BOOST_CHECK_EQUAL(designPtr->removeModule(module1Ptr), true);
    BOOST_CHECK_EQUAL(designPtr->removeModule(module2aPtr), true);
    BOOST_CHECK_EQUAL(designPtr->removeModule(module2bPtr), false);
    BOOST_CHECK(designPtr->getModuleCount() == 0);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

OutputStreamHelpersUnitTest

)

Unit test for the output stream helpers.

It's not pretty, and it's incomplete, but it'll have to do for now.

Definition at line 31 of file physical/OutputStreamHelpersUnitTest.cpp.

                                                  {
    std::stringstream s;

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Design& rhs);
    std::string designName = "blinker";
    std::string deviceName = "xc5vlx30";
    std::string devicePackage = "ff324";
    std::string deviceSpeedGrade = "-1";
    std::string xdlVersion = "v3.2";
    DesignSharedPtr designPtr = Factory::newDesignPtr(designName, deviceName, devicePackage, 
        deviceSpeedGrade, xdlVersion);
    s << *designPtr;
    BOOST_CHECK_EQUAL(s.str(), "blinker [xc5vlx30ff324-1, v3.2]");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Module& rhs);
    std::string moduleName = "osc7";
    std::string moduleAnchor = "x0y0";
    ModuleSharedPtr modulePtr = Factory::newModulePtr(moduleName, moduleAnchor);
    s << *modulePtr;
    BOOST_CHECK_EQUAL(s.str(), "osc7 [x0y0]");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Instance& rhs);
    std::string instanceName = "blink";
    std::string instanceType = "SLICEL";
    std::string instanceTile = "CLBLL_X16Y59";
    std::string instanceSite = "SLICE_X27Y59";
    InstanceSharedPtr instancePtr = Factory::newInstancePtr(instanceName, instanceType, 
        instanceTile, instanceSite);
    s << *instancePtr;
    BOOST_CHECK_EQUAL(s.str(), "blink");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Net& rhs);
    std::string netName = "blink";
    ENetType netType = eNetTypeNormal;
    NetSharedPtr netPtr = Factory::newNetPtr(netName, netType);
    s << *netPtr;
    BOOST_CHECK_EQUAL(s.str(), "blink");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const InstancePin& rhs);
    std::string pinName = "DQ";
    InstancePinSharedPtr instancePinPtr = Factory::newInstancePinPtr(instancePtr, pinName);
    s << *instancePinPtr;
    BOOST_CHECK_EQUAL(s.str(), "blink.DQ");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Pip& rhs);
    std::string pipTile = "CLBLL_X16Y59";
    std::string pipSource = "L_DQ";
    std::string pipSink = "SITE_LOGIC_OUTS3";
    EPipDirection pipDirection = ePipUnidirectionalBuffered;
    Pip pip = Factory::newPip(pipTile, pipSource, pipSink, pipDirection);
    s << pip;
    BOOST_CHECK_EQUAL(s.str(), "CLBLL_X16Y59 L_DQ -> SITE_LOGIC_OUTS3");
    s.str(std::string());

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const Config& rhs);
    std::string configName = "blink";
    std::string configValue = "#FF";
    Config config(configName, configValue);
    s << config;
    BOOST_CHECK_EQUAL(s.str(), "blink:#FF");
    s.str(std::string());
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

XdlImporterUnitTest

)

Unit test for the XdlImporter class.

Todo:

Finish testing XdlImporter functionality.

Definition at line 32 of file physical/XdlImporterUnitTest.cpp.

                                          {
    // members not tested:
    //      bool mTraceScanning;
    //      bool mTraceParsing;
    //      string mStreamName;
    // functions not tested:
    //      virtual ~XdlImporter(void);
    //      class torc::XdlScanner* lexer;
    //      DEPRECATED bool import(istream& in, const string& name = "stream input") 
    //      DEPRECATED bool import(const string& input, const string& name = "string stream") 
    //      bool operator()(const string& input, const string& name = "string stream");
    //      DEPRECATED bool import(const boost::filesystem::path& filename);
    //      bool operator()(const boost::filesystem::path& filename);
    //      void error(const location& l, const string& m);
    //      void error(const string& m);
    //      void failure(void);
    // functions not tested (because they are null virtual functions):
    //      virtual void initializeDatabase(void);
    //      virtual void bind(torc::physical::InstancePinSharedPtr&);
    //      virtual void bind(torc::physical::Pip&, EPipType);

    // create the appropriate file paths
    boost::filesystem::path referencePath = torc::common::DirectoryTree::getExecutablePath() 
        / "torc" / "physical" / "DesignUnitTest.reference.xdl";

    // functions tested:
    //      XdlImporter(void);
    //      bool operator()(istream& in, const string& name = "stream input");
    // import the XDL design
    std::fstream fileStream(referencePath.string().c_str());
    BOOST_REQUIRE(fileStream.good());
    XdlImporter importer;
    importer(fileStream, referencePath.string());
    BOOST_CHECK_EQUAL(referencePath.string(), importer.mStreamName);

    // functions tested:
    //      DesignSharedPtr getDesignPtr(void);
    DesignSharedPtr designPtr = importer.getDesignPtr();
    BOOST_REQUIRE(designPtr.get() != 0);
    BOOST_CHECK_EQUAL(designPtr->getName(), "blinker");
    BOOST_CHECK_EQUAL(designPtr->getDevice(), "xc5vlx30");
    BOOST_CHECK_EQUAL(designPtr->getPackage(), "ff324");
    BOOST_CHECK_EQUAL(designPtr->getSpeedGrade(), "-1");
    BOOST_CHECK_EQUAL(designPtr->getModuleCount(), 0u);
    BOOST_CHECK_EQUAL(designPtr->getInstanceCount(), 8u);
    BOOST_CHECK_EQUAL(designPtr->getNetCount(), 7u);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ProgenitorUnitTest

)

Unit test for the Progenitor class.

Definition at line 33 of file ProgenitorUnitTest.cpp.

                                         {
    // functions tested:
    //      [null constructor]
    //      void setSelfWeakPtr(WeakPtrType inSelfPtr);
    //      const WeakPtrType& getSelfWeakPtr(void) const;
    typedef Progenitor<A> progenitor_t;
    progenitor_t::SharedPtrType progenitorPtr(new A());
    BOOST_REQUIRE(progenitorPtr.get() != 0);
    progenitorPtr->setSelfWeakPtr(progenitorPtr);
    BOOST_CHECK(progenitorPtr->getSelfWeakPtr().lock() == progenitorPtr);
}

torc::physical::BOOST_AUTO_TEST_CASE

(

SampleCodeUnitTest

)

Unit test demonstrating some sample code.

Definition at line 33 of file SampleCodeUnitTest.cpp.

                                         {

    // create the appropriate file paths
    boost::filesystem::path referencePath = torc::common::DirectoryTree::getExecutablePath() 
        / "torc" / "physical" / "DesignUnitTest.reference.xdl";
    boost::filesystem::path generatedPath = torc::common::DirectoryTree::getExecutablePath() 
        / "regression" / "DesignUnitTest.reference.xdl";

    // import the XDL design
    std::fstream fileStream(referencePath.string().c_str());
    BOOST_REQUIRE(fileStream.good());
    XdlImporter importer;
    importer(fileStream, referencePath.string());

    // look up the design (and do something with it ...)
    DesignSharedPtr designPtr = importer.getDesignPtr();
    BOOST_REQUIRE(designPtr.get() != 0);

    // export the XDL design
    std::fstream xdlExport(generatedPath.string().c_str(), std::ios_base::out);
    XdlExporter fileExporter(xdlExport);
    fileExporter(designPtr);

}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ProgenyUnitTest

)

Unit test for the Progeny class.

Definition at line 34 of file ProgenyUnitTest.cpp.

                                      {
    // create an accessory progenitor
    typedef Progenitor<A> progenitor_t;
    progenitor_t::SharedPtrType progenitorPtr(new A());
    BOOST_REQUIRE(progenitorPtr.get() != 0);
    progenitorPtr->setSelfWeakPtr(progenitorPtr);

    // functions tested:
    //      Progeny(void);
    //      Progeny(const WeakPtrType& inParentPtr);
    //      void setParentWeakPtr(WeakPtrType inParentPtr);
    //      const WeakPtrType& getParentWeakPtr(void) const;
    //      void resetParentWeakPtr(void);
    B progeny1;
    B progeny2/*(progenitorPtr)*/;
    BOOST_CHECK_EQUAL(progeny1.getParentWeakPtr().expired(), true);
    BOOST_CHECK_EQUAL(progeny2.getParentWeakPtr().expired(), true);
    progeny2.setParentWeakPtr(progenitorPtr);
    BOOST_CHECK_EQUAL(progeny2.getParentWeakPtr().expired(), false);
    BOOST_CHECK(progeny2.getParentWeakPtr().lock() == progenitorPtr);
    progeny1.setParentWeakPtr(progeny2.getParentWeakPtr());
    progeny2.resetParentWeakPtr();
    BOOST_CHECK(progeny1.getParentWeakPtr().lock() == progenitorPtr);
    BOOST_CHECK_EQUAL(progeny1.getParentWeakPtr().expired(), false);
    BOOST_CHECK_EQUAL(progeny2.getParentWeakPtr().expired(), true);

    // functions broken:
    //      const SharedPtrType& getParentSharedPtr(void) const;
    //const progenitor_t::SharedPtrType otherPtr(progeny1.getParentSharedPtr());
}

torc::physical::BOOST_AUTO_TEST_CASE

(

DesignRegressionTest

)

Basic regression test for the entire XDL infrastructure.

Note: This is neither a pleasant nor recommended way to create a design.

Definition at line 35 of file DesignRegressionTest.cpp.

                                           {

    // determine whether or not to output additional debugging information; this serves primarily 
    // to show the user how certain design items can be accessed
    bool debug = false;

    // create a design
    DesignSharedPtr designPtr = Factory::newDesignPtr("blinker", "xc5vlx30", "ff324", "-1", "v3.2");
    designPtr->setConfig("_DESIGN_PROP", "P3_PLACE_OPTIONS", "EFFORT_LEVEL:high");
    designPtr->setConfig("_DESIGN_PROP", "", "P3_PLACED:");
    designPtr->setConfig("_DESIGN_PROP", "", "P3_PLACE_OPTIONS:");
    designPtr->setConfig("_DESIGN_PROP", "", "PK_NGMTIMESTAMP:1278102371");
    BOOST_CHECK_EQUAL(designPtr->getConfigCount(), 4u);
    if(debug) {
        ConfigMap::const_iterator p = designPtr->configBegin();
        ConfigMap::const_iterator e = designPtr->configEnd();
        while(p != e) {
            const std::string& setting = p->first;
            const Config& config = p->second;
            std::clog << "\t" << setting << ":" << config.getName() << ":" << config.getValue() 
                << std::endl;
            p++;
        }
    }

    // create the modules (this design has no modules)
    // verify the expected module count
    BOOST_CHECK_EQUAL(designPtr->getModuleCount(), 0u);
    if(debug) {
        Design::ModuleSharedPtrConstIterator p = designPtr->modulesBegin();
        Design::ModuleSharedPtrConstIterator e = designPtr->modulesEnd();
        while(p != e) {
            const ModuleSharedPtr& modulePtr = *p++;
            std::clog << "\tmodule " << modulePtr->getName() << std::endl;
        }
    }

    // create the instances
    // instance clk
    InstanceSharedPtr clkInstPtr 
        = Factory::newInstancePtr("clk", "IOB", "CIOB_X17Y61", "B6", eInstanceBondingBonded);
    clkInstPtr->setConfig("IMUX", "", "I");
    clkInstPtr->setConfig("INBUF", "clk_ibuf/IBUFG", "");
    clkInstPtr->setConfig("PAD", "clk", "");
    clkInstPtr->setConfig("ISTANDARD", "", "LVCMOS25");
    designPtr->addInstance(clkInstPtr);
    // instance reset
    InstanceSharedPtr resetInstPtr 
        = Factory::newInstancePtr("reset", "IOB", "CIOB_X17Y59", "F11", eInstanceBondingBonded);
    resetInstPtr->setConfig("IMUX", "", "I");
    resetInstPtr->setConfig("INBUF", "reset_ibuf", "");
    resetInstPtr->setConfig("PAD", "reset", "");
    resetInstPtr->setConfig("ISTANDARD", "", "LVCMOS25");
    designPtr->addInstance(resetInstPtr);
    // instance out
    InstanceSharedPtr outInstPtr 
        = Factory::newInstancePtr("out", "IOB", "CIOB_X17Y59", "G11", eInstanceBondingBonded);
    outInstPtr->setConfig("OUSED", "", "0");
    outInstPtr->setConfig("OUTBUF", "out_obuf", "");
    outInstPtr->setConfig("PAD", "out", "");
    outInstPtr->setConfig("DRIVE", "", "12");
    outInstPtr->setConfig("OSTANDARD", "", "LVCMOS25");
    outInstPtr->setConfig("SLEW", "", "SLOW");
    designPtr->addInstance(outInstPtr);
    // instance clk_ibuf/BUFG
    InstanceSharedPtr clkIbufInstPtr 
        = Factory::newInstancePtr("clk_ibuf/BUFG", "BUFG", "CLK_BUFGMUX_X47Y44", "BUFGCTRL_X0Y30");
    clkIbufInstPtr->setConfig("BUFG", "clk_ibuf/BUFG", "");
    designPtr->addInstance(clkIbufInstPtr);
    // instance blink
    InstanceSharedPtr blinkInstPtr 
        = Factory::newInstancePtr("blink", "SLICEL", "CLBLL_X16Y59", "SLICE_X27Y59");
    blinkInstPtr->setConfig("CLKINV", "", "CLK");
    blinkInstPtr->setConfig("D6LUT", "blink_i", "#LUT:O6=~A6");
    blinkInstPtr->setConfig("DFF", "blink", "#FF");
    blinkInstPtr->setConfig("DFFINIT", "", "INIT0");
    blinkInstPtr->setConfig("DFFMUX", "", "O6");
    blinkInstPtr->setConfig("DFFSR", "", "SRLOW");
    blinkInstPtr->setConfig("SRUSED", "", "0");
    blinkInstPtr->setConfig("SYNC_ATTR", "", "SYNC");
    designPtr->addInstance(blinkInstPtr);
    // instance XDL_DUMMY_IOI_X17Y59_OLOGIC_X1Y118
    InstanceSharedPtr OLOGIC_X1Y118InstPtr 
        = Factory::newInstancePtr("XDL_DUMMY_IOI_X17Y59_OLOGIC_X1Y118", "OLOGIC", "IOI_X17Y59", 
        "OLOGIC_X1Y118");
    OLOGIC_X1Y118InstPtr->setConfig("_NO_USER_LOGIC", "", "");
    OLOGIC_X1Y118InstPtr->setConfig("_ROUTETHROUGH", "D1", "OQ");
    designPtr->addInstance(OLOGIC_X1Y118InstPtr);
    // instance XDL_DUMMY_IOI_X17Y59_ILOGIC_X1Y119
    InstanceSharedPtr ILOGIC_X1Y119InstPtr 
        = Factory::newInstancePtr("XDL_DUMMY_IOI_X17Y59_ILOGIC_X1Y119", "ILOGIC", "IOI_X17Y59", 
        "ILOGIC_X1Y119");
    ILOGIC_X1Y119InstPtr->setConfig("_NO_USER_LOGIC", "", "");
    ILOGIC_X1Y119InstPtr->setConfig("_ROUTETHROUGH", "D", "O");
    designPtr->addInstance(ILOGIC_X1Y119InstPtr);
    // instance XDL_DUMMY_IOI_X17Y61_ILOGIC_X1Y123
    InstanceSharedPtr ILOGIC_X1Y123InstPtr 
        = Factory::newInstancePtr("XDL_DUMMY_IOI_X17Y61_ILOGIC_X1Y123", "ILOGIC", "IOI_X17Y61", 
        "ILOGIC_X1Y123");
    ILOGIC_X1Y123InstPtr->setConfig("_NO_USER_LOGIC", "", "");
    ILOGIC_X1Y123InstPtr->setConfig("_ROUTETHROUGH", "D", "O");
    designPtr->addInstance(ILOGIC_X1Y123InstPtr);
    // verify that expected instance count
    BOOST_CHECK_EQUAL(designPtr->getInstanceCount(), 8u);
    if(debug) {
        Design::InstanceSharedPtrConstIterator p = designPtr->instancesBegin();
        Design::InstanceSharedPtrConstIterator e = designPtr->instancesEnd();
        while(p != e) {
            const InstanceSharedPtr& instancePtr = *p++;
            std::clog << "\tinstance " << instancePtr->getName() << std::endl;
        }
    }

    // create the nets
    // net blink
    NetSharedPtr blinkNetPtr = Factory::newNetPtr("blink");
    InstancePinSharedPtr blinkNetPin1Ptr = Factory::newInstancePinPtr(blinkInstPtr, "DQ");
    blinkNetPtr->addSource(blinkNetPin1Ptr);
    InstancePinSharedPtr blinkNetPin2Ptr = Factory::newInstancePinPtr(blinkInstPtr, "D6");
    blinkNetPtr->addSink(blinkNetPin2Ptr);
    InstancePinSharedPtr blinkNetPin3Ptr = Factory::newInstancePinPtr(outInstPtr, "O");
    blinkNetPtr->addSink(blinkNetPin3Ptr);
    blinkNetPtr->addPip(Factory::newPip("CLBLL_X16Y59", "L_DQ", "SITE_LOGIC_OUTS3", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("CLBLL_X16Y59", "SITE_IMUX_B47", "L_D6", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("INT_X16Y59", "EL2BEG2", "IMUX_B47", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("INT_X16Y59", "LOGIC_OUTS3", "EL2BEG2", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("INT_X17Y59", "EL2MID2", "IMUX_B41", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_IMUX_B41", "IOI_O11", 
        ePipUnidirectionalBuffered));
    blinkNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_O11", "IOI_O_PINWIRE1", 
        ePipUnidirectionalBuffered, Factory::newRoutethroughPtr("_ROUTETHROUGH", 
        "D1", "OQ", OLOGIC_X1Y118InstPtr, "D1", "OQ")));
    blinkNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_O_PINWIRE1", "IOI_O1", 
        ePipUnidirectionalBuffered));
    designPtr->addNet(blinkNetPtr);
    // net clk
    NetSharedPtr clkNetPtr = Factory::newNetPtr("clk");
    clkNetPtr->setConfig("_BELSIG", "PAD,PAD,clk", "clk");
    designPtr->addNet(clkNetPtr);
    // net clk_c
    NetSharedPtr clkCNetPtr = Factory::newNetPtr("clk_c");
    InstancePinSharedPtr clkCNetPin1Ptr = Factory::newInstancePinPtr(clkIbufInstPtr, "O");
    clkCNetPtr->addSource(clkCNetPin1Ptr);
    InstancePinSharedPtr clkCNetPin2Ptr = Factory::newInstancePinPtr(blinkInstPtr, "CLK");
    clkCNetPtr->addSink(clkCNetPin2Ptr);
    clkCNetPtr->addPip(Factory::newPip("CLBLL_X16Y59", "SITE_CLK_B0", "L_CLK", 
        ePipUnidirectionalBuffered));
    clkCNetPtr->addPip(Factory::newPip("CLK_BUFGMUX_X47Y44", "CLK_BUFGMUX_POSTMUX_GCLKP30", 
        "CLK_BUFGMUX_GCLKP30", ePipUnidirectionalBuffered));
    clkCNetPtr->addPip(Factory::newPip("CLK_HROW_X17Y49", "CLK_HROW_GCLK_BUF30", 
        "CLK_HROW_HCLKL_P5", ePipUnidirectionalBuffered));
    clkCNetPtr->addPip(Factory::newPip("HCLK_X16Y49", "HCLK_G_HCLK_P5", "HCLK_LEAF_GCLK5", 
        ePipUnidirectionalBuffered));
    clkCNetPtr->addPip(Factory::newPip("INT_X16Y59", "GCLK5", "CLK_B0", 
        ePipUnidirectionalBuffered));
    designPtr->addNet(clkCNetPtr);
    // net clk_ibuf/IBUFG
    NetSharedPtr clkIibufIbufgNetPtr = Factory::newNetPtr("clk_ibuf/IBUFG");
    InstancePinSharedPtr clkIibufIbufgNetPin1Ptr = Factory::newInstancePinPtr(clkInstPtr, "I");
    clkIibufIbufgNetPtr->addSource(clkIibufIbufgNetPin1Ptr);
    InstancePinSharedPtr clkIibufIbufgNetPin2Ptr = Factory::newInstancePinPtr(clkIbufInstPtr, "I0");
    clkIibufIbufgNetPtr->addSink(clkIibufIbufgNetPin2Ptr);
    clkIibufIbufgNetPtr->addPip(Factory::newPip("CLK_BUFGMUX_X47Y44", 
        "CLK_BUFGMUX_MUXED_IN_CLKT_P28", "CLK_BUFGMUX_PREMUX0_CLK30", 
        ePipUnidirectionalBuffered));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("CLK_BUFGMUX_X47Y44", "CLK_BUFGMUX_PREMUX0_CLK30", 
        "CLK_BUFGMUX_CLKP0_30", ePipUnidirectionalBuffered));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("CLK_IOB_T_X17Y60", "CLK_IOB_CLK_BUF1", 
        "CLK_IOB_MUXED_CLKOUT28", ePipUnidirectionalBuffered));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("CLK_IOB_T_X17Y60", "CLK_IOB_PAD_CLK1", 
        "CLK_IOB_CLK_BUF1", ePipUnidirectionalBuffered));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("IOI_X17Y61", "IOI_D0", "IOI_I0", 
        ePipUnidirectionalBuffered, Factory::newRoutethroughPtr("_ROUTETHROUGH", 
        "D", "O", ILOGIC_X1Y123InstPtr, "D", "O")));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("IOI_X17Y61", "IOI_I0", "IOI_I_2GCLK0", 
        ePipUnidirectionalBuffered));
    clkIibufIbufgNetPtr->addPip(Factory::newPip("IOI_X17Y61", "IOI_IBUF0", "IOI_D0", 
        ePipUnidirectionalBuffered));
    designPtr->addNet(clkIibufIbufgNetPtr);
    // net out
    NetSharedPtr outNetPtr = Factory::newNetPtr("out");
    outNetPtr->setConfig("_BELSIG", "PAD,PAD,out", "out");
    designPtr->addNet(outNetPtr);
    // net reset
    NetSharedPtr resetNetPtr = Factory::newNetPtr("reset");
    resetNetPtr->setConfig("_BELSIG", "PAD,PAD,reset", "reset");
    designPtr->addNet(resetNetPtr);
    // net reset_c
    NetSharedPtr resetCNetPtr = Factory::newNetPtr("reset_c");
    InstancePinSharedPtr resetCNetPin1Ptr = Factory::newInstancePinPtr(resetInstPtr, "I");
    resetCNetPtr->addSource(resetCNetPin1Ptr);
    InstancePinSharedPtr resetCNetPin2Ptr = Factory::newInstancePinPtr(blinkInstPtr, "SR");
    resetCNetPtr->addSink(resetCNetPin2Ptr);
    resetCNetPtr->addPip(Factory::newPip("CLBLL_X16Y59", "SITE_CTRL_B2", "L_SR", 
        ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("INT_INTERFACE_X17Y59", "INT_INTERFACE_LOGIC_OUTS_B11", 
        "INT_INTERFACE_LOGIC_OUTS11", ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("INT_X16Y59", "CTRL2", "CTRL_B2", 
        ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("INT_X16Y59", "WS2MID2", "CTRL2", 
        ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("INT_X17Y59", "LOGIC_OUTS11", "WS2BEG2", 
        ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_D0", "IOI_I0", 
        ePipUnidirectionalBuffered, Factory::newRoutethroughPtr("_ROUTETHROUGH", 
        "D", "O", ILOGIC_X1Y119InstPtr, "D", "O")));
    resetCNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_I0", "IOI_LOGIC_OUTS11", 
        ePipUnidirectionalBuffered));
    resetCNetPtr->addPip(Factory::newPip("IOI_X17Y59", "IOI_IBUF0", "IOI_D0", 
        ePipUnidirectionalBuffered));
    designPtr->addNet(resetCNetPtr);
    // verify the expected net count
    BOOST_CHECK_EQUAL(designPtr->getNetCount(), 7u);
    if(debug) {
        Design::NetSharedPtrConstIterator p = designPtr->netsBegin();
        Design::NetSharedPtrConstIterator e = designPtr->netsEnd();
        while(p != e) {
            const NetSharedPtr& netPtr = *p++;
            std::clog << "\tnet " << netPtr->getName() << std::endl;
        }
    }

    // create the appropriate file paths
    boost::filesystem::path referencePath = torc::common::DirectoryTree::getExecutablePath()
        / "torc" / "physical" / "DesignUnitTest.reference.xdl";
    boost::filesystem::path generatedPath = torc::common::DirectoryTree::getExecutablePath()
        / "regression" / "DesignUnitTest.generated.xdl";
    // export the created design
    std::fstream xdlExport(generatedPath.string().c_str(), std::ios_base::out);
    XdlExporter fileExporter(xdlExport);
    fileExporter(designPtr);

    // compare the reference and generated XDL
    BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));

}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

XdlUnpackUnitTest

)

Unit test for the XdlUnpack class.

Definition at line 35 of file XdlUnpackUnitTest.cpp.

                                        {
    BOOST_MESSAGE("DEPRECATED: XdlUnpack is deprecated in favor of Unpacker.");
    return;

    // create the appropriate file paths
    boost::filesystem::path regressionPath 
        = torc::common::DirectoryTree::getExecutablePath() / "regression";
    boost::filesystem::path generatedPath = regressionPath / "XdlUnpackUnitTest.xdl";
    boost::filesystem::path referencePath = torc::common::DirectoryTree::getExecutablePath() 
        / "torc" / "physical" / "DesignUnitTest.reference.xdl";

    // import the XDL design
    std::fstream fileStream(referencePath.string().c_str());
    BOOST_REQUIRE(fileStream.good());
    torc::physical::XdlImporter importer;
    importer(fileStream, referencePath.string());

    // unpack the design
    torc::physical::DesignSharedPtr designPtr = importer.getDesignPtr();
    torc::physical::XdlUnpack unpacker;
    torc::physical::DesignSharedPtr unpackedDesignPtr = unpacker(designPtr);

    // export the created design
    std::fstream xdlExport(generatedPath.string().c_str(), std::ios_base::out);
    BOOST_REQUIRE(xdlExport.good());
    XdlExporter fileExporter(xdlExport);
    fileExporter(unpackedDesignPtr);

}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

XdlExporterUnitTest

)

Unit test for the XdlExporter class.

Definition at line 36 of file XdlExporterUnitTest.cpp.

                                          {
    // create the appropriate file paths
    boost::filesystem::path generatedPath = torc::common::DirectoryTree::getExecutablePath() 
        / "regression" / "XdlExporterUnitTest.generated.xdl";
    boost::filesystem::path referencePath = torc::common::DirectoryTree::getExecutablePath() 
        / "torc" / "physical" / "ModuleTransformerUnitTest.Scenario.02.Flatten.xdl";

    // import the XDL design
    std::fstream fileStream(referencePath.string().c_str());
    BOOST_REQUIRE(fileStream.good());
    XdlImporter importer;
    importer(fileStream, referencePath.string());

    // look up the design
    DesignSharedPtr designPtr = importer.getDesignPtr();
    BOOST_REQUIRE(designPtr.get() != 0);

    // members tested:
    //      std::ostream& mStream;
    //      int mIndentCount;
    //      std::string mIndentString;
    // functions tested:
    //      XdlExporter(std::ostream& inStream, const std::string& inIndentString = "\t");
    //      void operator() (const DesignSharedPtr& inDesignPtr);
    //      void indent(void) const;
    //      void write(const Circuit& circuit);
    //      void write(const Design& design);
    //      void write(const Module& module);
    //      void write(const Port& port);
    //      void write(const Instance& instance);
    //      void write(const Net& net);
    //      void write(const InstancePin& instancePin, EPinDirection pinDirection, bool comma);
    //      void write(const Pip& pip, bool comma);
    //      void write(const Routethrough& routethrough);
    //      void write(const ConfigMap& configMap);
    // export the XDL design
    std::fstream xdlExport(generatedPath.string().c_str(), std::ios_base::out);
    XdlExporter fileExporter(xdlExport);
    fileExporter(designPtr);
    BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

CircuitUnitTest

)

Unit test for the Circuit class.

Definition at line 38 of file CircuitUnitTest.cpp.

                                      {
    // functions tested:
    //      Circuit(const string& inName);
    //      size_t getInstanceCount(void) const;
    //      size_t getNetCount(void) const;
    //      InstanceSharedPtrIterator instancesBegin(void);
    //      InstanceSharedPtrIterator instancesEnd(void);
    //      InstanceSharedPtrIterator netsBegin(void);
    //      InstanceSharedPtrIterator netsEnd(void);
    // create a module, since we cannot create a circuit directly
    ModuleSharedPtr circuitPtr = Factory::newModulePtr("module", "anchor");
    // verify that the circuit exists, and that it is empty
    BOOST_REQUIRE(circuitPtr.get() != 0);
    BOOST_CHECK(circuitPtr->getInstanceCount() == 0);
    BOOST_CHECK(circuitPtr->getNetCount() == 0);
    BOOST_CHECK(circuitPtr->instancesBegin() == circuitPtr->instancesEnd());
    BOOST_CHECK(circuitPtr->netsBegin() == circuitPtr->netsEnd());

    // create a few instances and nets, and add them to the circuit
    InstanceSharedPtr instance1aPtr = Factory::newInstancePtr("instance", "SLICEL", "CLBLL_X16Y59", 
        "SLICE_X27Y59");
    InstanceSharedPtr instance1bPtr = Factory::newInstancePtr("instance", "dummy", "dummy", 
        "dummy"); // deliberate reuse of instance name
    NetSharedPtr net1Ptr = Factory::newNetPtr("net1");
    net1Ptr->addPip(Factory::newPip("CLBLL_X16Y59", "L_DQ", "SITE_LOGIC_OUTS3", 
        ePipUnidirectionalBuffered));
    NetSharedPtr net2aPtr = Factory::newNetPtr("net2");
    NetSharedPtr net2bPtr = Factory::newNetPtr("net2"); // deliberate reuse of net name
    NetSharedPtr net3Ptr = Factory::newNetPtr("net3");
    //RenamableInstance::recast(instance1aPtr)->setName("goodbye");

    // functions tested:
    //      bool addInstance(InstanceSharedPtr& inInstancePtr);
    //      bool addNet(NetSharedPtr& inNetPtr);
    //      InstanceSharedPtrIterator findInstance(const string& inName);
    //      NetSharedPtrIterator findNet(const string& inName);
    //      size_t getInstanceCount(void) const;
    //      size_t getNetCount(void) const;
    BOOST_CHECK_EQUAL(circuitPtr->addInstance(instance1aPtr), true);
    BOOST_CHECK_EQUAL(circuitPtr->addInstance(instance1bPtr), false); // name already exists
    BOOST_CHECK_EQUAL(circuitPtr->addNet(net1Ptr), true);
    BOOST_CHECK_EQUAL(circuitPtr->addNet(net2aPtr), true);
    BOOST_CHECK_EQUAL(circuitPtr->addNet(net2bPtr), false); // name already exists
    BOOST_CHECK_EQUAL(circuitPtr->addNet(net3Ptr), true);
    BOOST_CHECK(circuitPtr->getInstanceCount() == 1);
    BOOST_CHECK(circuitPtr->getNetCount() == 3);

    // functions tested:
    //      void unplace(void);
    //      void unroute(void);
    // unplace and unroute the circuit
    BOOST_CHECK(instance1aPtr->getTile().length() != 0);
    BOOST_CHECK(instance1aPtr->getSite().length() != 0);
    BOOST_CHECK(net1Ptr->getPipCount() != 0);
    circuitPtr->unplace();
    circuitPtr->unroute();
    BOOST_CHECK(instance1aPtr->getTile().length() == 0);
    BOOST_CHECK(instance1aPtr->getSite().length() == 0);
    BOOST_CHECK(net1Ptr->getPipCount() == 0);

    // functions tested:
    //      bool removeInstance(InstanceSharedPtr& inInstancePtr);
    //      bool removeNet(NetSharedPtr& inNetPtr);
    //      size_t getInstanceCount(void) const;
    //      size_t getNetCount(void) const;
    // find and remove instances and nets
    BOOST_CHECK(circuitPtr->removeInstance(*circuitPtr->findInstance("instance")));
    BOOST_CHECK(circuitPtr->removeNet(*circuitPtr->findNet("net1")));
    BOOST_CHECK(circuitPtr->removeNet(*circuitPtr->findNet("net2")));
    BOOST_CHECK(circuitPtr->removeNet(*circuitPtr->findNet("net3")));
    BOOST_CHECK(circuitPtr->getInstanceCount() == 0);
    BOOST_CHECK(circuitPtr->getNetCount() == 0);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithIntraNetUnitTest

)

Unit test for modularizing two instances with intra net.

Definition at line 422 of file ModuleTransformerUnitTest.cpp.

                                                     {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.01.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithInputInterNetUnitTest

)

Unit test for modularizing two instances with input inter net.

Definition at line 439 of file ModuleTransformerUnitTest.cpp.

                                                          {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.02.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithInputFanoutInterNetUnitTest

)

Unit test for modularizing two instances with input fanout input net.

Definition at line 456 of file ModuleTransformerUnitTest.cpp.

                                                                {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.03.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithOutputInterNetUnitTest

)

Unit test for modularizing two instances with output inter net.

Definition at line 473 of file ModuleTransformerUnitTest.cpp.

                                                           {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.04.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithOutputFanoutInterNetUnitTest

)

Unit test for modularizing two instances with output fanout inter net.

Definition at line 490 of file ModuleTransformerUnitTest.cpp.

                                                                 {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.05.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

ModularizeWithIntraAndInterNetUnitTest

)

Unit test for modularizing two instances with fanout intra and inter net.

Definition at line 507 of file ModuleTransformerUnitTest.cpp.

                                                             {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.06.Modularize.xdl");
    // Get instances to modularize
    InstanceSharedPtrVector instPtrVector = getInstancesToModularize(designPtr);
    // Pre modularization verifications
    preModularizationVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Modularize instances in instPtrVector
    moduleTransfomer.modularize(instPtrVector, sModuleDefinition, sModuleInstanceName);
    // Post modularization verifications
    postModularizationVerifications(designPtr, instPtrVector);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithIntraNetUnitTest

)

Unit test for flattening a module with two instances and an intra net.

Definition at line 526 of file ModuleTransformerUnitTest.cpp.

                                                  {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.01.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithInputInterNetUnitTest

)

Unit test for flattening two instances with input inter net.

Definition at line 541 of file ModuleTransformerUnitTest.cpp.

                                                       {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.02.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithInputFanoutInterNetUnitTest

)

Unit test for flattening two instances with input fanout input net.

Definition at line 556 of file ModuleTransformerUnitTest.cpp.

                                                             {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.03.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithOutputInterNetUnitTest

)

Unit test for flattening two instances with output inter net.

Definition at line 571 of file ModuleTransformerUnitTest.cpp.

                                                        {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.04.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithOutputFanoutInterNetUnitTest

)

Unit test for flattening two instances with output fanout inter net.

Definition at line 586 of file ModuleTransformerUnitTest.cpp.

                                                              {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.05.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

torc::physical::BOOST_AUTO_TEST_CASE

(

FlattenWithIntraAndInterNetUnitTest

)

Unit test for flattening two instances with fanout intra and inter net.

Definition at line 601 of file ModuleTransformerUnitTest.cpp.

                                                          {
    // Verify file opened successfully
    DesignSharedPtr designPtr 
        = verifyDesignOpenedSuccessfully("ModuleTransformerUnitTest.Scenario.06.Flatten.xdl");
    // Pre flattening verifications
    preFlatteningVerifications(designPtr);
    // Create a ModuleTransformer object
    ModuleTransformer moduleTransfomer(designPtr);
    // Flatten sModuleInstanceName
    moduleTransfomer.flatten(sModuleInstanceName);
    // Post flattening verifications
    postFlatteningVerifications(designPtr);
}

Here is the call graph for this function:

InstanceSharedPtrVector torc::physical::getInstancesToModularize

(

DesignSharedPtr

inDesignPtr

)

Retrieve the instances to modularize from the design and return them in a vector.

Parameters

inDesignPtr

The design shared pointer.

Definition at line 77 of file ModuleTransformerUnitTest.cpp.

                                                                              {
    // Create instances vector
    InstanceSharedPtrVector instPtrVector;
    // Select instance sInstanceOneName to modularize
    Design::InstanceSharedPtrIterator instIter = inDesignPtr->findInstance(sInstanceOneName);
    // Verify design has instance sInstanceOneName
    BOOST_REQUIRE(instIter != inDesignPtr->instancesEnd());
    // Add instance pointer to instance vector
    instPtrVector.push_back(*instIter);
    // Select instance sInstanceTwoName to modularize
    instIter = inDesignPtr->findInstance(sInstanceTwoName);
    // Verify design has instance sInstanceTwoName
    BOOST_REQUIRE(instIter != inDesignPtr->instancesEnd());
    instPtrVector.push_back(*instIter);
    // Return instance vector
    return instPtrVector;
}

Here is the caller graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Design &	rhs
	)

Design stream inserter.

Definition at line 26 of file physical/OutputStreamHelpers.cpp.

                                                                {
        return os << rhs.getName() << " [" << rhs.getDevice() << rhs.getPackage() 
            << rhs.getSpeedGrade() << ", " << rhs.getXdlVersion() << "]";
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Module &	rhs
	)

Module stream inserter.

Definition at line 31 of file physical/OutputStreamHelpers.cpp.

                                                                {
        return os << rhs.getName() << " [" << rhs.getAnchor() << "]";
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Instance &	rhs
	)

Instance stream inserter.

Definition at line 35 of file physical/OutputStreamHelpers.cpp.

                                                                 {
        return os << rhs.getName();
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Net &	rhs
	)

Net stream inserter.

Definition at line 39 of file physical/OutputStreamHelpers.cpp.

                                                             {
        return os << rhs.getName();
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const InstancePin &	rhs
	)

InstancePin stream inserter.

Definition at line 43 of file physical/OutputStreamHelpers.cpp.

                                                                    {
        InstanceWeakPtr instancePtr = rhs.getInstancePtr();
        return os << (instancePtr.expired() ? "[unnamed]" : instancePtr.lock()->getName()) << '.' 
            << rhs.getPinName();
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Pip &	rhs
	)

Pip stream inserter.

Definition at line 49 of file physical/OutputStreamHelpers.cpp.

                                                            {
        return os << rhs.getTileName() << ' ' << rhs.getSourceWireName() << ' '
            << rhs.getDirectionString() << ' ' << rhs.getSinkWireName();
    }

Here is the call graph for this function:

std::ostream & torc::physical::operator<<	(	std::ostream &	os,
		const Config &	rhs
	)

Config iterator stream inserter.

Definition at line 54 of file physical/OutputStreamHelpers.cpp.

                                                               {
        return os << rhs.getName() << ':' << rhs.getValue();
    }

Here is the call graph for this function:

void torc::physical::postFlatteningVerifications	(	DesignSharedPtr	inDesignPtr,
		bool	inKeepPlacement,
		bool	inKeepRouting
	)

Perform post-flattening tests on a design.

Parameters

inDesignPtr	The design shared pointer.
inKeepPlacement	The flag to keep placement when flattening, defaults to false.
inKeepRouting	The flag to keep routing when flattening, defaults to false.

The post-flattening tests consist of the following: 1 - Verify module definition still exists in design. 2 - Verify module instance does not exist in design. 3 - Verify module instances cloning & placement. 4 - Verify module intra nets cloning & routing. 5 - Verify inter nets do not reference module instance & inter net routing.

Definition at line 291 of file ModuleTransformerUnitTest.cpp.

                        {
    // Begin verify module definition existence and removal of module instance
    // Search design for sModuleDefinition
    Design::ModuleSharedPtrIterator modIter = inDesignPtr->findModule(sModuleDefinition);
    // Verify design has module sModuleDefinition
    BOOST_REQUIRE(modIter != inDesignPtr->modulesEnd());
    // Search design for sModuleInstanceName
    Design::InstanceSharedPtrIterator designInstIter 
        = inDesignPtr->findInstance(sModuleInstanceName);
    // Verify design has sModuleInstanceName
    BOOST_REQUIRE(designInstIter == inDesignPtr->instancesEnd());
    // End verify module definition existence and removal of module instance

    // Begin verify module instances cloning and placement
    // Get a pointer to the module definition
    ModuleSharedPtr modPtr = *modIter;
    // Get a begin iterator to module definition instances
    Design::InstanceSharedPtrConstIterator modInstancesBegin = modPtr->instancesBegin();
    // Get an end iterator to module definition instances
    Design::InstanceSharedPtrConstIterator modInstancesEnd = modPtr->instancesEnd();
    // Iterate over all module definition instances
    while(modInstancesBegin != modInstancesEnd) {
        // Get a pointer to the current instance
        InstanceSharedPtr modInstPtr = *modInstancesBegin;
        // Search for corresponding flattened instance in design
        designInstIter = inDesignPtr->findInstance(sModuleInstanceName +
            sHierarchySeparator + modInstPtr->getName());
        // Verify instance is cloned and moved to design
        BOOST_REQUIRE(designInstIter != inDesignPtr->instancesEnd());
        // Verify placement
        if(!inKeepPlacement) {
            // Get a pointer to the instance clone
            InstanceSharedPtr instPtr = *designInstIter;
            // Verify it is not placed
            BOOST_REQUIRE_EQUAL(instPtr->getTile().compare(""), 0);
            BOOST_REQUIRE_EQUAL(instPtr->getSite().compare(""), 0);
        }
        // Move to next instance
        modInstancesBegin++;
    }
    // End verify module instances cloning and placement

    // Begin verify intra net cloning and routing
    // Get a begin iterator to module nets
    Design::NetSharedPtrIterator moduleNetsBegin = modPtr->netsBegin();
    // Get an end iterator to module nets
    Design::NetSharedPtrIterator moduleNetsEnd = modPtr->netsEnd();
    // Iterate over all module nets
    while(moduleNetsBegin != moduleNetsEnd) {
        // Get a pointer to the current net
        NetSharedPtr moduleNetPtr = *moduleNetsBegin;
        // Search for corresponding flattened net in design
        Design::NetSharedPtrIterator designNetIter = inDesignPtr->findNet(sModuleInstanceName +
            sHierarchySeparator + moduleNetPtr->getName());
        // Verify net is cloned and moved to design
        BOOST_REQUIRE(designNetIter != inDesignPtr->netsEnd());
        // Get a pointer to the cloned design net
        NetSharedPtr designNetPtr = *designNetIter;
        // Verify routing
        if(!inKeepRouting) {
            BOOST_REQUIRE(designNetPtr->pipsBegin() == designNetPtr->pipsEnd());
        }
        // Move to next net
        moduleNetsBegin++;
    }
    // End verify intra net migration and routing

    // Begin verify inter nets does not reference module instance & routing
    // Get a begin iterator to design nets
    Design::NetSharedPtrIterator designNetsBegin = inDesignPtr->netsBegin();
    // Get an end iterator to design nets
    Design::NetSharedPtrIterator designNetsEnd = inDesignPtr->netsEnd();
    // Iterate over all design nets
    while(designNetsBegin != designNetsEnd) {
        // Get a pointer to the current net
        NetSharedPtr designNetPtr = *designNetsBegin;
        // Get a begin iterator to net sources
        Net::InstancePinSharedPtrIterator designNetSourcesBegin = designNetPtr->sourcesBegin();
        // Get an end iterator to net sources
        Net::InstancePinSharedPtrIterator designNetSourcesEnd = designNetPtr->sourcesEnd();
        // Iterate over all net source
        while(designNetSourcesBegin != designNetSourcesEnd) {
            // Get a pointer to the current net source pin
            InstancePinSharedPtr instPinPtr = *designNetSourcesBegin;
            // Get a pointer to the instance hosting the net source pin
            InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
            // Verify net does not point to flattened module instance
            BOOST_REQUIRE_NE(pinInstPtr->getName().compare(sModuleInstanceName), 0);

            // Was this an inter net once?
            if((pinInstPtr->getName()).find(sModuleInstanceName + sHierarchySeparator) 
                != string::npos) {
                // Verify routing
                if(!inKeepRouting) {
                    BOOST_REQUIRE(designNetPtr->pipsBegin() == designNetPtr->pipsEnd());
                }
            }
            // Move to next source
            designNetSourcesBegin++;
        }
        // Get a begin iterator to net sinks
        Net::InstancePinSharedPtrIterator designNetSinksBegin = designNetPtr->sinksBegin();
        // Get an end iterator to net sinks
        Net::InstancePinSharedPtrIterator designNetSinksEnd = designNetPtr->sinksEnd();
        // Iterate over all net source
        while(designNetSinksBegin != designNetSinksEnd) {
            // Get a pointer to the current net source pin
            InstancePinSharedPtr instPinPtr = *designNetSinksBegin;
            // Get a pointer to the instance hosting the net source pin
            InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
            // Verify net does not point to flattened module instance
            BOOST_REQUIRE_NE(pinInstPtr->getName().compare(sModuleInstanceName), 0);
            // Was this an inter net once?
            if((pinInstPtr->getName()).find(sModuleInstanceName + sHierarchySeparator) 
                != string::npos) {
                // Verify routing
                if(!inKeepRouting) {
                    BOOST_REQUIRE(designNetPtr->pipsBegin() == designNetPtr->pipsEnd());
                }
            }
            // Move to next sink
            designNetSinksBegin++;
        }
        // Move to next net
        designNetsBegin++;
    }
    // End verify inter nets does not reference module instance & routing
}

Here is the caller graph for this function:

void torc::physical::postModularizationVerifications	(	DesignSharedPtr	inDesignPtr,
		InstanceSharedPtrVector	inInstanceVector,
		bool	inKeepPlacement,
		bool	inKeepRouting
	)

Perform post-modularization tests on a design.

Parameters

inDesignPtr	The design shared pointer.
inInstanceVector	The vector of the instances that were modularized
inKeepPlacement	The flag to keep placement when modularizing, defaults to false.
inKeepRouting	The flag to keep routing when modularizing, defaults to false.

The post-modularization tests consist of the following: 1 - Verify module definition exists in design. 2 - Verify module instance exists in design. 3 - Verify module instance placement. 4 - Verify instances migration & placement. 5 - Verify intra net migration & routing. 6 - Verify inter net routing. 7 - Verify module definition port count.

Definition at line 124 of file ModuleTransformerUnitTest.cpp.

                                                                                        {
    // Begin verify module definition and module instance creation
    // Search design for sModuleDefinition
    Design::ModuleSharedPtrIterator modIter = inDesignPtr->findModule(sModuleDefinition);
    // Verify design has module sModuleDefinition
    BOOST_REQUIRE(modIter != inDesignPtr->modulesEnd());
    // Search design for sModuleInstanceName
    Design::InstanceSharedPtrIterator instIter = inDesignPtr->findInstance(sModuleInstanceName);
    // Verify design has sModuleInstanceName
    BOOST_REQUIRE(instIter != inDesignPtr->instancesEnd());
    // Get a pointer to the module definition
    ModuleSharedPtr modPtr = *modIter;
    // Get a pointer to the module instance
    InstanceSharedPtr instPtr = *instIter;
    // Verify placement
    if(!inKeepPlacement) {
        // Verify module instance is not placed
        BOOST_REQUIRE_EQUAL(instPtr->getTile().compare(""), 0);
        BOOST_REQUIRE_EQUAL(instPtr->getSite().compare(""), 0);
    }
    // End verify module definition and module instance creation

    // Begin verify instance migration and placement
    // Get a begin iterator to inInstanceVector
    Design::InstanceSharedPtrConstIterator inInstanceVectorBegin = inInstanceVector.begin();
    // Get an end iterator to inInstanceVector
    Design::InstanceSharedPtrConstIterator inInstanceVectorEnd = inInstanceVector.end();
    // Iterate over all instances in inInstanceVector
    while(inInstanceVectorBegin != inInstanceVectorEnd) {
        // Get a pointer to the current instance
        InstanceSharedPtr instPtr = *inInstanceVectorBegin;
        // Search design for instance
        instIter = inDesignPtr->findInstance(instPtr->getName());
        // Verify design does not have instance
        BOOST_REQUIRE(instIter == inDesignPtr->instancesEnd());
        // Search module definition for instance
        instIter = modPtr->findInstance(instPtr->getName());
        // Verify module definition has instance
        BOOST_REQUIRE(instIter != modPtr->instancesEnd());
        // Get a pointer to the looked up instance
        InstanceSharedPtr modInstPtr = *instIter;
        // Verify placement
        if(!inKeepPlacement) {
            // Verify instance is not placed
            BOOST_REQUIRE_EQUAL(modInstPtr->getTile().compare(""), 0);
            BOOST_REQUIRE_EQUAL(modInstPtr->getSite().compare(""), 0);
        }
        // Move to next instance
        inInstanceVectorBegin++;
    }
    // End verify instance migration and placement

    // Begin verify intra net migration and routing
    // Get a begin iterator to module nets
    Design::NetSharedPtrIterator moduleNetsBegin = modPtr->netsBegin();
    // Get an end iterator to module nets
    Design::NetSharedPtrIterator moduleNetsEnd = modPtr->netsEnd();
    // Iterate over all module nets
    while(moduleNetsBegin != moduleNetsEnd) {
        // Get a pointer to the current net
        NetSharedPtr moduleNetPtr = *moduleNetsBegin;
        // Verify routing
        if(!inKeepRouting) {
            BOOST_REQUIRE(moduleNetPtr->pipsBegin() == moduleNetPtr->pipsEnd());
        }
        // Search for net in design
        Design::NetSharedPtrIterator designNetItr = inDesignPtr->findNet(moduleNetPtr->getName());
        // Verify net does not exist in design
        BOOST_REQUIRE(designNetItr == inDesignPtr->netsEnd());
        // Move to next net
        moduleNetsBegin++;
    }
    // End verify intra net migration and routing

    // Begin verify module port count and inter net routing
    // Initialize port count
    u_int32_t portCount = 0;
    // Search design for sModuleInstanceName
    instIter = inDesignPtr->findInstance(sModuleInstanceName);
    // Get a pointer to the module instance
    instPtr = *instIter;
    // Get a begin iterator to design nets
    Design::NetSharedPtrIterator designNetsBegin = inDesignPtr->netsBegin();
    // Get an end iterator to design nets
    Design::NetSharedPtrIterator designNetsEnd = inDesignPtr->netsEnd();
    // Iterate over all design nets
    while(designNetsBegin != designNetsEnd) {
        // Get a pointer to the current net
        NetSharedPtr designNetPtr = *designNetsBegin;
        // Get a begin iterator to net sources
        Net::InstancePinSharedPtrIterator designNetSourcesBegin = designNetPtr->sourcesBegin();
        // Get an end iterator to net sources
        Net::InstancePinSharedPtrIterator designNetSourcesEnd = designNetPtr->sourcesEnd();
        // Iterate over all net source
        while(designNetSourcesBegin != designNetSourcesEnd) {
            // Get a pointer to the current net source pin
            InstancePinSharedPtr instPinPtr = *designNetSourcesBegin;
            // Get a pointer to the instance hosting the net source pin
            InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
            // Is this the module instance?
            if(pinInstPtr == instPtr) {
                // Verify routing
                if(!inKeepRouting) {
                    BOOST_REQUIRE(designNetPtr->pipsBegin() == designNetPtr->pipsEnd());
                }
                portCount++;
            }
            // Move to next source
            designNetSourcesBegin++;
        }
        // Get a begin iterator to net sinks
        Net::InstancePinSharedPtrIterator designNetSinksBegin = designNetPtr->sinksBegin();
        // Get an end iterator to net sinks
        Net::InstancePinSharedPtrIterator designNetSinksEnd = designNetPtr->sinksEnd();
        // Iterate over all net source
        while(designNetSinksBegin != designNetSinksEnd) {
            // Get a pointer to the current net source pin
            InstancePinSharedPtr instPinPtr = *designNetSinksBegin;
            // Get a pointer to the instance hosting the net source pin
            InstanceSharedPtr pinInstPtr = instPinPtr->getInstancePtr().lock();
            // Is this the module instance?
            if(pinInstPtr == instPtr) {
                // Verify routing
                if(!inKeepRouting) {
                    BOOST_REQUIRE(designNetPtr->pipsBegin() == designNetPtr->pipsEnd());
                }
                portCount++;
            }
            // Move to next sink
            designNetSinksBegin++;
        }
        // Move to next net
        designNetsBegin++;
    }

    // Verify that module definition has portCount ports
    BOOST_REQUIRE_EQUAL(modPtr->getPortCount(), portCount);
    // End verify module port count and inter net routing
}

Here is the caller graph for this function:

void torc::physical::preFlatteningVerifications

(

DesignSharedPtr

inDesignPtr

)

Perform pre-flattening tests on a design.

Parameters

inDesignPtr

The design shared pointer.

The pre-flattening tests consist of the following: 1 - Verify module definition exists in design. 2 - Verify module instance exists in design.

Definition at line 270 of file ModuleTransformerUnitTest.cpp.

                                                             {
    // Search design for sModuleDefinition
    Design::ModuleSharedPtrIterator modIter = inDesignPtr->findModule(sModuleDefinition);
    // Verify design has module sModuleDefinition
    BOOST_REQUIRE(modIter != inDesignPtr->modulesEnd());
    // Search design for sModuleInstanceName
    Design::InstanceSharedPtrIterator instIter = inDesignPtr->findInstance(sModuleInstanceName);
    // Verify design has sModuleInstanceName
    BOOST_REQUIRE(instIter != inDesignPtr->instancesEnd());
}

Here is the caller graph for this function:

void torc::physical::preModularizationVerifications

(

DesignSharedPtr

inDesignPtr

)

Perform pre-modularization tests on a design.

Parameters

inDesignPtr

The design shared pointer.

The pre-modularization tests consist of the following: 1 - Verify module definition does not exist in design. 2 - Verify module instance does not exist in design.

Definition at line 100 of file ModuleTransformerUnitTest.cpp.

                                                                 {
    // Search design for sModuleDefinition
    Design::ModuleSharedPtrIterator modIter = inDesignPtr->findModule(sModuleDefinition);
    // Verify design does not have module sModuleDefinition
    BOOST_REQUIRE(modIter == inDesignPtr->modulesEnd());
    // Search design for sModuleInstanceName
    Design::InstanceSharedPtrIterator instIter = inDesignPtr->findInstance(sModuleInstanceName);
    // Verify design does not have sModuleInstanceName
    BOOST_REQUIRE(instIter == inDesignPtr->instancesEnd());
}

Here is the caller graph for this function:

DesignSharedPtr torc::physical::verifyDesignOpenedSuccessfully

(

const string &

inDesignFileName

)

Verify that the design file opened successfully.

Parameters

inDesignFileName

The design file name.

Definition at line 53 of file ModuleTransformerUnitTest.cpp.

                                                                                {
    // Design shared pointer
    DesignSharedPtr designPtr;
    // Create the appropriate file paths
    boost::filesystem::path physicalPath =
    torc::common::DirectoryTree::getExecutablePath() / "torc" / "physical";
    // Original xdl
    boost::filesystem::path originalPath = physicalPath / inDesignFileName;
    // Import the XDL design
    std::fstream fileStream(originalPath.string().c_str());
    // Verify the file is good
    BOOST_REQUIRE(fileStream.good());
    // Import the xdl design
    XdlImporter importer;
    importer(fileStream, originalPath.string());
    // Get a pointer to the design
    designPtr = importer.getDesignPtr();
    // Verify the design pointer
    BOOST_REQUIRE(designPtr.get() != 0);
    return designPtr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const char torc::physical::delimiters[] = " \n\t\f"

static

Definition at line 24 of file ParsePrimitive.cpp.

const string torc::physical::elementNames = "SRUSED REVUSED PRECYINIT DUSED CUSED COUTUSED CEUSED BUSED AUSED DCY0 CCY0 BCY0 ACY0 END"

Definition at line 32 of file XdlUnpack.hpp.

const string torc::physical::extraInvNames = "CLKINV T1INV T2INV D1INV D2INV END"

Definition at line 38 of file XdlUnpack.hpp.

const string torc::physical::extraMuxNames = "CY0G CY0F GYMUX DYMUX FXMUX DXMUX CYINIT DIG_MUX DIF_MUX XBMUX DOUTMUX COUTMUX BOUTMUX AOUTMUX DFFMUX CFFMUX BFFMUX AFFMUX ACY0 BCY0 CCY0 DCY0 PRECYINIT CDI1MUX BDI1MUX ADI1MUX WEMUX TMUX OMUX IDELMUX D2OBYP_SEL IFFDELMUX IFFMUX END"

Definition at line 35 of file XdlUnpack.hpp.

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

static

Definition at line 39 of file ModuleTransformerUnitTest.cpp.

const string torc::physical::sInstanceOneName = "c1"

static

Definition at line 35 of file ModuleTransformerUnitTest.cpp.

const string torc::physical::sInstanceTwoName = "c2"

static

Definition at line 36 of file ModuleTransformerUnitTest.cpp.

const string torc::physical::sModuleDefinition = "aModule"

static

Definition at line 37 of file ModuleTransformerUnitTest.cpp.

const string torc::physical::sModuleInstanceName = "aModuleInstance"

static

Definition at line 38 of file ModuleTransformerUnitTest.cpp.