Function make_module_host

crates/core/src/host/host_controller.rs:694–736

(
    runtimes: Arc<HostRuntimes>,
    replica_ctx: Arc<ReplicaContext>,
    scheduler: Scheduler,
    program: Program,
    energy_monitor: Arc<dyn EnergyMonitor>,
    unregister: impl Fn() + Send + 

/// The passed replica_ctx may not be configured for this version of the program's database schema yet.
#[allow(clippy::too_many_arguments)]
async fn make_module_host(
    runtimes: Arc<HostRuntimes>,
    replica_ctx: Arc<ReplicaContext>,
    scheduler: Scheduler,
    program: Program,
    energy_monitor: Arc<dyn EnergyMonitor>,
    unregister: impl Fn() + Send + Sync + 'static,
    core: AllocatedJobCore,
) -> anyhow::Result<(Program, ModuleHost)> {
    // `make_actor` is blocking, as it needs to compile the wasm to native code,
    // which may be computationally expensive - sometimes up to 1s for a large module.
    // TODO: change back to using `spawn_rayon` here - asyncify runs on tokio blocking
    //       threads, but those aren't for computation. Also, wasmtime uses rayon
    //       to run compilation in parallel, so it'll need to run stuff in rayon anyway.
    let database_identity = replica_ctx.database_identity;

    let mcc = ModuleCreationContext {
        replica_ctx,
        scheduler,
        program_hash: program.hash,
        energy_monitor,
    };

    match HostType::from(program.kind) {
        HostType::Wasm => {
            asyncify(move || {
                let start = Instant::now();
                let module = runtimes.wasmtime.make_actor(mcc, &program.bytes, core)?;
                trace!("wasmtime::make_actor blocked for {:?}", start.elapsed());
                let module_host = ModuleHost::new(module, unregister, database_identity);
                Ok((program, module_host))
            })
            .await
        }
        HostType::Js => {
            let start = Instant::now();
            let module = runtimes.v8.make_actor(mcc, &program.bytes, core).await?;
            trace!("v8::make_actor blocked for {:?}", start.elapsed());
            let module_host = ModuleHost::new(module, unregister, database_identity);
            Ok((program, module_host))
        }
    }
}

async fn load_program(storage: &ProgramStorage, hash: Hash) -> anyhow::Result<Box<[u8]>> {
    storage