routing.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

	private static Pref getArcProtoBitPref(ArcProto ap, String what, Map<ArcProto,Pref> map)
	{
		Pref pref = map.get(ap);
		if (pref == null)
		{
			pref = Pref.makeBooleanPref("Default" + what + "For" + ap.getName() + "IN" + ap.getTechnology().getTechName(),
				User.getUserTool().prefs, false);
			map.put(ap, pref);
		}
		return pref;
	}

	/**
	 * Method to set the "sea-of-gates can use" bit for this ArcProto.
	 * @param prevent true if sea-of-gates routing should avoid this ArcProto.
	 */
	public static void setSeaOfGatesPrevent(ArcProto ap, boolean prevent) { getArcProtoBitPref(ap, "SeaOfGatesPrevent", defaultSOGPreventPrefs).setBoolean(prevent); }

	/**
	 * Method to tell if the "sea-of-gates" router can use this ArcProto.
	 * @return true if sea-of-gates routing should avoid this ArcProto.
	 */
	public static boolean isSeaOfGatesPrevent(ArcProto ap) { return getArcProtoBitPref(ap, "SeaOfGatesPrevent", defaultSOGPreventPrefs).getBoolean(); }

	/**
	 * Method to set the "sea-of-gates favor" bit for this ArcProto.
	 * @param favor true if sea-of-gates routing should favor this ArcProto.
	 */
	public static void setSeaOfGatesFavor(ArcProto ap, boolean favor) { getArcProtoBitPref(ap, "SeaOfGatesFavor", defaultSOGFavorPrefs).setBoolean(favor); }

	/**
	 * Method to tell if the "sea-of-gates" router can use this ArcProto, by default.
	 * @return true if sea-of-gates routing should avoid this ArcProto, by default.
	 */
	public static boolean isFactorySeaOfGatesPrevent(ArcProto ap) { return getArcProtoBitPref(ap, "SeaOfGatesPrevent", defaultSOGPreventPrefs).getBooleanFactoryValue(); }

	/**
	 * Method to tell if the "sea-of-gates" router should favor this ArcProto.
	 * @return true if sea-of-gates routing should favor this ArcProto.
	 */
	public static boolean isSeaOfGatesFavor(ArcProto ap) { return getArcProtoBitPref(ap, "SeaOfGatesFavor", defaultSOGFavorPrefs).getBoolean(); }

	/**
	 * Method to tell if the "sea-of-gates" router should favor this ArcProto, by default.
	 * @return true if sea-of-gates routing should favor this ArcProto, by default.
	 */
	public static boolean isFactorySeaOfGatesFavor(ArcProto ap) { return getArcProtoBitPref(ap, "SeaOfGatesFavor", defaultSOGFavorPrefs).getBooleanFactoryValue(); }

	private static Pref cacheSOGMaxWidth = Pref.makeDoublePref("SeaOfGatesMaxWidth", Routing.getRoutingTool().prefs, 10);
	/**
	 * Method to get the "sea-of-gates" maximum arc width.
	 * Since the SOG router places arcs that are as wide as the widest arc on the net,
	 * this may be too large (especially near pads).  This value limits the width.
	 * @return the maximum arc width in sea-of-gates routing.
	 */
	public static double getSeaOfGatesMaxWidth() { return cacheSOGMaxWidth.getDouble(); }
	/**
	 * Method to set the "sea-of-gates" maximum arc width.
	 * Since the SOG router places arcs that are as wide as the widest arc on the net,
	 * this may be too large (especially near pads).  This value limits the width.
	 * @param w the maximum arc width in sea-of-gates routing.
	 */
	public static void setSeaOfGatesMaxWidth(double w) { cacheSOGMaxWidth.setDouble(w); }
	/**
	 * Method to get the "sea-of-gates" maximum arc width, by default.
	 * Since the SOG router places arcs that are as wide as the widest arc on the net,
	 * this may be too large (especially near pads).  This value limits the width.
	 * @return the maximum arc width in sea-of-gates routing, by default.
	 */
	public static double getFactorySeaOfGatesMaxWidth() { return cacheSOGMaxWidth.getDoubleFactoryValue(); }

	private static Pref cacheSOGComplexityLimit = Pref.makeIntPref("SeaOfGatesComplexityLimit", Routing.getRoutingTool().prefs, 200000);
	/**
	 * Method to get the "sea-of-gates" complexity limit.
	 * This is the maximum number of steps allowed when searching for a routing path.
	 * @return the "sea-of-gates" complexity limit.
	 */
	public static int getSeaOfGatesComplexityLimit() { return cacheSOGComplexityLimit.getInt(); }
	/**
	 * Method to set the "sea-of-gates" complexity limit.
	 * This is the maximum number of steps allowed when searching for a routing path.
	 * @param c the "sea-of-gates" complexity limit.
	 */
	public static void setSeaOfGatesComplexityLimit(int c) { cacheSOGComplexityLimit.setInt(c); }
	/**
	 * Method to get the "sea-of-gates" complexity limit, by default.
	 * This is the maximum number of steps allowed when searching for a routing path.
	 * @return the "sea-of-gates" complexity limit, by default.
	 */
	public static int getFactorySeaOfGatesComplexityLimit() { return cacheSOGComplexityLimit.getIntFactoryValue(); }

	private static Pref cacheSOGUseParallelFromToRoutes = Pref.makeBooleanPref("SeaOfGatesUseParallelFromToRoutes", Routing.getRoutingTool().prefs, true);
	/**
	 * Method to tell whether the "sea-of-gates" router does from/to analysis in parallel.
	 * Normally, a path is found by looking both from one end to the other, and then from the other end back to the first.
	 * The best result of these two searches is used as the route.
	 * When true, both paths are run in parallel on separate processors if there are multiple processors (default is true).
	 * @return true if the "sea-of-gates" router does from/to analysis in parallel.
	 */
	public static boolean isSeaOfGatesUseParallelFromToRoutes() { return cacheSOGUseParallelFromToRoutes.getBoolean(); }
	/**
	 * Method to set whether the "sea-of-gates" router does from/to analysis in parallel.
	 * Normally, a path is found by looking both from one end to the other, and then from the other end back to the first.
	 * The best result of these two searches is used as the route.
	 * When true, both paths are run in parallel on separate processors if there are multiple processors (default is true).
	 * @param p true if the "sea-of-gates" router does from/to analysis in parallel.
	 */
	public static void setSeaOfGatesUseParallelFromToRoutes(boolean p) { cacheSOGUseParallelFromToRoutes.setBoolean(p); }
	/**
	 * Method to tell whether the "sea-of-gates" router does from/to analysis in parallel, by default.
	 * Normally, a path is found by looking both from one end to the other, and then from the other end back to the first.
	 * The best result of these two searches is used as the route.
	 * When true, both paths are run in parallel on separate processors if there are multiple processors.
	 * @return true if the "sea-of-gates" router does from/to analysis in parallel, by default.
	 */
	public static boolean isFactorySeaOfGatesUseParallelFromToRoutes() { return cacheSOGUseParallelFromToRoutes.getBooleanFactoryValue(); }

	private static Pref cacheSOGUseParallelRoutes = Pref.makeBooleanPref("SeaOfGatesUseParallelRoutes", Routing.getRoutingTool().prefs, false);
	/**
	 * Method to tell whether the "sea-of-gates" router finds routes in parallel.
	 * When true, multiple routes are searched using parallel threads, if there are multiple processors (default is false).
	 * @return true if the "sea-of-gates" router finds routes in parallel.
	 */
	public static boolean isSeaOfGatesUseParallelRoutes() { return cacheSOGUseParallelRoutes.getBoolean(); }
	/**
	 * Method to set whether the "sea-of-gates" router finds routes in parallel.
	 * When true, multiple routes are searched using parallel threads, if there are multiple processors (default is false).
	 * @param p true if the "sea-of-gates" router finds routes in parallel.
	 */
	public static void setSeaOfGatesUseParallelRoutes(boolean p) { cacheSOGUseParallelRoutes.setBoolean(p); }
	/**
	 * Method to tell whether the "sea-of-gates" router finds routes in parallel, by default.
	 * When true, multiple routes are searched using parallel threads, if there are multiple processors.
	 * @return true if the "sea-of-gates" router finds routes in parallel, by default.
	 */
	public static boolean isFactorySeaOfGatesUseParallelRoutes() { return cacheSOGUseParallelRoutes.getBooleanFactoryValue(); }

	/****************************** SUN ROUTER OPTIONS ******************************/

	private static Pref cacheSLRVerboseLevel = Pref.makeIntPref("SunRouterVerboseLevel", Routing.getRoutingTool().prefs, 2);
	/** verbose level can be 0: silent, 1: quiet, 2: normal 3: verbose */
	public static int getSunRouterVerboseLevel() { return cacheSLRVerboseLevel.getInt(); }
	public static void setSunRouterVerboseLevel(int v) { cacheSLRVerboseLevel.setInt(v); }
	public static int getFactorySunRouterVerboseLevel() { return cacheSLRVerboseLevel.getIntFactoryValue(); }

	private static Pref cacheSLRCostLimit = Pref.makeDoublePref("SunRouterCostLimit", Routing.getRoutingTool().prefs, 10);
	public static double getSunRouterCostLimit() { return cacheSLRCostLimit.getDouble(); }
	public static void setSunRouterCostLimit(double r) { cacheSLRCostLimit.setDouble(r); }
	public static double getFactorySunRouterCostLimit() { return cacheSLRCostLimit.getDoubleFactoryValue(); }

	private static Pref cacheSLRCutlineDeviation = Pref.makeDoublePref("SunRouterCutlineDeviation", Routing.getRoutingTool().prefs, 0.1);
	public static double getSunRouterCutlineDeviation() { return cacheSLRCutlineDeviation.getDouble(); }
	public static void setSunRouterCutlineDeviation(double r) { cacheSLRCutlineDeviation.setDouble(r); }
	public static double getFactorySunRouterCutlineDeviation() { return cacheSLRCutlineDeviation.getDoubleFactoryValue(); }

	private static Pref cacheSLRDelta = Pref.makeDoublePref("SunRouterDelta", Routing.getRoutingTool().prefs, 1);
	public static double getSunRouterDelta() { return cacheSLRDelta.getDouble(); }
	public static void setSunRouterDelta(double r) { cacheSLRDelta.setDouble(r); }
	public static double getFactorySunRouterDelta() { return cacheSLRDelta.getDoubleFactoryValue(); }

	private static Pref cacheSLRXBitSize = Pref.makeIntPref("SunRouterXBitSize", Routing.getRoutingTool().prefs, 20);
	public static int getSunRouterXBitSize() { return cacheSLRXBitSize.getInt(); }
	public static void setSunRouterXBitSize(int r) { cacheSLRXBitSize.setInt(r); }
	public static int getFactorySunRouterXBitSize() { return cacheSLRXBitSize.getIntFactoryValue(); }

	private static Pref cacheSLRYBitSize = Pref.makeIntPref("SunRouterYBitSize", Routing.getRoutingTool().prefs, 20);
	public static int getSunRouterYBitSize() { return cacheSLRYBitSize.getInt(); }
	public static void setSunRouterYBitSize(int r) { cacheSLRYBitSize.setInt(r); }
	public static int getFactorySunRouterYBitSize() { return cacheSLRYBitSize.getIntFactoryValue(); }

	private static Pref cacheSLRXTileSize = Pref.makeIntPref("SunRouterXTileSize", Routing.getRoutingTool().prefs, 40);
	public static int getSunRouterXTileSize() { return cacheSLRXTileSize.getInt(); }
	public static void setSunRouterXTileSize(int r) { cacheSLRXTileSize.setInt(r); }
	public static int getFactorySunRouterXTileSize() { return cacheSLRXTileSize.getIntFactoryValue(); }

	private static Pref cacheSLRYTileSize = Pref.makeIntPref("SunRouterYTileSize", Routing.getRoutingTool().prefs, 40);
	public static int getSunRouterYTileSize() { return cacheSLRYTileSize.getInt(); }
	public static void setSunRouterYTileSize(int r) { cacheSLRYTileSize.setInt(r); }
	public static int getFactorySunRouterYTileSize() { return cacheSLRYTileSize.getIntFactoryValue(); }

	private static Pref cacheSLRLayerAssgnCapF = Pref.makeDoublePref("SunRouterLayerAssgnCapF", Routing.getRoutingTool().prefs, 0.9);
	public static double getSunRouterLayerAssgnCapF() { return cacheSLRLayerAssgnCapF.getDouble(); }
	public static void setSunRouterLayerAssgnCapF(double r) { cacheSLRLayerAssgnCapF.setDouble(r); }
	public static double getFactorySunRouterLayerAssgnCapF() { return cacheSLRLayerAssgnCapF.getDoubleFactoryValue(); }

	private static Pref cacheSLRLengthLongNet = Pref.makeDoublePref("SunRouterLengthLongNet", Routing.getRoutingTool().prefs, 0);
	public static double getSunRouterLengthLongNet() { return cacheSLRLengthLongNet.getDouble(); }
	public static void setSunRouterLengthLongNet(double r) { cacheSLRLengthLongNet.setDouble(r); }
	public static double getFactorySunRouterLengthLongNet() { return cacheSLRLengthLongNet.getDoubleFactoryValue(); }

	private static Pref cacheSLRLengthMedNet = Pref.makeDoublePref("SunRouterLengthMedNet", Routing.getRoutingTool().prefs, 0);
	public static double getSunRouterLengthMedNet() { return cacheSLRLengthMedNet.getDouble(); }
	public static void setSunRouterLengthMedNet(double r) { cacheSLRLengthMedNet.setDouble(r); }
	public static double getFactorySunRouterLengthMedNet() { return cacheSLRLengthMedNet.getDoubleFactoryValue(); }

	private static Pref cacheSLRTilesPerPinLongNet = Pref.makeDoublePref("SunRouterTilesPerPinLongNet", Routing.getRoutingTool().prefs, 5);
	public static double getSunRouterTilesPerPinLongNet() { return cacheSLRTilesPerPinLongNet.getDouble(); }
	public static void setSunRouterTilesPerPinLongNet(double r) { cacheSLRTilesPerPinLongNet.setDouble(r); }
	public static double getFactorySunRouterTilesPerPinLongNet() { return cacheSLRTilesPerPinLongNet.getDoubleFactoryValue(); }

	private static Pref cacheSLRTilesPerPinMedNet = Pref.makeDoublePref("SunRouterTilesPerPinMedNet", Routing.getRoutingTool().prefs, 3);
	public static double getSunRouterTilesPerPinMedNet() { return cacheSLRTilesPerPinMedNet.getDouble(); }
	public static void setSunRouterTilesPerPinMedNet(double r) { cacheSLRTilesPerPinMedNet.setDouble(r); }
	public static double getFactorySunRouterTilesPerPinMedNet() { return cacheSLRTilesPerPinMedNet.getDoubleFactoryValue(); }
	
	private static Pref cacheSLROneTileFactor = Pref.makeDoublePref("SunRouterOneTileFactor", Routing.getRoutingTool().prefs, 2.65);
	public static double getSunRouterOneTileFactor() { return cacheSLROneTileFactor.getDouble(); }
	public static void setSunRouterOneTileFactor(double r) { cacheSLROneTileFactor.setDouble(r); }
	public static double getFactorySunRouterOneTileFactor() { return cacheSLROneTileFactor.getDoubleFactoryValue(); }

	private static Pref cacheSLROverloadLimit = Pref.makeIntPref("SunRouterOverloadLimit", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterOverloadLimit() { return cacheSLROverloadLimit.getInt(); }
	public static void setSunRouterOverloadLimit(int r) { cacheSLROverloadLimit.setInt(r); }
	public static int getFactorySunRouterOverloadLimit() { return cacheSLROverloadLimit.getIntFactoryValue(); }

	private static Pref cacheSLRPinFactor = Pref.makeIntPref("SunRouterPinFactor", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterPinFactor() { return cacheSLRPinFactor.getInt(); }
	public static void setSunRouterPinFactor(int r) { cacheSLRPinFactor.setInt(r); }
	public static int getFactorySunRouterPinFactor() { return cacheSLRPinFactor.getIntFactoryValue(); }

	private static Pref cacheSLRUPinDensityF = Pref.makeDoublePref("SunRouterUPinDensityF", Routing.getRoutingTool().prefs, 100);
	public static double getSunRouterUPinDensityF() { return cacheSLRUPinDensityF.getDouble(); }
	public static void setSunRouterUPinDensityF(double r) { cacheSLRUPinDensityF.setDouble(r); }
	public static double getFactorySunRouterUPinDensityF() { return cacheSLRUPinDensityF.getDoubleFactoryValue(); }

	private static Pref cacheSLRWindow = Pref.makeIntPref("SunRouterWindow", Routing.getRoutingTool().prefs, 30);
	public static int getSunRouterWindow() { return cacheSLRWindow.getInt(); }
	public static void setSunRouterWindow(int r) { cacheSLRWindow.setInt(r); }
	public static int getFactorySunRouterWindow() { return cacheSLRWindow.getIntFactoryValue(); }

	private static Pref cacheWireOffset = Pref.makeIntPref("SunRouterWireOffset", Routing.getRoutingTool().prefs, 0);
	public static int getSunRouterWireOffset() { return cacheWireOffset.getInt(); }
	public static void setSunRouterWireOffset(int r) { cacheWireOffset.setInt(r); }
	public static int getFactorySunRouterWireOffset() { return cacheWireOffset.getIntFactoryValue(); }

	private static Pref cacheWireModulo = Pref.makeIntPref("SunRouterWireModulo", Routing.getRoutingTool().prefs, -1);
	public static int getSunRouterWireModulo() { return cacheWireModulo.getInt(); }
	public static void setSunRouterWireModulo(int r) { cacheWireModulo.setInt(r); }
	public static int getFactorySunRouterWireModulo() { return cacheWireModulo.getIntFactoryValue(); }

	private static Pref cacheWireBlockageFactor = Pref.makeDoublePref("SunRouterWireBlockageFactor", Routing.getRoutingTool().prefs, 0);
	public static double getSunRouterWireBlockageFactor() { return cacheWireBlockageFactor.getDouble(); }
	public static void setSunRouterWireBlockageFactor(double r) { cacheWireBlockageFactor.setDouble(r); }
	public static double getFactorySunRouterWireBlockageFactor() { return cacheWireBlockageFactor.getDoubleFactoryValue(); }

	private static Pref cacheRipUpMaximum = Pref.makeIntPref("SunRouterRipUpMaximum", Routing.getRoutingTool().prefs, 3);
	public static int getSunRouterRipUpMaximum() { return cacheRipUpMaximum.getInt(); }
	public static void setSunRouterRipUpMaximum(int r) { cacheRipUpMaximum.setInt(r); }
	public static int getFactorySunRouterRipUpMaximum() { return cacheRipUpMaximum.getIntFactoryValue(); }

	private static Pref cacheRipUpPenalty = Pref.makeIntPref("SunRouterRipUpPenalty", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterRipUpPenalty() { return cacheRipUpPenalty.getInt(); }
	public static void setSunRouterRipUpPenalty(int r) { cacheRipUpPenalty.setInt(r); }
	public static int getFactorySunRouterRipUpPenalty() { return cacheRipUpPenalty.getIntFactoryValue(); }

	private static Pref cacheRipUpExpansion = Pref.makeIntPref("SunRouterRipUpExpansion", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterRipUpExpansion() { return cacheRipUpExpansion.getInt(); }
	public static void setSunRouterRipUpExpansion(int r) { cacheRipUpExpansion.setInt(r); }
	public static int getFactorySunRouterRipUpExpansion() { return cacheRipUpExpansion.getIntFactoryValue(); }

	private static Pref cacheZRipUpExpansion = Pref.makeIntPref("SunRouterZRipUpExpansion", Routing.getRoutingTool().prefs, 2);
	public static int getSunRouterZRipUpExpansion() { return cacheZRipUpExpansion.getInt(); }
	public static void setSunRouterZRipUpExpansion(int r) { cacheZRipUpExpansion.setInt(r); }
	public static int getFactorySunRouterZRipUpExpansion() { return cacheZRipUpExpansion.getIntFactoryValue(); }

	private static Pref cacheRipUpSearches = Pref.makeIntPref("SunRouterRipUpSearches", Routing.getRoutingTool().prefs, 1);
	public static int getSunRouterRipUpSearches() { return cacheRipUpSearches.getInt(); }
	public static void setSunRouterRipUpSearches(int r) { cacheRipUpSearches.setInt(r); }
	public static int getFactorySunRouterRipUpSearches() { return cacheRipUpSearches.getIntFactoryValue(); }

	private static Pref cacheGlobalPathExpansion = Pref.makeIntPref("SunRouterGlobalPathExpansion", Routing.getRoutingTool().prefs, 5);
	public static int getSunRouterGlobalPathExpansion() { return cacheGlobalPathExpansion.getInt(); }
	public static void setSunRouterGlobalPathExpansion(int r) { cacheGlobalPathExpansion.setInt(r); }
	public static int getFactorySunRouterGlobalPathExpansion() { return cacheGlobalPathExpansion.getIntFactoryValue(); }

	private static Pref cacheSourceAccessExpansion = Pref.makeIntPref("SunRouterSourceAccessExpansion", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterSourceAccessExpansion() { return cacheSourceAccessExpansion.getInt(); }
	public static void setSunRouterSourceAccessExpansion(int r) { cacheSourceAccessExpansion.setInt(r); }
	public static int getFactorySunRouterSourceAccessExpansion() { return cacheSourceAccessExpansion.getIntFactoryValue(); }

	private static Pref cacheSinkAccessExpansion = Pref.makeIntPref("SunRouterSinkAccessExpansion", Routing.getRoutingTool().prefs, 10);
	public static int getSunRouterSinkAccessExpansion() { return cacheSinkAccessExpansion.getInt(); }
	public static void setSunRouterSinkAccessExpansion(int r) { cacheSinkAccessExpansion.setInt(r); }
	public static int getFactorySunRouterSinkAccessExpansion() { return cacheSinkAccessExpansion.getIntFactoryValue(); }

	private static Pref cacheDenseViaAreaSize = Pref.makeIntPref("SunRouterDenseViaAreaSize", Routing.getRoutingTool().prefs, 60);
	public static int getSunRouterDenseViaAreaSize() { return cacheDenseViaAreaSize.getInt(); }
	public static void setSunRouterDenseViaAreaSize(int r) { cacheDenseViaAreaSize.setInt(r); }
	public static int getFactorySunRouterDenseViaAreaSize() { return cacheDenseViaAreaSize.getIntFactoryValue(); }

	private static Pref cacheRetryExpandRouting = Pref.makeIntPref("SunRouterRetryExpandRouting", Routing.getRoutingTool().prefs, 50);
	public static int getSunRouterRetryExpandRouting() { return cacheRetryExpandRouting.getInt(); }
	public static void setSunRouterRetryExpandRouting(int r) { cacheRetryExpandRouting.setInt(r); }
	public static int getFactorySunRouterRetryExpandRouting() { return cacheRetryExpandRouting.getIntFactoryValue(); }

	private static Pref cacheRetryDenseViaAreaSize = Pref.makeIntPref("SunRouterRetryDenseViaAreaSize", Routing.getRoutingTool().prefs, 100);
	public static int getSunRouterRetryDenseViaAreaSize() { return cacheRetryDenseViaAreaSize.getInt(); }
	public static void setSunRouterRetryDenseViaAreaSize(int r) { cacheRetryDenseViaAreaSize.setInt(r); }
	public static int getFactorySunRouterRetryDenseViaAreaSize() { return cacheRetryDenseViaAreaSize.getIntFactoryValue(); }

	private static Pref cachePathSearchControl = Pref.makeIntPref("SunRouterPathSearchControl", Routing.getRoutingTool().prefs, 10000);
	public static int getSunRouterPathSearchControl() { return cachePathSearchControl.getInt(); }
	public static void setSunRouterPathSearchControl(int r) { cachePathSearchControl.setInt(r); }
	public static int getFact