torc::architecture::segments_unit_test_helper Class Reference

Collaboration diagram for torc::architecture::segments_unit_test_helper:

Public Member Functions
	segments_unit_test_helper (DDB &inDDB)
	Basic constructor. More...
void	operator() (void)
	Analyze segment expansion, and detect any tilewire conflicts. More...
void	analyzeSegmentTilewire (const Tilewire &inTilewire)
	Verifies and enforces segment ownership of the specified tilewire. More...

Static Public Member Functions
static void	statistics (void)
	Outputs statistics on segment expansion. More...

Private Types
typedef xilinx::TileCount	TileCount
typedef xilinx::TileIndex	TileIndex
typedef xilinx::TileTypeIndex	TileTypeIndex
typedef xilinx::WireCount	WireCount
typedef xilinx::WireIndex	WireIndex
typedef Segments::SegmentReference	SegmentReference
typedef xilinx::CompactSegmentIndex	CompactSegmentIndex
typedef boost::uint64_t	uint64_t

Private Attributes
DDB &	mDDB
const Tiles &	mTiles
const Segments &	mSegments
std::map< Tilewire, CompactSegmentIndex >	mUsage
const CompactSegmentIndex	cUsagePruned
const CompactSegmentIndex	cUsageUndefined
uint64_t	mTilewireCount
uint64_t	mTilewiresAnalyzed
uint64_t	mTilewiresPruned
uint64_t	mTilewiresUndefined

Static Private Attributes
static uint64_t	sTotalTilewireCount = 0
	Total number of tilewires visited. More...
static uint64_t	sTotalTilewiresAnalyzed = 0
	Total number of tilewires analyzed (visited or expanded). More...
static uint64_t	sTotalTilewiresPruned = 0
	Total number of tilewires pruned from the device (absent from XDLRC). More...
static uint64_t	sTotalTilewiresUndefined = 0
	Total number of tilewires never defined (sanity check). More...

Detailed Description

Definition at line 50 of file SegmentsUnitTest.cpp.

Member Typedef Documentation

typedef xilinx::CompactSegmentIndex torc::architecture::segments_unit_test_helper::CompactSegmentIndex

private

Definition at line 57 of file SegmentsUnitTest.cpp.

typedef Segments::SegmentReference torc::architecture::segments_unit_test_helper::SegmentReference

private

Definition at line 56 of file SegmentsUnitTest.cpp.

typedef xilinx::TileCount torc::architecture::segments_unit_test_helper::TileCount

private

Definition at line 51 of file SegmentsUnitTest.cpp.

typedef xilinx::TileIndex torc::architecture::segments_unit_test_helper::TileIndex

private

Definition at line 52 of file SegmentsUnitTest.cpp.

typedef xilinx::TileTypeIndex torc::architecture::segments_unit_test_helper::TileTypeIndex

private

Definition at line 53 of file SegmentsUnitTest.cpp.

typedef boost::uint64_t torc::architecture::segments_unit_test_helper::uint64_t

private

Definition at line 58 of file SegmentsUnitTest.cpp.

typedef xilinx::WireCount torc::architecture::segments_unit_test_helper::WireCount

private

Definition at line 54 of file SegmentsUnitTest.cpp.

typedef xilinx::WireIndex torc::architecture::segments_unit_test_helper::WireIndex

private

Definition at line 55 of file SegmentsUnitTest.cpp.

Constructor & Destructor Documentation

torc::architecture::segments_unit_test_helper::segments_unit_test_helper ( DDB &  inDDB )

inline

Basic constructor.

Definition at line 75 of file SegmentsUnitTest.cpp.

                                          : mDDB(inDDB), mTiles(mDDB.getTiles()), 
        mSegments(mDDB.getSegments()), 
        cUsagePruned(CompactSegmentIndex(CompactSegmentIndex::undefined())), 
        cUsageUndefined(CompactSegmentIndex(static_cast<boost::uint32_t>(-2))), mTilewireCount(0), 
        mTilewiresAnalyzed(0), mTilewiresPruned(0), mTilewiresUndefined(0) {
        // functions tested during database initialization and deletion:
        //      Segments(void);
        //      size_t readTilewireSegments(DigestStream& inStream);
        //      size_t readSegments(DigestStream& inStream);
        //      size_t readIrregularArcs(DigestStream& inStream);
    }

Member Function Documentation

void torc::architecture::segments_unit_test_helper::analyzeSegmentTilewire ( const Tilewire &  inTilewire )

inline

