Struct JitState 

pub struct JitState { /* private fields */ }

The Tier-2 state of one runtime.

Owned by that runtime’s Tiers; see the module docs for the split between this and the handful of genuinely process-wide items below.

Implementations

impl JitState

pub fn install_backend(&self, backend: Arc<dyn JitBackend>)

Attach a JIT compiler to this runtime. Idempotent: the first backend installed wins, later attempts are ignored.

pub fn backend(&self) -> Option<&Arc<dyn JitBackend>>

This runtime’s JIT compiler, or None when no JIT is linked or installed (dispatch then stops at Tier 1).

pub fn get_native_fn(&self, arity_id: u64) -> Option<(*const (), u64)>

Return the compiled native function pointer and its reclamation epoch for arity_id, if native code is currently published.

The caller must keep the returned epoch live (via push_jit_frame) for the entire native call, so code unloading at a stop-the-world safepoint does not free the backing module while it executes.

pub fn store_native_fn(&self, arity_id: u64, ptr: *const (), epoch: u64)

Publish a compiled native function pointer and its reclamation epoch for arity_id. Called by the JIT worker thread after successful compilation.

Stores the epoch before the pointer (release ordering) so that any reader that observes a non-null pointer also observes the matching epoch.

pub fn take_native_epoch(&self, arity_id: u64) -> Option<u64>

Clear the published native pointer for arity_id and return the epoch that was backing it, if any.

Called when a var holding this function is redefined: future dispatches fall back to the interpreter immediately (the pointer is nulled), and the returned epoch is handed to the code cache so the now-superseded module is reclaimed at the next safepoint once no frame is executing it. Also drops the per-arity table entry, keeping the table bounded across a long REPL session of redefinitions.

pub fn stale_native_code(&self, arity_id: u64)

Null any published native code for arity_id (whole-function and OSR entries) and hand the backing epochs to the code cache for reclamation.

Used by cross-defn invalidation and by the var-rebind hook; a no-op when nothing was compiled or no JIT is installed.

pub fn arg_type_profile(&self, arity_id: u64) -> Option<Vec<u8>>

Snapshot the accumulated argument-type profile for arity_id (one bitmask byte per IR parameter), if any calls were profiled.

pub fn record_call( &self, arity_id: u64, ir_func: Arc<IrFunction>, profile_args: &[Value], )

Record a call to arity_id.

Bumps the invocation counter and folds the call’s argument types into the arity’s type profile (profile_args are the positional call arguments matching the IR parameters; for a variadic arity the caller passes only the fixed prefix, leaving the rest-list parameter unprofiled — it is padded with PROFILE_OTHER so it can never be specialized). When the counter crosses jit_threshold for the first time, submits a compilation request to this runtime’s backend.

Called on every Tier-1 IR dispatch; must be cheap. Profiling stops once the compile is queued, so the steady-state cost is one atomic increment, one compare, and one relaxed load.

pub fn record_interp_call(&self, arity_id: u64) -> bool

Record a Tier-0 (tree-walk) call to arity_id.

Returns true exactly when the warm threshold is crossed and no lowering request has been enqueued yet — the caller should snapshot the function and enqueue, then call Self::mark_lower_queued on success. Uses >= so a failed enqueue (full queue) retries on the next call.

pub fn compile_queued(&self, arity_id: u64) -> bool

Whether a JIT compile has been queued (or published) for arity_id. Used by the cold-IR sweep: an arity with an in-flight compile still needs its IR as the deoptimization fallback.

pub fn pins_ir(&self, arity_id: u64) -> bool

Whether the cold-IR sweep must keep arity_id’s IR: native code is published (the IR is its deoptimization fallback) or a compile is in flight (the worker will need it).

pub fn lower_queued(&self, arity_id: u64) -> bool

Whether a background lowering request is already queued for arity_id. Fast skip for the Tier-0 dispatch path.

pub fn mark_lower_queued(&self, arity_id: u64)

Mark that a background lowering request was accepted for arity_id.

pub fn clear_lower_queued(&self, arity_id: u64)

