Struct Timed 

pub struct Timed<'a, N, Lib>
where
    N: NetlistBase,
    Lib: DelayBase + LoadBase + ConstraintBase,
{ /* private fields */ }

Reference to STA engine in timed state.

Implementations

impl<'a, N, Lib> Timed<'a, N, Lib>

where N: NetlistBase, Lib: DelayBase + LoadBase + ConstraintBase,

pub fn report_clock( &self, pin: TerminalId<N>, edge_polarity: RiseFall, ) -> Option<ClockId>

For testing only.

pub fn report_critical_paths(&self, clock_id: ClockId, setup_hold: SetupHold)

Report longest or shortest paths.

Trait Implementations

impl<'a, N, Lib> Debug for Timed<'a, N, Lib>

where N: NetlistBase + Debug, Lib: DelayBase + LoadBase + ConstraintBase + Debug,

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

Formats the value using the given formatter.

impl<'a, N, Lib> Deref for Timed<'a, N, Lib>

where N: NetlistBase, Lib: DelayBase + LoadBase + ConstraintBase,

type Target = SimpleSTA<N, Lib>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'b, N, Lib> HierarchyBase for Timed<'b, N, Lib>

where N: NetlistBase, Lib: DelayBase + ConstraintBase,

type NameType = <N as HierarchyBase>::NameType

Type for names of cells, instances, etc.

fn num_dependent_cells(&self, cell: &Self::CellId) -> usize

Count all cells that are directly dependent on cell, i.e. contain an instance of cell.

fn get_cell_property( &self, cell: &Self::CellId, key: &Self::NameType, ) -> Option<PropertyValue>

Get a property of a cell.

fn cell_name(&self, cell: &Self::CellId) -> Self::NameType

Get the name of the cell.

fn template_cell(&self, cell_instance: &Self::CellInstId) -> Self::CellId

Get the ID of the template cell of this instance.

