[RWRoute] Yet more cleanup

src/com/xilinx/rapidwright/rwroute/CUFR.java

@@ -82,7 +82,7 @@ public CUFR(Design design, RWRouteConfig config) {
 
     public static class RouteNodeGraphCUFR extends RouteNodeGraph {
         public RouteNodeGraphCUFR(Design design, RWRouteConfig config) {
-            super(design, config, new ConcurrentHashMap<>());
+            super(design, config);
         }
 
         // Do not track createRnodeTime since it is meaningless when multithreading
@@ -92,7 +92,7 @@ protected void addCreateRnodeTime(long time) {}
 
     public static class RouteNodeGraphCUFRTimingDriven extends RouteNodeGraphTimingDriven {
         public RouteNodeGraphCUFRTimingDriven(Design design, RWRouteConfig config, DelayEstimatorBase delayEstimator) {
-            super(design, config, delayEstimator, new ConcurrentHashMap<>());
+            super(design, config, delayEstimator);
         }
 
         // Do not track createRnodeTime since it is meaningless when multithreading

src/com/xilinx/rapidwright/rwroute/Connection.java

@@ -215,19 +215,6 @@ public boolean isCongested() {
         return false;
     }
 
-    /**
-     * Checks if a connection is routed through any rnodes that have multiple drivers.
-     * @return
-     */
-    public boolean useRnodesWithMultiDrivers() {
-        for (RouteNode rn : getRnodes()) {
-            if (rn.hasMultiDrivers()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     /**
      * Add the give RouteNode to the list of those used by this Connection.
      * Expand the bounding box accordingly, since this node could describe an
@@ -299,6 +286,10 @@ public List<RouteNode> getAltSinkRnodes() {
         return altSinkRnodes == null ? Collections.emptyList() : altSinkRnodes;
     }
 
+    public boolean hasAltSinks() {
+        return altSinkRnodes != null && !altSinkRnodes.isEmpty();
+    }
+
     public void addAltSinkRnode(RouteNode sinkRnode) {
         if (altSinkRnodes == null) {
             altSinkRnodes = new ArrayList<>(1);
@@ -351,6 +342,10 @@ public NetWrapper getNetWrapper() {
         return this.netWrapper;
     }
 
+    public Net getNet() {
+        return netWrapper.getNet();
+    }
+
     public SitePinInst getSource() {
         return source;
     }
@@ -469,7 +464,7 @@ public String toString() {
     }
 
     public void setAllTargets(RWRoute.ConnectionState state) {
-        if (sinkRnode.countConnectionsOfUser(netWrapper) == 0 ||
+        if (sinkRnode.countConnectionsOfUser(netWrapper) == 1 ||
             sinkRnode.getIntentCode() == IntentCode.NODE_PINBOUNCE) {
             // Since this connection will have been ripped up, only mark a node
             // as a target if it's not already used by this net.
@@ -515,4 +510,12 @@ protected Pair<SitePinInst,RouteNode> getOrCreateAlternateSource(RouteNodeGraph
         assert(altSourceRnode != null);
         return new Pair<>(altSource, altSourceRnode);
     }
+
+    public boolean isRouted() {
+        return sink.isRouted();
+    }
+
+    public void setRouted(boolean isRouted) {
+        sink.setRouted(isRouted);
+    }
 }

src/com/xilinx/rapidwright/rwroute/NetWrapper.java

@@ -180,4 +180,34 @@ public SitePinInst getOrCreateAlternateSource(RouteNodeGraph routingGraph) {
     public RouteNode getAltSourceRnode() {
         return altSourceRnode;
     }
+
+    public boolean hasMultipleDrivers(int sequence) {
+        for (Connection connection : connections) {
+            List<RouteNode> rnodes = connection.getRnodes();
+            if (rnodes.isEmpty()) {
+                continue;
+            }
+
+            RouteNode driver = rnodes.get(rnodes.size() - 2);
+            for (int i = rnodes.size() - 1; i >= 0; i--) {
+                assert(driver != null);
+                RouteNode rnode = rnodes.get(i);
+                if (rnode.isVisited(sequence)) {
+                    // Rnode has already been visited by a prior connection;
+                    // check if driver is same as this connection
+                    RouteNode prev = rnode.getPrev();
+                    if (prev != driver) {
+                        return true;
+                    }
+                } else {
+                    // Rnode has not been visited by this net yet,
+                    // set initial prev
+                    rnode.setVisited(sequence);
+                    rnode.setPrev(driver);
+                }
+                driver = rnode;
+            }
+        }
+        return false;
+    }
 }

src/com/xilinx/rapidwright/rwroute/PartialCUFR.java

@@ -62,7 +62,7 @@ public PartialCUFR(Design design, RWRouteConfig config, Collection<SitePinInst>
 
     public static class RouteNodeGraphPartialCUFR extends RouteNodeGraphPartial {
         public RouteNodeGraphPartialCUFR(Design design, RWRouteConfig config) {
-            super(design, config, new ConcurrentHashMap<>());
+            super(design, config);
         }
 
         // Do not track createRnodeTime since it is meaningless when multithreading
@@ -72,7 +72,7 @@ protected void addCreateRnodeTime(long time) {}
 
     public static class RouteNodeGraphPartialCUFRTimingDriven extends RouteNodeGraphPartialTimingDriven {
         public RouteNodeGraphPartialCUFRTimingDriven(Design design, RWRouteConfig config, DelayEstimatorBase delayEstimator) {
-            super(design, config, delayEstimator, new ConcurrentHashMap<>());
+            super(design, config, delayEstimator);
         }
 
         // Do not track createRnodeTime since it is meaningless when multithreading
@@ -137,9 +137,10 @@ protected void routeIndirectConnections(Collection<Connection> connections) {
     }
 
     @Override
-    protected void unpreserveNet(Net net) {
-        super.unpreserveNet(net);
+    protected NetWrapper unpreserveNet(Net net) {
+        NetWrapper netWrapper = super.unpreserveNet(net);
         needsRepartitioning = true;
+        return netWrapper;
     }
 
     @Override

src/com/xilinx/rapidwright/rwroute/PartialRouter.java

@@ -28,7 +28,6 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -44,7 +43,6 @@
 import com.xilinx.rapidwright.device.Node;
 import com.xilinx.rapidwright.device.PIP;
 import com.xilinx.rapidwright.device.Series;
-import com.xilinx.rapidwright.device.Tile;
 import com.xilinx.rapidwright.router.UltraScaleClockRouting;
 import com.xilinx.rapidwright.tests.CodePerfTracker;
 import com.xilinx.rapidwright.timing.ClkRouteTiming;
@@ -71,12 +69,8 @@ public class PartialRouter extends RWRoute {
 
     protected static class RouteNodeGraphPartial extends RouteNodeGraph {
 
-        public RouteNodeGraphPartial(Design design, RWRouteConfig config, Map<Tile, RouteNode[]> nodesMap) {
-            super(design, config, nodesMap);
-        }
-
         public RouteNodeGraphPartial(Design design, RWRouteConfig config) {
-            this(design, config, new HashMap<>());
+            super(design, config);
         }
 
         @Override
@@ -90,17 +84,10 @@ protected boolean isExcluded(RouteNode parent, Node child) {
     }
 
     protected static class RouteNodeGraphPartialTimingDriven extends RouteNodeGraphTimingDriven {
-        public RouteNodeGraphPartialTimingDriven(Design design,
-                                                 RWRouteConfig config,
-                                                 DelayEstimatorBase delayEstimator,
-                                                 Map<Tile, RouteNode[]> nodesMap) {
-            super(design, config, delayEstimator, nodesMap);
-        }
-
         public RouteNodeGraphPartialTimingDriven(Design design,
                                                  RWRouteConfig config,
                                                  DelayEstimatorBase delayEstimator) {
-            this(design, config, delayEstimator, new HashMap<>());
+            super(design, config, delayEstimator);
         }
 
         @Override
@@ -168,7 +155,7 @@ protected static boolean isPartOfExistingRoute(RouteNodeGraph routingGraph, Rout
                 return false;
             }
 
-            if (prev.equals(start) && routingGraph.isPreserved(end)) {
+            if (prev == start && routingGraph.isPreserved(end)) {
                 // Arc matches start node and end node is preserved
                 // This implies that both start and end nodes must be preserved for the same net
                 // (which assumedly is the net we're currently routing, and is asserted upstream)
@@ -202,7 +189,7 @@ protected TimingManager createTimingManager(ClkRouteTiming clkTiming, Collection
     protected int getNumIndirectConnectionPins() {
         int totalSitePins = 0;
         for (Connection connection : indirectConnections) {
-            totalSitePins += (connection.getSink().isRouted() && !connection.isCongested()) ? 0 : 1;
+            totalSitePins += (connection.isRouted() && !connection.isCongested()) ? 0 : 1;
         }
         return totalSitePins;
     }
@@ -211,7 +198,7 @@ protected int getNumIndirectConnectionPins() {
     protected int getNumConnectionsCrossingSLRs() {
         int numCrossingSLRs = 0;
         for (Connection c : indirectConnections) {
-            numCrossingSLRs += (!c.isCrossSLR() || (c.getSink().isRouted() && !c.isCongested())) ? 0 : 1;
+            numCrossingSLRs += (!c.isCrossSLR() || (c.isRouted() && !c.isCongested())) ? 0 : 1;
         }
         return numCrossingSLRs;
     }
@@ -249,7 +236,7 @@ protected void determineRoutingTargets() {
         // if so, unpreserve that blocking net
         Set<Net> unpreserveNets = new HashSet<>();
         for (Connection connection : indirectConnections) {
-            Net net = connection.getNetWrapper().getNet();
+            Net net = connection.getNet();
             Net preservedNet;
             assert((preservedNet = routingGraph.getPreservedNet(connection.getSourceRnode())) == null || preservedNet == net);
             RouteNode sinkRnode = connection.getSinkRnode();
@@ -261,11 +248,33 @@ protected void determineRoutingTargets() {
         }
 
         if (!unpreserveNets.isEmpty()) {
-            System.out.println("INFO: Unpreserving " + unpreserveNets.size() + " nets to improve sink routability");
+            System.out.println("INFO: Unpreserving " + unpreserveNets.size() + " nets to ensure sink routability");
             for (Net net : unpreserveNets) {
                 System.out.println("\t" + net);
                 assert(!net.isStaticNet());
-                unpreserveNet(net);
+                NetWrapper netWrapper = unpreserveNet(net);
+                for (Connection connection : netWrapper.getConnections()) {
+                    List<RouteNode> rnodes = connection.getRnodes();
+                    if (rnodes.size() < 3) {
+                        continue;
+                    }
+                    // Look for overused exclusive sinks (with type PINFEED_I) within
+                    // this connection's used nodes (except for the first and last used node,
+                    // corresponding to source and sink)
+                    for (RouteNode rnode : rnodes.subList(1, rnodes.size() - 1)) {
+                        if (!rnode.getType().isAnyExclusiveSink() || !rnode.isOverUsed()) {
+                            continue;
+                        }
+
+                        // If an overused exclusive sink is found -- it must also be used
+                        // by the net to which that sink belongs to, so rip up this connection's
+                        // routing
+                        ripUp(connection);
+                        connection.resetRoute();
+                        connection.setRouted(false);
+                        break;
+                    }
+                }
             }
         }
     }
@@ -407,13 +416,6 @@ protected void addNetConnectionToRoutingTargets(Net net) {
                         continue;
                     }
 
-                    // Even though this connection is not expected to have any routing yet,
-                    // perform a rip up anyway in order to release any exclusive sinks
-                    // ahead of finishRouteConnection()
-                    assert(connection.getRnodes().isEmpty());
-                    connection.getSink().setRouted(false);
-                    ripUp(connection);
-
                     RouteNode sinkRnode = connection.getSinkRnode();
                     finishRouteConnection(connection, sinkRnode);
                 }
@@ -444,7 +446,7 @@ protected boolean saveRouting(Connection connection, RouteNode rnode) {
         assert(rnodes.size() > 1);
 
         // Check if alternate source exists (without creating one if it doesn't)
-        if (connection.getNetWrapper().getNet().getAlternateSource() != null) {
+        if (connection.getNet().getAlternateSource() != null) {
             Pair<SitePinInst,RouteNode> altSourceAndRnode = connection.getOrCreateAlternateSource(routingGraph);
             assert(altSourceAndRnode != null);
             RouteNode altSourceRnode = altSourceAndRnode.getSecond();
@@ -463,13 +465,8 @@ protected boolean saveRouting(Connection connection, RouteNode rnode) {
     protected void finishRouteConnection(Connection connection, RouteNode rnode) {
         super.finishRouteConnection(connection, rnode);
 
-        if (!connection.getSink().isRouted()) {
+        if (!connection.isRouted()) {
             connection.resetRoute();
-            if (connection.getAltSinkRnodes().isEmpty()) {
-                // Undo what ripUp() would have done for this connection which has a single exclusive sink
-                rnode.incrementUser(connection.getNetWrapper());
-                rnode.updatePresentCongestionCost(presentCongestionFactor);
-            }
         }
     }
 
@@ -537,7 +534,7 @@ protected int unpreserveNetsAndReleaseResources(Connection connection) {
         return unpreserveNets.size();
     }
 
-    protected void unpreserveNet(Net net) {
+    protected NetWrapper unpreserveNet(Net net) {
         assert(!net.getName().equals(Net.Z_NET));
 
         Set<RouteNode> rnodes = new HashSet<>();
@@ -614,13 +611,6 @@ protected void unpreserveNet(Net net) {
                 assert(sourceRnode.getType() == RouteNodeType.EXCLUSIVE_SOURCE);
                 assert(sinkRnode.getType().isAnyExclusiveSink());
 
-                // Even though this connection is not expected to have any routing yet,
-                // perform a rip up anyway in order to release any exclusive sinks
-                // ahead of finishRouteConnection()
-                assert(connection.getRnodes().isEmpty());
-                connection.getSink().setRouted(false);
-                ripUp(connection);
-
                 finishRouteConnection(connection, sinkRnode);
             }
 
@@ -655,6 +645,7 @@ protected void unpreserveNet(Net net) {
 
         numPreservedWire--;
         numPreservedRoutableNets--;
+        return netWrapper;
     }
 
     @Override
@@ -665,9 +656,9 @@ protected boolean handleUnroutableConnection(Connection connection) {
         }
         if (softPreserve && (
                 // First iteration, without alternate source
-                (routeIteration == 1 && connection.getNetWrapper().getNet().getAlternateSource() == null) ||
+                (routeIteration == 1 && connection.getNet().getAlternateSource() == null) ||
                 // Second iteration, with alternate source
-                (routeIteration == 2 && connection.getNetWrapper().getNet().getAlternateSource() != null))
+                (routeIteration == 2 && connection.getNet().getAlternateSource() != null))
         ) {
              int netsUnpreserved = unpreserveNetsAndReleaseResources(connection);
              if (netsUnpreserved > 0) {