Struct libreda_sta::SimpleSTA

pub struct SimpleSTA<'a, N, Lib, State>where
    N: NetlistBase,
    Lib: DelayBase + LoadBase + ConstraintBase,{
    pub(crate) netlist: N,
    pub(crate) top_cell: N::CellId,
    pub(crate) library: &'a Lib,
    pub(crate) input_signals: HashMap<N::PinId, Lib::Signal>,
    pub(crate) output_loads: HashMap<N::PinId, Lib::Load>,
    pub(crate) required_output_signals: HashMap<N::PinId, Lib::RequiredSignal>,
    pub(crate) clocks: HashMap<TerminalId<N>, ClockDefinition<Lib::Signal>>,
    pub(crate) timing_graph: TimingGraph<N, Lib>,
    pub(crate) generation: u32,
    pub(crate) _netlist_type: PhantomData<N>,
    pub(crate) _state: PhantomData<State>,
}

Simple static timing analysis engine.

Fields

netlist: N

top_cell: N::CellId

library: &'a Lib

input_signals: HashMap<N::PinId, Lib::Signal>

output_loads: HashMap<N::PinId, Lib::Load>

required_output_signals: HashMap<N::PinId, Lib::RequiredSignal>

clocks: HashMap<TerminalId<N>, ClockDefinition<Lib::Signal>>

timing_graph: TimingGraph<N, Lib>

generation: u32

Count the number of timing updates. Used to efficiently mark nodes in the timing graph which are relevant for the current incremental upgrade. Used to distinguish between the first full update (needs more initialization) and subsequent incremental updates.

_netlist_type: PhantomData<N>

_state: PhantomData<State>

Implementations

impl<'a, N, Lib, S> SimpleSTA<'a, N, Lib, S>where N: NetlistBase, Lib: DelayBase + ConstraintBase,

pub fn into_inner(self) -> N

Get ownership of the netlist data.

pub(crate) fn netlist(&self) -> &N

Shortcut to get the reference to the netlist.

pub(crate) fn top_cell_ref(&self) -> CellRef<'_, N>

impl<'a, N, Lib> SimpleSTA<'a, N, Lib, TimingAvailable>where N: NetlistBase, Lib: DelayBase + ConstraintBase,

pub fn to_modifiable(self) -> SimpleSTA<'a, N, Lib, Modifiable>

Convert to modifiable state. Call this function to modify the timing analysis settings or the netlist.

impl<'a, N, Lib> SimpleSTA<'a, N, Lib, Modifiable>where N: NetlistBaseMT, Lib: CellLoadModel<N> + CellDelayModel<N> + CellConstraintModel<N> + Sync,

pub fn update_timing( self ) -> Result<SimpleSTA<'a, N, Lib, TimingAvailable>, (StaError, Self)>

Compute the timing information. On success, returns the STA engine in TimingAvailable mode where timing queries are enabled. On error, returns a tuple with an error code and the STA engine in Modifiable mode.

impl<'a, N, Lib> SimpleSTA<'a, N, Lib, Modifiable>where N: NetlistBase, Lib: CellLoadModel<N> + CellDelayModel<N> + CellConstraintModel<N>,