fn each_cell_reference( &self, cell: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

Iterate over all instances of this cell, i.e. instances that use this cell as a template.

fn num_cell_dependencies(&self, cell: &Self::CellId) -> usize

Count all cells that are dependencies of cell.

fn get_cell_instance_property( &self, inst: &Self::CellInstId, key: &Self::NameType, ) -> Option<PropertyValue>

Get a property of a cell instance.

fn cell_instance_name( &self, cell_inst: &Self::CellInstId, ) -> Option<Self::NameType>

Get the name of the cell instance.

fn each_cell_dependency<'a>( &'a self, cell: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::CellId> + 'a>

Iterate over all cells that are instantiated in this cell.

fn each_dependent_cell<'a>( &'a self, cell: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::CellId> + 'a>

Iterate over each cell that directly depends on cell.

fn num_cells(&self) -> usize

Get the number of cell templates.

fn each_cell_vec(&self) -> Vec<Self::CellId>

Get a Vec of all cell IDs in this netlist.

fn for_each_cell_instance<F>(&self, cell: &Self::CellId, f: F)

where F: FnMut(Self::CellInstId),

Call a function on each instance in this cell.

fn for_each_cell_dependency<F>(&self, cell: &Self::CellId, f: F)

where F: FnMut(Self::CellId),

Call a function for each cell that is a child of this cell.

fn for_each_cell<F>(&self, f: F)

where F: FnMut(Self::CellId),

Call a function on each cell of the netlist.

fn parent_cell(&self, cell_instance: &Self::CellInstId) -> Self::CellId

Get the ID of the parent cell of this instance.

fn each_cell_instance_vec(&self, cell: &Self::CellId) -> Vec<Self::CellInstId>

Get a Vec of the IDs of all instances in this cell.

fn cell_instance_by_name( &self, parent_cell: &Self::CellId, name: &str, ) -> Option<Self::CellInstId>

Find a cell instance by its name. Returns None if the name does not exist.

fn for_each_dependent_cell<F>(&self, cell: &Self::CellId, f: F)

where F: FnMut(Self::CellId),

Call a function for each cell that directly depends on cell.

fn for_each_cell_reference<F>(&self, cell: &Self::CellId, f: F)

where F: FnMut(Self::CellInstId),

Iterate over all instances of this cell, i.e. instances that use this cell as a template.

fn cell_by_name(&self, name: &str) -> Option<Self::CellId>

Find a cell by its name. Return the cell with the given name. Returns None if the cell does not exist.

fn get_chip_property(&self, key: &Self::NameType) -> Option<PropertyValue>

Get a property of the top-level chip data structure.

fn each_cell_reference_vec(&self, cell: &Self::CellId) -> Vec<Self::CellInstId>

Get a Vec with all cell instances referencing this cell.

fn each_cell_dependency_vec(&self, cell: &Self::CellId) -> Vec<Self::CellId>

Get a Vec of each cell that is a child of this cell.

fn each_dependent_cell_vec(&self, cell: &Self::CellId) -> Vec<Self::CellId>

Get a Vec of each cell that directly depends on cell.

fn num_child_instances(&self, cell: &Self::CellId) -> usize

Get the number of cell instances inside the cell.

fn num_cell_references(&self, cell: &Self::CellId) -> usize

Count all instantiations of cell.

fn each_cell(&self) -> Box<dyn Iterator<Item = Self::CellId> + '_>

Iterate over all cells.

fn each_cell_instance( &self, cell: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

Iterate over all instances in a cell.

impl<'a, N, Lib> HierarchyIds for Timed<'a, N, Lib>

where N: NetlistBase, Lib: DelayBase + ConstraintBase,

type CellId = <N as HierarchyIds>::CellId

Cell/module identifier type.

type CellInstId = <N as HierarchyIds>::CellInstId

Cell instance identifier type.

impl<'b, N, Lib> L2NBase for Timed<'b, N, Lib>

where N: L2NBase, Lib: DelayBase + ConstraintBase,

fn shapes_of_net( &self, net_id: &Self::NetId, ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

Iterate over all shapes that are marked to belong to the specified net.

fn get_pin_of_shape(&self, shape_id: &Self::ShapeId) -> Option<Self::PinId>

Get the pin that belongs to the shape (if any).

fn get_net_of_shape(&self, shape_id: &Self::ShapeId) -> Option<Self::NetId>

Get the net of a shape.

fn shapes_of_pin( &self, pin_id: &Self::PinId, ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

Iterate over all shapes that are part of the pin.

impl<'b, N, Lib> LayoutBase for Timed<'b, N, Lib>

where N: NetlistBase + LayoutBase, Lib: DelayBase + ConstraintBase,

fn dbu(&self) -> Self::Coord

Get the distance unit used in this layout in ‘pixels per micron’.

fn get_shape_property( &self, shape: &Self::ShapeId, key: &Self::NameType, ) -> Option<PropertyValue>

Get a property of a shape.

fn get_transform( &self, cell_inst: &Self::CellInstId, ) -> SimpleTransform<Self::Coord>

Get the geometric transform that describes the location of a cell instance relative to its parent.

fn for_each_shape<F>(&self, cell: &Self::CellId, layer: &Self::LayerId, f: F)

where F: FnMut(&Self::ShapeId, &Geometry<Self::Coord>),

Call a function for each shape on this layer.

fn parent_of_shape( &self, shape_id: &Self::ShapeId, ) -> (Self::CellId, Self::LayerId)

Get the parent cell and the layer of a shape as a (cell, layer) tuple.

fn shape_geometry(&self, shape_id: &Self::ShapeId) -> Geometry<Self::Coord>

Get a clone of the shape geometry.

fn bounding_box(&self, cell: &Self::CellId) -> Option<Rect<Self::Coord>>

Compute the bounding box of the cell over all layers. The bounding box is not defined if the cell is empty. In this case return None.

fn each_layer(&self) -> Box<dyn Iterator<Item = Self::LayerId> + '_>

Iterate over all defined layers.

fn for_each_shape_recursive<F>( &self, cell: &Self::CellId, layer: &Self::LayerId, f: F, )

where F: FnMut(SimpleTransform<Self::Coord>, &Self::ShapeId, &Geometry<Self::Coord>),

Call a function f for each shape of this cell and its sub cells. Along to the geometric shape f also gets a transformation as argument. The transformation describes the actual position of the geometric shape relative to the cell.

fn with_shape<F, R>(&self, shape_id: &Self::ShapeId, f: F) -> R

where F: FnMut(&Self::LayerId, &Geometry<Self::Coord>) -> R,

Access a shape by its ID.

fn shape_layer(&self, shape_id: &Self::ShapeId) -> Self::LayerId

Get the layer of a shape.

fn bounding_box_per_layer( &self, cell: &Self::CellId, layer: &Self::LayerId, ) -> Option<Rect<Self::Coord>>

Compute the bounding box of the shapes on one layer. The bounding box also includes all child cell instances.

fn layer_by_name(&self, name: &str) -> Option<Self::LayerId>

Find layer index by the name.

fn layer_info(&self, layer: &Self::LayerId) -> LayerInfo<Self::NameType>

Get the LayerInfo data structure for this layer.

fn each_shape_id( &self, cell: &Self::CellId, layer: &Self::LayerId, ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

Iterate over the IDs of all shapes in the cell on a specific layer.

fn find_layer(&self, index: UInt, datatype: UInt) -> Option<Self::LayerId>

Find layer index by the (index, data type) tuple.

impl<'a, N, Lib> LayoutIds for Timed<'a, N, Lib>

where N: LayoutIds + NetlistBase, Lib: DelayBase + ConstraintBase,

type Area = <N as LayoutIds>::Area

Number type for areas. This is possibly another type then Coord for the following reasons:

type ShapeId = <N as LayoutIds>::ShapeId

Shape identifier type.

type Coord = <N as LayoutIds>::Coord

Number type used for coordinates and distances.

type LayerId = <N as LayoutIds>::LayerId

Layer identifier type.

impl<'b, N, Lib> NetlistBase for Timed<'b, N, Lib>

where N: NetlistBase, Lib: DelayBase + ConstraintBase,

fn each_pin_instance_vec( &self, circuit_instance: &Self::CellInstId, ) -> Vec<Self::PinInstId>

Get a Vec with the IDs of all pin instance of this circuit instance.

fn parent_of_pin_instance(&self, pin_inst: &Self::PinInstId) -> Self::CellInstId

Get the ID of the circuit instance that holds this pin instance.

fn each_internal_net<'a>( &'a self, circuit: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::NetId> + 'a>

Iterate over all defined nets inside a circuit.

fn each_pin_of_net_vec(&self, net: &Self::NetId) -> Vec<Self::PinId>

Get a Vec with all pin IDs connected to this net.

fn net_zero(&self, parent_circuit: &Self::CellId) -> Self::NetId

Get the net of the logical constant zero.

fn for_each_pin_instance_of_net<F>(&self, net: &Self::NetId, f: F)

where F: FnMut(Self::PinInstId),

Call a function for each pin instance connected to this net.

fn each_pin_instance<'a>( &'a self, circuit_instance: &Self::CellInstId, ) -> Box<dyn Iterator<Item = Self::PinInstId> + 'a>

Iterate over all pin instances of a circuit.

fn net_of_pin(&self, pin: &Self::PinId) -> Option<Self::NetId>

Get the internal net attached to this pin.

fn template_pin(&self, pin_instance: &Self::PinInstId) -> Self::PinId

Get the ID of the template pin of this pin instance.

fn pin_instance( &self, cell_inst: &Self::CellInstId, pin: &Self::PinId, ) -> Self::PinInstId

Get the ID of a pin instance given the cell instance and the pin ID.

fn for_each_pin_of_net<F>(&self, net: &Self::NetId, f: F)

where F: FnMut(Self::PinId),

Call a function for each pin connected to this net.

fn each_pin_instance_of_net<'a>( &'a self, net: &Self::NetId, ) -> Box<dyn Iterator<Item = Self::PinInstId> + 'a>

Iterate over all pins of a net.

fn net_by_name( &self, parent_circuit: &Self::CellId, name: &str, ) -> Option<Self::NetId>

Find a net by its name inside the parent circuit. Returns None if no such net can be found.

fn each_pin<'a>( &'a self, circuit: &Self::CellId, ) -> Box<dyn Iterator<Item = Self::PinId> + 'a>

Iterate over all pins of a circuit.

fn each_pin_instance_of_net_vec( &self, net: &Self::NetId, ) -> Vec<Self::PinInstId>

Get a Vec with all pin instance IDs connected to this net.

fn each_pin_of_net<'a>( &'a self, net: &Self::NetId, ) -> Box<dyn Iterator<Item = Self::PinId> + 'a>

Iterate over all pins of a net.

fn for_each_internal_net<F>(&self, circuit: &Self::CellId, f: F)

where F: FnMut(Self::NetId),

Call a function for net of the circuit.

fn net_of_pin_instance( &self, pin_instance: &Self::PinInstId, ) -> Option<Self::NetId>

Get the external net attached to this pin instance.

fn each_external_net_vec( &self, circuit_instance: &Self::CellInstId, ) -> Vec<Self::NetId>

Get a vector of all external nets connected to the circuit instance. A net might appear more than once.

fn pin_by_name( &self, parent_circuit: &Self::CellId, name: &str, ) -> Option<Self::PinId>

Find a pin by its name. Returns None if no such pin can be found.

fn net_one(&self, parent_circuit: &Self::CellId) -> Self::NetId

Get the net of the logical constant one.

fn num_net_pin_instances(&self, net: &Self::NetId) -> usize

Get the number of pin instances that are connected to this net.

fn pin_name(&self, pin: &Self::PinId) -> Self::NameType

Get the name of the pin.

fn each_external_net<'a>( &'a self, circuit_instance: &Self::CellInstId, ) -> Box<dyn Iterator<Item = Self::NetId> + 'a>

