torc::PhysicalDiff Class Reference

Diff utility class for comparing physical netlists. More...

#include <PhysicalDiff.hpp>

Public Member Functions
	PhysicalDiff (std::ostream &inOutStream)
bool	diff (const DesignSharedPtr &left, const DesignSharedPtr &right)
	Top level call to diff two designs. More...

Protected Types
typedef std::string	string
	Imported type name. More...
typedef torc::physical::DesignSharedPtr	DesignSharedPtr
	Imported type name. More...
typedef torc::physical::ModuleSharedPtr	ModuleSharedPtr
	Imported type name. More...
typedef std::vector < ModuleSharedPtr >	ModuleSharedPtrVector
	Imported type name. More...
typedef torc::physical::CircuitSharedPtr	CircuitSharedPtr
	Imported type name. More...
typedef torc::physical::InstanceSharedPtr	InstanceSharedPtr
	Imported type name. More...
typedef std::vector < InstanceSharedPtr >	InstanceSharedPtrVector
	Imported type name. More...
typedef torc::physical::NetSharedPtr	NetSharedPtr
	Imported type name. More...
typedef std::vector< NetSharedPtr >	NetSharedPtrVector
	Imported type name. More...
typedef torc::physical::Circuit::InstanceSharedPtrConstIterator	InstanceSharedPtrConstIterator
	Imported type name. More...
typedef torc::physical::Circuit::InstanceSharedPtrIterator	InstanceSharedPtrIterator
	Imported type name. More...
typedef torc::physical::Circuit::NetSharedPtrConstIterator	NetSharedPtrConstIterator
	Imported type name. More...
typedef torc::physical::Circuit::NetSharedPtrIterator	NetSharedPtrIterator
	Imported type name. More...
typedef torc::physical::InstanceWeakPtr	InstanceWeakPtr
	Imported type name. More...
typedef torc::physical::Design::ModuleSharedPtrConstIterator	ModuleSharedPtrConstIterator
	Imported type name. More...
typedef torc::physical::Design::ModuleSharedPtrIterator	ModuleSharedPtrIterator
	Imported type name. More...
typedef torc::physical::ConfigMap::const_iterator	ConfigMapConstIterator
	Imported type name. More...
typedef torc::physical::Net::InstancePinSharedPtrConstIterator	InstancePinSharedPtrConstIterator
	Imported type name. More...
typedef torc::physical::Net::PipConstIterator	PipConstIterator
	Imported type name. More...
typedef boost::shared_ptr < torc::physical::Named >	NamedSharedPtr
	Imported type name. More...
typedef boost::shared_ptr < torc::physical::ConfigMap >	ConfigMapSharedPtr
	Imported type name. More...
typedef torc::physical::Module::PortSharedPtrConstIterator	PortSharedPtrConstIterator
	Imported type name. More...

Protected Member Functions
bool	diffDesign (const DesignSharedPtr &left, const DesignSharedPtr &right)
	Diff design pointers and then recursively compare modules and inherited members. More...
bool	diffModule (const ModuleSharedPtr &left, const ModuleSharedPtr &right)
	Diff module pointers and then recursively compare inherited members from circuit. More...
bool	diffCircuit (const CircuitSharedPtr &left, const CircuitSharedPtr &right)
	Diff circuit pointers, recursively compare nets, instances and config map. More...
bool	diffConfigMap (const ConfigMapSharedPtr &left, const ConfigMapSharedPtr &right, const string &parentStr)
	Diff configuration information, this is called from circuits, instances and nets. More...
bool	diffInstance (const InstanceSharedPtr &left, const InstanceSharedPtr &right)
	Diff instance pointers and then the underlying config map. More...
bool	diffNet (const NetSharedPtr &left, const NetSharedPtr &right)
	Diff net pointers and then the underlying config map. More...

Protected Attributes
std::ostream &	mStream
	Output stream to use for comparison results. More...

Friends
class	utils::PhysicalDiffDesignUnitTest
	Unit test access to internal functions. More...
class	utils::PhysicalDiffModuleUnitTest
	Unit test access to internal functions. More...
class	utils::PhysicalDiffCircuitUnitTest
	Unit test access to internal functions. More...
class	utils::PhysicalDiffConfigMapUnitTest
	Unit test access to internal functions. More...
class	utils::PhysicalDiffInstanceUnitTest
	Unit test access to internal functions. More...
class	utils::PhysicalDiffNetUnitTest
	Unit test access to internal functions. More...

