torc::router::Trace Class Reference

Provides path extraction from usage information in a DDB instance.. More...

#include <Trace.hpp>

Collaboration diagram for torc::router::Trace:

Public Types
enum	ETraceMode {   eTraceFullNet = 0, eTraceToSinks, eTraceToBranch, eTraceToSources,   eTraceSinglePath }
	Enumeration for Trace modes. More...

Public Member Functions
	Trace (DDB &inDB, Tilewire inTilewire, ETraceMode inTraceMode=eTraceFullNet)
	Public Constructor. More...
	~Trace ()
	Destructor. More...
TraceNodePtrVector &	getSinks ()
	Get trace sink nodes. More...
TraceNodePtrVector &	getSources ()
	Get trace source nodes. More...
TraceNodePtrVector &	getBranchPoints ()
	Get trace branch point nodes. More...
ArcVector &	getArcs ()
	Get all Arcs found during the trace. More...

Protected Member Functions
void	traceWorker (TraceNode *inNode, ETraceMode inMode)
	Recursively traces from the specified TraceNode in the specified mode. More...
void	normalizeDepth (TraceNode *inNode)
	Normalize depth of nodes. More...
TraceNode *	createNode (Tilewire inTilewire)
	Create a TraceNode and update auxiliary structures. More...
TraceNode *	getNode (Tilewire inTilewire)
	Get a TraceNode based on its owning Tilewire. More...
Arc	findArc (TraceNode *source, TraceNode *sink)
	Find a traced Arc from the nodes that it connects. More...

Protected Attributes
DDB &	mDB
	Database reference. More...
ArcUsage &	mArcUsage
	ArcUsage reference. More...
TraceNode *	mInitialNode
	TraceNode representing the starting point for this trace. More...
TraceNodePtrVector	mSinks
	Vector of net sink nodes. More...
TraceNodePtrVector	mSources
	Vector of net source nodes. More...
TraceNodePtrVector	mBranchPoints
	Vector of net branch nodes. More...
TraceNodePtrVector	mAllNodes
	Vector of all TraceNode pointers. More...
std::map< Tilewire, TraceNode * >	mTilewireToTraceNode
	Map of Tilewires to owning TraceNode. More...
std::map< TraceNode *, std::map< TraceNode *, Arc > >	mTraceNodesToArc
	Map of TraceNode pointers to Arc that connects them. More...
ArcVector	mArcVector
	Vector of all arcs, populated on a getArcs call. More...

Private Types
typedef architecture::DDB	DDB
	Imported type name. More...
typedef architecture::ArcUsage	ArcUsage
typedef architecture::Tilewire	Tilewire
typedef architecture::Arc	Arc
typedef architecture::TilewireVector	TilewireVector
typedef architecture::ArcVector	ArcVector

Detailed Description

Provides path extraction from usage information in a DDB instance..

The tracer provides functions that recover a set of connected routing resources to build up complete or partial nets from the device usage information.

Definition at line 36 of file Trace.hpp.

Member Typedef Documentation

typedef architecture::Arc torc::router::Trace::Arc

private

Definition at line 42 of file Trace.hpp.

typedef architecture::ArcUsage torc::router::Trace::ArcUsage

private

Definition at line 40 of file Trace.hpp.

typedef architecture::ArcVector torc::router::Trace::ArcVector

private

Definition at line 44 of file Trace.hpp.

typedef architecture::DDB torc::router::Trace::DDB

private

Imported type name.

Definition at line 39 of file Trace.hpp.

typedef architecture::Tilewire torc::router::Trace::Tilewire

private

Definition at line 41 of file Trace.hpp.

typedef architecture::TilewireVector torc::router::Trace::TilewireVector

private

Definition at line 43 of file Trace.hpp.

Member Enumeration Documentation

enum torc::router::Trace::ETraceMode

Enumeration for Trace modes.

Enumerator
eTraceFullNet
eTraceToSinks
eTraceToBranch
eTraceToSources
eTraceSinglePath

Definition at line 72 of file Trace.hpp.

                        { eTraceFullNet = 0, eTraceToSinks, eTraceToBranch, 
            eTraceToSources, eTraceSinglePath };

Constructor & Destructor Documentation

torc::router::Trace::Trace ( DDB &  inDB, Tilewire  inTilewire, ETraceMode  inTraceMode = eTraceFullNet  )

inline

Public Constructor.

