torc::architecture Namespace Reference

Namespace for the Torc architecture support, providing device logic and wiring information, and design usage tracking. More...

Namespaces
	architecture
	xilinx
	Namespace for Xilinx architecture support.

Data Structures
class	Arc
	Encapsulation of an arc between two tilewires. More...
class	InvalidArcException
class	ArcUsage
	Encapsulation the design arc usage. More...
class	Array
	Encapsulation of a static array. More...
class	Array2D
	Encapsulation of a 2D static array. More...
class	DDB
	Device database, including complete wiring and logic support. More...
class	DDBConsoleStreams
	Device database console streams class. More...
class	DDBStreamHelper
	Device database stream helper class. More...
class	DigestStream
	Encapsulation of a device or family digest stream. More...
class	ExtendedWireInfo
	Verbose encapsulation of a wire's information. More...
class	InstancePin
	Physical design instance-pin pair, suitable for specifying a net endpoint. More...
class	Package
	Encapsulation of a physical device package and its pins. More...
class	Pad
	Encapsulation of the site index, pin name, and pin flags for a package. More...
class	PrimitiveConn
	Encapsulation of a PrimitiveDef internal connection. This class is analogous to a permanent net with one and only source pin. All PrimitiveConn objects are initialized from a family database by the Sites class. More...
class	PrimitiveDef
	Encapsulation of primitive site definition, with associated connections, elements, and pins. More...
class	PrimitiveElement
	Encapsulation of a primitive site element. Primitive elements are subcomponents of logic primitive sites. More...
class	PrimitiveElementPin
	Encapsulation of a primitive element pin's name, flags, and element pointer. Primitive element pins are sub-site inputs or outputs. More...
class	PinDirection
class	PrimitivePin
	Encapsulation of a primitive pin's name and flags. Primitive pins are logic site inputs or outputs. More...
class	Segments
	Segment and irregular arc data for the device. More...
class	segments_regression_test_helper
	Regression test class for segments consistency across all devices. More...
class	segments_unit_test_helper
class	Site
	Encapsulation of a device logic site. More...
class	Sites
	Site type and population data for the family and the device. More...
class	TileInfo
	Encapsulation of a tile within a device tile map. More...
class	Tiles
	Tile map, tile type, and wire information for the family and device. More...
class	Tilewire
	Encapsulation of a device tile and wire pair. More...
class	Versions
	Encapsulation of database version information. More...
class	VprExporter
	Device database exporter for the University of Toronto's VPR. More...
class	WireArray
	Array of wire indexes. More...
class	WireInfo
	Encapsulation of a wire within a tile type. More...
class	WireUsage
	Encapsulation the design wire usage. More...
class	XdlImporter
	Architecture aware importer from XDL format into a physical design. More...

Typedefs
typedef std::vector< Arc >	ArcVector
	Vector of Arc objects. More...
typedef boost::shared_ptr < InstancePin >	InstancePinSharedPtr
	Shared pointer encapsulation of an InstancePin. More...
typedef boost::weak_ptr < InstancePin >	InstancePinWeakPtr
	Weak pointer encapsulation of an InstancePin. More...
typedef std::vector < InstancePinSharedPtr >	InstancePinSharedPtrVector
	Vector of InstancePin shared pointers. More...
typedef Array< const Pad >	PadArray
	Array of constant Pad objects. More...
typedef Array < PrimitiveConnSharedPtr >	PrimitiveConnSharedPtrArray
	Array of shared pointers to PrimitiveConn objects. More...
typedef Array< const PrimitiveElement >	PrimitiveElementArray
	Array of constant PrimitiveElement objects. More...
typedef boost::shared_ptr < const PrimitiveConn >	PrimitiveConnSharedPtr
typedef Array< const PrimitiveElementPin >	PrimitiveElementPinArray
	Array of constant PrimitiveElementPin objects. More...
typedef std::vector< const PrimitiveElementPin * >	PrimitiveElementPinPtrVector
	Vector of constant PrimitiveElementPin pointers. More...
typedef Array< const PrimitivePin >	PrimitivePinArray
	Array of constant PrimitivePin objects. More...
typedef std::vector< Tilewire >	TilewireVector
	Vector of Tilewire objects. More...

Functions
std::size_t	hash_value (const Arc &inArc)
	BOOST_AUTO_TEST_CASE (ArcUnitTest)
	Unit test for the Arc class. More...
	BOOST_AUTO_TEST_CASE (ArcUsageUnitTest)
	Unit test for the ArcUsage class. More...
	BOOST_AUTO_TEST_CASE (ArrayUnitTest)
	Unit test for the Array class. More...
std::ostream &	operator<< (std::ostream &os, const DDB &ddb)
std::ostream &	operator<< (std::ostream &os, const class DDB &ddb)
	Insertion operator to associate the given device database with the given stream. More...
	BOOST_AUTO_TEST_CASE (DDBStreamHelperUnitTest)
	Unit test for the DDBStreamHelper class. More...
void	testDevice (const std::string &inDeviceName)
	BOOST_AUTO_TEST_CASE (DDBUnitTest)
	Unit test for the DDB class. More...
	BOOST_AUTO_TEST_CASE (DigestStreamUnitTest)
	Unit test for the DigestStream class. More...
	BOOST_AUTO_TEST_CASE (ExtendedWireInfoUnitTest)
	Unit test for the ExtendedWireInfo class. More...
	BOOST_AUTO_TEST_CASE (InstancePinUnitTest)
	Unit test for the InstancePin class. More...
std::ostream &	operator<< (std::ostream &os, const Tilewire &rhs)
	Tilewire stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const ExtendedWireInfo &rhs)
	ExtendedWireInfo stream inserter. More...
std::ostream &	operator<< (std::ostream &os, const Arc &rhs)
	Arc stream inserter. More...
	BOOST_AUTO_TEST_CASE (OutputStreamHelpersUnitTest)
	Unit test for the output stream helpers. More...
	BOOST_AUTO_TEST_CASE (PackageUnitTest)
	Unit test for the Package class. More...
	BOOST_AUTO_TEST_CASE (PadUnitTest)
	Unit test for the Pad class. More...
	BOOST_AUTO_TEST_CASE (PrimitiveConnUnitTest)
	Unit test for the PrimitiveConn class. More...
	BOOST_AUTO_TEST_CASE (PrimitiveDefUnitTest)
	Unit test for the PrimitiveDef class. More...
	BOOST_AUTO_TEST_CASE (PrimitiveElementPinUnitTest)
	Unit test for the PrimitiveElementPin class. More...
	BOOST_AUTO_TEST_CASE (PrimitiveElementUnitTest)
	Unit test for the Sites class. More...
	BOOST_AUTO_TEST_CASE (PrimitivePinUnitTest)
	Unit test for the PrimitivePin class. More...
	BOOST_AUTO_TEST_CASE (SegmentsRegressionTest)
	Regression test for the Segments class. More...
	BOOST_AUTO_TEST_CASE (SitesUnitTest)
	Unit test for the Sites class. More...
	BOOST_AUTO_TEST_CASE (iterate_configmaps)
	Unit test to iterate through the ConfigMaps of a XDL file. More...
bool	findLUTbyCfg (const std::string isit)
bool	findFFbyCfg (const std::string isit)
bool	findINV (const std::string isit)
bool	findROUTETHROUGH (const std::string isit)
bool	findAND (const std::string isit)
bool	findVCC (const std::string isit)
bool	findGND (const std::string isit)
	BOOST_AUTO_TEST_CASE (classify_elements)
	Unit test to iterate through a database and classify all existing elements into pseudo-types. More...
	BOOST_AUTO_TEST_CASE (SiteTypesUnitTest)
	Unit test for the SiteTypes class. More...
	BOOST_AUTO_TEST_CASE (SiteUnitTest)
	Unit test for the Site class. More...
	BOOST_AUTO_TEST_CASE (TileInfoUnitTest)
	Unit test for the TileInfo class. More...
void	testDeviceTiles (DDB &inDDB)
	BOOST_AUTO_TEST_CASE (TilesUnitTest)
	Unit test for the Tiles class. More...
std::size_t	hash_value (const Tilewire &inTilewire)
	BOOST_AUTO_TEST_CASE (VersionsUnitTest)
	Unit test for the Versions class. More...
	BOOST_AUTO_TEST_CASE (GenerateVprRoutingGraph)
	Experimental VPR routing graph exporter. More...
	BOOST_AUTO_TEST_CASE (WireInfoUnitTest)
	Unit test for the WireInfo class. More...
	BOOST_AUTO_TEST_CASE (WireUsageUnitTest)
	Unit test for the WireUsage class. More...
	BOOST_AUTO_TEST_CASE (XdlImporterUnitTest)
	Unit test for the device-aware XdlImporter class. More...

Detailed Description

Namespace for the Torc architecture support, providing device logic and wiring information, and design usage tracking.

Typedef Documentation

typedef std::vector<Arc> torc::architecture::ArcVector

Vector of Arc objects.

Definition at line 78 of file Arc.hpp.

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

Shared pointer encapsulation of an InstancePin.

Definition at line 66 of file architecture/InstancePin.hpp.

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

Vector of InstancePin shared pointers.

Definition at line 72 of file architecture/InstancePin.hpp.

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

Weak pointer encapsulation of an InstancePin.

Definition at line 69 of file architecture/InstancePin.hpp.

typedef Array<const Pad> torc::architecture::PadArray

