RouteNodeGraph

Object
- com.xilinx.rapidwright.rwroute.RouteNodeGraph

Direct Known Subclasses:

CUFR.RouteNodeGraphCUFR, PartialCUFR.RouteNodeGraphPartialCUFR, RouteNodeGraphTimingDriven
```
public class RouteNodeGraph
extends Object
```
Encapsulation of RWRoute's routing resource graph.

Field Summary

Fields
Modifier and Type	Field and Description
`int[]`	`intYToSLRIndex` Array mapping an INT tile's Y coordinate to its SLR index
`int[]`	`nextCrossingHalfColumn` Arrays mapping a half-tile X coordinate (see `RouteNode.getEndHalfTileXCoordinate()`) to that of the next (at or above) or previous (at or below) INT tile half from which super long lines can cross into another SLR: the west half of an INT tile with a Laguna column (UltraScale/UltraScale+), or either half beside an SLL column with SLLs that cross SLRs (Versal).
`int[]`	`prevCrossingHalfColumn`
`static int`	`SDQ_LOOKAHEAD_BASE_COST`
`static int`	`SDQ_LOOKAHEAD_END_HALF_X`
`static int`	`SDQ_LOOKAHEAD_END_Y`
`static int`	`SDQ_LOOKAHEAD_FIELDS`
`static int`	`SDQ_LOOKAHEAD_INHERIT_SIDE`
`static int`	`SDQ_LOOKAHEAD_TILE_X` Fields of a child wire in `RouteNodeGraph.sdqLookahead`: the offset in INT tile X and Y of the tile of its base wire, and that base wire's index (which identify it, so that tables measured from different tiles can be compared); its nominal wirelength in half tiles; the offset in half tiles and rows of where it ends (relative to twice the SDQ node's tile X, and its tile Y); 1 if it is of type `RouteNodeType.NON_LOCAL_INHERIT_PREV_SIDE` (it then ends on the side of its parent), else 0; and its base cost (as float bits).
`static int`	`SDQ_LOOKAHEAD_TILE_Y`
`static int`	`SDQ_LOOKAHEAD_WIRE`
`static int`	`SDQ_LOOKAHEAD_WIRELENGTH`
`int[]`	`slrFirstIntY` Array mapping an SLR index to the (lowest) Y coordinate of its first row of INT tiles
`int[]`	`slrLastIntY` Array mapping an SLR index to the (highest) Y coordinate of its last row of INT tiles
`short`	`SUPER_LONG_LINE_LENGTH_IN_TILES`
`static short`	`ULTRASCALE_SUPER_LONG_LINE_LENGTH_IN_TILES` Length of a super long line on UltraScale and UltraScale+, in INT tiles
`static short`	`VERSAL_SUPER_LONG_LINE_LENGTH_IN_TILES` Length of a super long line on Versal, in INT tiles

Constructor Summary

Constructors
Constructor and Description

RouteNodeGraph(Design design, RWRouteConfig config)

