Struct libreda_pnr::route::routing_problem::SimpleRoutingProblem

pub struct SimpleRoutingProblem<'a, LN, RoutingGuide = ()>where
    LN: L2NBase,{
    pub chip: &'a LN,
    pub top_cell: LN::CellId,
    pub nets: Vec<LN::NetId>,
    pub net_weights: HashMap<LN::NetId, f64>,
    pub boundary: Option<SimpleRPolygon<LN::Coord>>,
    pub routing_guides: HashMap<LN::NetId, RoutingGuide>,
}

Simple representation of the global and detail routing problems. Implements the RoutingProblem traits.

Fields

chip: &'a LN

A fused layout-netlist structure.

top_cell: LN::CellId

The ID of the top cell to be routed.

nets: Vec<LN::NetId>

The IDs of the nets to be routed.

net_weights: HashMap<LN::NetId, f64>

Weights of nets for optimizing the total wire-length. Default weight is 1.0. A net with weight 0.0 will not be optimized for length while a net with a high weight will be optimized for wiring length much more aggressively.

boundary: Option<SimpleRPolygon<LN::Coord>>

All routes should be contained within this boundary, if it is specified.

routing_guides: HashMap<LN::NetId, RoutingGuide>

Global routes.

Implementations

impl<'a, LN: L2NBase, RG> SimpleRoutingProblem<'a, LN, RG>

pub fn new(chip: &'a LN, top_cell: LN::CellId) -> Self

Create a new routing problem. By default, no nets are included. Nets which should be routed need to be added to the nets field.

pub fn with_routing_guides(self, routing_guides: HashMap<LN::NetId, RG>) -> Self

Set global routes.

Trait Implementations

impl<'a, LN: L2NBase, RG> DetailRoutingProblem<LN> for SimpleRoutingProblem<'a, LN, RG>where RG: RoutingGuide<LN>,

type RoutingGuide = RG

Representation of a global route which guides a single net.

fn routing_guide(&self, net: &LN::NetId) -> Option<&Self::RoutingGuide>

Get the routing guide for this net.

impl<'a, LN, RG> RoutingProblem<LN> for SimpleRoutingProblem<'a, LN, RG>where LN: L2NBase,

fn fused_layout_netlist(&self) -> &LN

Get the base layout/netlist structure.

fn top_cell(&self) -> LN::CellId

Get the top cell whose content should be placed.

fn nets(&self) -> Box<dyn Iterator<Item = LN::NetId> + '_>

Return the nets which should be routed.

fn net_weight(&self, net: &LN::NetId) -> f64

Get the weight of a net. Default is 1.0. When optimizing the wire-length, the weighted wire-length should be used. For example a weight 0.0 means that the net should not be considered for wire-length optimization. Place and route algorithms may or may not use the net weight.

fn blockages( &self ) -> Box<dyn Iterator<Item = (LN::LayerId, SimpleRPolygon<LN::Coord>)>>

Shapes where routes should not pass.

fn boundary(&self) -> Option<SimpleRPolygon<LN::Coord>>

Routes must remain within this boundary.

fn arc_weight( &self, _signal_source: &TerminalId<C>, _signal_destination: &TerminalId<C> ) -> f64

Weight of an ‘arc’, i.e. a net segment which starts at signal_source and ends at signal_destination. Default weight is 1.0`. Place and route algorithms may or may not use the arc weight.

impl<'a, LN: L2NBase, RG> GlobalRoutingProblem<LN> for SimpleRoutingProblem<'a, LN, RG>