Array of constant Pad objects.

Definition at line 70 of file Pad.hpp.

typedef boost::shared_ptr<const PrimitiveConn> torc::architecture::PrimitiveConnSharedPtr

Definition at line 36 of file PrimitiveElementPin.hpp.

typedef Array<PrimitiveConnSharedPtr> torc::architecture::PrimitiveConnSharedPtrArray

Array of shared pointers to PrimitiveConn objects.

Definition at line 53 of file PrimitiveConn.hpp.

typedef Array<const PrimitiveElement> torc::architecture::PrimitiveElementArray

Array of constant PrimitiveElement objects.

Definition at line 94 of file PrimitiveElement.hpp.

typedef Array<const PrimitiveElementPin> torc::architecture::PrimitiveElementPinArray

Array of constant PrimitiveElementPin objects.

Definition at line 88 of file PrimitiveElementPin.hpp.

typedef std::vector<const PrimitiveElementPin*> torc::architecture::PrimitiveElementPinPtrVector

Vector of constant PrimitiveElementPin pointers.

Definition at line 91 of file PrimitiveElementPin.hpp.

typedef Array<const PrimitivePin> torc::architecture::PrimitivePinArray

Array of constant PrimitivePin objects.

Definition at line 81 of file architecture/PrimitivePin.hpp.

typedef std::vector<Tilewire> torc::architecture::TilewireVector

Vector of Tilewire objects.

Definition at line 101 of file Tilewire.hpp.

Function Documentation

torc::architecture::BOOST_AUTO_TEST_CASE

(

ExtendedWireInfoUnitTest

)

Unit test for the ExtendedWireInfo class.

Definition at line 28 of file ExtendedWireInfoUnitTest.cpp.

                                               {
}

torc::architecture::BOOST_AUTO_TEST_CASE

(

PadUnitTest

)

Unit test for the Pad class.

Definition at line 28 of file PadUnitTest.cpp.

                                  {
    // members tested:
    //      SiteIndex mSiteIndex;
    //      string mName;
    //      SiteFlags mFlags;
    // functions tested:
    //      Pad(SiteIndex inSiteIndex, const string& inName, SiteFlags inFlags);
    //      Pad(void);
    //      SiteIndex getSiteIndex(void) const;
    //      const string& getName(void) const;
    //      SiteFlags getFlags(void) const;
    xilinx::SiteIndex siteIndex(15);
    std::string name("name");
    xilinx::SiteFlags flags(3);
    Pad pad1(siteIndex, name, flags);
    BOOST_CHECK_EQUAL(pad1.getSiteIndex(), siteIndex);
    BOOST_CHECK_EQUAL(pad1.getName(), name);
    BOOST_CHECK_EQUAL(pad1.getFlags(), flags);
    Pad pad2;
    BOOST_CHECK_EQUAL(pad2.getSiteIndex(), xilinx::SiteIndex());
    BOOST_CHECK_EQUAL(pad2.getName(), "");
    BOOST_CHECK_EQUAL(pad2.getFlags(), xilinx::SiteFlags());
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

PrimitiveConnUnitTest

)

Unit test for the PrimitiveConn class.

Definition at line 28 of file PrimitiveConnUnitTest.cpp.

                                            {
    // members tested:
    //      const PrimitiveElementPin* mSourcePtr;
    //      PrimitiveElementPinPtrVector mSinks;
    // functions tested:
    //      const PrimitiveElementPin* getSourcePtr(void) const
    //      const PrimitiveElementPinPtrVector& getSinks(void) const
    PrimitiveElementPin pin1;
    PrimitiveElementPin pin2;
    PrimitiveElementPin pin3;
    PrimitiveConn conn;
    conn.mSourcePtr = &pin1;
    conn.mSinks.push_back(&pin2);
    conn.mSinks.push_back(&pin3);
    BOOST_CHECK_EQUAL(conn.getSourcePtr(), &pin1);
    const PrimitiveElementPinPtrVector& sinks = conn.getSinks();
    PrimitiveElementPinPtrVector::const_iterator p = sinks.begin();
    BOOST_CHECK_EQUAL(*p++, &pin2);
    BOOST_CHECK_EQUAL(*p++, &pin3);
    BOOST_CHECK(p == sinks.end());
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

TileInfoUnitTest

)

Unit test for the TileInfo class.

Todo:

Write a unit test for torc::architecture::TileInfo.

Todo:

Write a unit test for torc::architecture::TileInfo.

Definition at line 28 of file TileInfoUnitTest.cpp.

                                       {
    // functions tested:
    //      friend uint32_t distance(const TileInfo& inA, const TileInfo& inB);
    // create a few TileInfo objects
    typedef xilinx::TileTypeIndex TileTypeIndex;
    typedef xilinx::TileRow TileRow;
    typedef xilinx::TileCol TileCol;
    TileInfo tileInfo1; tileInfo1.set(TileTypeIndex(1), TileRow( 0), TileCol( 0), "tile1");
    TileInfo tileInfo2; tileInfo2.set(TileTypeIndex(2), TileRow(10), TileCol(10), "tile2");
    TileInfo tileInfo3; tileInfo3.set(TileTypeIndex(3), TileRow(30), TileCol( 0), "tile3");
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo1, tileInfo2), uint32_t(20));
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo1, tileInfo2), 
        manhattanDistance(tileInfo2, tileInfo1));
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo1, tileInfo3), uint32_t(30));
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo1, tileInfo3), 
        manhattanDistance(tileInfo3, tileInfo1));
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo2, tileInfo3), uint32_t(30));
    BOOST_CHECK_EQUAL(manhattanDistance(tileInfo2, tileInfo3), 
        manhattanDistance(tileInfo3, tileInfo2));
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

PrimitiveElementPinUnitTest

)

Unit test for the PrimitiveElementPin class.

Todo:

Test mPrimitiveConn and getPrimitiveConn. Do a better job testing mElementPtr and getElementPtr.

Definition at line 28 of file PrimitiveElementPinUnitTest.cpp.

                                                  {
    /// \todo Test mPrimitiveConn and getPrimitiveConn.  Do a better job testing mElementPtr and 
    ///     getElementPtr.
    // members not tested:
    //      const PrimitiveConnSharedPtr mPrimitiveConn;
    // functions not tested:
    //      const PrimitiveConnSharedPtr getPrimitiveConn(void) const { return mPrimitiveConn; }

    // members tested:
    //      const PrimitiveElement* mElementPtr;
    //      string mName;
    //      PinFlags mFlags;
    // functions tested:
    //      PrimitiveElementPin(const string& inName, PinFlags inFlags);
    //      const PrimitiveElement* getElementPtr(void) const;
    //      const string& getName(void) const;
    //      PinFlags getFlags(void) const;
    //      PrimitiveElementPin(void);
    //      bool isInput(void) const;
    //      bool isOutput(void) const;
    std::string name = "name";
    xilinx::PinFlags flags(PinDirection::ePinDirectionOutput);
    PrimitiveElementPin pin1(0, name, flags);
    BOOST_CHECK_EQUAL(pin1.getElementPtr(), static_cast<void*>(0));
    BOOST_CHECK_EQUAL(pin1.getName(), name);
    BOOST_CHECK_EQUAL(pin1.getFlags(), flags);
    BOOST_CHECK(pin1.isInput() == false);
    BOOST_CHECK(pin1.isOutput() == true);
    PrimitiveElementPin pin2;
    BOOST_CHECK_EQUAL(pin2.getElementPtr(), static_cast<void*>(0));
    BOOST_CHECK_EQUAL(pin2.getName(), "");
    BOOST_CHECK_EQUAL(pin2.getFlags(), xilinx::PinFlags(0));
    BOOST_CHECK(pin2.isInput() == false);
    BOOST_CHECK(pin2.isOutput() == false);
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

PrimitivePinUnitTest

)

Unit test for the PrimitivePin class.

Definition at line 28 of file PrimitivePinUnitTest.cpp.

                                           {
    // members tested:
    //      string mName;
    //      PinFlags mFlags;
    // functions tested:
    //      PrimitivePin(const string& inName, PinFlags inFlags);
    //      const string& getName(void) const;
    //      PinFlags getFlags(void) const;
    //      PrimitivePin(void);
    //      bool isInput(void) const;
    //      bool isOutput(void) const;
    std::string name = "name";
    xilinx::PinFlags flags(PinDirection::ePinDirectionOutput);
    PrimitivePin pin1(name, flags);
    BOOST_CHECK_EQUAL(pin1.getName(), name);
    BOOST_CHECK_EQUAL(pin1.getFlags(), flags);
    BOOST_CHECK(pin1.isInput() == false);
    BOOST_CHECK(pin1.isOutput() == true);
    PrimitivePin pin2;
    BOOST_CHECK_EQUAL(pin2.getName(), "");
    BOOST_CHECK_EQUAL(pin2.getFlags(), xilinx::PinFlags(0));
    BOOST_CHECK(pin2.isInput() == false);
    BOOST_CHECK(pin2.isOutput() == false);
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

PackageUnitTest

)

Unit test for the Package class.

