torc::architecture::ArcUsage Class Reference

Encapsulation the design arc usage. More...

#include <ArcUsage.hpp>

Collaboration diagram for torc::architecture::ArcUsage:

Public Member Functions
	ArcUsage (const Tiles &inTiles)
	Public constructor. More...
	~ArcUsage (void)
	Non-virtual destructor. More...
void	autosize (void)
	Size the wire usage according to the number of device tiles. More...
void	use (const Arc &inArc)
	Marks the specified arc as being used. More...
void	use (const Tilewire &inTilewire1, const Tilewire &inTilewire2)
	Marks the specified arc as being used. More...
void	release (const Arc &inArc)
	Marks the specified arc as being unused. More...
void	release (const Tilewire &inTilewire1, const Tilewire &inTilewire2)
	Marks the specified arc as being unused. More...
void	clear (void)
	Marks all arcs as being unused, without releasing the bitset objects. More...
bool	isUsed (const Arc &inArc)
	Determines whether the specified arc is in use. More...
bool	isUsed (const Tilewire &inTilewire1, const Tilewire &inTilewire2) const
	Determines whether the specified arc is in use. More...
uint32_t	getArcUsageCount (void) const
	Returns the number of arcs in use. More...
TileCount	getTileUsageCount (void) const
	Returns the number of tiles that have been touched. More...
uint32_t	getBitCount (void) const
	Returns the number of bits allocated. More...

Protected Types
typedef boost::dynamic_bitset	dynamic_bitset
	Imported type name. More...
typedef xilinx::TileIndex	TileIndex
	Imported type name. More...
typedef xilinx::TileCount	TileCount
	Imported type name. More...
typedef xilinx::TileTypeIndex	TileTypeIndex
	Imported type name. More...
typedef xilinx::WireIndex	WireIndex
	Imported type name. More...

Protected Member Functions
uint32_t	getArcOffset (const Tilewire &inTilewire1, const Tilewire &inTilewire2) const
	Returns the offset into the bitset for the specified arc. More...

Protected Attributes
const Tiles &	mTiles
	Reference to the database Tiles object. More...
TileCount	mTileUsageCount
	The number of tiles for which bitsets are allocated. More...
Array< dynamic_bitset * >	mBitsets
	The wire usage bitset array. More...
uint32_t	mBitCount
	The number of bits allocated by the usage bitsets. More...
dynamic_bitset	mTileDirty
	The mask of tile bitsets that contain changes. More...

Friends
class	torc::architecture::architecture::ArcUsageUnitTest
	Our unit test class has access to our internals. More...

Detailed Description

Encapsulation the design arc usage.

This class uses a compact bitset representation to very efficiently track the arc usage of a design in an entire device. Internal bitset objects are maintained on a per-tile basis, and are not allocated until at least one arc in the tile has been marked used.

Definition at line 38 of file ArcUsage.hpp.

Member Typedef Documentation

typedef boost::dynamic_bitset torc::architecture::ArcUsage::dynamic_bitset

protected

Imported type name.

Definition at line 43 of file ArcUsage.hpp.

typedef xilinx::TileCount torc::architecture::ArcUsage::TileCount

protected

Imported type name.

Definition at line 45 of file ArcUsage.hpp.

typedef xilinx::TileIndex torc::architecture::ArcUsage::TileIndex

protected

Imported type name.

Definition at line 44 of file ArcUsage.hpp.

typedef xilinx::TileTypeIndex torc::architecture::ArcUsage::TileTypeIndex

protected

Imported type name.

Definition at line 46 of file ArcUsage.hpp.

typedef xilinx::WireIndex torc::architecture::ArcUsage::WireIndex

protected

Imported type name.

Definition at line 47 of file ArcUsage.hpp.

Constructor & Destructor Documentation

torc::architecture::ArcUsage::ArcUsage ( const Tiles &  inTiles )

inline

Public constructor.