Iterate over all external nets connected to the circuit instance. A net might appear more than once.

fn for_each_pin_instance<F>(&self, circuit_inst: &Self::CellInstId, f: F)

where F: FnMut(Self::PinInstId),

Call a function for each pin instance of the circuit instance.

fn parent_cell_of_net(&self, net: &Self::NetId) -> Self::CellId

Get the ID of the parent circuit of this net.

fn net_name(&self, net: &Self::NetId) -> Option<Self::NameType>

Get the name of the net.

fn each_pin_vec(&self, circuit: &Self::CellId) -> Vec<Self::PinId>

Get a Vec with the IDs of all pins of this circuit.

fn num_internal_nets(&self, circuit: &Self::CellId) -> usize

Return the number of nets defined inside a cell.

fn each_internal_net_vec(&self, circuit: &Self::CellId) -> Vec<Self::NetId>

Get a Vec with all nets in this circuit.

fn for_each_pin<F>(&self, circuit: &Self::CellId, f: F)

where F: FnMut(Self::PinId),

Call a function for each pin of the circuit.

fn num_net_pins(&self, net: &Self::NetId) -> usize

Get the number of pins that are connected to this net.

fn for_each_external_net<F>(&self, circuit_instance: &Self::CellInstId, f: F)

where F: FnMut(Self::NetId),