Verifies and enforces segment ownership of the specified tilewire.

Definition at line 185 of file SegmentsUnitTest.cpp.

                                                            {
        mTilewiresAnalyzed++;
        // extract the tilewire information
        TileIndex tileIndex = inTilewire.getTileIndex();
        WireIndex wireIndex = inTilewire.getWireIndex();
        const Array<SegmentReference>& tilewireSegments = mSegments.mTilewireSegments[tileIndex];
        // look up the segment reference information
        const SegmentReference& segmentReference = tilewireSegments[wireIndex];
        CompactSegmentIndex compactSegmentIndex = segmentReference.getCompactSegmentIndex();
        TileIndex anchorTileIndex = segmentReference.getAnchorTileIndex();
        (void) anchorTileIndex;
        // look up the current tilewire membership
        CompactSegmentIndex usageCompactSegmentIndex = mUsage[inTilewire];
        if(compactSegmentIndex == usageCompactSegmentIndex) {
            // there has been no change
            //std::cerr << "Match: " << static_cast<int>(compactSegmentIndex) << " for " 
            //  << inTilewire << std::endl;
        } else if(usageCompactSegmentIndex == cUsageUndefined) {
            // this wire was not previously defined, so we accept the new value
            mUsage[inTilewire] = compactSegmentIndex;
            //std::cerr << "Definition: " << static_cast<int>(compactSegmentIndex) << " for " 
            //  << inTilewire << std::endl;
        } else {
            std::cerr << "Mismatch (" << static_cast<int>(compactSegmentIndex) << " vs. " 
                << static_cast<int>(usageCompactSegmentIndex) << ") for " << inTilewire 
                << std::endl;
            BOOST_CHECK_EQUAL(static_cast<int>(compactSegmentIndex), 
                static_cast<int>(usageCompactSegmentIndex));
        }
    }

Here is the call graph for this function:

void torc::architecture::segments_unit_test_helper::operator() ( void  )

inline

Analyze segment expansion, and detect any tilewire conflicts.

Definition at line 99 of file SegmentsUnitTest.cpp.

                           {
        // functions tested:
        //      const Segments::SegmentReference& getTilewireSegment(const Tilewire& inTilewire);
        TileCount tileCount = mTiles.getTileCount();
        mUsage.clear();
//      int totalTrivialCount = 0;
//      int totalDefinedCount = 0;
//      for(TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
//          const TileInfo& tileInfo = mTiles.getTileInfo(tileIndex);
//          TileTypeIndex tileTypeIndex = tileInfo.getTypeIndex();
//          WireCount wireCount = mTiles.getWireCount(tileTypeIndex);
//          for(WireIndex wireIndex; wireIndex < wireCount; wireIndex++) {
//              Tilewire tilewire(tileIndex, wireIndex);
//              const SegmentReference& segmentReference 
//                  = mSegments.getTilewireSegment(tilewire);
//              if(segmentReference.isDefined()) { totalDefinedCount++; continue; }
//              if(segmentReference.isTrivial()) { totalTrivialCount++; continue; }
//              // this segment is real, so we want to track things
//          }
//      }
        //std::cerr << "totalTrivialCount: " << totalTrivialCount << std::endl;
        //std::cerr << "totalDefinedCount: " << totalDefinedCount << std::endl;
        //BOOST_CHECK_EQUAL(totalWireCount, mSegments.getTotalWireCount());

        // clear the usage information for all tilewires
        for(TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
            const Array<SegmentReference>& tilewireSegments 
                = mSegments.mTilewireSegments[tileIndex];
            WireCount wireCount = WireCount(tilewireSegments.getSize());
            for(WireIndex wireIndex; wireIndex < wireCount; wireIndex++) {
                Tilewire tilewire(tileIndex, wireIndex);
                mUsage[tilewire] = cUsageUndefined;
                mTilewireCount++;
            }
        }

        // iterate through all tilewires and look for any conflicting segment ownership
        for(TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
            const Array<SegmentReference>& tilewireSegments 
                = mSegments.mTilewireSegments[tileIndex];
            WireCount wireCount = WireCount(tilewireSegments.getSize());
            for(WireIndex wireIndex; wireIndex < wireCount; wireIndex++) {
                Tilewire tilewire(tileIndex, wireIndex);
                analyzeSegmentTilewire(tilewire);
                TilewireVector segmentTilewires;
                mDDB.expandSegment(tilewire, segmentTilewires, DDB::eExpandDirectionNone);
                TilewireVector::const_iterator p = segmentTilewires.begin();
                TilewireVector::const_iterator e = segmentTilewires.end();
                while(p < e) {
                    analyzeSegmentTilewire(*p++);
                }
            }
        }

        // look for any tilewires without segment definitions
        for(TileIndex tileIndex; tileIndex < tileCount; tileIndex++) {
            const Array<SegmentReference>& tilewireSegments 
                = mSegments.mTilewireSegments[tileIndex];
            WireCount wireCount = WireCount(tilewireSegments.getSize());
            for(WireIndex wireIndex; wireIndex < wireCount; wireIndex++) {
                Tilewire tilewire(tileIndex, wireIndex);
                CompactSegmentIndex usage = mUsage[tilewire];
                if(usage == cUsageUndefined) {
                    mTilewiresUndefined++;
                    std::cerr << "Undefined: " << tilewire << std::endl;
                    BOOST_CHECK(mUsage[tilewire] != cUsageUndefined);
                } else if(usage == cUsagePruned) {
                    mTilewiresPruned++;
                }
            }
        }
        std::cerr << "---------------------------------------" << std::endl;
        std::cerr << "Tilewire count:            " << std::setw(12) << mTilewireCount 
            << std::endl;
        std::cerr << "Tilewires analyzed:        " << std::setw(12) << mTilewiresAnalyzed 
            << std::endl;
        std::cerr << "Tilewires pruned:          " << std::setw(12) << mTilewiresPruned 
            << std::endl;
        std::cerr << "Tilewires undefined:       " << std::setw(12) << mTilewiresUndefined 
            << std::endl;
        sTotalTilewireCount += mTilewireCount;
        sTotalTilewiresAnalyzed += mTilewiresAnalyzed;
        sTotalTilewiresPruned += mTilewiresPruned;
        sTotalTilewiresUndefined += mTilewiresUndefined;
    }

