Struct JitBackend 

pub struct JitBackend { /* private fields */ }

Available on crate feature jit only.

JIT compilation backend with O(1) compiled-function lookup.

Created via JitBackend::new or JitBackend::disabled. This type is cheaply clonable (backed by Arc). All clones share the same backend thread, resident map, and statistics.

Implementations

impl JitBackend

pub fn disabled() -> JitBackend

Creates a disabled backend that performs no compilation and spawns no threads.

All lookup calls return LookupDecision::Interpret(Disabled). Call set_enabled to lazily spawn the backend thread with a default RuntimeConfig.

pub fn new(config: RuntimeConfig) -> Result<JitBackend, Report>

Creates a backend from the given config.

If enabled is true, the backend thread is spawned immediately and AOT artifacts are preloaded. Otherwise, both are deferred until the first set_enabled(true) call.

pub fn lookup(&self, req: LookupRequest) -> LookupDecision

Looks up a compiled function for the given request.

In normal mode this never blocks. In blocking mode, a miss triggers synchronous JIT compilation and the call blocks until it completes.

pub fn get_compiled( &self, code_hash: FixedBytes<32>, spec_id: SpecId, ) -> Option<Arc<CompiledProgram>>

Checks the resident map for a compiled program without enqueuing an event.

pub fn get_compiled_tracked( &self, code_hash: FixedBytes<32>, spec_id: SpecId, ) -> Option<Arc<CompiledProgram>>

Like get_compiled, but also records hit/miss stats.

pub fn lookup_blocking(&self, req: LookupRequest) -> LookupDecision

Looks up a compiled function, blocking until compilation completes if not yet ready.

If the function is already compiled, returns it immediately. Otherwise, enqueues a synchronous JIT compilation request and blocks until the result is available. Returns [LookupDecision::Interpret] if the bytecode is ineligible for compilation (see RuntimeTuning::should_compile) or compilation fails.

pub fn compile_jit(&self, req: LookupRequest)

Enqueues an explicit JIT compilation request for the given bytecode.

Blocks if the command channel is full to guarantee delivery.

pub fn compile_jit_sync(&self, req: LookupRequest) -> Result<(), Report>

Enqueues a JIT compilation request and blocks until the compilation completes.

Returns Ok(()) when the compiled function is available in the resident map, or when the compilation fails. Use get_compiled to retrieve the result after this returns.

pub fn prepare_aot(&self, req: AotRequest)

Enqueues a single AOT preparation request.

This is enqueue-only and returns immediately. The compilation happens asynchronously on the worker pool. The resulting artifact is persisted via [ArtifactStore::store] and loaded into the resident map.

pub fn prepare_aot_batch(&self, reqs: Vec<AotRequest>)

Enqueues a batch of AOT preparation requests.

Blocks if the command channel is full to guarantee delivery.

pub fn clear_resident(&self)

Clears the in-memory resident compiled map.

All compiled programs are removed from the map. Active references held by callers remain valid until dropped.

pub fn clear_persisted(&self)

Clears persisted artifacts from the artifact store.

pub fn clear_all(&self)

Clears both the resident map and persisted artifacts.

pub fn enabled(&self) -> bool

Returns whether the runtime is enabled.

pub fn pause(&self)

Pauses out-of-process helper execution.

Resident compiled functions are still returned by lookup, and lookup events are still processed for stats, hotness tracking, and compilation dispatch. In out-of-process mode, the helper process group is stopped until the pause depth returns to zero, so dispatched helper requests remain buffered and resume once the helper continues. In in-process mode, pause only tracks pause depth.

Pause delivery is best-effort and never blocks: callers pause around block validation on the engine’s critical path. If the backend thread is not running or the command channel is full, the command is skipped or dropped instead of blocking.

pub fn resume(&self)

Resumes out-of-process helper execution once all active pauses have been released.

Resume delivery is best-effort and never blocks, like pause.

pub fn is_paused(&self) -> bool

Returns whether out-of-process helper execution is paused.

pub fn set_enabled(&self, enabled: bool) -> Result<(), Report>

Sets whether the runtime is enabled, spawning the backend thread on first enable.

When enabled is true and the backend thread has not been spawned yet, this lazily starts it using the config provided at construction time.

pub fn stats(&self) -> RuntimeStatsSnapshot

Returns a point-in-time snapshot of runtime statistics.

Trait Implementations

impl Clone for JitBackend

fn clone(&self) -> JitBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JitBackend

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes