Struct ResidencyComparison 

pub struct ResidencyComparison { /* private fields */ }

Running versus suspended for the same VM over the same wall time.

The gap is roughly two orders of magnitude over a month, which is the entire argument for a warm suspended pool. cycles is here so the argument stays honest: each suspend/resume pays a snapshot write plus a read, and a pool that churns spends more on transitions than it saves on residency. The conclusion to draw is “avoid churn”, not “avoid residency”.

Both sides exclude image build and storage. They are the same for either choice, and leaving them in would dilute the ratio the comparison exists to show — and drag an unpriced build into a figure whose whole job is to be comparable.

Implementations

impl ResidencyComparison

pub fn size(&self) -> SizeClass

pub fn hold(&self) -> DurationP

The wall time both sides cover. Always Provenance::Projected: a comparison is a hypothetical about a hold nobody has taken yet.

pub fn cycles(&self) -> u32

pub fn running(&self) -> &CostReport

The report for leaving the VM running.

pub fn suspended(&self) -> &CostReport

The report for suspending it, transitions included.

pub fn ratio(&self) -> Decimal

How many times more the running VM costs.

Zero-safe by construction: snapshot storage always has the minimum-retention floor (COST-8), so the denominator is never zero. Both totals are Total::Exact because both sides exclude the unpriced build, which is what makes reading their floors sound here.

pub fn per_cycle(&self) -> Result<EstimatedUsd, Error>

One suspend/resume: a snapshot write plus a read, per GB.

Without it the honest conclusion inverts — “suspend constantly” reads as free.

pub fn break_even_seconds(&self) -> Result<Decimal, Error>

How long a VM must stay suspended for the cycle to pay for itself.

Below this, suspending and resuming costs more than having left the VM running — which is the number a pool scheduler actually needs, and the one a bare “100x cheaper” headline hides.

Returns a Decimal where the Python returned a float, so the seconds figure stays in the same representation as the money it was derived from. See ResidencyComparison::break_even_seconds_f64 for the lossy step, which is named as one.

pub fn break_even_seconds_f64(&self) -> Result<f64, Error>

The break-even hold as an f64, for a JSON envelope.

Lossy, and named so. The exact answer is ResidencyComparison::break_even_seconds; this exists because cli.py emits breakEvenSeconds as a JSON number and the two clients have to agree on it. Seconds, not dollars — no money figure has an f64 accessor (COST-2).

pub fn render(&self) -> Result<String, Error>

Plain text for a CLI, ending with the conclusion the numbers support.

impl ResidencyComparison

pub fn to_json(&self) -> Result<Value, Error>

The comparison as JSON: both reports in CostReport::to_json’s shape, with the per-cycle cost and the break-even hold that keep the argument honest.

Trait Implementations

impl Clone for ResidencyComparison

fn clone(&self) -> ResidencyComparison

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResidencyComparison

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

Formats the value using the given formatter.

impl Eq for ResidencyComparison

impl PartialEq for ResidencyComparison

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ResidencyComparison