Here is the call graph for this function:

static void torc::architecture::segments_unit_test_helper::statistics ( void  )

inlinestatic

Outputs statistics on segment expansion.

Definition at line 87 of file SegmentsUnitTest.cpp.

                                 {
        std::cerr << "=======================================" << std::endl;
        std::cerr << "Total tilewire count:      " << std::setw(12) << sTotalTilewireCount 
            << std::endl;
        std::cerr << "Total tilewires analyzed:  " << std::setw(12) << sTotalTilewiresAnalyzed 
            << std::endl;
        std::cerr << "Total tilewires pruned:    " << std::setw(12) << sTotalTilewiresPruned 
            << std::endl;
        std::cerr << "Total tilewires undefined: " << std::setw(12) << sTotalTilewiresUndefined 
            << std::endl;
    }

Field Documentation

const CompactSegmentIndex torc::architecture::segments_unit_test_helper::cUsagePruned

private

Definition at line 63 of file SegmentsUnitTest.cpp.

const CompactSegmentIndex torc::architecture::segments_unit_test_helper::cUsageUndefined

private

Definition at line 64 of file SegmentsUnitTest.cpp.

DDB& torc::architecture::segments_unit_test_helper::mDDB

private

Definition at line 59 of file SegmentsUnitTest.cpp.

const Segments& torc::architecture::segments_unit_test_helper::mSegments

private

Definition at line 61 of file SegmentsUnitTest.cpp.

const Tiles& torc::architecture::segments_unit_test_helper::mTiles

private

Definition at line 60 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::mTilewireCount

private

Definition at line 65 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::mTilewiresAnalyzed

private

Definition at line 66 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::mTilewiresPruned

private

Definition at line 67 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::mTilewiresUndefined

private

Definition at line 68 of file SegmentsUnitTest.cpp.

std::map<Tilewire, CompactSegmentIndex> torc::architecture::segments_unit_test_helper::mUsage

private

Definition at line 62 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::sTotalTilewireCount = 0

staticprivate

Total number of tilewires visited.

Definition at line 69 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::sTotalTilewiresAnalyzed = 0

staticprivate

Total number of tilewires analyzed (visited or expanded).

Definition at line 70 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::sTotalTilewiresPruned = 0

staticprivate

Total number of tilewires pruned from the device (absent from XDLRC).

Definition at line 71 of file SegmentsUnitTest.cpp.

uint64_t torc::architecture::segments_unit_test_helper::sTotalTilewiresUndefined = 0

staticprivate

Total number of tilewires never defined (sanity check).

Definition at line 72 of file SegmentsUnitTest.cpp.

---

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

• SegmentsUnitTest.cpp