Definition at line 29 of file PackageUnitTest.cpp.

                                      {
    // members tested:
    //      string mName;
    //      PadArray mPads;
    //      PadNameToPadIndexMap mPadNameToPadIndex;
    // functions tested:
    //      Package(const string& inName);
    //      PadArray& getPads(void);
    //      const string& getName(void) const;
    //      const PadArray& getPads(void) const;
    //      PadIndex findPadIndexByName(const string& inName) const;
    int index = 0;
    std::string name1("pad1");
    std::string name2("pad2");
    std::string name3("pad3");
    Pad pad1(xilinx::SiteIndex(), name1, xilinx::SiteFlags());
    Pad pad2(xilinx::SiteIndex(), name2, xilinx::SiteFlags());
    Pad pad3(xilinx::SiteIndex(), name3, xilinx::SiteFlags());
    std::string name("name");
    Package package1(name);
    PadArray& pads1 = package1.getPads();
    pads1.setSize(3);
    package1.mPadNameToPadIndex[name1] = xilinx::PadIndex(index);
    const_cast<Pad&>(pads1[index++]) = pad1;
    package1.mPadNameToPadIndex[name2] = xilinx::PadIndex(index);
    const_cast<Pad&>(pads1[index++]) = pad2;
    package1.mPadNameToPadIndex[name3] = xilinx::PadIndex(index);
    const_cast<Pad&>(pads1[index++]) = pad3;
    BOOST_CHECK_EQUAL(package1.getName(), name);
    const PadArray& pads2 = package1.getPads();
    index = 0;
    BOOST_CHECK_EQUAL(pads2[index++].getName(), pad1.getName());
    BOOST_CHECK_EQUAL(pads2[index++].getName(), pad2.getName());
    BOOST_CHECK_EQUAL(pads2[index++].getName(), pad3.getName());
    BOOST_CHECK_EQUAL(package1.findPadIndexByName(name1), xilinx::PadIndex(0));
    BOOST_CHECK_EQUAL(package1.findPadIndexByName(name2), xilinx::PadIndex(1));
    BOOST_CHECK_EQUAL(package1.findPadIndexByName(name3), xilinx::PadIndex(2));

    // functions tested:
    //      Package(void);
    //      PadArray& getPads(void);
    Package package2;
    BOOST_CHECK_EQUAL(package2.getName(), "");
    BOOST_CHECK_EQUAL(package2.getPads().getSize(), 0u);
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

ArcUnitTest

)

Unit test for the Arc class.

Definition at line 29 of file ArcUnitTest.cpp.

                                  {
    // supporting variables
    Tilewire tilewire1(xilinx::TileIndex(5), xilinx::WireIndex(3));
    Tilewire tilewire2(xilinx::TileIndex(0), xilinx::WireIndex(9));

    // members tested:
    //      Tilewire mSourceTilewire;
    //      Tilewire mSinkTilewire;
    // functions tested:
    //      Arc(void);
    //      Arc(const Tilewire& inSourceTilewire, const Tilewire& inSinkTilewire);
    //      bool operator ==(const Arc& rhs) const;
    //      bool operator <(const Arc& rhs) const;
    //      bool isUndefined(void) const;
    Arc arc1;
    Arc arc2;
    Arc arc3(tilewire1, tilewire2);
    Arc arc4(tilewire2, tilewire1);
    BOOST_CHECK((arc1 == arc2) == true);
    BOOST_CHECK((arc1 == arc3) == false);
    BOOST_CHECK((arc3 < arc4) == true);
    BOOST_CHECK((arc4 < arc3) == false);
    BOOST_CHECK(arc1.isUndefined());

    // functions tested:
    //      const Tilewire& getSourceTilewire(void) const;
    //      const Tilewire& getSinkTilewire(void) const;
    BOOST_CHECK(arc3.getSourceTilewire() == tilewire1);
    BOOST_CHECK(arc3.getSinkTilewire() == tilewire2);

    // functions tested:
    //      friend std::size_t hash_value(const Arc& inArc);
    BOOST_CHECK_EQUAL(hash_value(arc1), hash_value(arc2));
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

SiteUnitTest

)

Unit test for the Site class.

Todo:

Write a unit test for torc::architecture::Site.

Definition at line 29 of file SiteUnitTest.cpp.

                                   {

    /// \todo Write a unit test for torc::architecture::Site.
    BOOST_REQUIRE(false);

}

torc::architecture::BOOST_AUTO_TEST_CASE

(

OutputStreamHelpersUnitTest

)

Unit test for the output stream helpers.

Definition at line 29 of file architecture/OutputStreamHelpersUnitTest.cpp.

                                                  {
}

torc::architecture::BOOST_AUTO_TEST_CASE

(

PrimitiveDefUnitTest

)

Unit test for the PrimitiveDef class.

Todo:

Write a unit test for torc::architecture::PrimitiveDef.

Definition at line 29 of file PrimitiveDefUnitTest.cpp.

                                           {
    // elements not tested:
    //      std::string mName;
    //      PrimitivePinArray mPins;
    //      PrimitiveElementArray mElements;
    //      PrimitiveConnSharedPtrArray mConnections;
    //      PinNameToPinIndexMap mPinNameToPinIndex;
    // functions not tested:
    //      PrimitivePinArray& getPins(void);
    //      PrimitiveDef(void);
    //      PinIndex findPinIndexByName(const std::string& inName) const;
    //      const string& getName(void) const;
    //      const PrimitivePinArray& getPins(void) const;
    //      const PrimitiveElementArray& getElements(void) const;
    //      const PrimitiveConnSharedPtrArray& getConnections(void) const;
    /// \todo Write a unit test for torc::architecture::PrimitiveDef.
    BOOST_REQUIRE(false);
}

torc::architecture::BOOST_AUTO_TEST_CASE

(

WireInfoUnitTest

)

Unit test for the WireInfo class.

Todo:

Write a unit test for torc::architecture::WireInfo.

Definition at line 29 of file WireInfoUnitTest.cpp.

                                       {

    /// \todo Write a unit test for torc::architecture::WireInfo.
    BOOST_REQUIRE(false);

}

torc::architecture::BOOST_AUTO_TEST_CASE

(

WireUsageUnitTest

)

Unit test for the WireUsage class.

Todo:

Write a unit test for torc::architecture::WireUsage.

Definition at line 29 of file WireUsageUnitTest.cpp.

                                        {

    /// \todo Write a unit test for torc::architecture::WireUsage.
    BOOST_REQUIRE(false);

}

torc::architecture::BOOST_AUTO_TEST_CASE

(

PrimitiveElementUnitTest

)

Unit test for the Sites class.

Todo:

Write a unit test for torc::architecture::PrimitiveElement.

Definition at line 29 of file PrimitiveElementUnitTest.cpp.

                                               {
    // members not tested:
    //      string mName;
    //      PrimitiveElementPinArray mPins;
    //      StringSet mCfgs;
    //      bool mIsBel;
    //      PinNameToPinIndexMap mPinNameToPinIndex;
    // functions not tested:
    //      PrimitiveElementPinArray& getPins(void);
    //      PrimitiveElement(void);
    //      PinIndex findPinIndexByName(const string& inName) const;
    //      const string& getName(void) const;
    //      const PrimitiveElementPinArray& getPins(void) const;
    //      const StringSet& getCfgs(void) const;
    //      bool isBel(void) const;
    /// \todo Write a unit test for torc::architecture::PrimitiveElement.
    BOOST_REQUIRE(false);
}

torc::architecture::BOOST_AUTO_TEST_CASE

(

GenerateVprRoutingGraph

)

Experimental VPR routing graph exporter.

Definition at line 30 of file VprExporterUnitTest.cpp.

                                              {
    DDB ddb("xc6vlx240t");
    VprExporter vprExporter(ddb);
    vprExporter();
}

torc::architecture::BOOST_AUTO_TEST_CASE

(

VersionsUnitTest

)

Unit test for the Versions class.

Todo:

Write a unit test for torc::architecture::Versions.

Definition at line 31 of file VersionsUnitTest.cpp.

                                       {

    /// \todo Write a unit test for torc::architecture::Versions.
    BOOST_REQUIRE(false);

}

torc::architecture::BOOST_AUTO_TEST_CASE

(

ArcUsageUnitTest

)

Unit test for the ArcUsage class.