Definition at line 109 of file ArcUsage.hpp.

                                       : mTiles(inTiles), mTileUsageCount(), mBitsets(0), 
            mBitCount(0), mTileDirty(0) {}

torc::architecture::ArcUsage::~ArcUsage ( void  )

inline

Non-virtual destructor.

Definition at line 112 of file ArcUsage.hpp.

                        {
            size_t tileCount = mBitsets.getSize();
            for(TileIndex i; i < tileCount; i++) {
                if(mBitsets[i] != 0) { delete mBitsets[i]; mBitsets[i] = 0; }
            }
        }

Here is the call graph for this function:

Member Function Documentation

void torc::architecture::ArcUsage::autosize ( void  )

inline

Size the wire usage according to the number of device tiles.

Definition at line 120 of file ArcUsage.hpp.

                            {
            // release any existing bitsets
            for(TileCount i; i < mBitsets.getSize(); i++) {
                if(mBitsets[i] != 0) { delete mBitsets[i]; mBitsets[i] = 0; }
                mTileDirty.reset(i);
            }
            // resize for the new dimensions
            TileCount tileCount = mTiles.getTileCount();
            mBitsets.setSize(tileCount);
            for(TileCount i; i < tileCount; i++) mBitsets[i] = 0;
            mTileDirty.resize(tileCount);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::architecture::ArcUsage::clear ( void  )

inline

Marks all arcs as being unused, without releasing the bitset objects.

This capability allows the tracer to track the wires that it has visited while processing a particular net, and then to start again from scratch without incurring allocation and construction overheads.

Definition at line 192 of file ArcUsage.hpp.

                         {
            // iterate over all of the tiles
            size_t tileCount = mBitsets.getSize();
            for(TileIndex i; i < tileCount; i++) {
                // skip this tile if it isn't dirty
                if(!mTileDirty[i]) continue;
                // mark the tile clean
                mTileDirty.reset(i);
                // look up the bitset for this tile
                dynamic_bitset* bitset = mBitsets[i];
                // skip tiles without an associated bitset (should never happen for dirty tiles)
                if(bitset == 0) continue;
                // clear the entire bitset
                bitset->reset();
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t torc::architecture::ArcUsage::getArcOffset ( const Tilewire &  inTilewire1, const Tilewire &  inTilewire2  ) const

inlineprotected

Returns the offset into the bitset for the specified arc.

Note

The ordering of regular, irregular, routethrough, and tied sinks does not matter as long as it is consistent. The only impact comes from the likelihood of access for the different types, where more common ones ought to be visited first.

Todo:

Throw a meaningful exception.

Definition at line 64 of file ArcUsage.hpp.

                                                                                              {
            // first make sure the arc is defined
            if(inTilewire1.isUndefined() || inTilewire2.isUndefined()) 
                throw InvalidArcException(Arc(inTilewire1, inTilewire2));
            // look up the relevant tile and wire indexes
            TileIndex tile1 = inTilewire1.getTileIndex();
            WireIndex wire1 = inTilewire1.getWireIndex();
            WireIndex wire2 = inTilewire2.getWireIndex();
            // determine the tile type
            const TileInfo& tileInfo = mTiles.getTileInfo(tile1);
            TileTypeIndex type = tileInfo.getTypeIndex();
            // next get the wire's base arc offset
            const WireInfo& wireInfo = mTiles.getWireInfo(type, wire1);
            uint32_t offset = wireInfo.getArcOffset();
            // look for a regular sink
            const WireArray& sinks = wireInfo.getSinks();
            for(WireIndex i; i < sinks.getSize(); i++) {
                if(sinks[i] == wire2) return offset;
                offset++;
            }
            // look for an irregular sink
            const WireArray& irregularSinks = wireInfo.getIrregularSinks();
            for(WireIndex i; i < irregularSinks.getSize(); i++) {
                if(irregularSinks[i] == wire2) return offset;
                offset++;
            }
            // look for a routethrough sink
            const WireArray& routethroughSinks = wireInfo.getRoutethroughSinks();
            for(WireIndex i; i < routethroughSinks.getSize(); i++) {
                if(routethroughSinks[i] == wire2) return offset;
                offset++;
            }
            // look for a tied sink
            const WireArray& tiedSinks = wireInfo.getTiedSinks();
            for(WireIndex i; i < tiedSinks.getSize(); i++) {
                if(tiedSinks[i] == wire2) return offset;
                offset++;
            }
            // if we didn't find the sink in the regular or irregular arcs, the call failed
            /// \todo Throw a meaningful exception.
            throw InvalidArcException(Arc(inTilewire1, inTilewire2));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t torc::architecture::ArcUsage::getArcUsageCount ( void  ) const

inline

Returns the number of arcs in use.

Todo:

Question: can we get away with only checking dirty bitsets? / skip this tile if it isn't dirty

Definition at line 228 of file ArcUsage.hpp.

                                              {
            uint32_t usageCount = 0;
            size_t tileCount = mBitsets.getSize();
            for(TileIndex i; i < tileCount; i++) {
                /// \todo Question: can we get away with only checking dirty bitsets?
                //// skip this tile if it isn't dirty
                //if(!mTileDirty[i]) continue;
                // look up the bitset for this tile
                dynamic_bitset* bitset = mBitsets[i];
                // skip tiles without an associated bitset
                if(bitset == 0) continue;
                // clear the entire bitset
                usageCount += bitset->count();
            }
            return usageCount;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t torc::architecture::ArcUsage::getBitCount ( void  ) const

inline

Returns the number of bits allocated.

Definition at line 248 of file ArcUsage.hpp.

{ return mBitCount; }

Here is the caller graph for this function:

TileCount torc::architecture::ArcUsage::getTileUsageCount ( void  ) const

inline

Returns the number of tiles that have been touched.

Definition at line 246 of file ArcUsage.hpp.

{ return mTileUsageCount; }

Here is the caller graph for this function:

bool torc::architecture::ArcUsage::isUsed ( const Arc &  inArc )

inline

Determines whether the specified arc is in use.

Definition at line 209 of file ArcUsage.hpp.

            { return isUsed(inArc.getSourceTilewire(), inArc.getSinkTilewire()); }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::architecture::ArcUsage::isUsed ( const Tilewire &  inTilewire1, const Tilewire &  inTilewire2  ) const

inline

Determines whether the specified arc is in use.

Todo:

Throw a meaningful exception.

Definition at line 212 of file ArcUsage.hpp.

                                                                                    {
            // extract the tile indexes
            TileIndex tileIndex1 = inTilewire1.getTileIndex();
            TileIndex tileIndex2 = inTilewire2.getTileIndex();
            // ensure that these tilewires belong to the same tile
            /// \todo Throw a meaningful exception.
            if(tileIndex1 != tileIndex2) throw -1;

            // if there is no entry for the tile, the tilewire is already implicitly unused.
            dynamic_bitset* bitset = mBitsets[tileIndex1];
            if(bitset == 0) return false;

            // otherwise, interrogate the bit
            return bitset->test(getArcOffset(inTilewire1, inTilewire2));
        }

Here is the call graph for this function:

void torc::architecture::ArcUsage::release ( const Arc &  inArc )

inline

Marks the specified arc as being unused.

Definition at line 169 of file ArcUsage.hpp.

            { release(inArc.getSourceTilewire(), inArc.getSinkTilewire()); }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::architecture::ArcUsage::release ( const Tilewire &  inTilewire1, const Tilewire &  inTilewire2  )

inline

Marks the specified arc as being unused.

Todo:

Throw a meaningful exception.

Definition at line 172 of file ArcUsage.hpp.

                                                                               {
            // extract the tile indexes
            TileIndex tileIndex1 = inTilewire1.getTileIndex();
            TileIndex tileIndex2 = inTilewire2.getTileIndex();
            // ensure that these tilewires belong to the same tile
            /// \todo Throw a meaningful exception.
            if(tileIndex1 != tileIndex2) throw -1;

            // if there is no entry for the tile, the arc is already implicitly unused.
            dynamic_bitset* bitset = mBitsets[tileIndex1];
            if(bitset == 0) return;

            // otherwise clear the bit and mark the tile dirty
            bitset->set(getArcOffset(inTilewire1, inTilewire2), false);
            mTileDirty.set(tileIndex1, true);
        }

Here is the call graph for this function:

void torc::architecture::ArcUsage::use ( const Arc &  inArc )

inline

Marks the specified arc as being used.

Definition at line 133 of file ArcUsage.hpp.

            { use(inArc.getSourceTilewire(), inArc.getSinkTilewire()); }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::architecture::ArcUsage::use ( const Tilewire &  inTilewire1, const Tilewire &  inTilewire2  )

inline

Marks the specified arc as being used.

Todo:

Throw a meaningful exception.

Definition at line 136 of file ArcUsage.hpp.

                                                                           {
            // extract the tile indexes
            TileIndex tileIndex1 = inTilewire1.getTileIndex();
            TileIndex tileIndex2 = inTilewire2.getTileIndex();
            // ensure that these tilewires belong to the same tile
            /// \todo Throw a meaningful exception.
            if(tileIndex1 != tileIndex2) throw InvalidArcException(Arc(inTilewire1, inTilewire2));

            // make sure we have a bitset for this tile
            dynamic_bitset* bitset = mBitsets[tileIndex1];
            if(bitset == 0) {
                // determine how many arcs are in this tile
                const TileInfo& tileInfo = mTiles.getTileInfo(tileIndex1);
                TileTypeIndex type = tileInfo.getTypeIndex();
                const Array<const WireInfo>& wires = mTiles.getWireInfo(type);
                if(wires.getSize() == 0) return;
                const WireInfo& wireInfo = mTiles.getWireInfo(type, WireIndex(wires.getSize() - 1));
                // caution: we have to add the regular and irregular sink count from the last wire
                size_t size = wireInfo.getArcOffset() + wireInfo.getSinks().getSize() 
                    + wireInfo.getIrregularSinks().getSize() 
                    + wireInfo.getRoutethroughSinks().getSize()
                    + wireInfo.getTiedSinks().getSize();
                bitset = mBitsets[tileIndex1] = new dynamic_bitset(size);
                // track the statistics
                mTileUsageCount++;
                mBitCount += size;
            }

            // set the bit and mark the tile dirty
            bitset->set(getArcOffset(inTilewire1, inTilewire2));
            mTileDirty.set(tileIndex1, true);
        }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class torc::architecture::architecture::ArcUsageUnitTest

friend

Our unit test class has access to our internals.

Definition at line 40 of file ArcUsage.hpp.

Field Documentation

uint32_t torc::architecture::ArcUsage::mBitCount

protected

The number of bits allocated by the usage bitsets.

Definition at line 56 of file ArcUsage.hpp.

Array<dynamic_bitset*> torc::architecture::ArcUsage::mBitsets

protected

The wire usage bitset array.

Definition at line 54 of file ArcUsage.hpp.

dynamic_bitset torc::architecture::ArcUsage::mTileDirty

protected

The mask of tile bitsets that contain changes.

Definition at line 58 of file ArcUsage.hpp.

const Tiles& torc::architecture::ArcUsage::mTiles

protected

Reference to the database Tiles object.

Definition at line 50 of file ArcUsage.hpp.

TileCount torc::architecture::ArcUsage::mTileUsageCount

protected

The number of tiles for which bitsets are allocated.

Definition at line 52 of file ArcUsage.hpp.

---

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

• ArcUsage.hpp