pub fn new( netlist: N, top_cell: N::CellId, cell_timing_library: &'a Lib ) -> Result<Self, StaError>

Create a new static timing analysis engine which analyzes the given netlist using timing information of the cells from the given library.

pub(crate) fn init(&mut self) -> Result<(), StaError>

pub fn set_input_signal( &mut self, primary_input: N::PinId, signal: Lib::Signal ) -> Result<(), StaError>

Set the signal at a primary input.

pub fn set_output_load( &mut self, primary_output: N::PinId, load: Lib::Load ) -> Result<(), StaError>

Set the load attached to a primary output.

pub fn set_required_output_signal( &mut self, primary_output: N::PinId, required_signal: Lib::RequiredSignal ) -> Result<(), StaError>

Specify the timing constraint of a primary output.

pub fn create_clock( &mut self, clock_pin: TerminalId<N>, clock_definition: ClockDefinition<Lib::Signal> ) -> Result<(), StaError>

Specify a clock source.

pub(crate) fn build_timing_graph(&mut self) -> Result<(), StaError>

Create graph of delay arcs.

pub(crate) fn init_input_signals(&mut self) -> Result<(), StaError>

Copy the defined input signals into the nodes of the timing graph.

pub(crate) fn init_required_output_signals(&mut self) -> Result<(), StaError>

Copy the specified output signals into the timing graph.

pub(crate) fn init_output_loads(&mut self) -> Result<(), StaError>

Copy the specified output loads into the timing graph.

pub(crate) fn init_clock_signals(&mut self) -> Result<(), StaError>

pub(crate) fn propagate_signals( &mut self, net_loads: &FnvHashMap<N::NetId, Lib::Load> ) -> Result<(), StaError>where Lib: Sync, N: NetlistBaseMT,

Compute actual and required arival times.

pub(crate) fn toposort_delay_graph( &self ) -> Result<Vec<TerminalId<N>>, StaError>

pub(crate) fn debug_print_actual_signals(&self)

pub(crate) fn debug_print_timing_graph(&self)

pub(crate) fn run_sta(&mut self) -> Result<(), StaError>where Lib: Sync, N: NetlistBaseMT,

Do static timing analysis of the top cell. A single clock is allowed and specified with clock_input. Results are just printed on stdout.

pub(crate) fn check_library(&self) -> Result<(), StaError>

Check that all cells in the circuit are covered by the library. TODO: Maybe move this into the library adapter.

pub(crate) fn check_clock_sources(&self) -> Result<(), StaError>

Do some sanity checks.

Trait Implementations

impl<'a, N, Lib, State: Debug> Debug for SimpleSTA<'a, N, Lib, State>where N: NetlistBase + Debug, Lib: DelayBase + LoadBase + ConstraintBase + Debug, N::CellId: Debug, N::PinId: Debug, Lib::Signal: Debug, Lib::Load: Debug, Lib::RequiredSignal: Debug,

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

Formats the value using the given formatter.

impl<'b, N, Lib, S> HierarchyBase for SimpleSTA<'b, N, Lib, S>where N: NetlistBase, Lib: DelayBase + ConstraintBase,

type NameType = <N as HierarchyBase>::NameType

Type for names of cells, instances, etc.

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

Get the name of the cell instance.

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

Get a Vec of all cell IDs in this netlist.

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

Iterate over all cells.

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<'a>( &'a self, cell: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellId> + 'a>

Iterate over 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 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 parent_cell(&self, cell_instance: &Self::CellInstId) -> Self::CellId

Get the ID of the parent cell of this instance.

fn num_cells(&self) -> usize

Get the number of cell templates.

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

Get the name of the cell.

fn for_each_cell<F>(&self, f: F)where F: FnMut(Self::CellId),

Call a function on each cell of the netlist.

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 each_cell_instance_vec(&self, cell: &Self::CellId) -> Vec<Self::CellInstId>

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

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_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 get_cell_property( &self, cell: &Self::CellId, key: &Self::NameType ) -> Option<PropertyValue>

Get a property of a 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 num_cell_references(&self, cell: &Self::CellId) -> usize

Count all instantiations of cell.

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 each_cell_instance( &self, cell: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

Iterate over all instances in a cell.

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

Count all cells that are dependencies of cell.

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

Get the ID of the template cell of this instance.

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 get_chip_property(&self, key: &Self::NameType) -> Option<PropertyValue>

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

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

Get a property of a cell instance.

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 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 each_dependent_cell_vec(&self, cell: &Self::CellId) -> Vec<Self::CellId>

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

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.

impl<'b, N, Lib, S> HierarchyEdit for SimpleSTA<'b, N, Lib, S>where N: NetlistBase + HierarchyEdit, Lib: DelayBase + ConstraintBase + CellDelayModel<N> + CellConstraintModel<N>,

fn remove_cell(&mut self, cell_id: &Self::CellId)

Remove a cell and all the instances of it.

fn create_cell_instance( &mut self, parent_cell: &Self::CellId, template_cell: &Self::CellId, name: Option<Self::NameType> ) -> Self::CellInstId

Create a new instance of template_cell in parent_cell. Recursive instantiation is forbidden and might panic.

fn remove_cell_instance(&mut self, inst: &Self::CellInstId)

Remove cell instance if it exists.

fn set_cell_property( &mut self, cell: &Self::CellId, key: Self::NameType, value: PropertyValue )

Set a property of a cell.

fn set_cell_instance_property( &mut self, inst: &Self::CellInstId, key: Self::NameType, value: PropertyValue )

Set a property of a cell instance.

fn rename_cell_instance( &mut self, inst: &Self::CellInstId, new_name: Option<Self::NameType> )

Change the name of a cell instance.

fn rename_cell(&mut self, cell: &Self::CellId, new_name: Self::NameType)

Change the name of a cell.

fn create_cell(&mut self, name: Self::NameType) -> Self::CellId

Create a new and empty cell template. A cell template can be be instantiated in other cells.

fn set_chip_property(&mut self, key: Self::NameType, value: PropertyValue)

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

impl<'a, N, Lib, S> HierarchyIds for SimpleSTA<'a, N, Lib, S>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, S> L2NBase for SimpleSTA<'b, N, Lib, S>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 shapes_of_pin( &self, pin_id: &Self::PinId ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

Iterate over all shapes that are part of the pin.

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

Get the net of a shape.

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

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

impl<'b, N, Lib, S> L2NEdit for SimpleSTA<'b, N, Lib, S>where N: L2NEdit, Lib: DelayBase + ConstraintBase + CellDelayModel<N> + CellConstraintModel<N>,

fn set_pin_of_shape( &mut self, shape_id: &Self::ShapeId, pin: Option<Self::PinId> ) -> Option<Self::PinId>

Create the link between a circuit pin and its shapes in the layout. Return the current pin.

fn set_net_of_shape( &mut self, shape_id: &Self::ShapeId, net: Option<Self::NetId> ) -> Option<Self::NetId>

Set the net of a shape. Return the current net.

impl<'b, N, Lib, S> LayoutBase for SimpleSTA<'b, N, Lib, S>where N: NetlistBase + LayoutBase, Lib: DelayBase + ConstraintBase,

fn with_shape<F, R>(&self, shape_id: &Self::ShapeId, f: F) -> Rwhere F: FnMut(&Self::LayerId, &Geometry<Self::Coord>) -> R,

Access a shape by its ID.

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 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 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 find_layer(&self, index: UInt, datatype: UInt) -> Option<Self::LayerId>

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

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

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

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

Iterate over all defined layers.

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

Find layer index by the name.

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 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 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 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 layer_info(&self, layer: &Self::LayerId) -> LayerInfo<Self::NameType>

Get the LayerInfo data structure for this layer.

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

Get the layer of a shape.

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

Get a clone of the shape geometry.

impl<'b, N, Lib, S> LayoutEdit for SimpleSTA<'b, N, Lib, S>where N: NetlistBase + LayoutEdit, Lib: DelayBase + ConstraintBase + CellDelayModel<N> + CellConstraintModel<N>,

fn insert_shape( &mut self, parent_cell: &Self::CellId, layer: &Self::LayerId, geometry: Geometry<Self::Coord> ) -> Self::ShapeId

Insert a geometric shape into the parent cell.

fn remove_shape( &mut self, shape_id: &Self::ShapeId ) -> Option<Geometry<Self::Coord>>

Remove shape from the parent cell.

fn replace_shape( &mut self, shape_id: &Self::ShapeId, geometry: Geometry<Self::Coord> ) -> Geometry<Self::Coord>

Replace the geometry of a shape.

fn set_transform( &mut self, cell_inst: &Self::CellInstId, tf: SimpleTransform<Self::Coord> )

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

fn set_layer_name( &mut self, layer: &Self::LayerId, name: Option<Self::NameType> ) -> Option<Self::NameType>

Set the name of a layer or clear the layer name when passing None. This method should not change the ID of the layer. Returns the previous name of the layer.

fn create_layer_with_id( &mut self, layer_id: Self::LayerId, index: UInt, datatype: UInt ) -> Result<(), ()>

Create a new layer with a specific ID. This is used to clone layer-stacks between layouts while preserving their IDs. Returns an Err when the ID already exists.

fn create_layer(&mut self, index: UInt, datatype: UInt) -> Self::LayerId

Create a new layer. Use set_layer_name() to define a name.

fn set_shape_property( &mut self, shape: &Self::ShapeId, key: Self::NameType, value: PropertyValue )

Set a property of a shape.

fn set_dbu(&mut self, dbu: Self::Coord)

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

impl<'a, N, Lib, S> LayoutIds for SimpleSTA<'a, N, Lib, S>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 LayerId = <N as LayoutIds>::LayerId

Layer identifier type.

type Coord = <N as LayoutIds>::Coord

Number type used for coordinates and distances.

type ShapeId = <N as LayoutIds>::ShapeId

Shape identifier type.

impl<'b, N, Lib, S> NetlistBase for SimpleSTA<'b, N, Lib, S>where N: NetlistBase, Lib: DelayBase + ConstraintBase,

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_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 num_net_pins(&self, net: &Self::NetId) -> usize

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

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

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

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

Get the ID of the parent circuit of this pin.

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

Get the signal direction of the pin.

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 each_internal_net_vec(&self, circuit: &Self::CellId) -> Vec<Self::NetId>

Get a Vec with all nets in this circuit.

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_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<'a>( &'a self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::PinId> + 'a>

Iterate over all pins of a circuit.

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 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 each_pin_of_net_vec(&self, net: &Self::NetId) -> Vec<Self::PinId>

Get a Vec with all pin IDs 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_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_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 net_of_pin(&self, pin: &Self::PinId) -> Option<Self::NetId>

Get the internal net attached to this pin.

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 net_of_pin_instance( &self, pin_instance: &Self::PinInstId ) -> Option<Self::NetId>

Get the external net attached to this pin instance.

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

Get the number of pins of a circuit.

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 each_pin_vec(&self, circuit: &Self::CellId) -> Vec<Self::PinId>

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

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 net_name(&self, net: &Self::NetId) -> Option<Self::NameType>

Get the name of the net.

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

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

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

Return the number of nets defined inside a cell.

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 net_zero(&self, parent_circuit: &Self::CellId) -> Self::NetId

Get the net of the logical constant zero.

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 pin_name(&self, pin: &Self::PinId) -> Self::NameType

Get the name of the pin.

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 parent_cell_of_net(&self, net: &Self::NetId) -> Self::CellId

Get the ID of the parent circuit of this 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 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 each_internal_net<'a>( &'a self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::NetId> + 'a>

Iterate over all defined nets inside a circuit.

impl<'b, N, Lib, S> NetlistEdit for SimpleSTA<'b, N, Lib, S>where N: NetlistEdit, Lib: DelayBase + ConstraintBase + CellDelayModel<N> + CellConstraintModel<N>,

fn create_pin( &mut self, cell: &Self::CellId, name: Self::NameType, direction: Direction ) -> Self::PinId

Create a new pin in this cell. Also adds the pin to all instances of the cell.

fn remove_pin(&mut self, id: &Self::PinId)

Remove the pin from this circuit and from all instances of this circuit.

fn remove_net(&mut self, net: &Self::NetId)

Delete the net if it exists and disconnect all connected terminals.

fn connect_pin( &mut self, pin: &Self::PinId, net: Option<Self::NetId> ) -> Option<Self::NetId>

Connect a pin to a net. Returns the old connected net, if any.

fn connect_pin_instance( &mut self, pin: &Self::PinInstId, net: Option<Self::NetId> ) -> Option<Self::NetId>

Connect a pin instance to a net. Returns the old connected net, if any.

fn create_net( &mut self, parent: &Self::CellId, name: Option<Self::NameType> ) -> Self::NetId

Create a net net that lives in the parent circuit.

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

Disconnect the pin from any connected net. Returns the old connected net, if any.

fn rename_pin( &mut self, pin: &Self::PinId, new_name: Self::NameType ) -> Self::NameType

Change the name of the pin, returns the old name.

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

Disconnect the pin instance from any connected net. Returns the old connected net, if any.

fn rename_net( &mut self, net_id: &Self::NetId, new_name: Option<Self::NameType> ) -> Option<Self::NameType>

Set a new name for the net. This might panic if the name already exists. Returns the old name.

impl<'a, N, Lib, S> NetlistIds for SimpleSTA<'a, N, Lib, S>where N: NetlistBase, Lib: DelayBase + ConstraintBase,

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.

type NetId = <N as NetlistIds>::NetId

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

impl<'a, N, Lib> TimingQuery for SimpleSTA<'a, N, Lib, TimingAvailable>where N: NetlistBase + 'static, 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>) -> 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>) -> 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>) -> 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.