Definition at line 31 of file ArcUsageUnitTest.cpp.

                                       {
    // supporting variables
    DDB ddb("xcv50");
    const Tiles& tiles = ddb.getTiles();
    Tilewire tilewire1 = ddb.lookupTilewire("R1C1", "S0_X");
    Tilewire tilewire2 = ddb.lookupTilewire("R1C1", "OUT0");
    Tilewire tilewire3(tilewire2.getTileIndex(), WireIndex(10000));
    Arc arc1(tilewire1, tilewire2);
    uint32_t virtexCenterArcCount = 1511u;

    // members tested:
    //      const Tiles& mTiles;
    //      Array<dynamic_bitset*> mBitsets;
    //      dynamic_bitset mTileDirty;
    // functions tested:
    //      ArcUsage(const Tiles& inTiles);
    //      void autosize(void);
    //      uint32_t getArcUsageCount(void) const;
    //      TileCount getTileUsageCount(void) const;
    //      uint32_t getBitCount(void) const;
    ArcUsage arcUsage(tiles);
    arcUsage.autosize();
    BOOST_CHECK(arcUsage.mBitsets.getSize() > 0);
    BOOST_CHECK(arcUsage.getArcUsageCount() == 0);
    BOOST_CHECK(arcUsage.getTileUsageCount() == TileCount(0));
    BOOST_CHECK(arcUsage.getBitCount() == 0);

    // members tested:
    //      TileCount mTileUsageCount;
    //      uint32_t mBitCount;
    // functions tested:
    //      inline bool isUsed(const Arc& inArc);
    //      bool isUsed(const Tilewire& inTilewire1, const Tilewire& inTilewire2) const;
    //      inline void use(const Arc& inArc) ;
    //      void use(const Tilewire& inTilewire1, const Tilewire& inTilewire2);
    //      inline void release(const Arc& inArc);
    //      void release(const Tilewire& inTilewire1, const Tilewire& inTilewire2);
    //      uint32_t getArcUsageCount(void) const;
    //      TileCount getTileUsageCount(void) const;
    //      uint32_t getBitCount(void) const;
    BOOST_CHECK_EQUAL(arcUsage.isUsed(arc1), false);
    arcUsage.use(arc1);
    BOOST_CHECK_EQUAL(arcUsage.isUsed(arc1), true);
    BOOST_CHECK_EQUAL(arcUsage.getArcUsageCount(), 1u);
    BOOST_CHECK_EQUAL(arcUsage.getTileUsageCount(), TileCount(1));
    BOOST_CHECK_EQUAL(arcUsage.getBitCount(), virtexCenterArcCount);
    arcUsage.release(arc1);
    BOOST_CHECK_EQUAL(arcUsage.isUsed(arc1), false);
    BOOST_CHECK_EQUAL(arcUsage.getArcUsageCount(), 0u);
    BOOST_CHECK_EQUAL(arcUsage.getTileUsageCount(), TileCount(1));
    BOOST_CHECK_EQUAL(arcUsage.getBitCount(), virtexCenterArcCount);

    // exceptions tested:
    //      InvalidArcException;
    // functions tested:
    //      uint32_t getArcOffset(const Tilewire& inTilewire1, const Tilewire& inTilewire2) const;
    bool threwInvalidArcException = false;
    try {
        // this arc's tilewires are undefined
        (void) arcUsage.getArcOffset(Tilewire(), Tilewire());
    }
    catch(InvalidArcException iae) {
        threwInvalidArcException = true;        
    }
    BOOST_CHECK_EQUAL(threwInvalidArcException, true);
    threwInvalidArcException = false;
    try {
        // this arc is valid (and its tilewires are defined)
        (void) arcUsage.getArcOffset(tilewire1, tilewire2);
    }
    catch(InvalidArcException iae) {
        threwInvalidArcException = true;        
    }
    BOOST_CHECK_EQUAL(threwInvalidArcException, false);
    threwInvalidArcException = false;
    try {
        // this arc's tilewires are defined, but the are is invalid
        (void) arcUsage.getArcOffset(tilewire1, tilewire3);
    }
    catch(InvalidArcException iae) {
        threwInvalidArcException = true;        
    }
    BOOST_CHECK_EQUAL(threwInvalidArcException, true);

    // functions tested:
    //      void clear(void);
    arcUsage.use(arc1);
    arcUsage.clear();
    BOOST_CHECK_EQUAL(arcUsage.getArcUsageCount(), 0u);
    BOOST_CHECK_EQUAL(arcUsage.getTileUsageCount(), TileCount(1));
    BOOST_CHECK_EQUAL(arcUsage.getBitCount(), virtexCenterArcCount);

    // functions not tested:
    //      ~ArcUsage(void);
    ArcUsage* arcUsagePtr = new ArcUsage(tiles);
    arcUsagePtr->autosize();
    arcUsagePtr->use(arc1);
    arcUsagePtr->~ArcUsage();
    uint32_t bitsetsAfterDestruction = 0;
    for(uint32_t i = 0; i < arcUsagePtr->mBitsets.getSize(); i++) { 
        bitsetsAfterDestruction += (arcUsagePtr->mBitsets[i] != 0); 
    }
    BOOST_CHECK_EQUAL(bitsetsAfterDestruction, 0u);
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

DigestStreamUnitTest

)

Unit test for the DigestStream class.

Definition at line 32 of file DigestStreamUnitTest.cpp.

                                           {
    // functions tested:
    //      DigestStream(const boost::filesystem::path& inPath);
    DigestStream digestStream(torc::common::DirectoryTree::getDevicesPath() / "xc5vlx30.db");
    Versions versions;

    // functions tested:
    //      std::istream& read(uint8_t& outValue);
    //      std::istream& read(uint16_t& outValue);
    //      std::istream& read(uint32_t& outValue);
    //      std::istream& read(char* s, std::streamsize n);
    BOOST_CHECK(versions.readVersions(digestStream, true) > 0);
    std::string header;

    // functions tested:
    //      void readSectionHeader(string& outHeader);
    //      std::istream& read(uint8_t& outValue);
    //      std::istream& read(uint16_t& outValue);
    //      std::istream& read(uint32_t& outValue);
    //      std::istream& read(char* s, std::streamsize n);
    digestStream.readSectionHeader(header);
    BOOST_CHECK_EQUAL(header, ">>>> Family >>>>");
    boost::uint16_t familyNameLength;
    digestStream.read(familyNameLength);
    BOOST_CHECK_EQUAL(familyNameLength, 7u);
    boost::scoped_ptr<char> familyNamePtr(new char[familyNameLength]);
    digestStream.read(familyNamePtr.get(), familyNameLength);
    BOOST_CHECK(memcmp(familyNamePtr.get(), "Virtex5", familyNameLength) == 0);
    digestStream.readSectionHeader(header);
    BOOST_CHECK_EQUAL(header, ">>>> Speeds >>>>");
    uint16_t speedGradeCount;
    digestStream.read(speedGradeCount);
    BOOST_CHECK_EQUAL(speedGradeCount, 3);

    // members tested:
    //      size_t mBytesRead;
    // functions tested:
    //      size_t getBytesRead(void) const;
    BOOST_CHECK(digestStream.getBytesRead() > 0u);
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

InstancePinUnitTest

)

Unit test for the InstancePin class.

Definition at line 32 of file architecture/InstancePinUnitTest.cpp.

                                          {
    // create objects to work with
    torc::physical::InstanceSharedPtr instancePtr 
        = torc::physical::Factory::newInstancePtr("name", "type", "tile", "site");
    torc::physical::InstancePinSharedPtr physicalInstancePinPtr 
        = torc::physical::Factory::newInstancePinPtr(instancePtr, "pin");

    // features tested:
    //      sizeof(InstancePin);
    BOOST_REQUIRE_EQUAL(sizeof(InstancePin), sizeof(torc::physical::InstancePin));

    // macros tested:
    //      INSTANCE_PIN_PHYSICAL_TO_ARCHITECTURE(x);
    //      INSTANCE_PIN_ARCHITECTURE_TO_PHYSICAL(x);
    InstancePinSharedPtr& architectureInstancePinPtr 
        = INSTANCE_PIN_PHYSICAL_TO_ARCHITECTURE(physicalInstancePinPtr);
    torc::physical::InstancePinSharedPtr& physicalInstancePin2Ptr 
        = INSTANCE_PIN_ARCHITECTURE_TO_PHYSICAL(architectureInstancePinPtr);
    BOOST_CHECK_EQUAL(architectureInstancePinPtr->getTileIndex(), xilinx::TileIndex(0));
    BOOST_CHECK_EQUAL(architectureInstancePinPtr->getWireIndex(), xilinx::WireIndex(0));

    // functions tested:
    //      Tilewire& getTilewire(void);
    Tilewire& tilewire = architectureInstancePinPtr->getTilewire();
    tilewire = Tilewire(xilinx::TileIndex(32), xilinx::WireIndex(16));
    BOOST_CHECK_EQUAL(tilewire.getTileIndex(), xilinx::TileIndex(32));
    BOOST_CHECK_EQUAL(tilewire.getWireIndex(), xilinx::WireIndex(16));
    BOOST_REQUIRE_EQUAL(sizeof(*physicalInstancePin2Ptr), sizeof(*architectureInstancePinPtr));
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

ArrayUnitTest

)

Unit test for the Array class.

