Struct JitBackend 

pub struct JitBackend {
    inner: Arc<BackendInner>,
}

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.

Fields

inner: Arc<BackendInner>

Implementations

impl JitBackend

pub fn disabled() -> Self

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<Self>

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: B256, 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: B256, 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<()>

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 set_enabled(&self, enabled: bool) -> Result<()>

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.

fn ensure_started(&self) -> Result<()>

Spawns the backend thread if it hasn’t been started yet.

fn preload_aot( store: Option<&dyn ArtifactStore>, ) -> Result<Vec<(RuntimeCacheKey, Arc<CompiledProgram>)>>

Preloads AOT artifacts from the store as Arc<CompiledProgram>s ready to insert.

fn load_artifact( key: &ArtifactKey, stored: &StoredArtifact, ) -> Result<CompiledProgram>

Loads a single artifact: dlopens the dylib path and resolves the symbol.

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

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