SubCircuit::SolverWorker::DiEdge Struct Reference

Collaboration diagram for SubCircuit::SolverWorker::DiEdge:

Public Member Functions
bool	operator< (const DiEdge &other) const
bool	compare (const DiEdge &other, const std::map< std::string, std::string > &mapFromPorts, const std::map< std::string, std::string > &mapToPorts) const
bool	compareWithFromAndToPermutations (const DiEdge &other, const std::map< std::string, std::string > &mapFromPorts, const std::map< std::string, std::string > &mapToPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &swapPermutations) const
bool	compareWithToPermutations (const DiEdge &other, const std::map< std::string, std::string > &mapFromPorts, const std::map< std::string, std::string > &mapToPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &swapPermutations) const
bool	compare (const DiEdge &other, const std::map< std::string, std::set< std::set< std::string >>> &swapPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &swapPermutations) const
bool	compare (const DiEdge &other, const std::map< std::string, std::string > &mapFromPorts, const std::map< std::string, std::set< std::set< std::string >>> &swapPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &swapPermutations) const
std::string	toString () const

Static Public Member Functions
static void	findEdgesInGraph (const Graph &graph, std::map< std::pair< int, int >, DiEdge > &edges)

Data Fields
DiNode	fromNode
DiNode	toNode
std::set< DiBit >	bits
std::string	userAnnotation

Detailed Description

Definition at line 455 of file subcircuit.cc.

Member Function Documentation

bool SubCircuit::SolverWorker::DiEdge::compare ( const DiEdge &  other, const std::map< std::string, std::string > &  mapFromPorts, const std::map< std::string, std::string > &  mapToPorts  ) const

inline

Definition at line 472 of file subcircuit.cc.

        {
            // Rules for matching edges:
            //
            // For all bits in the needle edge:
            //   - ignore if needle ports don't exist in haystack edge
            //   - otherwise: matching bit in haystack edge must exist
            //
            // There is no need to check in the other direction, as checking
            // of the isExtern properties is already performed in node matching.
            //
            // Note: "this" is needle, "other" is haystack

            for (auto bit : bits)
            {
                if (mapFromPorts.count(bit.fromPort) > 0)
                    bit.fromPort = mapFromPorts.at(bit.fromPort);
                if (mapToPorts.count(bit.toPort) > 0)
                    bit.toPort = mapToPorts.at(bit.toPort);

                if (other.fromNode.portSizes.count(bit.fromPort) == 0)
                    continue;
                if (other.toNode.portSizes.count(bit.toPort) == 0)
                    continue;

                if (bit.fromBit >= other.fromNode.portSizes.at(bit.fromPort))
                    continue;
                if (bit.toBit >= other.toNode.portSizes.at(bit.toPort))
                    continue;

                if (other.bits.count(bit) == 0)
                    return false;
            }

            return true;
        }

Here is the caller graph for this function:

bool SubCircuit::SolverWorker::DiEdge::compare ( const DiEdge &  other, const std::map< std::string, std::set< std::set< std::string >>> &  swapPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &  swapPermutations  ) const

inline

Definition at line 535 of file subcircuit.cc.

        {
            // brute force method for port swapping: try all variations

            std::vector<std::vector<std::string>> swapFromPorts;
            std::vector<std::vector<std::string>> swapToPorts;

            // only use groups that are relevant for this edge

            if (swapPorts.count(fromNode.typeId) > 0)
                for (const auto &ports : swapPorts.at(fromNode.typeId)) {
                    for (const auto &bit : bits)
                        if (ports.count(bit.fromPort))
                            goto foundFromPortMatch;
                    if (0) {
                foundFromPortMatch:
                        std::vector<std::string> portsVector;
                        for (const auto &port : ports)
                            portsVector.push_back(port);
                        swapFromPorts.push_back(portsVector);
                    }
                }

            if (swapPorts.count(toNode.typeId) > 0)
                for (const auto &ports : swapPorts.at(toNode.typeId)) {
                    for (const auto &bit : bits)
                        if (ports.count(bit.toPort))
                            goto foundToPortMatch;
                    if (0) {
                foundToPortMatch:
                        std::vector<std::string> portsVector;
                        for (const auto &port : ports)
                            portsVector.push_back(port);
                        swapToPorts.push_back(portsVector);
                    }
                }

            // try all permutations

            std::map<std::string, std::string> mapFromPorts, mapToPorts;
            int fromPortsPermutations = numberOfPermutationsArray(swapFromPorts);
            int toPortsPermutations = numberOfPermutationsArray(swapToPorts);

            for (int i = 0; i < fromPortsPermutations; i++)
            {
                permutateVectorToMapArray(mapFromPorts, swapFromPorts, i);

                for (int j = 0; j < toPortsPermutations; j++) {
                    permutateVectorToMapArray(mapToPorts, swapToPorts, j);
                    if (compareWithFromAndToPermutations(other, mapFromPorts, mapToPorts, swapPermutations))
                        return true;
                }
            }

            return false;
        }

Here is the call graph for this function:

bool SubCircuit::SolverWorker::DiEdge::compare ( const DiEdge &  other, const std::map< std::string, std::string > &  mapFromPorts, const std::map< std::string, std::set< std::set< std::string >>> &  swapPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &  swapPermutations  ) const

inline