Clear the lowering-queued flag for arity_id, re-arming the dispatch seam’s enqueue. Used by the lowering worker when it abandons an arity after exhausting its rebind-retry budget.

pub fn on_ir_published(&self, arity_id: u64)

Called by the lowering worker when it publishes IR for arity_id.

Restarts the invocation counter so the JIT threshold counts pure Tier-1 calls (and the argument-type profile gets a full window). Deliberately does not drop the JitEntry: lower_queued must stay set, or the Tier-0 path could re-enqueue between publish and the next IR dispatch.

pub fn evict_entry_if_cold(&self, arity_id: u64) -> bool

Drop the JitEntry for arity_id iff it has no published native code and no queued compile. Returns whether it was dropped.

Used by the cold-IR TTL sweep: dropping the entry clears the counters and lower_queued, so an evicted function can re-warm from zero.

pub fn set_bootstrap_watermark(&self, w: u64)

Record the bootstrap/user boundary: every arity id strictly below w was defined before this runtime’s compiler became ready. Called by the runtime builder with crate::interp::arity::next_arity_id().

pub fn is_bootstrap_arity(&self, arity_id: u64) -> bool

Whether arity_id belongs to a bootstrap-era definition (excluded from background lowering).

pub fn is_deopt_result(&self, result: *const Value) -> bool

Whether result is the deopt sentinel returned by a failed entry guard. Always false without a backend: nothing produced native code.

pub fn take_pending_exception(&self) -> Option<Value>

Take (and clear) the thread’s pending exception, if any.

Called by the JIT-native and OSR dispatch seams immediately after native code returns. Returns None when no JIT is installed.

pub fn specialization_allowed(&self, arity_id: u64) -> bool

Whether arity_id may be compiled with type specializations.

pub fn record_deopt(&self, arity_id: u64)

Record an entry-guard deopt for arity_id.

Once the failure count crosses deopt_limit, the specialized code is unpublished (dispatch falls back to Tier 1 immediately), its module is handed to the code cache for reclamation, the arity is banned from re-specialization, and its invocation counter restarts so the generic recompile triggers through the ordinary hot path.

pub fn osr_poll(&self, arity_id: u64, header: u32) -> OsrPoll

Poll for a compiled OSR entry for the loop at header in arity_id.

pub fn osr_request(&self, arity_id: u64, header: u32, ir_func: &IrFunction)

Request OSR compilation for the loop at header in arity_id. Idempotent: only the first request per (arity_id, header) enqueues (and pays for one IrFunction clone); with no JIT installed the entry is marked failed so callers stop polling.

pub fn store_osr_fn( &self, arity_id: u64, header: u32, ptr: *const (), epoch: u64, live_ins: Vec<VarId>, )

Publish a compiled OSR entry. Called by the JIT worker thread.

pub fn mark_osr_failed(&self, arity_id: u64, header: u32)

Record that OSR compilation for (arity_id, header) declined or failed, so interpreters stop polling and the loop stays at Tier 1.

pub fn take_osr_epochs(&self, arity_id: u64) -> Vec<u64>

Drop all OSR entries for arity_id (the owning var was rebound), returning the epochs of published code so the caller can hand them to the code cache for reclamation once no frame executes them.

pub fn stale_osr_code(&self, arity_id: u64)

Drop all OSR entries for arity_id and hand their published epochs to the code cache for reclamation. Used by the cold-IR TTL sweep: OSR-entry code is only reachable from Tier-1 interpretation of the evicted IR, so it is equally cold. A no-op when nothing was compiled or no JIT is installed.

Trait Implementations

impl Drop for JitState

Release this runtime’s compiled code when the runtime goes away.

The code cache is process-global (one executable-memory budget, one worker), so nothing else would ever look at these modules again: their only referents were the tables being dropped right here. Staling them hands them to the cache’s reclaim path, which frees each one at the next stop-the-world safepoint at which no thread is executing it — the same live-frame scan that guards redefinition, so a native frame still on some thread’s stack is as safe here as it is there.

Without this, a host that creates and drops runtimes — the case per-runtime tier state exists to support — would leak every module it ever compiled. The CLI, with one runtime for the life of the process, never reaches it.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.