Definition at line 33 of file ArrayUnitTest.cpp.

                                    {
    // functions not tested:
    //      ~Array<T>(void);

    // functions tested:
    //      Array<T>(void);
    //      Array<T>(uint32_t inSize);
    //      void allocate(uint32_t inSize);
    //      void deallocate(void);
    uint32_t size5 = 5;
    uint32_t size3 = 3;
    typedef Array<int> int_array_t;
    typedef Array<Tilewire> tilewire_array_t;
    int_array_t intArray;
    tilewire_array_t tilewireArray(size3);

    // macros tested:
    //      enforceBounds(index)
    bool boundsEnforced = false;
    try {
        // if bounds checking is enabled and correct, we won't be able to read index 3
        Tilewire outOfRange = tilewireArray[size3];
        (void) outOfRange;
    } catch(std::out_of_range oor) {
        std::cerr << "Bounds checking generated message \"" << oor.what() << "\"" << std::endl;
        boundsEnforced = true;
    }
    BOOST_CHECK(boundsEnforced);

    // functions tested:
    //      inline int getSize(void) const;
    //      inline void setSize(uint32_t inSize);
    BOOST_CHECK_EQUAL(intArray.getSize(), 0u);
    BOOST_CHECK_EQUAL(tilewireArray.getSize(), size3);
    intArray.setSize(size5);
    BOOST_CHECK_EQUAL(intArray.getSize(), size5);

    // functions tested:
    //      T& operator [](uint32_t inIndex);
    //      T* begin(void);
    //      T* end(void);
    intArray[0] = 0;
    intArray[1] = 1;
    intArray[2] = 2;
    intArray[3] = 3;
    intArray[4] = 4;
    int_array_t::iterator ip = intArray.begin();
    int_array_t::iterator ie = intArray.end();
    BOOST_CHECK(*ip++ == 0);
    BOOST_CHECK(*ip++ == 1);
    BOOST_CHECK(*ip++ == 2);
    BOOST_CHECK(*ip++ == 3);
    BOOST_CHECK(*ip++ == 4);
    BOOST_CHECK_EQUAL(ip, ie);

    // functions tested:
    //      const T& operator [](uint32_t inIndex) const;
    //      const T* begin(void) const;
    //      const T* end(void) const;
    Tilewire tilewire1(TileIndex(1), WireIndex(1));
    Tilewire tilewire2(TileIndex(1), WireIndex(2));
    Tilewire tilewire3(TileIndex(4), WireIndex(9));
    tilewireArray[0] = tilewire1;
    tilewireArray[1] = tilewire2;
    tilewireArray[2] = tilewire3;
    tilewire_array_t::const_iterator tp = tilewireArray.begin();
    tilewire_array_t::const_iterator te = tilewireArray.end();
    BOOST_CHECK(*tp++ == tilewireArray[0]);
    BOOST_CHECK(*tp++ == tilewireArray[1]);
    BOOST_CHECK(*tp++ == tilewireArray[2]);
    BOOST_CHECK_EQUAL(tp, te);

    // template tested:
    //      template <class T> class Array2D;
    int i = 1;
    typedef Array2D<int> int_array2d_t;
    int_array2d_t intArray2d(2);
    intArray2d[0].setSize(3);
    intArray2d[1].setSize(1);
    intArray2d[0][0] = i++;
    intArray2d[0][1] = i++;
    intArray2d[0][2] = i++;
    intArray2d[1][0] = i++;
    Array<Array<int> >::const_iterator l1p = intArray2d.begin();
    int_array2d_t::const_iterator l1e = intArray2d.end();
    i = 1;
    while(l1p < l1e) {
        int_array_t::const_iterator l2p = l1p->begin();
        int_array_t::const_iterator l2e = l1p->end();
        while(l2p < l2e) {
            BOOST_CHECK_EQUAL(*l2p++, i++);
        }
        l1p++;
    }
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

TilesUnitTest

)

Unit test for the Tiles class.

Definition at line 33 of file TilesUnitTest.cpp.

                                    {

    // iterate over the devices
    const torc::common::DeviceVector& devices = torc::common::Devices::getUnitTestDevices();
    torc::common::DeviceVector::const_iterator dp = devices.begin();
    torc::common::DeviceVector::const_iterator de = devices.end();
    while(dp < de) {
        const std::string& device = *dp++;
        if(device.empty()) break;
        DDB ddb(device);
        testDeviceTiles(ddb);
    }

}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

DDBStreamHelperUnitTest

)

Unit test for the DDBStreamHelper class.

Definition at line 33 of file DDBStreamHelperUnitTest.cpp.

                                              {
    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const class DDB& ddb);
    //      static const class DDB* getDDBPtr(std::ostream& os);
    DDB ddb("xc2vp2");
    std::stringstream s;
    s << ddb;
    BOOST_CHECK(DDBStreamHelper::getDDBPtr(s) == &ddb);

    // functions tested:
    //      std::ostream& operator <<(std::ostream& os, const DDB& ddb);
    //      std::ostream& operator <<(std::ostream& os, const Tilewire& rhs);
    s << ddb << Tilewire(TileIndex(1), WireIndex(0));
    BOOST_CHECK_EQUAL(s.str(), "CNR_TBTERM_N6A1@[0,1] CNR_TTERM \"LIOITTERM\" (0@1)");
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

XdlImporterUnitTest

)

Unit test for the device-aware XdlImporter class.

Definition at line 34 of file architecture/XdlImporterUnitTest.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.generated.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 ...)
    torc::physical::DesignSharedPtr designPtr = importer.getDesignPtr();
    BOOST_REQUIRE(designPtr.get() != 0);
    BOOST_REQUIRE(false); // we haven't actually tested anything yet
    BOOST_TEST_MESSAGE("Need to fix XdlImporter::bind(torc::physical::Pip& inPip, EPipType inPipType) and XDL design regression test files for directionality of pips.");

    // look up the device database (and do something with it ...)
    DDB* ddbPtr = importer.releaseDDBPtr();
    (void) ddbPtr;
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

SitesUnitTest

)

Unit test for the Sites class.

Todo:

Write a unit test for torc::architecture::Sites.

Definition at line 35 of file SitesUnitTest.cpp.

                                    {
/*
    typedef boost::bimap< boost::bimaps::multiset_of<std::string>, boost::bimaps::multiset_of<std::string> > bm_type;
    bm_type bm;

    bm.insert( bm_type::value_type( "SLICEL", "SLICEL" ) );
    bm.insert( bm_type::value_type( "SLICEL", "SLICEM" ) );
    bm.insert( bm_type::value_type( "SLICEM", "SLICEM" ) );

    bm.insert( bm_type::value_type( "BUFG", "BUFGCTRL" ) );
    bm.insert( bm_type::value_type( "BUFGCTRL", "BUFGCTRL" ) );

    bm.insert( bm_type::value_type( "IOBS", "IOBS" ) );
    bm.insert( bm_type::value_type( "IOB", "IOBS" ) );
    bm.insert( bm_type::value_type( "IOB", "IOBM" ) );
    bm.insert( bm_type::value_type( "IOBM", "IOBM" ) );

    bm.upper_bound("IOBS");

    BOOST_CHECK(bm.size() == 9);
    assert( bm.size() == 9 );
*/
    /// \todo Write a unit test for torc::architecture::Sites.
    BOOST_REQUIRE(false);

}

torc::architecture::BOOST_AUTO_TEST_CASE

(

iterate_configmaps

)

Unit test to iterate through the ConfigMaps of a XDL file.

Definition at line 44 of file SiteTypesUnitTest.cpp.

                                         {

    using namespace torc::physical;

    // create the appropriate file paths                                                                
    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());
    XdlImporter importer;
    
    importer(fileStream, referencePath.string());

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

    Circuit::InstanceSharedPtrConstIterator p = designPtr->instancesBegin();
    Circuit::InstanceSharedPtrConstIterator e = designPtr->instancesEnd();

    while(p < e) { 
        InstanceSharedPtr instancePtr = *p++;
        std::cout << "Instance:" << instancePtr->getName() << std::endl;
        ConfigMap::const_iterator cp = instancePtr->configBegin();
        ConfigMap::const_iterator ce = instancePtr->configEnd();
        while(cp != ce) {   
            std::cout << "\tConfig:" << cp->first << "---->" << cp->second.getName() << ":" << cp->second.getValue() << std::endl;
            cp++;
        }
    }
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

DDBUnitTest

)

Unit test for the DDB class.

Definition at line 87 of file DDBUnitTest.cpp.

                                  {
    // iterate over the devices
    const torc::common::DeviceVector& devices = torc::common::Devices::getUnitTestDevices();
    torc::common::DeviceVector::const_iterator dp = devices.begin();
    torc::common::DeviceVector::const_iterator de = devices.end();
    while(dp < de) {
        const std::string& device = *dp++;
        if(device.empty()) break;
        testDevice(device);
    }
}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

classify_elements

)

Unit test to iterate through a database and classify all existing elements into pseudo-types.

Map of all elements.

Map of all terminals.

Map of all switches.

Map of all orphans.

Map of all muxes.

Map of all inverters.

Map of all luts.

Map of all flops.

Map of all main elements.

Map of all main elements.

Map of all main elements.

Map of all main elements.

Map of all elements.

Capture the 'main' elements.

