Struct BackendState 

struct BackendState {
    inner: Arc<BackendShared>,
    resident_meta: HashMap<RuntimeCacheKey, ResidentMeta>,
    entries: HashMap<RuntimeCacheKey, EntryState>,
    workers: WorkerPool,
    result_rx: Receiver<WorkerResult>,
    store: Option<Arc<dyn ArtifactStore>>,
    tuning: RuntimeTuning,
    aot: bool,
    pending_jobs: usize,
    generation: u64,
    last_sweep: Instant,
    on_compilation: Option<Arc<dyn Fn(CompilationEvent) + Send + Sync>>,
}

All backend-thread-owned mutable state.

Fields

inner: Arc<BackendShared>

Shared state (resident map, event queue, stats).

resident_meta: HashMap<RuntimeCacheKey, ResidentMeta>

Per-key metadata for eviction (backend-only).

entries: HashMap<RuntimeCacheKey, EntryState>

Per-key tracking state (backend-only).

workers: WorkerPool

Worker pool for JIT compilation.

result_rx: Receiver<WorkerResult>

Receiver for worker results.

store: Option<Arc<dyn ArtifactStore>>

Artifact store for persisted artifacts.

tuning: RuntimeTuning

Tuning knobs.

aot: bool

Whether observed misses compile AOT artifacts instead of JIT code.

pending_jobs: usize

Number of keys currently in Working phase.

generation: u64

Monotonically increasing generation counter, bumped on clear/invalidation.

last_sweep: Instant

Last time an eviction sweep was run.

on_compilation: Option<Arc<dyn Fn(CompilationEvent) + Send + Sync>>

Optional user callback for compilation events.

Implementations

impl BackendState

fn handle(&mut self, cmd: Command) -> ControlFlow<()>

fn tick(&mut self)

fn drain_events(&mut self)

Drains all currently-queued lookup events.

fn handle_lookup_observed(&mut self, event: LookupRequest)

fn handle_compile_jit(&mut self, req: CompileJitRequest)

fn handle_prepare_aot(&mut self, reqs: Vec<PrepareAotRequest>)

fn try_admit( &mut self, kind: CompilationKind, key: RuntimeCacheKey, bytecode: Bytes, sync_notifier: SyncNotifier, mode: AdmitMode, )

Common admission path for JIT and AOT compilation requests.

Handles the cold→working state machine, hotness gating, in-flight dedup, persisted AOT probing, and worker dispatch. Observed promotion is gated by hotness; explicit requests are unconditional.

fn try_load_persisted_aot(&mut self, key: &RuntimeCacheKey) -> bool

Tries to load an already-persisted AOT artifact from the store into the resident map. Returns true if the artifact was loaded successfully.

fn handle_clear_resident(&mut self)

fn handle_clear_persisted(&mut self)

fn handle_clear_all(&mut self)

fn insert_resident( &mut self, key: RuntimeCacheKey, program: Arc<CompiledProgram>, )

fn remove_resident(&mut self, key: &RuntimeCacheKey)

fn handle_worker_result(&mut self, result: WorkerResult)

fn handle_aot_success(&mut self, key: RuntimeCacheKey, success: AotSuccess)

fn run_eviction_sweep(&mut self)

Runs an eviction sweep: removes idle entries and enforces the memory budget.

fn should_sweep(&self) -> bool

Returns whether eviction is configured and a sweep is due.

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: 368 bytes