Definition at line 78 of file Trace.hpp.

            : mDB(inDB), mArcUsage(inDB.getArcUsage()) {
            mInitialNode = createNode(inTilewire);
            switch (inTraceMode) {
                case eTraceFullNet:
                case eTraceToSinks:
                case eTraceToBranch:
                case eTraceToSources:
                case eTraceSinglePath:
                    break;
                default:
                    std::cout << "Invalid Trace mode setting." << std::endl;
                    return;
            }
            traceWorker(mInitialNode, inTraceMode);
        }

Here is the call graph for this function:

torc::router::Trace::~Trace ( )

inline

Destructor.

Definition at line 95 of file Trace.hpp.

                 {
            std::cout << "Destroying Trace!" << std::endl;
            TraceNodePtrVector::iterator p;
            TraceNodePtrVector::iterator e = mAllNodes.end();
            for (p = mAllNodes.begin(); p != e; p++) {
                delete *p;
            }
            mAllNodes.clear();
            mSinks.clear();
            mSources.clear();
            mBranchPoints.clear();
            //delete mInitialNode;
        }

Member Function Documentation

TraceNode* torc::router::Trace::createNode ( Tilewire  inTilewire )

inlineprotected

Create a TraceNode and update auxiliary structures.

Definition at line 319 of file Trace.hpp.

                                                   {
            std::map<Tilewire, TraceNode*>::iterator it;
            it = mTilewireToTraceNode.find(inTilewire);
            if (it != mTilewireToTraceNode.end()) {
                return 0;
            }
            TilewireVector segmentTilewires;
            mDB.expandSegment(inTilewire, segmentTilewires);
            TraceNode* newNode = new TraceNode(inTilewire);
            mAllNodes.push_back(newNode);
            for (unsigned int i = 0; i < segmentTilewires.size(); i++) {
                mTilewireToTraceNode.insert(
                    std::pair<Tilewire, TraceNode*>(segmentTilewires[i], newNode));
            }
            return newNode;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Arc torc::router::Trace::findArc ( TraceNode *  source, TraceNode *  sink  )

inlineprotected

Find a traced Arc from the nodes that it connects.

Definition at line 346 of file Trace.hpp.

                                                        {
            // returns the Arc connecting the two nodes if the arc exists.
            std::map<TraceNode*, std::map<TraceNode*, Arc> >::iterator outer_p;
            std::map<TraceNode*, std::map<TraceNode*, Arc> >::iterator outer_end;
            std::map<TraceNode*, Arc>::iterator inner_p;
            std::map<TraceNode*, Arc>::iterator inner_end;
            outer_end = mTraceNodesToArc.end();
            outer_p = mTraceNodesToArc.find(source);
            if (outer_p != outer_end) {
                std::map<TraceNode*, Arc> innermap = outer_p->second;
                inner_end = innermap.end();
                inner_p = innermap.find(sink);
                if (inner_p != inner_end) {
                    return inner_p->second;
                }
            }
            return Arc();
        }

Here is the caller graph for this function:

ArcVector& torc::router::Trace::getArcs ( )

inline

Get all Arcs found during the trace.

Definition at line 121 of file Trace.hpp.

                             {
            mArcVector.clear();
            std::map<TraceNode*, std::map<TraceNode*, Arc> >::iterator outer_p;
            std::map<TraceNode*, std::map<TraceNode*, Arc> >::iterator outer_end;
            std::map<TraceNode*, Arc>::iterator inner_p;
            std::map<TraceNode*, Arc>::iterator inner_end;
            outer_end = mTraceNodesToArc.end();
            for (outer_p = mTraceNodesToArc.begin(); outer_p != outer_end; outer_p++) {
                std::map<TraceNode*, Arc> innermap = outer_p->second;
                inner_end = innermap.end();
                for (inner_p = innermap.begin(); inner_p != inner_end; inner_p++) {
                    mArcVector.push_back(inner_p->second);
                    //std::cout << mArcVector.back() << std::endl;
                }
            }
            //std::cout << mArcVector.size() << std::endl;
            return mArcVector;
        }

Here is the caller graph for this function:

TraceNodePtrVector& torc::router::Trace::getBranchPoints ( )

inline

Get trace branch point nodes.

Definition at line 117 of file Trace.hpp.

                                              {
            return mBranchPoints;
        }

Here is the caller graph for this function:

TraceNode* torc::router::Trace::getNode ( Tilewire  inTilewire )

inlineprotected

Get a TraceNode based on its owning Tilewire.

Definition at line 336 of file Trace.hpp.

                                                {
            std::map<Tilewire, TraceNode*>::iterator it;
            it = mTilewireToTraceNode.find(inTilewire);
            if (it == mTilewireToTraceNode.end()) {
                return 0;
            } else {
                return it->second;
            }
        }

Here is the caller graph for this function:

TraceNodePtrVector& torc::router::Trace::getSinks ( )

inline

Get trace sink nodes.

Definition at line 109 of file Trace.hpp.

                                       {
            return mSinks;
        }

Here is the caller graph for this function:

TraceNodePtrVector& torc::router::Trace::getSources ( )

inline

Get trace source nodes.

Definition at line 113 of file Trace.hpp.

                                         {
            return mSources;
        }

Here is the caller graph for this function:

void torc::router::Trace::normalizeDepth ( TraceNode *  inNode )

inlineprotected

Normalize depth of nodes.

Definition at line 270 of file Trace.hpp.

                                               {
            TraceNode::TraceNodePtrVector parents;
            TraceNode::TraceNodePtrList wavefront;
            TraceNode* node;
            std::set<Tilewire> nodesVisited;
            
            // not needed anymore since we save sources
            //findTop(parents, inNode);
            
            for (unsigned int i = 0; i < parents.size(); i++) {
                parents[i]->setDepth(0);
                std::cout << "PARENT " << parents[i]->getTilewire() << std::endl;
                nodesVisited.insert(parents[i]->getTilewire());
                for (unsigned int j = 0; j < parents[i]->getNumChildren(); j++) {
                    wavefront.push_back(parents[i]->getChild(j));
                }
            }
            while (wavefront.size() != 0) {
                node = wavefront.front();
                wavefront.pop_front();
                
                Tilewire tw = node->getTilewire();
                if (nodesVisited.find(tw) == nodesVisited.end()) {
                    nodesVisited.insert(node->getTilewire());
                } else {
                    std::cout << "Already visited " << tw << std::endl;
                }
                
                if (node->getNumParents() == 0) {
                    std::cout << "SOURCE NODE" << std::endl;
                    node->setDepth(0);
                } else {
                    for (unsigned int i = 0; i < node->getNumParents(); i++) {
                        std::cout << "PARENT DEPTH " << node->getParent(i)->getDepth() << std::endl;
                        if (node->getParent(i)->getDepth() + 1 > node->getDepth()) {
                            node->setDepth(node->getParent(i)->getDepth() + 1);
                        }
                    }
                }
                if (node->getNumChildren() == 0) {
                    std::cout << "SINK NODE" << std::endl;
                }
                for (unsigned int i = 0; i < node->getNumChildren(); i++) {
                        wavefront.push_back(node->getChild(i));
                }
            }
            
        }

Here is the call graph for this function:

void torc::router::Trace::traceWorker ( TraceNode *  inNode, ETraceMode  inMode  )

inlineprotected

Recursively traces from the specified TraceNode in the specified mode.

Definition at line 141 of file Trace.hpp.

                                                               {
            TraceNodePtrVector activeArcs;
            
            //std::cout << "\t## traceWorker ## " << inNode->getTilewire() << std::endl;
            
            ArcVector outArcs;
            ArcVector inArcs;
            TraceNodePtrVector activeSinks;
            TraceNodePtrVector activeSources;
            Tilewire nodeTilewire = inNode->getTilewire();
            
            unsigned int childCount = 0;
            unsigned int parentCount = 0;
            mDB.expandSegmentSinks(nodeTilewire, outArcs);
            for (unsigned int i = 0 ; i < outArcs.size(); i++) {
                if (mArcUsage.isUsed(outArcs[i]))
                    childCount++;
            }
            mDB.expandSegmentSources(nodeTilewire, inArcs);
            for (unsigned int i = 0; i < inArcs.size(); i++) {
                if (mArcUsage.isUsed(inArcs[i]))
                    parentCount++;
            }
            bool isBranch;
            if (childCount == 0) {
                mSinks.push_back(inNode);
                std::cout << "FOUND A SINK NODE: " << nodeTilewire << std::endl;
            }
            if (parentCount == 0) {
                mSources.push_back(inNode);
                std::cout << "FOUND A SOURCE NODE: " << nodeTilewire << std::endl;
            }
            if (childCount > 1 || parentCount > 1) {
                mBranchPoints.push_back(inNode);
                std::cout << "FOUND A BRANCH NODE: " << nodeTilewire
                    << " children: " << childCount << " parents: " << parentCount << std::endl;
                isBranch = true;
            } else {
                isBranch = false;
            }
            if (childCount == 1 && parentCount == 1) {
                //std::cout << "NODE: " << inNode->getTilewire() << std::endl;
            }
            
            // mode selection
            bool traceSinks = inMode != eTraceToSources;
            bool traceSources = inMode != eTraceToSinks;
            if (inMode == eTraceToBranch || inMode == eTraceSinglePath) {
                traceSinks = !isBranch;
            }
            if (inMode == eTraceToBranch || inMode == eTraceSinglePath) {
                traceSources = !isBranch;
            }
            
            // node creation
            if (traceSinks) { // only trace to sources doesn't look at sinks
                for (unsigned int i = 0; i < outArcs.size(); i++) {
                    const Tilewire& sinkTilewire = outArcs[i].getSinkTilewire();
                    // if the arc is used we need to check this out
                    if (mArcUsage.isUsed(outArcs[i])) {
                        //std::cout << "\tOUT ARC USED " << outArcs[i] << std::endl;
                        // get the node
                        TraceNode* arcNode = getNode(sinkTilewire);
                        if (arcNode == 0) {
                            // node doesn't exist, create it
                            arcNode = createNode(sinkTilewire);
                            // store it for traversal
                            activeSinks.push_back(arcNode);
                        }
                        if (findArc(inNode, arcNode) == Arc()) {
                            // arc does not exist so add it
                            inNode->addChild(arcNode);
                            arcNode->addParent(inNode);
                        } else {
                            // arc already traversed, don't do it again
                            continue;
                        }
                        // record this arc in the trace
                        mTraceNodesToArc[inNode][arcNode] = outArcs[i];
                    }
                }
            }
            if (traceSources) { // only trace to sinks doesn't look at sources
                for (unsigned int i = 0; i < inArcs.size(); i++) {
                    const Tilewire& sourceTilewire = inArcs[i].getSourceTilewire();
                    // if the arc is used we need to check this out
                    if (mArcUsage.isUsed(inArcs[i])) {
                        //std::cout << "\tIN ARC USED " << inArcs[i] << std::endl;
                        // get the node
                        TraceNode* arcNode = getNode(sourceTilewire);
                        if (arcNode == 0) {
                            // node doesn't exist, create it
                            arcNode = createNode(sourceTilewire);
                            // store it for traversal
                            activeSources.push_back(arcNode);
                        }
                        if (findArc(arcNode, inNode) == Arc()) {
                            // arc does not exist so add it
                            arcNode->addChild(inNode);
                            inNode->addParent(arcNode);
                        } else {
                            // arc already traversed, don't do it again
                            continue;
                        }
                        // record this arc in the trace
                        mTraceNodesToArc[arcNode][inNode] = inArcs[i];
                    }
                }
            }
            
            // recursive calls
            if (traceSinks) {
                for (unsigned int i = 0; i < activeSinks.size(); i++) {
                    if (inMode == eTraceToBranch)
                        traceWorker(activeSinks[i], eTraceToSinks);
                    else
                        traceWorker(activeSinks[i], inMode);
                }
            }
            if (traceSources) { // only trace to sinks doesn't look at sources
                for (unsigned int i = 0; i < activeSources.size(); i++) {
                    traceWorker(activeSources[i], inMode);
                }
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

TraceNodePtrVector torc::router::Trace::mAllNodes

protected

Vector of all TraceNode pointers.

Definition at line 62 of file Trace.hpp.

ArcUsage& torc::router::Trace::mArcUsage

protected

ArcUsage reference.

Definition at line 50 of file Trace.hpp.

ArcVector torc::router::Trace::mArcVector

protected

Vector of all arcs, populated on a getArcs call.

Definition at line 68 of file Trace.hpp.

TraceNodePtrVector torc::router::Trace::mBranchPoints

protected

Vector of net branch nodes.

Definition at line 59 of file Trace.hpp.

DDB& torc::router::Trace::mDB

protected

Database reference.

Definition at line 48 of file Trace.hpp.

TraceNode* torc::router::Trace::mInitialNode

protected

TraceNode representing the starting point for this trace.

Definition at line 53 of file Trace.hpp.

TraceNodePtrVector torc::router::Trace::mSinks

protected

Vector of net sink nodes.

Definition at line 55 of file Trace.hpp.

TraceNodePtrVector torc::router::Trace::mSources

protected

Vector of net source nodes.

Definition at line 57 of file Trace.hpp.

std::map<Tilewire, TraceNode*> torc::router::Trace::mTilewireToTraceNode

protected

Map of Tilewires to owning TraceNode.

Definition at line 64 of file Trace.hpp.

std::map<TraceNode*, std::map<TraceNode*, Arc> > torc::router::Trace::mTraceNodesToArc

protected

Map of TraceNode pointers to Arc that connects them.

Definition at line 66 of file Trace.hpp.

---

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

• Trace.hpp