Constructors
Constructor and Description
`RouteNodeGraph(Design design, RWRouteConfig config)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`averageChildren()`
`void`	`awaitPreserve()`
`boolean`	`checkSourceSideKnown(Node sourceNode)` Checks that the side of its INT tile that a node RWRoute routes from (a net's source or alternate source, as projected by RouterHelper.projectOutputPinToINTNode()) is on is known to `RouteNodeGraph.isEastSideWire(TileTypeEnum, int)`: that its tile type is listed in `RouteNodeGraph.SITE_TILE_TYPE_ON_EAST_SIDE`, or has east-side wires of its own (e.g.
`int`	`getCrossingWidenedXMax(int xMin, int xMax)` Gets the highest X coordinate of the horizontal span of an SLR-crossing bounding box, widened if needed so that the span contains at least one INT tile column from which super long lines can cross SLRs (Laguna on UltraScale/UltraScale+, SLL on Versal): the next such column at or above its lowest X coordinate, if any (see also `RouteNodeGraph.getCrossingWidenedXMin(int, int)`).
`int`	`getCrossingWidenedXMin(int xMin, int xMax)` Gets the lowest X coordinate of the horizontal span of an SLR-crossing bounding box, widened if needed so that the span contains at least one INT tile column from which super long lines can cross SLRs: the previous such column at or below its highest X coordinate, if any (see also `RouteNodeGraph.getCrossingWidenedXMax(int, int)`).
`DelayEstimatorBase<InterconnectInfo>`	`getDelayEstimator()` Gets the delay estimator that this graph computes its node delays with.
`RouteNodeType`	`getExclusiveSinkType(RouteNode sinkRnode)` Gets the type that a (single) sink is to be given: `RouteNodeType.EXCLUSIVE_SINK_CTRL` for CTRL_* pins on UltraScale/UltraScale+ and CTRL pins on Versal, `RouteNodeType.EXCLUSIVE_SINK_SLL_INPUT` for SLL inputs on Versal, otherwise `RouteNodeType.EXCLUSIVE_SINK`.
`RouteNode`	`getNode(Node node)`
`RouteNode`	`getOrCreate(Node node)`
`RouteNode`	`getOrCreate(Node node, RouteNodeType type)`
`RouteNode`	`getOrCreateSinkDriver(Tile sinkTile, int rowOffset, int wireIndex)` Gets the rnode of a sink's driver given by `RouteNodeGraph.getSinkDriverWires(RouteNode)`, creating it if it has none yet, as RWRoute.setFinishCosts() does for a driver found from the device.
`float`	`getPresentCongestionCost(int occupancy)` Gets the present congestion cost of a node with the given occupancy: RouteNode.initialPresentCongestionCost, plus the present congestion factor (see setPresentCongestionFactor()) for each user that the node would have over its capacity with one more.
`Net`	`getPreservedNet(Node node)`
`Iterable<RouteNode>`	`getRnodes()`
`int[]`	`getSdqLookahead(RouteNode rnode)` Gets the child wires of an SDQ node, as listed in `RouteNodeGraph.sdqLookahead`.
`int`	`getSendingSLLRow(RouteNode rnode)` Gets the row from which the super long line that a node on the sending side of a chain leads to is taken (that of the IMUX and Laguna tile of its chain on UltraScale/UltraScale+, or of its SLL tile on Versal): for an UltraScale/UltraScale+ SDQ node or single (NON_LOCAL_LEADING_TO_SLL), the row of its base tile, by which it is keyed (see populateLagunaLookups()), even if it is a feedthrough that ends in the next row (e.g.
`int[]`	`getSinkDriverRowOffsets(RouteNode sinkRnode)` Gets the offsets of the tiles of a sink's drivers (see `TileTypeInfo#sinkDriverRowOffsets`), for a sink whose drivers are given by `RouteNodeGraph.getSinkDriverWires(RouteNode)`.
`int[]`	`getSinkDriverWires(RouteNode sinkRnode)` Gets the drivers of a sink from the tables built by buildSinkDriverTables(), where they give them: if its drivers are all INODEs, GNODEs, BNODEs or CNODEs and, where any is in another tile, the sink is in a clean row (see `TileTypeInfo#cleanRows`) and there is no PBlock (as RWRoute.setFinishCosts() treats a driver outside the PBlock differently depending on whether it has an rnode yet).
`void`	`initialize()`
`boolean`	`isAccessible(RouteNode childRnode, RouteNode parentRnode, Connection connection)`
`boolean`	`isAllowedTile(Node child)`
`boolean`	`isEastSideWire(TileTypeEnum tileTypeEnum, int wireIndex)` Checks if a node ends on the east side of an interconnect tile (otherwise, it is considered to end on the west side): every node of a tile type beside the east side of its INT tile (see `RouteNodeGraph.SITE_TILE_TYPE_ON_EAST_SIDE`), or one given by `TileTypeInfo#eastSideWires`.
`static boolean`	`isExcludedTile(Node child)`
`boolean`	`isInheritPrevSideWire(TileTypeEnum tileTypeEnum, int wireIndex)` Checks if a node is to be a `RouteNodeType.NON_LOCAL_INHERIT_PREV_SIDE` node (see `TileTypeInfo#inheritPrevSideWires`).
`boolean`	`isNorthboundSLLRow(int y)` Checks whether nodes leading to a super long line (see `RouteNodeType.LOCAL_LEADING_TO_SLL`) in the given row lead to one crossing into the SLR to the north (else south): such nodes are only found in the band of rows next to an SLR boundary, so those in the upper half of their SLR lead north, and those in the lower half south.
`boolean`	`isOnBothSides(RouteNode rnode)` Checks if a node is not on either side of an INT tile but between two (on the east side of the INT tile at `RouteNode.getEndTileXCoordinate()` and the west side of the next), and is thus considered to be on both: Versal SLL inputs, outputs and data, in SLL tiles (see `RouteNodeInfo.isOnBothSides(IntentCode)`).
`boolean`	`isPreserved(Node node)`
`boolean`	`isSendingSLLRow(int y)` Checks whether super long lines crossing into another SLR can be taken from the given row: whether it is within one super long line's length of the boundary of its SLR that it is nearer to (see isNorthboundSLLRow()), other than the top and bottom edges of the device.
`boolean`	`isSidedLocalWire(TileTypeEnum tileTypeEnum, int wireIndex)` Checks if a local node serves only one side (half) of its interconnect tile.
`static boolean`	`isSllTileType(TileTypeEnum tileTypeEnum)` Checks if a tile type is a Versal SLL tile: SLL, or SLL2 (xcvp1902).
`boolean`	`isVersalLagOutRoutethru(Node parent, Node child)` Determine if the given nodes represent a SLICE routethru from an input site pin dedicated for SLLs to the [A-H]Q or [A-H]Q2 output.
`int`	`numNodes()`
`void`	`preserve(Net net)`
`void`	`preserve(Net net, List<SitePinInst> pins)`
`void`	`preserveAsync(Net net)`
`void`	`preserveAsync(Net net, List<SitePinInst> pins)`
`void`	`setPresentCongestionFactor(float presentCongestionFactor)`
`boolean`	`unpreserve(Node node)`

