Struct CaravelProject 

pub struct CaravelProject {

    pub key: &'static str,
    pub macro_module: &'static str,
    pub carries: &'static str,
    pub macro_die_um: (u32, u32),
    pub macro_origin_um: (u32, u32),
    pub clock: HarnessClock,
    pub clock_period_ps: u32,
    pub synth_strategy: Option<SynthStrategy>,
    pub macro_hold_margin_ps: u32,
    pub macro_density_permille: Option<u16>,
    pub macro_met1_penalty_permille: Option<u16>,
    pub macro_grt_overflow_iters: Option<u16>,
    pub macro_grt_adjustment_permille: Option<u16>,
    pub macro_grt_antenna_margin_pct: Option<u8>,
    pub macro_grt_antenna_iters: Option<u8>,
    pub macro_antenna_threshold_um: Option<u16>,
    pub macro_dpl_padding_per_side: Option<u8>,
    pub macro_setup_margin_ps: Option<u32>,
    pub macro_upsize_margin_pct: u8,
    pub macro_grid: MacroGrid,
    pub macro_design: &'static str,
    pub wrapper_design: &'static str,
    pub wrapper_rtl: &'static str,
    pub macro_ledger: &'static str,
    pub wrapper_ledger: &'static str,
    pub golden_key: &'static str,
    pub precheck_ledger: &'static str,
    pub submission_dir: &'static str,
    pub overlay: &'static str,
}

One user project on the Caravel harness.

Fields

key: &'static str

The name the flow scripts are invoked with.

macro_module: &'static str

The user macro’s module. Its RTL is benchmarks/silicon/<macro_module>.v.

carries: &'static str

What the macro carries, as the wrapper’s header names it.

macro_die_um: (u32, u32)

The macro’s die, and the lower-left corner the wrapper places it at, in µm of the user area.

macro_origin_um: (u32, u32)

clock: HarnessClock

The harness clock the macro’s logic runs on, and its period: the clock the chip runs the project at. On the core clock the period is no shorter than the chip signs that clock off at; user_clock2 takes its own.

clock_period_ps: u32

synth_strategy: Option<SynthStrategy>

The macro’s technology-mapping script, when OpenLane’s default is not the one it closes with (see flow_config::ClosureSettings::synth_strategy).

macro_hold_margin_ps: u32

The hold slack every path of the macro is closed to (flow_config::VehicleMacro::hold_margin_ns), in ps.

macro_density_permille: Option<u16>

The macro’s global placement density target, in thousandths, when the closure default does not route it.

macro_met1_penalty_permille: Option<u16>

The macro’s met1 global-route penalty, in thousandths, when the closure recipe’s (flow_config::ClosureSettings::met1_route_penalty) leaves it too little met1 to route.

macro_grt_overflow_iters: Option<u16>

The macro’s global-route overflow iterations, when OpenLane’s own 50 do not route it (flow_config::ClosureSettings::grt_overflow_iters).

macro_grt_adjustment_permille: Option<u16>

The share of each gcell’s capacity the macro’s global route holds back, in thousandths, when OpenLane’s own 0.3 leaves it over capacity (flow_config::ClosureSettings::grt_adjustment).

macro_grt_antenna_margin_pct: Option<u8>

The share past each antenna ratio the macro’s global router repairs to, in percent, when the closure default (flow_config::ClosureSettings::grt_antenna_margin_pct) inserts more diodes than the route has room for.

macro_grt_antenna_iters: Option<u8>

How many passes the macro’s global router makes to repair antennas, when the closure default (flow_config::ClosureSettings::grt_antenna_iters) reroutes the block past what its route holds.

macro_antenna_threshold_um: Option<u16>

The span, in µm, past which the macro’s heuristic pass gives a net a protection diode before routing, when the closure default (flow_config::ClosureSettings::heuristic_antenna_threshold) floods a dense patch with them.

macro_dpl_padding_per_side: Option<u8>

The sites a side the macro’s legalization keeps around every cell, when abutting cells leave a dense patch’s pins no room (flow_config::ClosureSettings::dpl_cell_padding_per_side).

macro_setup_margin_ps: Option<u32>

The setup slack, in ps, the macro’s placement and global-route timing repairs close every path to, when its routed paths at the max-RC corner outgrow the estimates the repairs judge (flow_config::ClosureSettings::setup_slack_margin_ns).

macro_upsize_margin_pct: u8

How far below the slew limit the macro’s post-diode upsize detects, in percent, at every corner (flow_config::ClosureSettings::post_diode_upsize_margin_pct). The global-route estimate it detects on reads below the extracted slew signoff judges, by an amount that depends on the design.

macro_grid: MacroGrid

How the macro takes power from the wrapper, and so how high it routes.

macro_design: &'static str

The OpenLane designs, under tools/OpenLane/designs/, the macro and the wrapper are hardened in.

wrapper_design: &'static str

wrapper_rtl: &'static str

The wrapper RTL under benchmarks/silicon/, staged into the wrapper design under the same name. Its module is always user_project_wrapper, the harness’s name for the user area.

macro_ledger: &'static str

The ledger the macro’s own block signoff is recorded in.

wrapper_ledger: &'static str

The wrapper’s signoff record, the key its golden-deck verdict is filed under in golden_precheck.json, the precheck record, and the directory the submission is assembled in — regenerated OpenLane output, kept beside the runs it is assembled from under the ignored tools/.

golden_key: &'static str

precheck_ledger: &'static str

submission_dir: &'static str

overlay: &'static str

The submission files that are this project’s own — README, pad configuration, bring-up bench — laid over the efabless scaffold at the same relative paths.

Implementations

impl CaravelProject

pub fn by_key(key: &str) -> Option<&'static CaravelProject>

pub fn clock_period_ns(&self) -> f64

pub fn macro_period_ns(&self) -> f64

The period the macro is hardened at: its registered signoff period once a run has measured one, and the chip’s clock for the build that takes the first measurement.

pub fn wrapper_verilog(&self) -> String

The wrapper RTL: the harness’s user_project_wrapper around this project’s macro.

pub fn check(&self, pdk: &PdkTarget) -> Result<(), CaravelProjectUnplaceable>

The project fits the process’s vehicle, the vehicle’s timing is known, the macro guarantees the chip’s clock, and a project on the core clock runs it no faster than the chip signs it off at.

pub fn wrapper_clocks_ns(&self, harness: &HarnessTiming) -> (f64, Option<f64>)

The clocks the wrapper is timed at, in ns: clk on the core clock, at this project’s period when it runs there and at the chip’s signoff period when it does not, and usr_clk on user_clock2 at this project’s period when it runs there.

pub fn flow_shell( &self, pdk: &PdkTarget, ) -> Result<String, CaravelProjectUnplaceable>

What the flow scripts eval: the project, then the clock the vehicle’s chip is signed off with, which every harden of the chain is timed at, then the clocks the wrapper is timed at (CaravelProject::wrapper_clocks_ns, none for a clock it does not have) — or the refusal, when the project does not fit the vehicle.

pub fn shell(&self) -> String

The project as NAME=value lines for the flow scripts to eval. Every value is a bare word — an identifier, a number or a repo-relative path — so the assignment needs no quoting.

Trait Implementations

impl Clone for CaravelProject

fn clone(&self) -> CaravelProject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CaravelProject

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

Formats the value using the given formatter.

impl PartialEq for CaravelProject

fn eq(&self, other: &CaravelProject) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CaravelProject

impl Eq for CaravelProject

impl StructuralPartialEq for CaravelProject