Definition at line 593 of file subcircuit.cc.

        {
            // strip-down version of the last function: only try permutations for mapToPorts, mapFromPorts is already provided by the caller

            std::vector<std::vector<std::string>> swapToPorts;

            if (swapPorts.count(toNode.typeId) > 0)
                for (const auto &ports : swapPorts.at(toNode.typeId)) {
                    for (const auto &bit : bits)
                        if (ports.count(bit.toPort))
                            goto foundToPortMatch;
                    if (0) {
                foundToPortMatch:
                        std::vector<std::string> portsVector;
                        for (const auto &port : ports)
                            portsVector.push_back(port);
                        swapToPorts.push_back(portsVector);
                    }
                }

            std::map<std::string, std::string> mapToPorts;
            int toPortsPermutations = numberOfPermutationsArray(swapToPorts);

            for (int j = 0; j < toPortsPermutations; j++) {
                permutateVectorToMapArray(mapToPorts, swapToPorts, j);
                if (compareWithToPermutations(other, mapFromPorts, mapToPorts, swapPermutations))
                    return true;
            }

            return false;
        }

Here is the call graph for this function:

bool SubCircuit::SolverWorker::DiEdge::compareWithFromAndToPermutations ( const DiEdge &  other, const std::map< std::string, std::string > &  mapFromPorts, const std::map< std::string, std::string > &  mapToPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &  swapPermutations  ) const

inline

Definition at line 509 of file subcircuit.cc.

        {
            if (swapPermutations.count(fromNode.typeId) > 0)
                for (const auto &permutation : swapPermutations.at(fromNode.typeId)) {
                    std::map<std::string, std::string> thisMapFromPorts = mapFromPorts;
                    applyPermutation(thisMapFromPorts, permutation);
                    if (compareWithToPermutations(other, thisMapFromPorts, mapToPorts, swapPermutations))
                        return true;
                }
            return compareWithToPermutations(other, mapFromPorts, mapToPorts, swapPermutations);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SubCircuit::SolverWorker::DiEdge::compareWithToPermutations ( const DiEdge &  other, const std::map< std::string, std::string > &  mapFromPorts, const std::map< std::string, std::string > &  mapToPorts, const std::map< std::string, std::set< std::map< std::string, std::string >>> &  swapPermutations  ) const

inline

Definition at line 522 of file subcircuit.cc.

        {
            if (swapPermutations.count(toNode.typeId) > 0)
                for (const auto &permutation : swapPermutations.at(toNode.typeId)) {
                    std::map<std::string, std::string> thisMapToPorts = mapToPorts;
                    applyPermutation(thisMapToPorts, permutation);
                    if (compare(other, mapFromPorts, thisMapToPorts))
                        return true;
                }
            return compare(other, mapFromPorts, mapToPorts);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

static void SubCircuit::SolverWorker::DiEdge::findEdgesInGraph ( const Graph &  graph, std::map< std::pair< int, int >, DiEdge > &  edges  )

inlinestatic

Definition at line 636 of file subcircuit.cc.

        {
            edges.clear();
            for (const auto &edge : graph.edges) {
                if (edge.constValue != 0)
                    continue;
                for (const auto &fromBit : edge.portBits)
                for (const auto &toBit : edge.portBits)
                    if (&fromBit != &toBit) {
                        DiEdge &de = edges[std::pair<int, int>(fromBit.nodeIdx, toBit.nodeIdx)];
                        de.fromNode = DiNode(graph, fromBit.nodeIdx);
                        de.toNode = DiNode(graph, toBit.nodeIdx);
                        std::string fromPortId = graph.nodes[fromBit.nodeIdx].ports[fromBit.portIdx].portId;
                        std::string toPortId = graph.nodes[toBit.nodeIdx].ports[toBit.portIdx].portId;
                        de.bits.insert(DiBit(fromPortId, fromBit.bitIdx, toPortId, toBit.bitIdx));
                    }
            }
        }

Here is the caller graph for this function:

bool SubCircuit::SolverWorker::DiEdge::operator< ( const DiEdge &  other ) const

inline

Definition at line 461 of file subcircuit.cc.

        {
            if (fromNode < other.fromNode || other.fromNode < fromNode)
                return fromNode < other.fromNode;
            if (toNode < other.toNode || other.toNode < toNode)
                return toNode < other.toNode;
            if (bits < other.bits || other.bits < bits)
                return bits < other.bits;
            return userAnnotation < other.userAnnotation;
        }

std::string SubCircuit::SolverWorker::DiEdge::toString ( ) const

inline

Definition at line 626 of file subcircuit.cc.

        {
            std::string buffer = fromNode.toString() + " " + toNode.toString();
            for (const auto &bit : bits)
                buffer += " " + bit.toString();
            if (!userAnnotation.empty())
                buffer += " " + userAnnotation;
            return buffer;
        }

Here is the call graph for this function:

Field Documentation

std::set<DiBit> SubCircuit::SolverWorker::DiEdge::bits

Definition at line 458 of file subcircuit.cc.

DiNode SubCircuit::SolverWorker::DiEdge::fromNode

Definition at line 457 of file subcircuit.cc.

DiNode SubCircuit::SolverWorker::DiEdge::toNode

Definition at line 457 of file subcircuit.cc.

std::string SubCircuit::SolverWorker::DiEdge::userAnnotation

Definition at line 459 of file subcircuit.cc.

---

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

• subcircuit.cc