Methods inherited from class Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ULTRASCALE_SUPER_LONG_LINE_LENGTH_IN_TILES
```
public static final short ULTRASCALE_SUPER_LONG_LINE_LENGTH_IN_TILES
```
    Length of a super long line on UltraScale and UltraScale+, in INT tiles
    
    See Also:
    
    Constant Field Values
  - VERSAL_SUPER_LONG_LINE_LENGTH_IN_TILES
```
public static final short VERSAL_SUPER_LONG_LINE_LENGTH_IN_TILES
```
    Length of a super long line on Versal, in INT tiles
    
    See Also:
    
    Constant Field Values
  - SUPER_LONG_LINE_LENGTH_IN_TILES
```
public final short SUPER_LONG_LINE_LENGTH_IN_TILES
```
  - intYToSLRIndex
```
public final int[] intYToSLRIndex
```
    Array mapping an INT tile's Y coordinate to its SLR index
  - slrFirstIntY
```
public final int[] slrFirstIntY
```
    Array mapping an SLR index to the (lowest) Y coordinate of its first row of INT tiles
  - slrLastIntY
```
public final int[] slrLastIntY
```
    Array mapping an SLR index to the (highest) Y coordinate of its last row of INT tiles
  - nextCrossingHalfColumn
```
public final int[] nextCrossingHalfColumn
```
    Arrays mapping a half-tile X coordinate (see RouteNode.getEndHalfTileXCoordinate()) to that of the next (at or above) or previous (at or below) INT tile half from which super long lines can cross into another SLR: the west half of an INT tile with a Laguna column (UltraScale/UltraScale+), or either half beside an SLL column with SLLs that cross SLRs (Versal). Integer.MAX_VALUE/Integer.MIN_VALUE if there is none; null if the device has no such columns. Every SLR boundary has the same such columns (on all multi-SLR devices examined).
  - prevCrossingHalfColumn
```
public final int[] prevCrossingHalfColumn
```
  - SDQ_LOOKAHEAD_TILE_X
```
public static final int SDQ_LOOKAHEAD_TILE_X
```
    Fields of a child wire in RouteNodeGraph.sdqLookahead: the offset in INT tile X and Y of the tile of its base wire, and that base wire's index (which identify it, so that tables measured from different tiles can be compared); its nominal wirelength in half tiles; the offset in half tiles and rows of where it ends (relative to twice the SDQ node's tile X, and its tile Y); 1 if it is of type RouteNodeType.NON_LOCAL_INHERIT_PREV_SIDE (it then ends on the side of its parent), else 0; and its base cost (as float bits).
    
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_TILE_Y
```
public static final int SDQ_LOOKAHEAD_TILE_Y
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_WIRE
```
public static final int SDQ_LOOKAHEAD_WIRE
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_WIRELENGTH
```
public static final int SDQ_LOOKAHEAD_WIRELENGTH
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_END_HALF_X
```
public static final int SDQ_LOOKAHEAD_END_HALF_X
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_END_Y
```
public static final int SDQ_LOOKAHEAD_END_Y
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_INHERIT_SIDE
```
public static final int SDQ_LOOKAHEAD_INHERIT_SIDE
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_BASE_COST
```
public static final int SDQ_LOOKAHEAD_BASE_COST
```
    See Also:
    
    Constant Field Values
  - SDQ_LOOKAHEAD_FIELDS
```
public static final int SDQ_LOOKAHEAD_FIELDS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RouteNodeGraph
```
public RouteNodeGraph(Design design,
                      RWRouteConfig config)
```
- Method Detail
  - getSdqLookahead
```
public int[] getSdqLookahead(RouteNode rnode)
```
    Gets the child wires of an SDQ node, as listed in RouteNodeGraph.sdqLookahead.
    
    Parameters:
    
    rnode - The node in question.
    
    Returns:
    
    Its entry, or null if it is not an SDQ node of an INT tile (or there is no table).
  - getSinkDriverWires
```
public int[] getSinkDriverWires(RouteNode sinkRnode)
```
    Gets the drivers of a sink from the tables built by buildSinkDriverTables(), where they give them: if its drivers are all INODEs, GNODEs, BNODEs or CNODEs and, where any is in another tile, the sink is in a clean row (see TileTypeInfo#cleanRows) and there is no PBlock (as RWRoute.setFinishCosts() treats a driver outside the PBlock differently depending on whether it has an rnode yet).
    
    Parameters:
    
    sinkRnode - The sink.
    
    Returns:
    
    Base wire indices of its drivers (with their tiles given by RouteNodeGraph.getSinkDriverRowOffsets(RouteNode)), in the order that Node.getAllUphillNodes() gives them (less repeats), or null if not given (as for every sink of a tile type with no entry in RouteNodeGraph.tileTypeInfos).
  - getSinkDriverRowOffsets
```
public int[] getSinkDriverRowOffsets(RouteNode sinkRnode)
```
    Gets the offsets of the tiles of a sink's drivers (see TileTypeInfo#sinkDriverRowOffsets), for a sink whose drivers are given by RouteNodeGraph.getSinkDriverWires(RouteNode).
    
    Parameters:
    
    sinkRnode - The sink.
    
    Returns:
    
    Their offsets in device rows, or null if they are all in the sink's tile.
  - getOrCreateSinkDriver
```
public RouteNode getOrCreateSinkDriver(Tile sinkTile,
                                       int rowOffset,
                                       int wireIndex)
```
    Gets the rnode of a sink's driver given by RouteNodeGraph.getSinkDriverWires(RouteNode), creating it if it has none yet, as RWRoute.setFinishCosts() does for a driver found from the device. Drivers are created only then, not with their sink: an rnode makes its node unavailable to the clock and static net routers (see RWRoute.getGlobalRoutingNodeStatus()), which run after the sinks are created and before signal routing.
    
    Parameters:
    
    sinkTile - The sink's tile.
    
    rowOffset - The offset of the driver's tile, in device rows (see TileTypeInfo#sinkDriverRowOffsets).
    
    wireIndex - The driver's base wire index.
    
    Returns:
    
    Its rnode.
  - isNorthboundSLLRow
```
public boolean isNorthboundSLLRow(int y)
```
    Checks whether nodes leading to a super long line (see RouteNodeType.LOCAL_LEADING_TO_SLL) in the given row lead to one crossing into the SLR to the north (else south): such nodes are only found in the band of rows next to an SLR boundary, so those in the upper half of their SLR lead north, and those in the lower half south.
    
    Parameters:
    
    y - INT tile Y coordinate of the node's base tile.
    
    Returns:
    
    True if northbound.
  - isSendingSLLRow
```
public boolean isSendingSLLRow(int y)
```
    Checks whether super long lines crossing into another SLR can be taken from the given row: whether it is within one super long line's length of the boundary of its SLR that it is nearer to (see isNorthboundSLLRow()), other than the top and bottom edges of the device. (On UltraScale/UltraScale+, the Laguna tiles whose super long lines cross SLRs are in the clock region next to that boundary, as tall as a super long line is long; see populateLagunaLookups().)
    
    Parameters:
    
    y - INT tile Y coordinate.
    
    Returns:
    
    True if so.
  - getSendingSLLRow
```
public int getSendingSLLRow(RouteNode rnode)
```
    Gets the row from which the super long line that a node on the sending side of a chain leads to is taken (that of the IMUX and Laguna tile of its chain on UltraScale/UltraScale+, or of its SLL tile on Versal):
    - for an UltraScale/UltraScale+ SDQ node or single (NON_LOCAL_LEADING_TO_SLL), the row of its base tile, by which it is keyed (see populateLagunaLookups()), even if it is a feedthrough that ends in the next row (e.g. WW1_E_7_FT0 on UltraScale+, SDND[NS]W_E_15_FTN on UltraScale);
    - otherwise, the row where the node ends (that of the IMUXes driven by an UltraScale+ feedthrough INODE from the next row), unless super long lines crossing SLRs cannot be taken from there (see isSendingSLLRow()), when it is the row of its base tile: an UltraScale feedthrough INODE (INODE_[12]_[EW]_*_FT[NS], which drives the IMUXes of both its rows) in the row farthest from the SLR boundary from which they can be taken (e.g. INT_X45Y359/INODE_2_W_28_FTN and INT_X37Y240/INODE_2_W_1_FTS on xcku115).
    Parameters:
    
    rnode - A node of type LOCAL_LEADING_TO_SLL or NON_LOCAL_LEADING_TO_SLL.
    
    Returns:
    
    INT tile Y coordinate of that row.
  - getCrossingWidenedXMax
```
public int getCrossingWidenedXMax(int xMin,
                                  int xMax)
```
    Gets the highest X coordinate of the horizontal span of an SLR-crossing bounding box, widened if needed so that the span contains at least one INT tile column from which super long lines can cross SLRs (Laguna on UltraScale/UltraScale+, SLL on Versal): the next such column at or above its lowest X coordinate, if any (see also RouteNodeGraph.getCrossingWidenedXMin(int, int)).
    
    Parameters:
    
    xMin - Lowest INT tile X coordinate of the span.
    
    xMax - Highest INT tile X coordinate of the span.
    
    Returns:
    
    That X coordinate (xMax if there are no such columns at all).
  - getCrossingWidenedXMin
```
public int getCrossingWidenedXMin(int xMin,
                                  int xMax)
```
    Gets the lowest X coordinate of the horizontal span of an SLR-crossing bounding box, widened if needed so that the span contains at least one INT tile column from which super long lines can cross SLRs: the previous such column at or below its highest X coordinate, if any (see also RouteNodeGraph.getCrossingWidenedXMax(int, int)).
    
    Parameters:
    
    xMin - Lowest INT tile X coordinate of the span.
    
    xMax - Highest INT tile X coordinate of the span.
    
    Returns:
    
    That X coordinate (xMin if there are no such columns at all).
  - initialize
```
public void initialize()
```
  - isSidedLocalWire
```
public boolean isSidedLocalWire(TileTypeEnum tileTypeEnum,
                                int wireIndex)
```
    Checks if a local node serves only one side (half) of its interconnect tile.
    
    Parameters:
    
    tileTypeEnum - Tile type of the node's base wire.
    
    wireIndex - Wire index of the node's base wire.
    
    Returns:
    
    True if so.
  - isEastSideWire
```
public boolean isEastSideWire(TileTypeEnum tileTypeEnum,
                              int wireIndex)
```
    Checks if a node ends on the east side of an interconnect tile (otherwise, it is considered to end on the west side): every node of a tile type beside the east side of its INT tile (see RouteNodeGraph.SITE_TILE_TYPE_ON_EAST_SIDE), or one given by TileTypeInfo#eastSideWires.
    
    Parameters:
    
    tileTypeEnum - Tile type of the node's base wire.
    
    wireIndex - Wire index of the node's base wire.
    
    Returns:
    
    True if so.
  - checkSourceSideKnown
```
public boolean checkSourceSideKnown(Node sourceNode)
```
    Checks that the side of its INT tile that a node RWRoute routes from (a net's source or alternate source, as projected by RouterHelper.projectOutputPinToINTNode()) is on is known to RouteNodeGraph.isEastSideWire(TileTypeEnum, int): that its tile type is listed in RouteNodeGraph.SITE_TILE_TYPE_ON_EAST_SIDE, or has east-side wires of its own (e.g. INT). Otherwise the node is placed on the west side, whichever side it is on, which only makes the estimates of the distance from it less accurate: print a warning, once per tile type.
    
    Parameters:
    
    sourceNode - The projected source node.
    
    Returns:
    
    True if its side is known.
  - isInheritPrevSideWire
```
public boolean isInheritPrevSideWire(TileTypeEnum tileTypeEnum,
                                     int wireIndex)
```
    Checks if a node is to be a RouteNodeType.NON_LOCAL_INHERIT_PREV_SIDE node (see TileTypeInfo#inheritPrevSideWires).
    
    Parameters:
    
    tileTypeEnum - Tile type of the node's base wire.
    
    wireIndex - Wire index of the node's base wire.
    
    Returns:
    
    True if so.
  - isOnBothSides
```
public boolean isOnBothSides(RouteNode rnode)
```
    Checks if a node is not on either side of an INT tile but between two (on the east side of the INT tile at RouteNode.getEndTileXCoordinate() and the west side of the next), and is thus considered to be on both: Versal SLL inputs, outputs and data, in SLL tiles (see RouteNodeInfo.isOnBothSides(IntentCode)).
    
    Parameters:
    
    rnode - Node in question.
    
    Returns:
    
    True if so.
  - getExclusiveSinkType
```
public RouteNodeType getExclusiveSinkType(RouteNode sinkRnode)
```
    Gets the type that a (single) sink is to be given: RouteNodeType.EXCLUSIVE_SINK_CTRL for CTRL_* pins on UltraScale/UltraScale+ and CTRL pins on Versal, RouteNodeType.EXCLUSIVE_SINK_SLL_INPUT for SLL inputs on Versal, otherwise RouteNodeType.EXCLUSIVE_SINK.
    
    Parameters:
    
    sinkRnode - Sink node in question.
    
    Returns:
    
    Its type.
  - preserve
```
public void preserve(Net net,
                     List<SitePinInst> pins)
```
  - preserveAsync
```
public void preserveAsync(Net net,
                          List<SitePinInst> pins)
```
  - preserve
```
public void preserve(Net net)
```
  - preserveAsync
```
public void preserveAsync(Net net)
```
  - awaitPreserve
```
public void awaitPreserve()
```
  - unpreserve
```
public boolean unpreserve(Node node)
```
  - isPreserved
```
public boolean isPreserved(Node node)
```
  - isSllTileType
```
public static boolean isSllTileType(TileTypeEnum tileTypeEnum)
```
    Checks if a tile type is a Versal SLL tile: SLL, or SLL2 (xcvp1902). Both host super long lines, CLE [BC]NODEs and CTRL pins.
    
    Parameters:
    
    tileTypeEnum - Tile type in question.
    
    Returns:
    
    True if so.
  - isExcludedTile
```
public static boolean isExcludedTile(Node child)
```
  - isAllowedTile
```
public boolean isAllowedTile(Node child)
```
  - getPreservedNet
```
public Net getPreservedNet(Node node)
```
  - getNode
```
public RouteNode getNode(Node node)
```
  - getRnodes
```
public Iterable<RouteNode> getRnodes()
```
  - numNodes
```
public int numNodes()
```
  - getOrCreate
```
public RouteNode getOrCreate(Node node)
```
  - getOrCreate
```
public RouteNode getOrCreate(Node node,
                             RouteNodeType type)
```
  - averageChildren
```
public int averageChildren()
```
  - isAccessible
```
public boolean isAccessible(RouteNode childRnode,
                            RouteNode parentRnode,
                            Connection connection)
```
  - setPresentCongestionFactor
```
public void setPresentCongestionFactor(float presentCongestionFactor)
```
  - getPresentCongestionCost
```
public float getPresentCongestionCost(int occupancy)
```
    Gets the present congestion cost of a node with the given occupancy: RouteNode.initialPresentCongestionCost, plus the present congestion factor (see setPresentCongestionFactor()) for each user that the node would have over its capacity with one more. Linear in the occupancy, so computed rather than looked up, for any occupancy.
    
    Parameters:
    
    occupancy - Number of users of the node.
    
    Returns:
    
    That cost.
  - getDelayEstimator
```
public DelayEstimatorBase<InterconnectInfo> getDelayEstimator()
```
    Gets the delay estimator that this graph computes its node delays with.
    
    Returns:
    
    That delay estimator, or null since this graph is not timing driven.
  - isVersalLagOutRoutethru
```
public boolean isVersalLagOutRoutethru(Node parent,
                                       Node child)
```
    Determine if the given nodes represent a SLICE routethru from an input site pin dedicated for SLLs to the [A-H]Q or [A-H]Q2 output.
    
    Parameters:
    
    parent - Start node of PIP
    
    child - End node of PIP
    
    Returns:
    
    True if routethru

Class RouteNodeGraph

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

ULTRASCALE_SUPER_LONG_LINE_LENGTH_IN_TILES

VERSAL_SUPER_LONG_LINE_LENGTH_IN_TILES

SUPER_LONG_LINE_LENGTH_IN_TILES

intYToSLRIndex

slrFirstIntY

slrLastIntY

nextCrossingHalfColumn

prevCrossingHalfColumn

SDQ_LOOKAHEAD_TILE_X

SDQ_LOOKAHEAD_TILE_Y

SDQ_LOOKAHEAD_WIRE

SDQ_LOOKAHEAD_WIRELENGTH

SDQ_LOOKAHEAD_END_HALF_X

SDQ_LOOKAHEAD_END_Y

SDQ_LOOKAHEAD_INHERIT_SIDE

SDQ_LOOKAHEAD_BASE_COST

SDQ_LOOKAHEAD_FIELDS

Constructor Detail

RouteNodeGraph

Method Detail

getSdqLookahead

getSinkDriverWires

getSinkDriverRowOffsets

getOrCreateSinkDriver

isNorthboundSLLRow

isSendingSLLRow

getSendingSLLRow

getCrossingWidenedXMax

getCrossingWidenedXMin

initialize

isSidedLocalWire

isEastSideWire

checkSourceSideKnown

isInheritPrevSideWire

isOnBothSides

getExclusiveSinkType

preserve

preserveAsync

preserve

preserveAsync

awaitPreserve

unpreserve

isPreserved

isSllTileType

isExcludedTile

isAllowedTile

getPreservedNet

getNode

getRnodes

numNodes

getOrCreate

getOrCreate

averageChildren

isAccessible

setPresentCongestionFactor

getPresentCongestionCost

getDelayEstimator

isVersalLagOutRoutethru