[RWRoute] Versal optimizations

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

@@ -305,7 +305,7 @@ public void addAltSinkRnode(RouteNode sinkRnode) {
         } else {
             assert(!altSinkRnodes.contains(sinkRnode));
         }
-        assert(sinkRnode.getType().isExclusiveSink() ||
+        assert(sinkRnode.getType().isAnyExclusiveSink() ||
                // Can be a WIRE if node is not exclusive a sink
                sinkRnode.getType() == RouteNodeType.NON_LOCAL);
         altSinkRnodes.add(sinkRnode);
@@ -487,7 +487,7 @@ public void setAllTargets(RWRoute.ConnectionState state) {
                 // where the same physical pin services more than one logical pin
                 if (rnode.countConnectionsOfUser(netWrapper) == 0 ||
                     // Except if it is not an EXCLUSIVE_SINK
-                    rnode.getType().isExclusiveSink()) {
+                    rnode.getType().isAnyExclusiveSink()) {
                     assert(rnode.getIntentCode() != IntentCode.NODE_PINBOUNCE);
                     rnode.markTarget(state);
                 }

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

@@ -256,7 +256,7 @@ protected void determineRoutingTargets() {
             preservedNet = routingGraph.getPreservedNet(sinkRnode);
             if (preservedNet != null && preservedNet != net) {
                 unpreserveNets.add(preservedNet);
-                assert(sinkRnode.getType().isExclusiveSink());
+                assert(sinkRnode.getType().isAnyExclusiveSink());
             }
         }
 
@@ -599,7 +599,7 @@ protected void unpreserveNet(Net net) {
                 RouteNode sourceRnode = connection.getSourceRnode();
                 RouteNode sinkRnode = connection.getSinkRnode();
                 assert(sourceRnode.getType() == RouteNodeType.EXCLUSIVE_SOURCE);
-                assert(sinkRnode.getType().isExclusiveSink());
+                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

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

@@ -325,6 +325,32 @@ protected void determineRoutingTargets() {
 
         // Wait for all outstanding RouteNodeGraph.preserveAsync() calls to complete
         routingGraph.awaitPreserve();
+
+        // On Versal only, reserve all uphills of NODE_(CLE|INTF)_CTRL sinks since
+        // their [BC]NODEs can also be used to reach NODE_INODEs --- not applying this
+        // heuristic can lead to avoidable congestion
+        if (routingGraph.isVersal) {
+            for (Connection connection : indirectConnections) {
+                RouteNode sinkRnode = connection.getSinkRnode();
+                if (sinkRnode.getType() == RouteNodeType.EXCLUSIVE_SINK_BOTH) {
+                    for (Node uphill : sinkRnode.getAllUphillNodes()) {
+                        if (uphill.isTiedToVcc()) {
+                            continue;
+                        }
+                        Net preservedNet = routingGraph.getPreservedNet(uphill);
+                        if (preservedNet != null && preservedNet != connection.getNetWrapper().getNet()) {
+                            continue;
+                        }
+                        assert((sinkRnode.getIntentCode() == IntentCode.NODE_CLE_CTRL &&
+                                        (uphill.getIntentCode() == IntentCode.NODE_CLE_CNODE || uphill.getIntentCode() == IntentCode.NODE_CLE_BNODE)) ||
+                                (sinkRnode.getIntentCode() == IntentCode.NODE_INTF_CTRL &&
+                                        (uphill.getIntentCode() == IntentCode.NODE_INTF_CNODE || uphill.getIntentCode() == IntentCode.NODE_INTF_BNODE)));
+                        RouteNode rnode = routingGraph.getOrCreate(uphill, RouteNodeType.LOCAL_RESERVED);
+                        rnode.setType(RouteNodeType.LOCAL_RESERVED);
+                    }
+                }
+            }
+        }
     }
 
     private void categorizeNets() {
@@ -601,19 +627,19 @@ protected NetWrapper createNetWrapperAndConnections(Net net) {
                 }
 
                 indirectConnections.add(connection);
-                BitSet[] eastWestWires = (routingGraph.eastWestWires == null) ? null :
-                        routingGraph.eastWestWires.get(sinkINTNode.getTile().getTileTypeEnum());
-                RouteNode sinkRnode;
-                if (eastWestWires != null && eastWestWires[0].get(sinkINTNode.getWireIndex())) {
-                    sinkRnode = routingGraph.getOrCreate(sinkINTNode, RouteNodeType.EXCLUSIVE_SINK_EAST);
-                    sinkRnode.setType(RouteNodeType.EXCLUSIVE_SINK_EAST);
-                } else if (eastWestWires != null && eastWestWires[1].get(sinkINTNode.getWireIndex())) {
-                    sinkRnode = routingGraph.getOrCreate(sinkINTNode, RouteNodeType.EXCLUSIVE_SINK_WEST);
-                    sinkRnode.setType(RouteNodeType.EXCLUSIVE_SINK_WEST);
-                } else {
-                    sinkRnode = routingGraph.getOrCreate(sinkINTNode, RouteNodeType.EXCLUSIVE_SINK);
-                    sinkRnode.setType(RouteNodeType.EXCLUSIVE_SINK);
-                }
+
+                // Inform RouteNodeInfo.getType() that this a sink to prevent it from returning
+                // RouteNodeType.LAGUNA_PINFEED and instead return LOCAL_{EAST,WEST}
+                boolean forceSink = true;
+                RouteNodeType sinkType = RouteNodeInfo.getType(sinkINTNode, null, routingGraph, forceSink);
+                assert(sinkType.isAnyLocal());
+                sinkType = sinkType == RouteNodeType.LOCAL_EAST ? RouteNodeType.EXCLUSIVE_SINK_EAST :
+                           sinkType == RouteNodeType.LOCAL_WEST ? RouteNodeType.EXCLUSIVE_SINK_WEST :
+                           sinkType == RouteNodeType.LOCAL_BOTH ? RouteNodeType.EXCLUSIVE_SINK_BOTH :
+                           null;
+                assert(sinkType != null);
+                RouteNode sinkRnode = routingGraph.getOrCreate(sinkINTNode, sinkType);
+                sinkRnode.setType(sinkType);
                 connection.setSinkRnode(sinkRnode);
 
                 // Where appropriate, allow all 6 LUT pins to be swapped to begin with
@@ -665,7 +691,7 @@ protected NetWrapper createNetWrapperAndConnections(Net net) {
                         continue;
                     }
                     RouteNode altSinkRnode = routingGraph.getOrCreate(node, sinkRnode.getType());
-                    assert(altSinkRnode.getType().isExclusiveSink());
+                    assert(altSinkRnode.getType().isAnyExclusiveSink());
                     connection.addAltSinkRnode(altSinkRnode);
                 }
 
@@ -1811,22 +1837,24 @@ private void exploreAndExpand(ConnectionState state, RouteNode rnode) {
                     continue;
                 }
                 switch (childRNode.getType()) {
-                    case LOCAL:
+                    case LOCAL_RESERVED:
+                    case LOCAL_BOTH:
                     case LOCAL_EAST:
                     case LOCAL_WEST:
                         if (!routingGraph.isAccessible(childRNode, connection)) {
                             continue;
                         }
-                        // Verify invariant that east/west wires stay east/west
-                        assert(rnode.getType() != RouteNodeType.LOCAL_EAST || childRNode.getType() == RouteNodeType.LOCAL_EAST);
-                        assert(rnode.getType() != RouteNodeType.LOCAL_WEST || childRNode.getType() == RouteNodeType.LOCAL_WEST);
+                        // Verify invariant that east/west wires stay east/west ...
+                        assert(rnode.getType() != RouteNodeType.LOCAL_EAST || childRNode.getType() == RouteNodeType.LOCAL_EAST ||
+                                // ... unless it's an exclusive sink using a LOCAL_RESERVED node
+                                (childRNode.getType() == RouteNodeType.LOCAL_RESERVED && connection.getSinkRnode().getType() == RouteNodeType.EXCLUSIVE_SINK_BOTH));
+                        assert(rnode.getType() != RouteNodeType.LOCAL_WEST || childRNode.getType() == RouteNodeType.LOCAL_WEST ||
+                                (childRNode.getType() == RouteNodeType.LOCAL_RESERVED && connection.getSinkRnode().getType() == RouteNodeType.EXCLUSIVE_SINK_BOTH));
                         break;
                     case NON_LOCAL:
                         // LOCALs cannot connect to NON_LOCALs except via a LUT routethru
-                        assert(!rnode.getType().isLocal() ||
-                               routingGraph.lutRoutethru && rnode.getIntentCode() == IntentCode.NODE_PINFEED ||
-                               // FIXME:
-                               design.getSeries() == Series.Versal);
+                        assert(!rnode.getType().isAnyLocal() ||
+                               routingGraph.lutRoutethru && rnode.getIntentCode() == IntentCode.NODE_PINFEED);
 
                         if (!routingGraph.isAccessible(childRNode, connection)) {
                             continue;
@@ -1837,14 +1865,16 @@ private void exploreAndExpand(ConnectionState state, RouteNode rnode) {
                             continue;
                         }
                         break;
-                    case EXCLUSIVE_SINK:
+                    case EXCLUSIVE_SINK_BOTH:
                     case EXCLUSIVE_SINK_EAST:
                     case EXCLUSIVE_SINK_WEST:
                         assert(childRNode.getType() != RouteNodeType.EXCLUSIVE_SINK_EAST || rnode.getType() == RouteNodeType.LOCAL_EAST);
                         assert(childRNode.getType() != RouteNodeType.EXCLUSIVE_SINK_WEST || rnode.getType() == RouteNodeType.LOCAL_WEST);
-                        assert(childRNode.getType() != RouteNodeType.EXCLUSIVE_SINK || rnode.getType() == RouteNodeType.LOCAL ||
-                                // FIXME:
-                                design.getSeries() == Series.Versal);
+                        assert(childRNode.getType() != RouteNodeType.EXCLUSIVE_SINK_BOTH || rnode.getType() == RouteNodeType.LOCAL_BOTH ||
+                               // [BC]NODEs are LOCAL_{EAST,WEST} since they connect to INODEs, but also service CTRL sinks
+                               (routingGraph.isVersal && EnumSet.of(IntentCode.NODE_CLE_BNODE, IntentCode.NODE_CLE_CNODE,
+                                                                    IntentCode.NODE_INTF_BNODE, IntentCode.NODE_INTF_CNODE)
+                                       .contains(rnode.getIntentCode())));
                         if (!isAccessibleSink(childRNode, connection)) {
                             continue;
                         }
@@ -1889,7 +1919,7 @@ protected boolean isAccessibleSink(RouteNode child, Connection connection) {
     }
 
     protected boolean isAccessibleSink(RouteNode child, Connection connection, boolean assertOnOveruse) {
-        assert(child.getType().isExclusiveSink());
+        assert(child.getType().isAnyExclusiveSink());
         assert(!assertOnOveruse || !child.isOverUsed());
 
         if (child.isTarget()) {

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

@@ -33,6 +33,7 @@
 import com.xilinx.rapidwright.util.RuntimeTracker;
 
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
@@ -123,22 +124,24 @@ private void setBaseCost(Series series) {
                 assert(length == 0 ||
                         (length <= 3 && series == Series.Versal));
                 break;
-            case EXCLUSIVE_SINK:
+            case EXCLUSIVE_SINK_BOTH:
             case EXCLUSIVE_SINK_EAST:
             case EXCLUSIVE_SINK_WEST:
                 assert(length == 0 ||
                        (length == 1 && (series == Series.UltraScalePlus || series == Series.UltraScale) && getIntentCode() == IntentCode.NODE_PINBOUNCE));
                 break;
-            case LOCAL:
+            case LOCAL_BOTH:
                 assert(length == 0);
                 break;
             case LOCAL_EAST:
             case LOCAL_WEST:
+            case LOCAL_RESERVED:
                 assert(length == 0 ||
                        (length == 1 && (
                                ((series == Series.UltraScalePlus || series == Series.UltraScale) && getIntentCode() == IntentCode.NODE_PINBOUNCE) ||
                                (series == Series.UltraScalePlus && getWireName().matches("INODE_[EW]_\\d+_FT[01]")) ||
-                               (series == Series.UltraScale && getWireName().matches("INODE_[12]_[EW]_\\d+_FT[NS]"))
+                               (series == Series.UltraScale && getWireName().matches("INODE_[12]_[EW]_\\d+_FT[NS]")) ||
+                               (series == Series.Versal && EnumSet.of(IntentCode.NODE_CLE_BNODE, IntentCode.NODE_CLE_CNODE).contains(getIntentCode()))
                        ))
                    );
                 break;
@@ -221,20 +224,6 @@ private void setBaseCost(Series series) {
                                // Feedthrough nodes to reach tiles immediately above/below
                                (length == 1 && getWireName().matches("OUT_[NESW]NODE_[EW]_\\d+")));
                         break;
-                    case NODE_INODE:        // INT.INT_NODE_IMUX_ATOM_*_INT_OUT[01]
-                    case NODE_IMUX:         // INT.IMUX_B_[EW]*
-                    case NODE_CLE_CTRL:     // CLE_BC_CORE*.CTRL_[LR]_B*
-                    case NODE_INTF_CTRL:    // INTF_[LR]OCF_[TB][LR]_TILE.INTF_IRI*
-                        assert(length == 0);
-                        break;
-                    case NODE_CLE_BNODE:    // CLE_BC_CORE*.BNODE_OUTS_[EW]*
-                    case NODE_CLE_CNODE:    // CLE_BC_CORE*.CNODE_OUTS_[EW]*
-                    case NODE_INTF_BNODE:   // INTF_[LR]OCF_[TB][LR]_TILE.IF_INT_BNODE_OUTS*
-                    case NODE_INTF_CNODE:   // INTF_[LR]OCF_[TB][LR]_TILE.IF_INT_CNODE_OUTS*
-                        // length == 1 because one side of BCNODE-s are shared between CLE_W_CORE_XaYb and CLE_E_CORE_X(a+1)Yb
-                        // or CLE_W_CORE_X(a-1)Yb and CLE_E_CORE_XaYb
-                        assert(length <= 1);
-                        break;
                     default:
                         throw new RuntimeException(ic.toString());
                 }
@@ -367,10 +356,13 @@ public RouteNodeType getType() {
     public void setType(RouteNodeType type) {
         assert(this.type == type ||
                 // Support demotion from EXCLUSIVE_SINK to LOCAL since they have the same base cost
-                (this.type.isExclusiveSink() && type.isLocal()) ||
+                (this.type.isAnyExclusiveSink() && type.isAnyLocal()) ||
                 // Or promotion from LOCAL to EXCLUSIVE_SINK (by PartialRouter when NODE_PINBOUNCE on
                 // a newly unpreserved net becomes a sink)
-                (this.type.isLocal() && type.isExclusiveSink()));
+                (this.type.isAnyLocal() && type.isAnyExclusiveSink())) ||
+                // Or promotion for any LOCAL to a LOCAL_RESERVED (by determineRoutingTargets()
+                // for uphills of CTRL sinks)
+                (this.type.isAnyLocal() && type == RouteNodeType.LOCAL_RESERVED);
         this.type = type;
     }