Module cache optimization round2

lib/api/src/sys/engine.rs

@@ -128,8 +128,12 @@ impl NativeEngineExt for crate::engine::Engine {
         &self,
         file_ref: &Path,
     ) -> Result<crate::Module, DeserializeError> {
-        let bytes = std::fs::read(file_ref)?;
-        let artifact = Arc::new(Artifact::deserialize_unchecked(&self.0, bytes.into())?);
+        let file = std::fs::File::open(file_ref)?;
+        let artifact = Arc::new(Artifact::deserialize_unchecked(
+            &self.0,
+            OwnedBuffer::from_file(&file)
+                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
+        )?);
         Ok(crate::Module(super::module::Module::from_artifact(
             artifact,
         )))

lib/compiler/src/artifact_builders/artifact_builder.rs

@@ -4,8 +4,10 @@
 #[cfg(feature = "compiler")]
 use super::trampoline::{libcall_trampoline_len, make_libcall_trampolines};
 use crate::ArtifactCreate;
+#[cfg(feature = "compiler")]
 use crate::EngineInner;
 use crate::Features;
+#[cfg(feature = "compiler")]
 use crate::{ModuleEnvironment, ModuleMiddlewareChain};
 use core::mem::MaybeUninit;
 use enumset::EnumSet;
@@ -18,7 +20,6 @@ use wasmer_types::entity::{ArchivedPrimaryMap, PrimaryMap};
 use wasmer_types::ArchivedOwnedDataInitializer;
 use wasmer_types::ArchivedSerializableCompilation;
 use wasmer_types::ArchivedSerializableModule;
-#[cfg(feature = "compiler")]
 use wasmer_types::CompileModuleInfo;
 use wasmer_types::DeserializeError;
 use wasmer_types::{
@@ -134,19 +135,18 @@ impl ArtifactBuild {
     }
 
     /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
-    #[cfg(not(feature = "compiler"))]
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn new(
-        _inner_engine: &mut EngineInner,
-        _data: &[u8],
-        _target: &Target,
-        _memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
-        _table_styles: PrimaryMap<TableIndex, TableStyle>,
-    ) -> Result<Self, CompileError> {
-        Err(CompileError::Codegen(
-            "Compilation is not enabled in the engine".to_string(),
-        ))
-    }
+    // #[cfg(not(feature = "compiler"))]
+    // pub fn new(
+    //     _inner_engine: &mut EngineInner,
+    //     _data: &[u8],
+    //     _target: &Target,
+    //     _memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
+    //     _table_styles: PrimaryMap<TableIndex, TableStyle>,
+    // ) -> Result<Self, CompileError> {
+    //     Err(CompileError::Codegen(
+    //         "Compilation is not enabled in the engine".to_string(),
+    //     ))
+    // }
 
     /// Create a new ArtifactBuild from a SerializableModule
     pub fn from_serializable(serializable: SerializableModule) -> Self {
@@ -250,6 +250,7 @@ impl<'a> ArtifactCreate<'a> for ArtifactBuild {
 
 /// Module loaded from an archive. Since `CompileModuleInfo` is part of the public
 /// interface of this crate and has to be mutable, it has to be deserialized completely.
+#[derive(Debug)]
 pub struct ModuleFromArchive<'a> {
     /// The main serializable compilation object
     pub compilation: &'a ArchivedSerializableCompilation,
@@ -283,11 +284,14 @@ self_cell!(
         #[covariant]
         dependent: ModuleFromArchive,
     }
+
+    impl {Debug}
 );
 
 /// A compiled wasm module that was loaded from a serialized archive.
+#[derive(Clone, Debug)]
 pub struct ArtifactBuildFromArchive {
-    cell: ArtifactBuildFromArchiveCell,
+    cell: Arc<ArtifactBuildFromArchiveCell>,
 
     /// Compilation informations
     compile_info: CompileModuleInfo,
@@ -314,7 +318,15 @@ impl ArtifactBuildFromArchive {
 
         // Safety: we know the lambda will execute before getting here and assign both values
         let compile_info = unsafe { compile_info.assume_init() };
-        Ok(Self { cell, compile_info })
+        Ok(Self {
+            cell: Arc::new(cell),
+            compile_info,
+        })
+    }
+
+    /// Gets the owned buffer
+    pub fn owned_buffer(&self) -> &OwnedBuffer {
+        self.cell.borrow_owner()
     }
 
     /// Get Functions Bodies ref
@@ -392,6 +404,13 @@ impl ArtifactBuildFromArchive {
         }
     }
 
+    /// Get Function Relocations ref
+    pub fn get_frame_info_ref(
+        &self,
+    ) -> &ArchivedPrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo> {
+        &self.cell.borrow_dependent().compilation.function_frame_info
+    }
+
     /// Get Function Relocations ref
     pub fn deserialize_frame_info_ref(
         &self,

lib/compiler/src/artifact_builders/mod.rs

@@ -1,7 +1,9 @@
 //! Generic Artifact abstraction for Wasmer Engines.
 
 mod artifact_builder;
+#[cfg(feature = "compiler")]
 mod trampoline;
 
 pub use self::artifact_builder::{ArtifactBuild, ArtifactBuildFromArchive, ModuleFromArchive};
+#[cfg(feature = "compiler")]
 pub use self::trampoline::*;

lib/compiler/src/engine/artifact.rs

@@ -7,6 +7,7 @@ use crate::ArtifactBuild;
 use crate::ArtifactBuildFromArchive;
 use crate::ArtifactCreate;
 use crate::Features;
+use crate::FrameInfosVariant;
 use crate::ModuleEnvironment;
 use crate::{
     register_frame_info, resolve_imports, FunctionExtent, GlobalFrameInfoRegistration,
@@ -680,8 +681,10 @@ impl Artifact {
             self.artifact.create_module_info(),
             &finished_function_extents,
             match &self.artifact {
-                ArtifactBuildVariant::Plain(p) => p.get_frame_info_ref().clone(),
-                ArtifactBuildVariant::Archived(a) => a.deserialize_frame_info_ref()?,
+                ArtifactBuildVariant::Plain(p) => {
+                    FrameInfosVariant::Owned(p.get_frame_info_ref().clone())
+                }
+                ArtifactBuildVariant::Archived(a) => FrameInfosVariant::Archived(a.clone()),
             },
         );