Definition at line 128 of file SiteTypesUnitTest.cpp.

                                       {  
//xc6vhx380t xc5vlx30 xc4vfx60 xc6slx9l xc2vp40 xc2v40 xc3s250e
    
    // open and initialize a database  
    DDB ddb("xc5vlx30");  
    // look up the logic sites in the device  
    const Sites& sites = ddb.getSites();  

    // look up the primitive def types  
    typedef const Array<const PrimitiveDef> PrimitiveDefArray;  
    PrimitiveDefArray& primitiveDefs = sites.getSiteTypes();  
    PrimitiveDefArray::const_iterator p = primitiveDefs.begin();  
    PrimitiveDefArray::const_iterator e = primitiveDefs.end();

    /// \brief Map of all elements.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllElements;
    AllElements allElements;
    /// \brief Map of all terminals.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllTerminals;
    AllTerminals allTerminals;
    /// \brief Map of all switches.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllSwitches;
    AllSwitches allSwitches;
    /// \brief Map of all orphans.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllOrphans;
    AllOrphans allOrphans;
    /// \brief Map of all muxes.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllMuxes;
    AllMuxes allMuxes;
    /// \brief Map of all inverters.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllInverters;
    AllInverters allInverters;
    /// \brief Map of all luts.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllLuts;
    AllLuts allLuts;
    /// \brief Map of all flops.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllFlops;
    AllFlops allFlops;
    /// \brief Map of all main elements.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllMains;
    AllMains allMains;
    /// \brief Map of all main elements.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllAnds;
    AllAnds allAnds;
    /// \brief Map of all main elements.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllVccs;
    AllVccs allVccs;
    /// \brief Map of all main elements.                                                          
    typedef std::map<std::string, PrimitiveElement*> AllGnds;
    AllGnds allGnds;

    //int i = 0;  
    // iterate over the primitive defs  
    while(p < e) {    
    // look up the current primitive def    
        const PrimitiveDef& primitiveDef = *p++;    
        //std::cout << "Inside Primitive Def:" << primitiveDef.getName() << std::endl << std::endl;
        typedef const Array<const PrimitivePin> PrimitivePinArray;
        // look up the primitive def pins
        const PrimitivePinArray& primitivePins = primitiveDef.getPins();
        PrimitivePinArray::const_iterator sp = primitivePins.begin();
        PrimitivePinArray::const_iterator se = primitivePins.end();
        const PrimitivePin primitivePin;
        // keep a track of all the primitive pins (to find the main elements, we need to compare elements with site pins)
        std::vector<std::string> primitivePinNames; 
        std::vector<std::string>::const_iterator spe = unique(primitivePinNames.begin(), primitivePinNames.end());
        (void) spe;

        // iterate over the primitive def pins
        if(primitivePins.getSize() > 0) {
          //std::cout << "    ";
            while(sp < se) {
                const PrimitivePin& primitivePin = *sp++;
                primitivePinNames.push_back(primitivePin.getName());          
            }
            //std::cout << std::endl;
        }

        // look up the primitive def elements    
        const PrimitiveElementArray& elements = primitiveDef.getElements();    
        PrimitiveElementArray::const_iterator ep = elements.begin();    
        PrimitiveElementArray::const_iterator ee = elements.end();    
        
        
        // iterate over the primitive def elements    
        if(elements.getSize() > 0) {      
            while(ep < ee) {    
                const PrimitiveElement& element = *ep++;    

                //std::cout << "Inside ELEMENT NAME:" << element.getName() << std::endl;
                /// \brief Map of all elements.                                                          
                allElements[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 

                /// \brief Capture the 'main' elements.                                                 
                if(primitiveDef.getName() == element.getName()){ 
                    //std::cout << "\tMAIN element:" << element.getName() << std::endl;
                    allMains[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }                   
                //typedef const Array<const Sites::ElementPin> ElementPinArray; 
                const PrimitiveElementPinArray& elementPins = element.getPins();    
                PrimitiveElementPinArray::const_iterator pp = elementPins.begin();  
                PrimitiveElementPinArray::const_iterator pe = elementPins.end();

                //Count input pins of Muxes/Invs    
                int countPins = 0;  
                int isINV = 0;  
                std::string cfgValue;
                int totalPinCount = 0;          
                int cfgSize = 0;
                int notEmpty = 0;
                int isLUT = 0;
                int isFF = 0;
                int isVCC = 0;
                int isGND = 0;
                int isAND = 0;

                std::vector<std::string> elementPinNames;   
                std::vector<std::string>::const_iterator ppe = unique(elementPinNames.begin(), elementPinNames.end());
                (void) ppe;
    
                //Iterate through Element PINS  
                while(pp < pe) {      
                    const PrimitiveElementPin& elementPin = *pp++;    
                    //(void) elementPin;
          
                    //Check if the pin is an Input pin    
                    if(elementPin.isInput() == 1){      
                        typedef std::set<std::string> StringSet;        
                        const StringSet elementCfgs = element.getCfgs();        
                        StringSet::const_iterator cp = elementCfgs.begin();     
                        StringSet::const_iterator ce = elementCfgs.end();
                
                        //Iterate through the Cfgs      
                        while(cp != ce){
          
                            const std::string& isit = *cp++;          
                            //Check if the pin names and cfgs match           
                            if(elementPin.getName() == isit){       
                                if(findINV(isit) == 1){       
                                    elementPinNames.push_back(elementPin.getName());          
                                    isINV = 1;        
                                    countPins++;        
                                }else{        
                                    elementPinNames.push_back(elementPin.getName());          
                                    countPins++;        
                                }
                                break;
                            }
                            cfgValue = isit;
                            //trying to check if the # of cgfs and # of element pins match
                            cfgSize = elementCfgs.size();
                            if(!elementCfgs.empty()) notEmpty = 1;
                                if(findLUTbyCfg(isit) == 1){
                                isLUT = 1;
                            }else if(findFFbyCfg(isit) == 1){
                                isFF = 1;
                            }                                                     
                        }
                    }
                    if((findVCC(element.getName()) == 1) && (elementPin.getName() == "1")){
                        isVCC = 1;
                    }else if((findGND(element.getName()) == 1) && (elementPin.getName() == "0")){
                        isGND = 1;
                    }else if((findAND(element.getName()) == 1) && ((elementPin.getName() == "0") || (elementPin.getName() == "1"))){
                        isAND = 1;
                    }
                    totalPinCount++;
                }   
                
                    if(countPins > 0) {             
                //If the pin names and cfgs match, it is a MUX (or INV)                 
                    if(countPins == 1){
                        //std::cout << "\tSWITCH: " << element.getName() << "    "; //std::endl;
                        allMuxes[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allSwitches[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allElements.erase(element.getName());
                        }else if(isINV == 1){       
                        //std::cout << "\tINV: " << element.getName() << "    ";
                        allMuxes[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allInverters[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allElements.erase(element.getName());
                    }else if(isINV == 0){       
                        //std::cout << "\tMUX: " << element.getName() << "    ";        
                        allMuxes[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allElements.erase(element.getName());
                    }         
                    //std::cout << countPins << "    "; // << std::endl;      
                    //print the PINs that are matched with cfg within that element    
                    for(std::vector<std::string>::const_iterator b = elementPinNames.begin(); b != elementPinNames.end(); b++) {        
                        //std::cout << *b << "    ";        
                    }
                    // check if the number of pins is equal to the number of cfgs 
                    if(notEmpty == 1){
                        if(countPins != cfgSize) throw 0;
                    }

                }else if(isLUT == 1){
                    //std::cout << "\tLUT: " << element.getName() << std::endl;//"    ";
                    allLuts[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }else if(isFF == 1){
                    //std::cout << "\tFLOP: " << element.getName() << std::endl;//"    ";
                    allFlops[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());      
                }
                if(totalPinCount == 0){
                    //std::cout << "\tORPHAN:" << element.getName() <<std::endl;
                    allOrphans[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }
                if(findROUTETHROUGH(element.getName()) == 1){
                    //std::cout << "ROUTETHROUGH FOUND! ---- d e l e t i n g !" << std::endl;
                    allElements.erase(element.getName());
                }
                if(isAND == 1){//if(findAND(element.getName()) == 1){
                    allAnds[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }
                if(isVCC == 1){
                    allVccs[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }
                if(isGND == 1){
                    allGnds[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                    allElements.erase(element.getName());
                }
                for(std::vector<std::string>::const_iterator s = primitivePinNames.begin(); s != primitivePinNames.end(); s++) {        
                    if(element.getName() == *s){
                        //std::cout << "\tTERMINAL:" << element.getName() << std::endl;
                        allTerminals[element.getName()] = const_cast <PrimitiveElement*>(&element); //element.getName(); 
                        allElements.erase(element.getName());
                        break;
                    }
                }
            }
        }
        
        //std::cout << "-----------------------------------------------------------" <<std::endl;           
        //std::cout << std::endl;   
    }
    std::map<std::string, PrimitiveElement*>::const_iterator pos;
    std::cout << "------ UNCLASSIFIED ELEMENTS -------" <<std::endl;
    for(pos = allElements.begin(); pos != allElements.end(); ++pos) {
        std::cout << "Element: " << pos->first << std::endl;// "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ MUXES -------" <<std::endl;
    for(pos = allMuxes.begin(); pos != allMuxes.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ LUTS -------" <<std::endl;
    for(pos = allLuts.begin(); pos != allLuts.end(); ++pos) {
            std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }   
    std::cout << std::endl;
    std::cout << "------ FLOPS -------" <<std::endl;
    for(pos = allFlops.begin(); pos != allFlops.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ TERMINALS -------" <<std::endl;
    for(pos = allTerminals.begin(); pos != allTerminals.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ SWITCHES -------" <<std::endl;
    for(pos = allSwitches.begin(); pos != allSwitches.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ ANDS -------" <<std::endl;
    for(pos = allAnds.begin(); pos != allAnds.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
    std::cout << std::endl;
    std::cout << "------ VCCS -------" <<std::endl;
    for(pos = allVccs.begin(); pos != allVccs.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }
        std::cout << std::endl;
    std::cout << "------ GNDS -------" <<std::endl;
    for(pos = allGnds.begin(); pos != allGnds.end(); ++pos) {
        std::cout << "Element: " << pos->first  << std::endl; //<< "    ";
        //std::cout << "Value:" << pos->second << std::endl;
    }


}    

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

SegmentsRegressionTest

)

Regression test for the Segments class.

Definition at line 221 of file SegmentsRegressionTest.cpp.

                                             {

    // iterate over the devices
    const torc::common::DeviceVector& devices = torc::common::Devices::getSupportedDevices();
    torc::common::DeviceVector::const_iterator dp = devices.begin();
    torc::common::DeviceVector::const_iterator de = devices.end();
    while(dp < de) {
        const std::string& device = *dp++;
        if(device.empty()) break;
        DDB ddb(device);
        std::cerr << ddb;
        segments_regression_test_helper segmentTester(ddb);
        segmentTester();
    }
    segments_regression_test_helper::statistics();

}

Here is the call graph for this function:

torc::architecture::BOOST_AUTO_TEST_CASE

(

SiteTypesUnitTest

)

Unit test for the SiteTypes class.

Definition at line 436 of file SiteTypesUnitTest.cpp.

                                        {

        // open and initialize a database
        DDB ddb("xc5vlx30");
        // look up the logic sites in the device
        const Sites& sites = ddb.getSites();
        // look up the primitive def types
        typedef const Array<const PrimitiveDef> PrimitiveDefArray;
        PrimitiveDefArray& primitiveDefs = sites.getSiteTypes();
        PrimitiveDefArray::const_iterator p = primitiveDefs.begin();
        PrimitiveDefArray::const_iterator e = primitiveDefs.end();
        int i = 0;
        // iterate over the primitive defs
    while(p < e) {
        // look up the current primitive def
        const PrimitiveDef& primitiveDef = *p++;
        std::cout << i << ": " << primitiveDef.getName() << std::endl;
        typedef const Array<const PrimitivePin> PrimitivePinArray;
        // look up the primitive def pins
        const PrimitivePinArray& primitivePins = primitiveDef.getPins();
        PrimitivePinArray::const_iterator sp = primitivePins.begin();
        PrimitivePinArray::const_iterator se = primitivePins.end();
        // iterate over the primitive def pins
        if(false && primitivePins.getSize() > 0) {
            std::cout << "    ";
            // output each of the pin names along with the flags (2-INPUT, 4-OUTPUT)
            while(sp < se) {
                const PrimitivePin& primitivePin = *sp++;
                std::cout << primitivePin.getName() << " ";
                std::cout << primitivePin.getFlags() << " ";
            }
            std::cout << std::endl;
        }
        // look up the primitive def elements
        
        const PrimitiveElementArray& elements = primitiveDef.getElements();
        PrimitiveElementArray::const_iterator ep = elements.begin();
        PrimitiveElementArray::const_iterator ee = elements.end();
        // iterate over the primitive def elements
        if(true && elements.getSize() > 0) {
            // output each of the element names and if the pin is a basic element
            while(ep < ee) {
                const PrimitiveElement& element = *ep++;
                std::cout << "ELEMENT NAME:" << element.getName() << " "<< std::endl;
                //std::cout << "    ";
                //std::cout<< "ELEMENT IS Basic ELement:" << element.isBel() << " " << std::endl;
                
                const PrimitiveElementPinArray& elementPins = element.getPins();
                PrimitiveElementPinArray::const_iterator pp = elementPins.begin();
                PrimitiveElementPinArray::const_iterator pe = elementPins.end();
                // iterate over the element pins
                if(elementPins.getSize()> 0) {
                    
                    // output each of the element pin names along with the element flags (2-Input, 4-Output)
                    while(pp < pe) {
                    //  std::cout << "    ";
                        const PrimitiveElementPin& elementPin = *pp++;
                        std::cout << elementPin.getElementPtr()->getName() << "." << elementPin.getName() << " ";
                        //std::cout << ((elementPin.getElement()->getName() == element.getName()) 
                                             //? "" : (elementPin.getElement()->getName() + " "));
                        //std::cout<< "ELEMENT PIN NAME:" << elementPin.getName() << " " << std::endl;
                        //std::cout << "    ";
                        //std::cout<< "ELEMENT FLAG NAME:" << elementPin.getFlags() << " " << std::endl;
                        // typedef std::set<std::string> StringSet;
                        // const StringSet elementCfgs = element.getCfgs();
                        // StringSet::const_iterator cp = elementCfgs.begin();
                        // StringSet::const_iterator ce = elementCfgs.end();
                        // // iterate over the configs
                        // if(elementCfgs.size() != 0){
                        //  // output each of the configs
                        //  while(cp != ce){
                        //          std::cout << "    ";
                                                //                 std::cout << "CONFIG NAME: " << *cp << " " << std::endl;
                        //      *cp++;
                        //  }
                        // }
                    }
                    std::cout << std::endl;
                }
            }
            std::cout << std::endl;
        }
        const PrimitiveConnSharedPtrArray& connections = primitiveDef.getConnections();
        PrimitiveConnSharedPtrArray::const_iterator ccp = connections.begin();
        PrimitiveConnSharedPtrArray::const_iterator cce = connections.end();
        // iterate over the primitive element connections
        while(true && ccp < cce) {
            const PrimitiveConn& connection = *(*ccp++);
            const PrimitiveElementPin& source = *connection.getSourcePtr();
            const PrimitiveElementPinPtrVector& sinks = connection.getSinks();
            std::cout << source.getElementPtr()->getName() << "." << source.getName() << " ==> ";
            PrimitiveElementPinPtrVector::const_iterator epp = sinks.begin();
            PrimitiveElementPinPtrVector::const_iterator epe = sinks.end();
            while(epp < epe) {
                const PrimitiveElementPin& sink = **epp++;
                std::cout << sink.getElementPtr()->getName() << "." << sink.getName() << " ";
            }
            std::cout << std::endl;
        }
        i++;
    }
    BOOST_REQUIRE(true);
    
}

Here is the call graph for this function:

bool torc::architecture::findAND

(

const std::string

isit

)

Definition at line 107 of file SiteTypesUnitTest.cpp.

{
        static const boost::regex e("^.*AND.*");
    return regex_match(isit, e);
}

Here is the caller graph for this function:

bool torc::architecture::findFFbyCfg

(

const std::string

isit

)

Definition at line 89 of file SiteTypesUnitTest.cpp.

{    
    static const boost::regex e("(^#(FF|LATCH)$)");    
    return regex_match(isit, e);  
}

Here is the caller graph for this function:

bool torc::architecture::findGND

(

const std::string

isit

)

Definition at line 119 of file SiteTypesUnitTest.cpp.

{
        static const boost::regex e("^.*GND$");
    return regex_match(isit, e);
}

Here is the caller graph for this function:

bool torc::architecture::findINV

(

const std::string

isit

)

Definition at line 95 of file SiteTypesUnitTest.cpp.

{
        static const boost::regex e("^.*_B$");
    return regex_match(isit, e);
}

Here is the caller graph for this function:

bool torc::architecture::findLUTbyCfg

(

const std::string

isit

)

Definition at line 83 of file SiteTypesUnitTest.cpp.

{    
    static const boost::regex e("(^(<eqn>)|((#LUT:|#RAM:|#ROM:)<eqn>)$)");    
    return regex_match(isit, e);  
}

Here is the caller graph for this function:

bool torc::architecture::findROUTETHROUGH

(

const std::string

isit

)

Definition at line 101 of file SiteTypesUnitTest.cpp.

{
        static const boost::regex e("^_ROUTETHROUGH.*");
    return regex_match(isit, e);
}

Here is the caller graph for this function:

bool torc::architecture::findVCC

(

const std::string

isit

)

Definition at line 113 of file SiteTypesUnitTest.cpp.

{
        static const boost::regex e("^.*VCC$");
    return regex_match(isit, e);
}

Here is the caller graph for this function:

std::size_t torc::architecture::hash_value

(

const Arc &

inArc

)

Definition at line 25 of file Arc.cpp.

                                           {
        std::size_t seed = 0;
        boost::hash_combine(seed, inArc.getSourceTilewire());
        boost::hash_combine(seed, inArc.getSinkTilewire());
        return seed;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

std::size_t torc::architecture::hash_value

(

const Tilewire &

inTilewire

)

Definition at line 27 of file Tilewire.cpp.

                                                     {
        std::size_t seed = 0;
        boost::hash_combine(seed, inTilewire.getTileIndex());
        boost::hash_combine(seed, inTilewire.getWireIndex());
        return seed;
    }

Here is the call graph for this function:

std::ostream& torc::architecture::operator<<	(	std::ostream &	os,
		const DDB &	ddb
	)

Definition at line 27 of file DDBStreamHelper.cpp.

                                                            {
        // check to see whether there is an existing database association for this stream
        typedef std::map<std::ostream*, const class DDB*> OStreamToDDBMap;
        OStreamToDDBMap::const_iterator p = DDBStreamHelper::sStreamToDatabase.find(&os);       
        if(p == DDBStreamHelper::sStreamToDatabase.end()) {
            // if no association exists, create a new association between the stream and database
            std::pair<OStreamToDDBMap::iterator, bool> inserted
                = DDBStreamHelper::sStreamToDatabase.insert(std::make_pair(&os, &ddb));
            p = inserted.first; // implicitly assuming that insertion always succeeds
        }
        return os;
    }

std::ostream & torc::architecture::operator<<	(	std::ostream &	os,
		const Tilewire &	rhs
	)

Tilewire stream inserter.

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

                                                                 {
        const DDB* ddbPtr = DDBStreamHelper::getDDBPtr(os);
        if(ddbPtr) {
            // the database is available: look up the extended tilewire information
            os << ExtendedWireInfo(*ddbPtr, rhs);
        } else {
            // the database is not available: write out the basic tilewire information
            os << rhs.getWireIndex() << "@" << rhs.getTileIndex();
        }
        return os;
    }

Here is the call graph for this function:

std::ostream & torc::architecture::operator<<	(	std::ostream &	os,
		const ExtendedWireInfo &	rhs
	)

ExtendedWireInfo stream inserter.

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

                                                                         {
        // handle uninitialized wire info
        if(rhs.mTileIndex.isUndefined()) return os << "[UNINITIALIZED]";

        // handle regular wire info
        return os << rhs.mWireName << "@[" << rhs.mTileRow << "," << rhs.mTileCol << "] " 
            << rhs.mTileTypeName << " \"" << rhs.mTileName << "\" (" << rhs.mWireIndex << "@" 
            << rhs.mTileIndex << ")"
            << (WireInfo::isHidden(rhs.mWireFlags) ? " HIDDEN" : "")
            << (WireInfo::isInput(rhs.mWireFlags) ? " INPUT" : "")
            << (WireInfo::isOutput(rhs.mWireFlags) ? " OUTPUT" : "")
            << (WireInfo::isRemote(rhs.mWireFlags) ? " REMOTE" : "")
            << (WireInfo::isRemoteNodeCapable(rhs.mWireFlags) ? " REMOTE_NODE_CAPABLE" : "")
            << (WireInfo::isRemoteArcCapable(rhs.mWireFlags) ? " REMOTE_ARC_CAPABLE" : "")
            ;
    }

Here is the call graph for this function:

std::ostream & torc::architecture::operator<<	(	std::ostream &	os,
		const Arc &	rhs
	)

Arc stream inserter.

Definition at line 60 of file architecture/OutputStreamHelpers.cpp.

                                                            {
        return os << rhs.getSourceTilewire() << " >> " << rhs.getSinkTilewire();
    }

Here is the call graph for this function:

std::ostream& torc::architecture::operator<<	(	std::ostream &	os,
		const class DDB &	ddb
	)

Insertion operator to associate the given device database with the given stream.

This operator does not generate any stream output, but instead associates the given device database with the stream. This allows lightweight objects such as tilewires to decorate their output with database information, without including a database reference.

void torc::architecture::testDevice

(

const std::string &

inDeviceName

)

Definition at line 37 of file DDBUnitTest.cpp.

                                               {
    // functions not tested:
    // (note: some of these functions are tested in their respective classes)
    //      const string& getFamilyName(void) const;
    //      const Segments& getSegments(void) const;
    //      const WireUsage& getWireUsage(void) const;
    //      const ArcUsage& getArcUsage(void) const;
    //      void clearUsage(void);

    // functions tested:
    //      DDB(const string& inDeviceName);
    DDB ddb(inDeviceName);

    // functions tested:
    //      const string& getDeviceName(void) const;
    BOOST_CHECK_EQUAL(ddb.getDeviceName(), inDeviceName);

    // for now this test merely opens representative device databases; regression tests are 
    // performed elsewhere
    if(true) return;

    // functions tested:
    //      const Tiles& getTiles(void) const;
    std::map<TileTypeIndex, int> tileTypeMap;
    const Tiles& tiles = ddb.getTiles();
    TileCount tileCount = tiles.getTileCount();
    for(TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
        const TileInfo& tileInfo = tiles.getTileInfo(tileIndex);
        TileTypeIndex tileTypeIndex = tileInfo.getTypeIndex();
        const std::string& tileTypeName = tiles.getTileTypeName(tileTypeIndex);
        tileTypeMap[tileTypeIndex] = 0;
        (void) tileTypeName;
    }
    std::cout << tileTypeMap.size() << " tile types" << std::endl;

    // functions tested
    //      const Sites& getSites(void) const;
    std::map<std::string, int> siteTypeMap;
    const Sites& sites = ddb.getSites();
    SiteCount siteCount = sites.getSiteCount();
    for(SiteIndex siteIndex; siteIndex < siteCount; siteIndex++) {
        const Site& site = sites.getSite(siteIndex);
        const std::string& siteTypeName = site.getPrimitiveDefPtr()->getName();
        siteTypeMap[siteTypeName] = 0;
    }
    std::cout << ddb;
    std::cout << siteTypeMap.size() << " site types" << std::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::architecture::testDeviceTiles

(

DDB &

inDDB

)

Definition at line 48 of file TilesUnitTest.cpp.

                                 {
    // functions tested during database initialization and deletion:
    //      Tiles(void);
    //      ~Tiles(void);
    //      size_t readTileTypes(DigestStream& inStream);
    //      size_t readTileWireInfo(DigestStream& inStream);
    //      size_t readTileMap(DigestStream& inStream);
    const Tiles& tiles = inDDB.getTiles();

    // functions tested:
    //      TileTypeCount getTileTypeCount(void) const;
    // members tested:
    //      TileTypeCount mTileTypeCount;
    xilinx::TileTypeCount tileTypeCount = tiles.getTileTypeCount();
    if(tileTypeCount == xilinx::TileTypeCount(0)) // to reduce output
        BOOST_CHECK(tileTypeCount != 0);

    // functions tested:
    //      const char* getTileTypeName(TileTypeIndex inTileTypeIndex) const;
    // members tested:
    //      Array<const CharStringWrapper> mTileTypeNames;
    for(xilinx::TileTypeIndex tileTypeIndex; tileTypeIndex < tileTypeCount; tileTypeIndex++) {
        const char* tileTypeName = tiles.getTileTypeName(tileTypeIndex);
        if(*tileTypeName == 0) // to reduce output
            BOOST_CHECK(*tileTypeName != 0);
    }

    // functions tested:
    //      TileCount getTileCount(void) const;
    //      TileRow getRowCount(void) const;
    //      TileCol getColCount(void) const;
    // members tested:
    //      TileCount mTileCount;
    //      TileRow mRowCount;
    //      TileCol mColCount;
    xilinx::TileCount tileCount = tiles.getTileCount();
    xilinx::TileRow rowCount = tiles.getRowCount();
    xilinx::TileCol colCount = tiles.getColCount();
    if(tileCount == xilinx::TileCount(0)) // to reduce output
        BOOST_CHECK(tileCount != 0);
    if(rowCount == xilinx::TileRow(0)) // to reduce output
        BOOST_CHECK(rowCount != 0);
    if(colCount == xilinx::TileCol(0)) // to reduce output
        BOOST_CHECK(colCount != 0);
    if(static_cast<int>(tileCount) != rowCount * colCount) // to reduce output
        BOOST_CHECK_EQUAL(static_cast<int>(tileCount), rowCount * colCount);

    // functions tested:
    //      const TileInfo& getTileInfo(TileIndex inTileIndex) const;
    //      TileIndex getTileIndex(TileRow inRow, TileCol inCol) const;
    //      TileIndex findTileIndex(const string& inName) const;
    //      static bool CompareTilePairByName(const TileNameIndexPair& inA, 
    //          const TileNameIndexPair& inB);
    // members tested:
    //      TileIndex** mTileMap;
    //      Array<const TileInfo> mTiles;
    //      Array<const TileNameIndexPair> mOrderedTileNames;
    for(xilinx::TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
        // look up the tile info
        const TileInfo& tileInfo = tiles.getTileInfo(tileIndex);
        // verify that tile indexes and coordinates are consistent
        xilinx::TileRow tileRow = tileInfo.getRow();
        xilinx::TileCol tileCol = tileInfo.getCol();
        const char* tileName = tileInfo.getName();
        if(*tileName == 0) // to reduce output
            BOOST_CHECK(*tileName != 0);
        xilinx::TileIndex rowColTileIndex = tiles.getTileIndex(tileRow, tileCol);
        if(tileIndex != rowColTileIndex) // to reduce output
            BOOST_CHECK_EQUAL(tileIndex, rowColTileIndex);
        xilinx::TileIndex findTileIndex = tiles.findTileIndex(tileName);
        if(tileIndex != findTileIndex) // to reduce output
            BOOST_CHECK_EQUAL(tileIndex, findTileIndex);
    }

    // functions tested:
    //      const Array<const WireInfo>& getWireInfo(TileTypeIndex inTileTypeIndex) const;
    //      const WireInfo& getWireInfo(TileTypeIndex inTileTypeIndex, WireIndex inWireIndex) const;
    //      static bool CompareWirePairByName(const WireNameIndexPair& inA, 
    //          const WireNameIndexPair& inB);
    //      WireIndex findWireIndex(TileTypeIndex inTileTypeIndex, const string& inName) const;
    // members tested:
    //      Array2D<const WireInfo> mWires;
    //      Array2D<const WireNameIndexPair> mOrderedWireNames;
    for(xilinx::TileTypeIndex tileTypeIndex; tileTypeIndex < tileTypeCount; tileTypeIndex++) {
    // verify that wire indexes are consistent
        xilinx::WireCount wireCount = tiles.getWireCount(tileTypeIndex);
        const Array<const WireInfo>& wireInfoArray = tiles.getWireInfo(tileTypeIndex);
        for(xilinx::WireIndex wireIndex; wireIndex < wireCount; wireIndex++) {
            const WireInfo& wireInfo = tiles.getWireInfo(tileTypeIndex, wireIndex);
            if(&wireInfo != &wireInfoArray[wireIndex]) // to reduce output
                BOOST_CHECK(&wireInfo == &wireInfoArray[wireIndex]);
            const char* wireName = wireInfo.getName();
            if(*wireName == 0) // to reduce output
                BOOST_CHECK(*wireName != 0);
            xilinx::WireIndex findWireIndex = tiles.findWireIndex(tileTypeIndex, wireName);
            if(wireIndex != findWireIndex) // to reduce output
                BOOST_CHECK_EQUAL(wireIndex, findWireIndex);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: