Struct atoll::grid::RoutingState

impl<L> RoutingState<L>

pub fn grid(&self) -> &RoutingGrid<L>

Returns a reference to the routing grid.

pub fn layer(&self, layer: usize) -> &Grid<PointState>

Returns a reference to a layer’s state.

pub fn layer_mut(&mut self, layer: usize) -> &mut Grid<PointState>

Returns a mutable reference to a layer’s state.

impl<L: AtollLayer + Clone> RoutingState<L>

pub fn new(stack: LayerStack<L>, top: usize, nx: i64, ny: i64) -> Self

Creates a new RoutingState.

pub fn find(&self, net: NetId) -> Option<GridCoord>

Finds a single grid coordinate belonging to the given net.

Searches the topmost layer first, starting from the lower left. Returns the first grid point with a matching net ID, or None if no grid point has the given net ID.

pub fn find_all(&self, net: NetId) -> Vec<GridCoord>

Finds all grid coordinates belonging to the given net.

Searches the topmost layer first, starting from the lower left. Returns the first grid point with a matching net ID, or None if no grid point has the given net ID.

pub fn successors( &self, node: RoutingNode, path: &[RoutingNode], net: NetId ) -> Vec<(RoutingNode, usize)>

The set of points reachable from coord.

M0 <-> M1 vias are always easy, since both layers have the same grid.

MN <-> M(N+1) vias require interpolation. We first identify the coordinate that stays constant in the transition. If MN has horizontal going tracks, the y-coordinate is constant. If MN has vertical going tracks, the x-coordinate is constant. The non-constant coordinate must be interpolated.

Interpolation is done as follows:

We translate the track coordinate to a physical coordinate, and retrieve the coordinate in the interpolated direction
We find two track coordinates on M(N+1): one by rounding up; the other by rounding down.
If the two coordinates are equal, we report a successor to that grid point.
Otherwise, we report a successor to the track with a closer physical coordinate, assuming the farther coordinate is unobstructed.

pub fn grid_to_rel_physical(&self, coord: GridCoord) -> Point

Converts the given grid point to physical coordinates.

Assumes that (0,0) in grid coordinates is the same as (0,0) in track coordinates. In other words, this assumes that grid and track coordinates are the same; there is not shift between grid and track coordinates.

Trait Implementations§

impl<L: Clone> Clone for RoutingState<L>

fn clone(&self) -> RoutingState<L>

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<L: Debug> Debug for RoutingState<L>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<L> Index<GridCoord> for RoutingState<L>

type Output = PointState

The returned type after indexing.

fn index(&self, index: GridCoord) -> &Self::Output

Performs the indexing (container[index]) operation. Read more

impl<L> IndexMut<GridCoord> for RoutingState<L>

fn index_mut(&mut self, index: GridCoord) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation. Read more

Auto Trait Implementations§

impl<L> UnwindSafe for RoutingState<L>
where L: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T, U> CustomHardwareType<Flipped<T>> for U
where U: CustomHardwareType<T>, T: HardwareType,

fn from_layout_type(other: &Flipped<T>) -> U

Creates this layout type from another layout type.

impl<T, U> CustomHardwareType<InOut<T>> for U
where U: CustomHardwareType<T>, T: HardwareType,

fn from_layout_type(other: &InOut<T>) -> U

Creates this layout type from another layout type.

impl<T, U> CustomHardwareType<Input<T>> for U
where U: CustomHardwareType<T>, T: HardwareType,

fn from_layout_type(other: &Input<T>) -> U

Creates this layout type from another layout type.

impl<T, U> CustomHardwareType<Output<T>> for U
where U: CustomHardwareType<T>, T: HardwareType,

fn from_layout_type(other: &Output<T>) -> U

Creates this layout type from another layout type.

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.