[RWRoute] Add "--lutPinSwapping" option

src/com/xilinx/rapidwright/design/DesignTools.java

@@ -2000,7 +2000,7 @@ public static boolean stampPlacement(Design design, Module stamp, Map<String,Sit
     /**
      * Looks in the site instance for BEL pins connected to this site pin.
      * @param pin The SitePinInst to examine for connected BEL pins
-     * param action Perform this action on each conncted BELPin
+     * @param action Perform this action on each connected BELPin.
      */
     private static void foreachConnectedBELPin(SitePinInst pin, Consumer<BELPin> action) {
         SiteInst si = pin.getSiteInst();

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

@@ -25,8 +25,10 @@
 package com.xilinx.rapidwright.rwroute;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
+import com.xilinx.rapidwright.device.IntentCode;
 import com.xilinx.rapidwright.design.Net;
 import com.xilinx.rapidwright.design.SitePinInst;
 import com.xilinx.rapidwright.device.Node;
@@ -49,7 +51,7 @@ public class Connection implements Comparable<Connection>{
     private RouteNode sourceRnode;
     private RouteNode altSourceRnode;
     private RouteNode sinkRnode;
-    private RouteNode altSinkRnode;
+    private List<RouteNode> altSinkRnodes;
     /**
      * true to indicate the source and the sink are connected through dedicated resources,
      * such as the carry chain connections and connections between cascaded BRAMs.
@@ -294,13 +296,25 @@ public RouteNode getSinkRnode() {
         return sinkRnode;
     }
 
-    public void setSinkRnode(RouteNode childRnode) {
-        sinkRnode = childRnode;
+    public void setSinkRnode(RouteNode sinkRnode) {
+        this.sinkRnode = sinkRnode;
     }
 
-    public RouteNode getAltSinkRnode() { return altSinkRnode; }
+    public List<RouteNode> getAltSinkRnodes() {
+        return altSinkRnodes == null ? Collections.emptyList() : altSinkRnodes;
+    }
 
-    public void setAltSinkRnode(RouteNode childRnode) { altSinkRnode = childRnode; }
+    public void addAltSinkRnode(RouteNode sinkRnode) {
+        if (altSinkRnodes == null) {
+            altSinkRnodes = new ArrayList<>(1);
+        } else {
+            assert(!altSinkRnodes.contains(sinkRnode));
+        }
+        assert(sinkRnode.getType() == RouteNodeType.PINFEED_I ||
+               // Can be a WIRE if node is not exclusive a sink
+               sinkRnode.getType() == RouteNodeType.WIRE);
+        altSinkRnodes.add(sinkRnode);
+    }
 
     public short getXMinBB() {
         return xMinBB;
@@ -467,10 +481,30 @@ public String toString() {
         return s.toString();
     }
 
-    public void setTarget(boolean target) {
-        sinkRnode.setTarget(target);
-        if (altSinkRnode != null) {
-            altSinkRnode.setTarget(target);
+    public void setAllTargets(boolean target) {
+        if (sinkRnode.countConnectionsOfUser(netWrapper) == 0 ||
+            sinkRnode.getNode().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.
+            // This prevents -- for the case where the same net needs to be routed
+            // to the same LUT more than once -- the illegal case of the same
+            // physical pin servicing more than one logical pin
+            sinkRnode.setTarget(target);
+        } else {
+            assert(altSinkRnodes != null && !altSinkRnodes.isEmpty());
+        }
+        if (altSinkRnodes != null) {
+            for (RouteNode rnode : altSinkRnodes) {
+                // Same condition as above: only allow this as an alternate sink
+                // if it's not already in use by the current net to prevent the case
+                // where the same physical pin services more than one logical pin
+                if (rnode.countConnectionsOfUser(netWrapper) == 0 ||
+                    // Except if it is not a PINFEED_I
+                    rnode.getType() != RouteNodeType.PINFEED_I) {
+                    assert(rnode.getNode().getIntentCode() != IntentCode.NODE_PINBOUNCE);
+                    rnode.setTarget(target);
+                }
+            }
         }
     }
 }

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

@@ -33,6 +33,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -353,17 +354,19 @@ protected void determineRoutingTargets() {
             // (it's possible for another connection to use a bounce node, but now that node is
             // needed as a site pin)
             for (Connection connection : netWrapper.getConnections()) {
-                for (RouteNode rnode : Arrays.asList(connection.getSinkRnode(), connection.getAltSinkRnode())) {
+                Consumer<RouteNode> action = (rnode) -> {
                     if (rnode == null) {
-                        continue;
+                        return;
                     }
                     RouteNode prev = rnode.getPrev();
                     if (prev == null) {
-                        continue;
+                        return;
                     }
                     stashedPrev.put(rnode, prev);
                     rnode.clearPrev();
-                }
+                };
+                action.accept(connection.getSinkRnode());
+                connection.getAltSinkRnodes().forEach(action);
             }
 
             // Create all nodes used by this net and set its previous pointer so that:
@@ -395,7 +398,20 @@ protected void determineRoutingTargets() {
                 RouteNode sinkRnode = connection.getSinkRnode();
                 assert(sourceRnode.getType() == RouteNodeType.PINFEED_O);
                 assert(sinkRnode.getType() == RouteNodeType.PINFEED_I);
+
+                // 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);
+                if (!connection.getSink().isRouted() && connection.getAltSinkRnodes().isEmpty()) {
+                    // Undo what ripUp() did for this connection which has a single exclusive sink
+                    sinkRnode.incrementUser(connection.getNetWrapper());
+                    sinkRnode.updatePresentCongestionCost(presentCongestionFactor);
+                }
             }
 
             // Restore prev to avoid assertions firing
@@ -631,7 +647,20 @@ protected void unpreserveNet(Net net) {
                 RouteNode sinkRnode = connection.getSinkRnode();
                 assert(sourceRnode.getType() == RouteNodeType.PINFEED_O);
                 assert(sinkRnode.getType() == RouteNodeType.PINFEED_I);
+
+                // 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);
+                if (!connection.getSink().isRouted() && connection.getAltSinkRnodes().isEmpty()) {
+                    // Undo what ripUp() did for this connection which has a single exclusive sink
+                    sinkRnode.incrementUser(connection.getNetWrapper());
+                    sinkRnode.updatePresentCongestionCost(presentCongestionFactor);
+                }
             }
 
             netToPins.put(net, net.getSinkPins());