Detailed Description

Diff utility class for comparing physical netlists.

This class takes two design pointers and compares them.

Definition at line 42 of file PhysicalDiff.hpp.

Member Typedef Documentation

typedef torc::physical::CircuitSharedPtr torc::PhysicalDiff::CircuitSharedPtr

protected

Imported type name.

Definition at line 65 of file PhysicalDiff.hpp.

typedef torc::physical::ConfigMap::const_iterator torc::PhysicalDiff::ConfigMapConstIterator

protected

Imported type name.

Definition at line 89 of file PhysicalDiff.hpp.

typedef boost::shared_ptr<torc::physical::ConfigMap> torc::PhysicalDiff::ConfigMapSharedPtr

protected

Imported type name.

Definition at line 98 of file PhysicalDiff.hpp.

typedef torc::physical::DesignSharedPtr torc::PhysicalDiff::DesignSharedPtr

protected

Imported type name.

Definition at line 59 of file PhysicalDiff.hpp.

typedef torc::physical::Net::InstancePinSharedPtrConstIterator torc::PhysicalDiff::InstancePinSharedPtrConstIterator

protected

Imported type name.

Definition at line 92 of file PhysicalDiff.hpp.

typedef torc::physical::InstanceSharedPtr torc::PhysicalDiff::InstanceSharedPtr

protected

Imported type name.

Definition at line 67 of file PhysicalDiff.hpp.

typedef torc::physical::Circuit::InstanceSharedPtrConstIterator torc::PhysicalDiff::InstanceSharedPtrConstIterator

protected

Imported type name.

Definition at line 75 of file PhysicalDiff.hpp.

typedef torc::physical::Circuit::InstanceSharedPtrIterator torc::PhysicalDiff::InstanceSharedPtrIterator

protected

Imported type name.

Definition at line 77 of file PhysicalDiff.hpp.

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

protected

Imported type name.

Definition at line 69 of file PhysicalDiff.hpp.

typedef torc::physical::InstanceWeakPtr torc::PhysicalDiff::InstanceWeakPtr

protected

Imported type name.

Definition at line 83 of file PhysicalDiff.hpp.

typedef torc::physical::ModuleSharedPtr torc::PhysicalDiff::ModuleSharedPtr

protected

Imported type name.

Definition at line 61 of file PhysicalDiff.hpp.

typedef torc::physical::Design::ModuleSharedPtrConstIterator torc::PhysicalDiff::ModuleSharedPtrConstIterator

protected

Imported type name.

Definition at line 85 of file PhysicalDiff.hpp.

typedef torc::physical::Design::ModuleSharedPtrIterator torc::PhysicalDiff::ModuleSharedPtrIterator

protected

Imported type name.

Definition at line 87 of file PhysicalDiff.hpp.

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

protected

Imported type name.

Definition at line 63 of file PhysicalDiff.hpp.

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

protected

Imported type name.

Definition at line 96 of file PhysicalDiff.hpp.

typedef torc::physical::NetSharedPtr torc::PhysicalDiff::NetSharedPtr

protected

Imported type name.

Definition at line 71 of file PhysicalDiff.hpp.

typedef torc::physical::Circuit::NetSharedPtrConstIterator torc::PhysicalDiff::NetSharedPtrConstIterator

protected

Imported type name.

Definition at line 79 of file PhysicalDiff.hpp.

typedef torc::physical::Circuit::NetSharedPtrIterator torc::PhysicalDiff::NetSharedPtrIterator

protected

Imported type name.

Definition at line 81 of file PhysicalDiff.hpp.

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

protected

Imported type name.

Definition at line 73 of file PhysicalDiff.hpp.

typedef torc::physical::Net::PipConstIterator torc::PhysicalDiff::PipConstIterator

protected

Imported type name.

Definition at line 94 of file PhysicalDiff.hpp.

typedef torc::physical::Module::PortSharedPtrConstIterator torc::PhysicalDiff::PortSharedPtrConstIterator

protected

Imported type name.

Definition at line 100 of file PhysicalDiff.hpp.

typedef std::string torc::PhysicalDiff::string

protected

Imported type name.

Definition at line 57 of file PhysicalDiff.hpp.

Constructor & Destructor Documentation

torc::PhysicalDiff::PhysicalDiff ( std::ostream &  inOutStream )

inline

Todo:

Improve Pip comparison.

Port comparison should use port name.

Config sequence index is not used.

Instance does not check the reference pointer.