Iterate over all external nets connected to the circuit instance. A net might appear more than once.

fn pin_direction(&self, pin: &Self::PinId) -> Direction

Get the signal direction of the pin.

fn parent_cell_of_pin(&self, pin: &Self::PinId) -> Self::CellId

Get the ID of the parent circuit of this pin.

fn num_pins(&self, circuit: &Self::CellId) -> usize

Get the number of pins of a circuit.

fn num_net_terminals(&self, net: &Self::NetId) -> usize

Get the number of terminals that are connected to this net.

impl<'a, N, Lib> NetlistIds for Timed<'a, N, Lib>

where N: NetlistBase, Lib: DelayBase + ConstraintBase,

type NetId = <N as NetlistIds>::NetId

Net identifier type. Uniquely identifies a net in the whole netlist.

type PinId = <N as NetlistIds>::PinId

Pin identifier type. Uniquely identifies a pin in the whole netlist.

type PinInstId = <N as NetlistIds>::PinInstId

Pin instance identifier type. Uniquely identifies a pin instance in the whole netlist. A pin instance is a pin of a circuit instance.

impl<'a, N, Lib> TimingQuery for Timed<'a, N, Lib>

where N: NetlistBase, Lib: DelayBase + ConstraintBase,

type NetlistIds = N

Type which defines IDs of netlist components.

type ArrivalTime = <Lib as TimingBase>::Signal

Type for the actual arrival times.

type RequiredArrivalTime = <Lib as ConstraintBase>::RequiredSignal

Type for required arrival times.

type Slack = <Lib as ConstraintBase>::Slack

Type for delays (time difference) such as slack.

fn report_aat( &self, pin: TerminalId<N>, edge_polarity: RiseFall, ) -> Option<Self::ArrivalTime>

Report arrival time. Assumes prior call to update_timing if the netlist was modified. Might panic otherwise. Returns an Option because some it is possible that no arrival time is defined (for example for a floating part of the netlist which is not attached to a clock).

fn report_rat( &self, pin: TerminalId<N>, edge_polarity: RiseFall, ) -> Option<Self::RequiredArrivalTime>

Report required arrival time. Assumes prior call to update_timing if the netlist was modified. Might panic otherwise.

fn report_slack( &self, pin: TerminalId<N>, edge_polarity: RiseFall, ) -> Option<Self::Slack>

Report slack (arrival time - required arrival time). Assumes prior call to update_timing if the netlist was modified. Might panic otherwise.

fn report_timing(&self) -> Vec<()>

Report a list of worst paths.