From fd15636604f706728a966584ce4c98ffa67c0247 Mon Sep 17 00:00:00 2001 From: Ivan Enderlin Date: Mon, 22 Mar 2021 12:04:27 +0100 Subject: [PATCH] !module second --- Cargo.lock | 1 + lib/compiler/src/address_map.rs | 5 +++-- lib/compiler/src/function.rs | 7 ++++--- lib/compiler/src/jump_table.rs | 3 ++- lib/compiler/src/module.rs | 3 ++- lib/compiler/src/relocation.rs | 7 ++++--- lib/compiler/src/section.rs | 9 +++++---- lib/compiler/src/sourceloc.rs | 4 ++-- lib/compiler/src/trap.rs | 3 ++- lib/compiler/src/unwind.rs | 3 ++- lib/engine-jit/src/artifact.rs | 3 +++ lib/engine-jit/src/serialize.rs | 5 +++-- lib/engine-native/src/artifact.rs | 2 +- lib/engine-native/src/serialize.rs | 3 ++- lib/engine-object-file/src/artifact.rs | 3 +++ lib/engine-object-file/src/serialize.rs | 4 +++- lib/engine/src/serialize.rs | 5 +++-- lib/engine/src/trap/frame_info.rs | 2 ++ lib/vm/Cargo.toml | 2 +- lib/vm/src/instance/mod.rs | 1 - lib/vm/src/libcalls.rs | 3 ++- lib/vm/src/module.rs | 5 +++-- lib/vm/src/trap/trapcode.rs | 3 ++- lib/wasmer-types/src/entity/primary_map.rs | 1 - lib/wasmer-types/src/entity/secondary_map.rs | 1 - lib/wasmer-types/src/initializers.rs | 7 ++++--- tests/lib/engine-dummy/src/artifact.rs | 5 ++++- 27 files changed, 63 insertions(+), 37 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3ebaca6ac15..e766866da1f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1161,6 +1161,7 @@ source = "git+https://github.com/wasmerio/loupe?branch=master#63c2f4a5acf1f3a8ed dependencies = [ "loupe-derive", "rustversion", + "indexmap", ] [[package]] diff --git a/lib/compiler/src/address_map.rs b/lib/compiler/src/address_map.rs index 40d37a073f6..ab6b227da50 100644 --- a/lib/compiler/src/address_map.rs +++ b/lib/compiler/src/address_map.rs @@ -3,12 +3,13 @@ use crate::lib::std::vec::Vec; use crate::sourceloc::SourceLoc; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; /// Single source location to generated address mapping. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub struct InstructionAddressMap { /// Original source location. pub srcloc: SourceLoc, @@ -22,7 +23,7 @@ pub struct InstructionAddressMap { /// Function and its instructions addresses mappings. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, Default)] +#[derive(Debug, Clone, PartialEq, Eq, Default, MemoryUsage)] pub struct FunctionAddressMap { /// Instructions maps. /// The array is sorted by the InstructionAddressMap::code_offset field. diff --git a/lib/compiler/src/function.rs b/lib/compiler/src/function.rs index 6be0ae9ac52..f2567559d42 100644 --- a/lib/compiler/src/function.rs +++ b/lib/compiler/src/function.rs @@ -12,6 +12,7 @@ use crate::lib::std::vec::Vec; use crate::section::{CustomSection, SectionIndex}; use crate::trap::TrapInformation; use crate::{CompiledFunctionUnwindInfo, FunctionAddressMap, JumpTableOffsets, Relocation}; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_types::entity::PrimaryMap; @@ -22,7 +23,7 @@ use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex}; /// This structure is only used for reconstructing /// the frame information after a `Trap`. #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))] -#[derive(Debug, Clone, PartialEq, Eq, Default)] +#[derive(Debug, Clone, PartialEq, Eq, Default, MemoryUsage)] pub struct CompiledFunctionFrameInfo { /// The traps (in the function body). /// @@ -35,7 +36,7 @@ pub struct CompiledFunctionFrameInfo { /// The function body. #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub struct FunctionBody { /// The function body bytes. #[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))] @@ -79,7 +80,7 @@ pub type CustomSections = PrimaryMap; /// In the future this structure may also hold other information useful /// for debugging. #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))] -#[derive(Debug, PartialEq, Eq, Clone)] +#[derive(Debug, PartialEq, Eq, Clone, MemoryUsage)] pub struct Dwarf { /// The section index in the [`Compilation`] that corresponds to the exception frames. /// [Learn diff --git a/lib/compiler/src/jump_table.rs b/lib/compiler/src/jump_table.rs index 19da678c77a..5f4ff41c500 100644 --- a/lib/compiler/src/jump_table.rs +++ b/lib/compiler/src/jump_table.rs @@ -5,6 +5,7 @@ //! [Learn more](https://en.wikipedia.org/wiki/Branch_table). use super::CodeOffset; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_types::entity::{entity_impl, SecondaryMap}; @@ -14,7 +15,7 @@ use wasmer_types::entity::{entity_impl, SecondaryMap}; /// `JumpTable`s are used for indirect branching and are specialized for dense, /// 0-based jump offsets. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, MemoryUsage)] pub struct JumpTable(u32); entity_impl!(JumpTable, "jt"); diff --git a/lib/compiler/src/module.rs b/lib/compiler/src/module.rs index dacbdf3560a..a0e90c18684 100644 --- a/lib/compiler/src/module.rs +++ b/lib/compiler/src/module.rs @@ -1,4 +1,5 @@ use crate::lib::std::sync::Arc; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_types::entity::PrimaryMap; @@ -10,7 +11,7 @@ use wasmer_vm::{MemoryStyle, ModuleInfo, TableStyle}; /// This differs from [`ModuleInfo`] because it have extra info only /// possible after translation (such as the features used for compiling, /// or the `MemoryStyle` and `TableStyle`). -#[derive(Debug)] +#[derive(Debug, MemoryUsage)] #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))] pub struct CompileModuleInfo { /// The features used for compiling the module diff --git a/lib/compiler/src/relocation.rs b/lib/compiler/src/relocation.rs index c0e6306ed6e..8e110a27489 100644 --- a/lib/compiler/src/relocation.rs +++ b/lib/compiler/src/relocation.rs @@ -13,6 +13,7 @@ use crate::lib::std::fmt; use crate::lib::std::vec::Vec; use crate::section::SectionIndex; use crate::{Addend, CodeOffset, JumpTable}; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_types::entity::PrimaryMap; @@ -21,7 +22,7 @@ use wasmer_vm::libcalls::LibCall; /// Relocation kinds for every ISA. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Copy, Clone, Debug, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, MemoryUsage)] pub enum RelocationKind { /// absolute 4-byte Abs4, @@ -79,7 +80,7 @@ impl fmt::Display for RelocationKind { /// A record of a relocation to perform. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub struct Relocation { /// The relocation kind. pub kind: RelocationKind, @@ -93,7 +94,7 @@ pub struct Relocation { /// Destination function. Can be either user function or some special one, like `memory.grow`. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, MemoryUsage)] pub enum RelocationTarget { /// A relocation to a function defined locally in the wasm (not an imported one). LocalFunc(LocalFunctionIndex), diff --git a/lib/compiler/src/section.rs b/lib/compiler/src/section.rs index 096cbcc8cf7..8879a457368 100644 --- a/lib/compiler/src/section.rs +++ b/lib/compiler/src/section.rs @@ -7,13 +7,14 @@ use crate::lib::std::vec::Vec; use crate::Relocation; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_types::entity::entity_impl; /// Index type of a Section defined inside a WebAssembly `Compilation`. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, MemoryUsage)] pub struct SectionIndex(u32); entity_impl!(SectionIndex); @@ -22,7 +23,7 @@ entity_impl!(SectionIndex); /// /// Determines how a custom section may be used. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub enum CustomSectionProtection { /// A custom section with read permission. Read, @@ -36,7 +37,7 @@ pub enum CustomSectionProtection { /// This is used so compilers can store arbitrary information /// in the emitted module. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub struct CustomSection { /// Memory protection that applies to this section. pub protection: CustomSectionProtection, @@ -55,7 +56,7 @@ pub struct CustomSection { /// The bytes in the section. #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, Default)] +#[derive(Debug, Clone, PartialEq, Eq, Default, MemoryUsage)] pub struct SectionBody(#[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))] Vec); impl SectionBody { diff --git a/lib/compiler/src/sourceloc.rs b/lib/compiler/src/sourceloc.rs index 2964e144d47..82b3577d44f 100644 --- a/lib/compiler/src/sourceloc.rs +++ b/lib/compiler/src/sourceloc.rs @@ -8,7 +8,7 @@ //! and tracing errors. use crate::lib::std::fmt; - +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; @@ -22,7 +22,7 @@ use serde::{Deserialize, Serialize}; serde(transparent) )] #[repr(transparent)] -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, MemoryUsage)] pub struct SourceLoc(u32); impl SourceLoc { diff --git a/lib/compiler/src/trap.rs b/lib/compiler/src/trap.rs index 058f7e21c2e..e52767bbe32 100644 --- a/lib/compiler/src/trap.rs +++ b/lib/compiler/src/trap.rs @@ -1,11 +1,12 @@ use crate::CodeOffset; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use wasmer_vm::TrapCode; /// Information about trap. #[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))] -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq, MemoryUsage)] pub struct TrapInformation { /// The offset of the trapping instruction in native code. It is relative to the beginning of the function. pub code_offset: CodeOffset, diff --git a/lib/compiler/src/unwind.rs b/lib/compiler/src/unwind.rs index 30949281477..fce474a7f21 100644 --- a/lib/compiler/src/unwind.rs +++ b/lib/compiler/src/unwind.rs @@ -6,6 +6,7 @@ //! //! [Learn more](https://en.wikipedia.org/wiki/Call_stack). use crate::lib::std::vec::Vec; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; @@ -17,7 +18,7 @@ use serde::{Deserialize, Serialize}; /// /// [unwind info]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=vs-2019 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, MemoryUsage)] pub enum CompiledFunctionUnwindInfo { /// Windows UNWIND_INFO. WindowsX64(Vec), diff --git a/lib/engine-jit/src/artifact.rs b/lib/engine-jit/src/artifact.rs index e9d91e10bdc..fdba309690e 100644 --- a/lib/engine-jit/src/artifact.rs +++ b/lib/engine-jit/src/artifact.rs @@ -6,6 +6,7 @@ use crate::link::link_module; #[cfg(feature = "compiler")] use crate::serialize::SerializableCompilation; use crate::serialize::SerializableModule; +use loupe_derive::MemoryUsage; use std::sync::{Arc, Mutex}; use wasmer_compiler::{CompileError, Features, Triple}; #[cfg(feature = "compiler")] @@ -26,9 +27,11 @@ use wasmer_vm::{ }; /// A compiled wasm module, ready to be instantiated. +#[derive(MemoryUsage)] pub struct JITArtifact { serializable: SerializableModule, finished_functions: BoxedSlice, + #[memoryusage(ignore)] finished_function_call_trampolines: BoxedSlice, finished_dynamic_function_trampolines: BoxedSlice, signatures: BoxedSlice, diff --git a/lib/engine-jit/src/serialize.rs b/lib/engine-jit/src/serialize.rs index 92596ff3362..b02823a5393 100644 --- a/lib/engine-jit/src/serialize.rs +++ b/lib/engine-jit/src/serialize.rs @@ -1,3 +1,4 @@ +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use wasmer_compiler::{ CompileModuleInfo, CustomSection, Dwarf, FunctionBody, JumpTableOffsets, Relocation, @@ -18,7 +19,7 @@ use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, Sign // } /// The compilation related data for a serialized modules -#[derive(Serialize, Deserialize)] +#[derive(Serialize, Deserialize, MemoryUsage)] pub struct SerializableCompilation { pub function_bodies: PrimaryMap, pub function_relocations: PrimaryMap>, @@ -37,7 +38,7 @@ pub struct SerializableCompilation { /// Serializable struct that is able to serialize from and to /// a `JITArtifactInfo`. -#[derive(Serialize, Deserialize)] +#[derive(Serialize, Deserialize, MemoryUsage)] pub struct SerializableModule { pub compilation: SerializableCompilation, pub compile_info: CompileModuleInfo, diff --git a/lib/engine-native/src/artifact.rs b/lib/engine-native/src/artifact.rs index 147ab93d2a8..c767a576dbb 100644 --- a/lib/engine-native/src/artifact.rs +++ b/lib/engine-native/src/artifact.rs @@ -41,9 +41,9 @@ use wasmer_vm::{ #[derive(MemoryUsage)] pub struct NativeArtifact { sharedobject_path: PathBuf, - #[memoryusage(ignore)] metadata: ModuleMetadata, finished_functions: BoxedSlice, + #[memoryusage(ignore)] finished_function_call_trampolines: BoxedSlice, finished_dynamic_function_trampolines: BoxedSlice, signatures: BoxedSlice, diff --git a/lib/engine-native/src/serialize.rs b/lib/engine-native/src/serialize.rs index 88fa9965d27..b1bdf0595f6 100644 --- a/lib/engine-native/src/serialize.rs +++ b/lib/engine-native/src/serialize.rs @@ -1,10 +1,11 @@ +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use wasmer_compiler::{CompileModuleInfo, SectionIndex, Symbol, SymbolRegistry}; use wasmer_types::entity::{EntityRef, PrimaryMap}; use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SignatureIndex}; /// Serializable struct that represents the compiled metadata. -#[derive(Serialize, Deserialize, Debug)] +#[derive(Serialize, Deserialize, Debug, MemoryUsage)] pub struct ModuleMetadata { pub compile_info: CompileModuleInfo, pub prefix: String, diff --git a/lib/engine-object-file/src/artifact.rs b/lib/engine-object-file/src/artifact.rs index fcba7872224..46c37026993 100644 --- a/lib/engine-object-file/src/artifact.rs +++ b/lib/engine-object-file/src/artifact.rs @@ -3,6 +3,7 @@ use crate::engine::{ObjectFileEngine, ObjectFileEngineInner}; use crate::serialize::{ModuleMetadata, ModuleMetadataSymbolRegistry}; +use loupe_derive::MemoryUsage; use std::collections::BTreeMap; use std::error::Error; use std::mem; @@ -30,10 +31,12 @@ use wasmer_vm::{ }; /// A compiled wasm module, ready to be instantiated. +#[derive(MemoryUsage)] pub struct ObjectFileArtifact { metadata: ModuleMetadata, module_bytes: Vec, finished_functions: BoxedSlice, + #[memoryusage(ignore)] finished_function_call_trampolines: BoxedSlice, finished_dynamic_function_trampolines: BoxedSlice, signatures: BoxedSlice, diff --git a/lib/engine-object-file/src/serialize.rs b/lib/engine-object-file/src/serialize.rs index 8ec7da0302d..30143a66a4e 100644 --- a/lib/engine-object-file/src/serialize.rs +++ b/lib/engine-object-file/src/serialize.rs @@ -1,10 +1,11 @@ +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use wasmer_compiler::{CompileModuleInfo, SectionIndex, Symbol, SymbolRegistry}; use wasmer_types::entity::{EntityRef, PrimaryMap}; use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SignatureIndex}; /// Serializable struct that represents the compiled metadata. -#[derive(Serialize, Deserialize, Debug)] +#[derive(Serialize, Deserialize, Debug, MemoryUsage)] pub struct ModuleMetadata { pub compile_info: CompileModuleInfo, pub prefix: String, @@ -13,6 +14,7 @@ pub struct ModuleMetadata { pub function_body_lengths: PrimaryMap, } +#[derive(MemoryUsage)] pub struct ModuleMetadataSymbolRegistry { pub prefix: String, } diff --git a/lib/engine/src/serialize.rs b/lib/engine/src/serialize.rs index d501332c931..240fba41c60 100644 --- a/lib/engine/src/serialize.rs +++ b/lib/engine/src/serialize.rs @@ -1,3 +1,4 @@ +use loupe_derive::MemoryUsage; use serde::de::{Deserializer, Visitor}; use serde::ser::Serializer; use serde::{Deserialize, Serialize}; @@ -5,7 +6,7 @@ use std::fmt; use wasmer_compiler::CompiledFunctionFrameInfo; /// This is the unserialized verison of `CompiledFunctionFrameInfo`. -#[derive(Clone, Serialize, Deserialize)] +#[derive(Clone, Serialize, Deserialize, MemoryUsage)] #[serde(transparent)] #[repr(transparent)] pub struct UnprocessedFunctionFrameInfo { @@ -44,7 +45,7 @@ impl UnprocessedFunctionFrameInfo { /// of compiling at the same time that emiting the JIT. /// In that case, we don't need to deserialize/process anything /// as the data is already in memory. -#[derive(Clone)] +#[derive(Clone, MemoryUsage)] pub enum SerializableFunctionFrameInfo { /// The unprocessed frame info (binary) Unprocessed(UnprocessedFunctionFrameInfo), diff --git a/lib/engine/src/trap/frame_info.rs b/lib/engine/src/trap/frame_info.rs index 8906a4478c7..c479e23418c 100644 --- a/lib/engine/src/trap/frame_info.rs +++ b/lib/engine/src/trap/frame_info.rs @@ -11,6 +11,7 @@ //! FRAME_INFO.register(module, compiled_functions); //! ``` use crate::serialize::SerializableFunctionFrameInfo; +use loupe_derive::MemoryUsage; use std::cmp; use std::collections::BTreeMap; use std::sync::{Arc, RwLock}; @@ -44,6 +45,7 @@ pub struct GlobalFrameInfo { /// An RAII structure used to unregister a module's frame information when the /// module is destroyed. +#[derive(MemoryUsage)] pub struct GlobalFrameInfoRegistration { /// The key that will be removed from the global `ranges` map when this is /// dropped. diff --git a/lib/vm/Cargo.toml b/lib/vm/Cargo.toml index cc12923e68b..056316a84d0 100644 --- a/lib/vm/Cargo.toml +++ b/lib/vm/Cargo.toml @@ -21,7 +21,7 @@ more-asserts = "0.2" cfg-if = "0.1" backtrace = "0.3" serde = { version = "1.0", features = ["derive", "rc"] } -loupe = { git = "https://github.com/wasmerio/loupe", branch = "master" } +loupe = { git = "https://github.com/wasmerio/loupe", branch = "master", features = ["enable-indexmap"] } [target.'cfg(target_os = "windows")'.dependencies] winapi = { version = "0.3", features = ["winbase", "memoryapi", "errhandlingapi"] } diff --git a/lib/vm/src/instance/mod.rs b/lib/vm/src/instance/mod.rs index 75a07e0c98a..986ee9d5156 100644 --- a/lib/vm/src/instance/mod.rs +++ b/lib/vm/src/instance/mod.rs @@ -28,7 +28,6 @@ use crate::vmcontext::{ use crate::{FunctionBodyPtr, ModuleInfo, VMOffsets}; use crate::{VMExportFunction, VMExportGlobal, VMExportMemory, VMExportTable}; use loupe::{MemoryUsage, MemoryUsageTracker}; -use loupe_derive::MemoryUsage; use memoffset::offset_of; use more_asserts::assert_lt; use std::any::Any; diff --git a/lib/vm/src/libcalls.rs b/lib/vm/src/libcalls.rs index 5267d35a6e5..00c50b4fafa 100644 --- a/lib/vm/src/libcalls.rs +++ b/lib/vm/src/libcalls.rs @@ -38,6 +38,7 @@ use crate::probestack::PROBESTACK; use crate::trap::{raise_lib_trap, Trap, TrapCode}; use crate::vmcontext::VMContext; +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use std::fmt; use wasmer_types::{DataIndex, ElemIndex, LocalMemoryIndex, MemoryIndex, TableIndex}; @@ -405,7 +406,7 @@ pub static wasmer_probestack: unsafe extern "C" fn() = PROBESTACK; /// The name of a runtime library routine. /// /// This list is likely to grow over time. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, MemoryUsage)] pub enum LibCall { /// ceil.f32 CeilF32, diff --git a/lib/vm/src/module.rs b/lib/vm/src/module.rs index 82d951f46c2..6f7ccefffb8 100644 --- a/lib/vm/src/module.rs +++ b/lib/vm/src/module.rs @@ -5,6 +5,7 @@ //! `wasmer::Module`. use indexmap::IndexMap; +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::fmt; @@ -19,7 +20,7 @@ use wasmer_types::{ TableIndex, TableInitializer, TableType, }; -#[derive(Debug, Clone)] +#[derive(Debug, Clone, MemoryUsage)] pub struct ModuleId { id: usize, } @@ -41,7 +42,7 @@ impl Default for ModuleId { /// A translated WebAssembly module, excluding the function bodies and /// memory initializers. -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Debug, Clone, Serialize, Deserialize, MemoryUsage)] pub struct ModuleInfo { /// A unique identifier (within this process) for this module. /// diff --git a/lib/vm/src/trap/trapcode.rs b/lib/vm/src/trap/trapcode.rs index 32121fbd08e..e3740339e9b 100644 --- a/lib/vm/src/trap/trapcode.rs +++ b/lib/vm/src/trap/trapcode.rs @@ -5,13 +5,14 @@ use core::fmt::{self, Display, Formatter}; use core::str::FromStr; +use loupe_derive::MemoryUsage; use serde::{Deserialize, Serialize}; use thiserror::Error; /// A trap code describing the reason for a trap. /// /// All trap instructions have an explicit trap code. -#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize, Deserialize, Error)] +#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize, Deserialize, Error, MemoryUsage)] #[repr(u32)] pub enum TrapCode { /// The current stack space was exhausted. diff --git a/lib/wasmer-types/src/entity/primary_map.rs b/lib/wasmer-types/src/entity/primary_map.rs index e875ebef377..a3a07eec81d 100644 --- a/lib/wasmer-types/src/entity/primary_map.rs +++ b/lib/wasmer-types/src/entity/primary_map.rs @@ -13,7 +13,6 @@ use crate::lib::std::ops::{Index, IndexMut}; use crate::lib::std::slice; use crate::lib::std::vec::Vec; use loupe::{MemoryUsage, MemoryUsageTracker}; -use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use std::mem; diff --git a/lib/wasmer-types/src/entity/secondary_map.rs b/lib/wasmer-types/src/entity/secondary_map.rs index 35776d17820..ac19c432fb7 100644 --- a/lib/wasmer-types/src/entity/secondary_map.rs +++ b/lib/wasmer-types/src/entity/secondary_map.rs @@ -12,7 +12,6 @@ use crate::lib::std::ops::{Index, IndexMut}; use crate::lib::std::slice; use crate::lib::std::vec::Vec; use loupe::{MemoryUsage, MemoryUsageTracker}; -use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{ de::{Deserializer, SeqAccess, Visitor}, diff --git a/lib/wasmer-types/src/initializers.rs b/lib/wasmer-types/src/initializers.rs index 0d47554c502..d8cf3d51b1c 100644 --- a/lib/wasmer-types/src/initializers.rs +++ b/lib/wasmer-types/src/initializers.rs @@ -1,11 +1,12 @@ use crate::indexes::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex}; use crate::lib::std::boxed::Box; +use loupe_derive::MemoryUsage; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; /// A WebAssembly table initializer. -#[derive(Clone, Debug, Hash, Serialize, Deserialize)] +#[derive(Clone, Debug, Hash, Serialize, Deserialize, MemoryUsage)] pub struct TableInitializer { /// The index of a table to initialize. pub table_index: TableIndex, @@ -19,7 +20,7 @@ pub struct TableInitializer { /// A memory index and offset within that memory where a data initialization /// should be performed. -#[derive(Clone, Debug)] +#[derive(Clone, Debug, MemoryUsage)] #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] pub struct DataInitializerLocation { /// The index of the memory to initialize. @@ -45,7 +46,7 @@ pub struct DataInitializer<'data> { /// As `DataInitializer` but owning the data rather than /// holding a reference to it -#[derive(Debug, Clone)] +#[derive(Debug, Clone, MemoryUsage)] #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] pub struct OwnedDataInitializer { /// The location where the initialization is to be performed. diff --git a/tests/lib/engine-dummy/src/artifact.rs b/tests/lib/engine-dummy/src/artifact.rs index ea542256d06..89e3070a7f2 100644 --- a/tests/lib/engine-dummy/src/artifact.rs +++ b/tests/lib/engine-dummy/src/artifact.rs @@ -2,6 +2,7 @@ //! done as separate steps. use crate::engine::DummyEngine; +use loupe_derive::MemoryUsage; #[cfg(feature = "serialize")] use serde::{Deserialize, Serialize}; use std::sync::Arc; @@ -21,6 +22,7 @@ use wasmer_vm::{ /// Serializable struct for the artifact #[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))] +#[derive(MemoryUsage)] pub struct DummyArtifactMetadata { pub module: Arc, pub features: Features, @@ -34,10 +36,11 @@ pub struct DummyArtifactMetadata { /// /// This artifact will point to fake finished functions and trampolines /// as no functions are really compiled. +#[derive(MemoryUsage)] pub struct DummyArtifact { metadata: DummyArtifactMetadata, - finished_functions: BoxedSlice, + #[memoryusage(ignore)] finished_function_call_trampolines: BoxedSlice, finished_dynamic_function_trampolines: BoxedSlice, signatures: BoxedSlice,