Definition at line 110 of file PhysicalDiff.hpp.

                                          : mStream(inOutStream)
    {
        mStream << "WARNING: Pip comparison uses only tile, source, direction "
            << "and sink!" << std::endl;
        mStream << "WARNING: Port comparison does not use the port name!" << std::endl;
        mStream << "WARNING: Config sequence index not used!" << std::endl;
        mStream << "WARNING: Instance does not check reference pointer!" << std::endl;
    }

Member Function Documentation

bool torc::PhysicalDiff::diff ( const DesignSharedPtr &  left, const DesignSharedPtr &  right  )

inline

Top level call to diff two designs.

Definition at line 120 of file PhysicalDiff.hpp.

                                                                         {
        return diffDesign(left, right);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffCircuit ( const CircuitSharedPtr &  left, const CircuitSharedPtr &  right  )

inlineprotected

Diff circuit pointers, recursively compare nets, instances and config map.

Definition at line 251 of file PhysicalDiff.hpp.

                                                                                  {
        bool rval = true;
        
        InstanceSharedPtrVector leftInstances;
        InstanceSharedPtrVector rightInstances;
        InstanceSharedPtrIterator ileft;
        InstanceSharedPtrIterator iright;
        
        for (ileft = left->instancesBegin(); ileft!= left->instancesEnd(); ileft++) {
            leftInstances.push_back(*ileft);
        }
        for (iright = right->instancesBegin(); iright!= right->instancesEnd(); iright++) {
            rightInstances.push_back(*iright);
        }
        for (ileft = leftInstances.begin(); ileft != leftInstances.end(); ileft++) {
            bool found = false;
            for (iright = rightInstances.begin(); iright != rightInstances.end(); iright++) {
                if ((*ileft)->getName() == (*iright)->getName()) {
                    found = true;
                    break;
                }
            }
            if (found) {
                //mStream << "Instance " << (*ileft)->getName() << std::endl;
                rval = diffInstance(*ileft, *iright) && rval;
                rightInstances.erase(iright);
            } else {
                mStream << "< Instance " << (*ileft)->getName() << std::endl;
                rval = false;
            }
        }
        for (iright = rightInstances.begin(); iright != rightInstances.end(); iright++) {
            mStream << "> Instance " << (*iright)->getName() << std::endl;
            rval = false;
        }
        leftInstances.clear();
        rightInstances.clear();
        
        NetSharedPtrVector leftNets;
        NetSharedPtrVector rightNets;
        NetSharedPtrIterator nleft;
        NetSharedPtrIterator nright;
        
        for (nleft = left->netsBegin(); nleft!= left->netsEnd(); nleft++) {
            leftNets.push_back(*nleft);
        }
        for (nright = right->netsBegin(); nright!= right->netsEnd(); nright++) {
            rightNets.push_back(*nright);
        }
        for (nleft = leftNets.begin(); nleft != leftNets.end(); nleft++) {
            bool found = false;
            for (nright = rightNets.begin(); nright != rightNets.end(); nright++) {
                if ((*nleft)->getName() == (*nright)->getName()) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rval = diffNet(*nleft, *nright) && rval;
                rightNets.erase(nright);
            } else {
                mStream << "< Net " << (*nleft)->getName() << std::endl;
                rval = false;
            }
        }
        for (nright = rightNets.begin(); nright != rightNets.end(); nright++) {
            mStream << "> Net " << (*nright)->getName() << std::endl;
            rval = false;
        }
        leftNets.clear();
        rightNets.clear();
        
        string circuitname = "Circuit ";
        circuitname.append(left->getName());
        // A circuit is a configmap.
        rval = diffConfigMap(left, right, circuitname) && rval;
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffConfigMap ( const ConfigMapSharedPtr &  left, const ConfigMapSharedPtr &  right, const string &  parentStr  )

inlineprotected

Diff configuration information, this is called from circuits, instances and nets.

Definition at line 330 of file PhysicalDiff.hpp.

                                 {
        bool rval = true;
        
        std::vector<string> leftConfigs;
        std::vector<string> rightConfigs;
        std::vector<string>::iterator ileft;
        std::vector<string>::iterator iright;
        
        torc::physical::ConfigMap::const_iterator p = left->configBegin();
        torc::physical::ConfigMap::const_iterator e = left->configEnd();
        while (p != e) {
            const torc::physical::Config& config = p->second;
            string t = p->first;
            t.append(":");
            t.append(config.getName());
            t.append(":");
            t.append(config.getValue());
            leftConfigs.push_back(t);
            p++;
        }
        p = right->configBegin();
        e = right->configEnd();
        while (p != e) {
            const torc::physical::Config& config = p->second;
            string t = p->first;
            t.append(":");
            t.append(config.getName());
            t.append(":");
            t.append(config.getValue());
            rightConfigs.push_back(t);
            p++;
        }
        for (ileft = leftConfigs.begin(); ileft != leftConfigs.end(); ileft++) {
            bool found = false;
            for (iright = rightConfigs.begin(); iright != rightConfigs.end(); iright++) {
                if (*ileft == *iright) {
                    found = true;
                    break;
                }
            }
            if (found) {
                //mStream << "Net " << (*nleft)->getName() << std::endl;
                rightConfigs.erase(iright);
            } else {
                mStream << "< " << parentStr << " Config " << *ileft << std::endl;
                rval = false;
            }
        }
        for (iright = rightConfigs.begin(); iright != rightConfigs.end(); iright++) {
            mStream << "> " << parentStr << " Config " << *iright << std::endl;
            rval = false;
        }
        leftConfigs.clear();
        rightConfigs.clear();
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffDesign ( const DesignSharedPtr &  left, const DesignSharedPtr &  right  )

inlineprotected

Diff design pointers and then recursively compare modules and inherited members.

Definition at line 125 of file PhysicalDiff.hpp.

                                                                               {
        bool rval = true;
        string designNameLeft = left->getName();
        string designNameRight = right->getName();

        if (!(designNameLeft == designNameRight)) {
            mStream << "! Design Name: " << designNameLeft << " | " 
                << designNameRight << std::endl;
            rval = false;
        }
        if (!(left->getDevice() == right->getDevice())) {
            mStream << "! Device: " << left->getDevice() << " | " 
                << right->getDevice() << std::endl;
            rval = false;
        }
        if (!(left->getPackage() == right->getPackage())) {
            mStream << "! Package: " << left->getPackage() << " | "
                << right->getPackage() << std::endl;
            rval = false;
        }
        if (!(left->getSpeedGrade() == right->getSpeedGrade())) {
            mStream << "! Speed grade: " << left->getSpeedGrade() 
                << " | " << right->getSpeedGrade() << std::endl;
            rval = false;
        }
        if (!(left->getXdlVersion() == right->getXdlVersion())) {
            mStream << "! XDL version differs: " << left->getXdlVersion() 
                << " | " << right->getXdlVersion() << std::endl;
            rval = false;
        }
        
        ModuleSharedPtrVector leftModules;
        ModuleSharedPtrVector rightModules;
        
        for (ModuleSharedPtrConstIterator p = left->modulesBegin(); p!= left->modulesEnd(); p++) {
            leftModules.push_back(*p);
        }
        for (ModuleSharedPtrConstIterator p = right->modulesBegin(); p!= right->modulesEnd(); p++) {
            rightModules.push_back(*p);
        }
        
        // look left to right
        ModuleSharedPtrIterator ileft;
        ModuleSharedPtrIterator iright;
        for (ileft = leftModules.begin(); ileft != leftModules.end(); ileft++) {
            bool found = false;
            for (iright = rightModules.begin(); iright != rightModules.end(); iright++) {
                if ((*ileft)->getName() == (*iright)->getName()) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rval = diffModule(*ileft, *iright) && rval;
                rightModules.erase(iright);
            } else {
                mStream << "< Module " << (*ileft)->getName() << std::endl;
                rval = false;
            }
        }
        // anything left on the right doesn't appear on the left
        for (iright = rightModules.begin(); iright != rightModules.end(); iright++) {
            mStream << "> Module " << (*iright)->getName() << std::endl;
            rval = false;
        }
        // A design is a circuit
        rval = diffCircuit(left, right) && rval;
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffInstance ( const InstanceSharedPtr &  left, const InstanceSharedPtr &  right  )

inlineprotected

Diff instance pointers and then the underlying config map.

Definition at line 388 of file PhysicalDiff.hpp.

                                                                                     {
        bool rval = true;
        if (!(left->getType() == right->getType())) {
            mStream << "! Instance " << left->getName() << " type: " << left->getType() 
                << " | " << right->getType() << std::endl;
            rval = false;
        }
        if (!(left->getTile() == right->getTile())) {
            mStream << "! Instance " << left->getName() << " tile: " << left->getTile() 
                << " | " << right->getTile() << std::endl;;
            rval = false;
        }
        if (!(left->getSite() == right->getSite())) {
            mStream << "! Instance " << left->getName() << "site: " << left->getSite() 
                << " | " << right->getSite() << std::endl;
            rval = false;
        }
        if (!(left->getBonding() == right->getBonding())) {
            mStream << "! Instance " << left->getName() << " bonding: " << left->getBonding() 
                << " | " << right->getBonding() << std::endl;
            rval = false;
        }

        string instancename = "Instance ";
        instancename.append(left->getName());
        // An instance is a configmap.
        rval = diffConfigMap(left, right, instancename) && rval;
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffModule ( const ModuleSharedPtr &  left, const ModuleSharedPtr &  right  )

inlineprotected

Diff module pointers and then recursively compare inherited members from circuit.

Definition at line 195 of file PhysicalDiff.hpp.

                                                                               {
        bool rval = true;
        
        if (!(left->getAnchor() == right->getAnchor())) {
            mStream << "! Module " << left->getName() << " anchor: " << left->getAnchor()
                << " | " << right->getAnchor() << std::endl;
            rval = false;
        }
        
        std::vector<string> leftPorts;
        std::vector<string> rightPorts;
        std::vector<string>::iterator leftport;
        std::vector<string>::iterator rightport;
        for (PortSharedPtrConstIterator leftport = left->portsBegin(); 
            leftport != left->portsEnd(); leftport++) {
            string t = (*leftport)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*leftport)->getPinName());
            leftPorts.push_back(t);
        }
        for (PortSharedPtrConstIterator rightport = right->portsBegin(); 
            rightport != right->portsEnd(); rightport++) {
            string t = (*rightport)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*rightport)->getPinName());
            rightPorts.push_back(t);
        }
        for (leftport = leftPorts.begin(); leftport != leftPorts.end(); leftport++) {
            bool found = false;
            for (rightport = rightPorts.begin(); rightport != rightPorts.end(); rightport++) {
                if (*leftport == *rightport) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rightPorts.erase(rightport);
            } else {
                mStream << "< Module " << left->getName() << " port: "
                    << *leftport << std::endl;
                rval = false;
            }
        }
        for (rightport = rightPorts.begin(); rightport != rightPorts.end(); rightport++) {
            mStream << "> Module " << right->getName() << " port: "
                << *rightport << std::endl;
            rval = false;
        }
        leftPorts.clear();
        rightPorts.clear();

        // A module is a circuit
        rval = diffCircuit(left, right) && rval;
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool torc::PhysicalDiff::diffNet ( const NetSharedPtr &  left, const NetSharedPtr &  right  )

inlineprotected

Diff net pointers and then the underlying config map.

Definition at line 418 of file PhysicalDiff.hpp.

                                                                      {
        bool rval = true;
        if (!(left->getNetType() == right->getNetType())) {
            mStream << "! Net " << left->getName() << " type: " << left->getNetType()
                << " | " << right->getNetType() << std::endl;
            rval = false;
        }
        
        std::vector<string> leftPins;
        std::vector<string> rightPins;
        std::vector<string>::iterator leftpin;
        std::vector<string>::iterator rightpin;
        
        for (InstancePinSharedPtrConstIterator leftpinPtr = left->sourcesBegin(); 
            leftpinPtr != left->sourcesEnd(); leftpinPtr++) {
            string t = (*leftpinPtr)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*leftpinPtr)->getPinName());
            leftPins.push_back(t);
        }
        for (InstancePinSharedPtrConstIterator rightpinPtr = right->sourcesBegin(); 
            rightpinPtr != right->sourcesEnd(); rightpinPtr++) {
            string t = (*rightpinPtr)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*rightpinPtr)->getPinName());
            rightPins.push_back(t);
        }
        for (leftpin = leftPins.begin(); leftpin != leftPins.end(); leftpin++) {
            bool found = false;
            for (rightpin = rightPins.begin(); rightpin != rightPins.end(); rightpin++) {
                if (*leftpin == *rightpin) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rightPins.erase(rightpin);
            } else {
                mStream << "< Net " << left->getName() << " outpin: "
                    << *leftpin << std::endl;
                rval = false;
            }
        }
        for (rightpin = rightPins.begin(); rightpin != rightPins.end(); rightpin++) {
            mStream << "> Net " << right->getName() << " outpin: "
                << *rightpin << std::endl;
            rval = false;
        }
        leftPins.clear();
        rightPins.clear();
        
        for (InstancePinSharedPtrConstIterator leftpinPtr = left->sinksBegin(); 
            leftpinPtr != left->sinksEnd(); leftpinPtr++) {
            string t = (*leftpinPtr)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*leftpinPtr)->getPinName());
            leftPins.push_back(t);
        }
        for (InstancePinSharedPtrConstIterator rightpinPtr = right->sinksBegin(); 
            rightpinPtr != right->sinksEnd(); rightpinPtr++) {
            string t = (*rightpinPtr)->getInstancePtr().lock()->getName();
            t.append(".");
            t.append((*rightpinPtr)->getPinName());
            rightPins.push_back(t);
        }
        for (leftpin = leftPins.begin(); leftpin != leftPins.end(); leftpin++) {
            bool found = false;
            for (rightpin = rightPins.begin(); rightpin != rightPins.end(); rightpin++) {
                if (*leftpin == *rightpin) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rightPins.erase(rightpin);
            } else {
                mStream << "< Net " << left->getName() << " inpin: "
                    << *leftpin << std::endl;
                rval = false;
            }
        }
        for (rightpin = rightPins.begin(); rightpin != rightPins.end(); rightpin++) {
            mStream << "> Net " << right->getName() << " inpin: "
                << *rightpin << std::endl;
            rval = false;
        }
        leftPins.clear();
        rightPins.clear();
        
        std::vector<string> leftPips;
        std::vector<string> rightPips;
        std::vector<string>::iterator leftpip;
        std::vector<string>::iterator rightpip;
        for (PipConstIterator leftpip = left->pipsBegin(); 
            leftpip != left->pipsEnd(); leftpip++) {
            string t = leftpip->getTileName();
            t.append(" ");
            t.append(leftpip->getSourceWireName());
            t.append(" ");
            t.append(leftpip->getDirectionString());
            t.append(" ");
            t.append(leftpip->getSinkWireName());
            leftPips.push_back(t);
        }
        for (PipConstIterator rightpip = right->pipsBegin(); 
            rightpip != right->pipsEnd(); rightpip++) {
            string t = rightpip->getTileName();
            t.append(" ");
            t.append(rightpip->getSourceWireName());
            t.append(" ");
            t.append(rightpip->getDirectionString());
            t.append(" ");
            t.append(rightpip->getSinkWireName());
            rightPips.push_back(t);
        }
        for (leftpip = leftPips.begin(); leftpip != leftPips.end(); leftpip++) {
            bool found = false;
            for (rightpip = rightPips.begin(); rightpip != rightPips.end(); rightpip++) {
                if (*leftpip == *rightpip) {
                    found = true;
                    break;
                }
            }
            if (found) {
                rightPips.erase(rightpip);
            } else {
                mStream << "< Net " << left->getName() << " pip: "
                    << *leftpip << std::endl;
                rval = false;
            }
        }
        for (rightpip = rightPips.begin(); rightpip != rightPips.end(); rightpip++) {
            mStream << "> Net " << right->getName() << " pip: "
                << *rightpip << std::endl;
            rval = false;
        }
        leftPips.clear();
        rightPips.clear();
        
        string netname = "Net ";
        netname.append(left->getName());
        // A net is a configmap.
        rval = diffConfigMap(left, right, netname) && rval;
        return rval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class utils::PhysicalDiffCircuitUnitTest

friend

Unit test access to internal functions.

Definition at line 48 of file PhysicalDiff.hpp.

friend class utils::PhysicalDiffConfigMapUnitTest

friend

Unit test access to internal functions.

Definition at line 50 of file PhysicalDiff.hpp.

friend class utils::PhysicalDiffDesignUnitTest

friend

Unit test access to internal functions.

Definition at line 44 of file PhysicalDiff.hpp.

friend class utils::PhysicalDiffInstanceUnitTest

friend

Unit test access to internal functions.

Definition at line 52 of file PhysicalDiff.hpp.

friend class utils::PhysicalDiffModuleUnitTest

friend

Unit test access to internal functions.

Definition at line 46 of file PhysicalDiff.hpp.

friend class utils::PhysicalDiffNetUnitTest

friend

Unit test access to internal functions.

Definition at line 54 of file PhysicalDiff.hpp.

Field Documentation

std::ostream& torc::PhysicalDiff::mStream

protected

Output stream to use for comparison results.

Definition at line 103 of file PhysicalDiff.hpp.

---

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

• PhysicalDiff.hpp