wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-20.0.2/src/runtime/profiling.rs

@@ -1,224 +0,0 @@
-use crate::{instantiate::CompiledModule, AsContext, Module};
-#[allow(unused_imports)]
-use anyhow::bail;
-use anyhow::Result;
-#[cfg(feature = "profiling")]
-use fxprof_processed_profile::{
-    debugid::DebugId, CategoryHandle, Frame, FrameFlags, FrameInfo, LibraryInfo, Profile,
-    ReferenceTimestamp, Symbol, SymbolTable, Timestamp,
-};
-use std::ops::Range;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use wasmtime_environ::demangle_function_name_or_index;
-use wasmtime_runtime::Backtrace;
-
-// TODO: collect more data
-// - Provide additional hooks for recording host-guest transitions, to be
-//   invoked from a Store::call_hook
-// - On non-Windows, measure thread-local CPU usage between events with
-//   rustix::time::clock_gettime(ClockId::ThreadCPUTime)
-// - Report which wasm module, and maybe instance, each frame came from
-
-/// Collects basic profiling data for a single WebAssembly guest.
-///
-/// This profiler can't provide measurements that are as accurate or detailed
-/// as a platform-specific profiler, such as `perf` on Linux. On the other
-/// hand, this profiler works on every platform that Wasmtime supports. Also,
-/// as an embedder you can use this profiler selectively on individual guest
-/// instances rather than profiling the entire process.
-///
-/// To use this, you'll need to arrange to call [`GuestProfiler::sample`] at
-/// regular intervals while the guest is on the stack. The most straightforward
-/// way to do that is to call it from a callback registered with
-/// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-///
-/// # Accuracy
-///
-/// The data collection granularity is limited by the mechanism you use to
-/// interrupt guest execution and collect a profiling sample.
-///
-/// If you use epoch interruption, then samples will only be collected at
-/// function entry points and loop headers. This introduces some bias to the
-/// results. In addition, samples will only be taken at times when WebAssembly
-/// functions are running, not during host-calls.
-///
-/// It is technically possible to use fuel interruption instead. That
-/// introduces worse bias since samples occur after a certain number of
-/// WebAssembly instructions, which can take different amounts of time.
-///
-/// You may instead be able to use platform-specific methods, such as
-/// `setitimer(ITIMER_VIRTUAL, ...)` on POSIX-compliant systems, to sample on
-/// a more accurate interval. The only current requirement is that the guest
-/// you wish to profile must be on the same stack where you call `sample`,
-/// and executing within the same thread. However, the `GuestProfiler::sample`
-/// method is not currently async-signal-safe, so doing this correctly is not
-/// easy.
-///
-/// # Security
-///
-/// Profiles produced using this profiler do not include any configuration
-/// details from the host, such as virtual memory addresses, or from any
-/// WebAssembly modules that you haven't specifically allowed. So for
-/// example, these profiles should be safe to share with untrusted users
-/// who have provided untrusted code that you are running in a multi-tenancy
-/// environment.
-///
-/// However, the profile does include byte offsets into the text section of
-/// the compiled module, revealing some information about the size of the code
-/// generated for each module. For user-provided modules, the user could get
-/// the same information by compiling the module for themself using a similar
-/// version of Wasmtime on the same target architecture, but for any module
-/// where they don't already have the WebAssembly module binary available this
-/// could theoretically lead to an undesirable information disclosure. So you
-/// should only include user-provided modules in profiles.
-#[cfg(feature = "profiling")]
-#[derive(Debug)]
-pub struct GuestProfiler {
-    profile: Profile,
-    modules: Vec<(Range<usize>, fxprof_processed_profile::LibraryHandle)>,
-    process: fxprof_processed_profile::ProcessHandle,
-    thread: fxprof_processed_profile::ThreadHandle,
-    start: Instant,
-}
-
-#[cfg(feature = "profiling")]
-impl GuestProfiler {
-    /// Begin profiling a new guest. When this function is called, the current
-    /// wall-clock time is recorded as the start time for the guest.
-    ///
-    /// The `module_name` parameter is recorded in the profile to help identify
-    /// where the profile came from.
-    ///
-    /// The `interval` parameter should match the rate at which you intend
-    /// to call `sample`. However, this is used as a hint and not required to
-    /// exactly match the real sample rate.
-    ///
-    /// Only modules which are present in the `modules` vector will appear in
-    /// stack traces in this profile. Any stack frames which were executing
-    /// host code or functions from other modules will be omitted. See the
-    /// "Security" section of the [`GuestProfiler`] documentation for guidance
-    /// on what modules should not be included in this list.
-    pub fn new(module_name: &str, interval: Duration, modules: Vec<(String, Module)>) -> Self {
-        let zero = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
-        let mut profile = Profile::new(module_name, zero, interval.into());
-
-        let mut modules: Vec<_> = modules
-            .into_iter()
-            .filter_map(|(name, module)| {
-                let compiled = module.compiled_module();
-                let text = compiled.text().as_ptr_range();
-                let address_range = text.start as usize..text.end as usize;
-                module_symbols(name, compiled).map(|lib| (address_range, profile.add_lib(lib)))
-            })
-            .collect();
-
-        modules.sort_unstable_by_key(|(range, _)| range.start);
-
-        profile.set_reference_timestamp(std::time::SystemTime::now().into());
-        let process = profile.add_process(module_name, 0, Timestamp::from_nanos_since_reference(0));
-        let thread = profile.add_thread(process, 0, Timestamp::from_nanos_since_reference(0), true);
-        let start = Instant::now();
-        Self {
-            profile,
-            modules,
-            process,
-            thread,
-            start,
-        }
-    }
-
-    /// Add a sample to the profile. This function collects a backtrace from
-    /// any stack frames for allowed modules on the current stack. It should
-    /// typically be called from a callback registered using
-    /// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-    ///
-    /// The `delta` parameter is the amount of CPU time that was used by this
-    /// guest since the previous sample. It is allowed to pass `Duration::ZERO`
-    /// here if recording CPU usage information is not needed.
-    pub fn sample(&mut self, store: impl AsContext, delta: Duration) {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-
-        let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
-        let frames = backtrace
-            .frames()
-            // Samply needs to see the oldest frame first, but we list the newest
-            // first, so iterate in reverse.
-            .rev()
-            .filter_map(|frame| {
-                // Find the first module whose start address includes this PC.
-                let module_idx = self
-                    .modules
-                    .partition_point(|(range, _)| range.start > frame.pc());
-                if let Some((range, lib)) = self.modules.get(module_idx) {
-                    if range.contains(&frame.pc()) {
-                        return Some(FrameInfo {
-                            frame: Frame::RelativeAddressFromReturnAddress(
-                                *lib,
-                                u32::try_from(frame.pc() - range.start).unwrap(),
-                            ),
-                            category_pair: CategoryHandle::OTHER.into(),
-                            flags: FrameFlags::empty(),
-                        });
-                    }
-                }
-                None
-            });
-
-        self.profile
-            .add_sample(self.thread, now, frames, delta.into(), 1);
-    }
-
-    /// When the guest finishes running, call this function to write the
-    /// profile to the given `output`. The output is a JSON-formatted object in
-    /// the [Firefox "processed profile format"][fmt]. Files in this format may
-    /// be visualized at <https://profiler.firefox.com/>.
-    ///
-    /// [fmt]: https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
-    pub fn finish(mut self, output: impl std::io::Write) -> Result<()> {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-        self.profile.set_thread_end_time(self.thread, now);
-        self.profile.set_process_end_time(self.process, now);
-
-        serde_json::to_writer(output, &self.profile)?;
-        Ok(())
-    }
-}
-
-#[cfg(feature = "profiling")]
-fn module_symbols(name: String, compiled: &CompiledModule) -> Option<LibraryInfo> {
-    let symbols = Vec::from_iter(compiled.finished_functions().map(|(defined_idx, _)| {
-        let loc = compiled.func_loc(defined_idx);
-        let func_idx = compiled.module().func_index(defined_idx);
-        let mut name = String::new();
-        demangle_function_name_or_index(
-            &mut name,
-            compiled.func_name(func_idx),
-            defined_idx.as_u32() as usize,
-        )
-        .unwrap();
-        Symbol {
-            address: loc.start,
-            size: Some(loc.length),
-            name,
-        }
-    }));
-    if symbols.is_empty() {
-        return None;
-    }
-
-    Some(LibraryInfo {
-        name,
-        debug_name: String::new(),
-        path: String::new(),
-        debug_path: String::new(),
-        debug_id: DebugId::nil(),
-        code_id: None,
-        arch: None,
-        symbol_table: Some(Arc::new(SymbolTable::new(symbols))),
-    })
-}

data/ext/cargo-vendor/wasmtime-20.0.2/src/runtime/resources.rs

@@ -1,33 +0,0 @@
-/// A summary of the amount of resources required to instantiate a particular
-/// [`Module`][crate::Module] or [`Component`][crate::component::Component].
-///
-/// Example uses of this information:
-///
-/// * Determining whether your pooling allocator configuration supports
-///   instantiating this module.
-///
-/// * Deciding how many of which `Module` you want to instantiate within a
-///   fixed amount of resources, e.g. determining whether to create 5
-///   instances of module `X` or 10 instances of module `Y`.
-pub struct ResourcesRequired {
-    /// The number of memories that are required.
-    pub num_memories: u32,
-    /// The maximum initial size required by any memory, in units of Wasm pages.
-    pub max_initial_memory_size: Option<u64>,
-    /// The number of tables that are required.
-    pub num_tables: u32,
-    /// The maximum initial size required by any table.
-    pub max_initial_table_size: Option<u32>,
-}
-
-impl ResourcesRequired {
-    #[cfg(feature = "component-model")]
-    pub(crate) fn add(&mut self, other: &ResourcesRequired) {
-        self.num_memories += other.num_memories;
-        self.max_initial_memory_size =
-            std::cmp::max(self.max_initial_memory_size, other.max_initial_memory_size);
-        self.num_tables += other.num_tables;
-        self.max_initial_table_size =
-            std::cmp::max(self.max_initial_table_size, other.max_initial_table_size);
-    }
-}

data/ext/cargo-vendor/wasmtime-20.0.2/src/runtime/signatures.rs

@@ -1,216 +0,0 @@
-//! Implement a registry of function signatures, for fast indirect call
-//! signature checking.
-
-use std::{
-    collections::{hash_map::Entry, HashMap},
-    sync::RwLock,
-};
-use std::{convert::TryFrom, sync::Arc};
-use wasmtime_environ::{ModuleTypes, PrimaryMap, SignatureIndex, WasmFuncType};
-use wasmtime_runtime::VMSharedSignatureIndex;
-
-/// Represents a collection of shared signatures.
-///
-/// This is used to register shared signatures with a shared signature registry.
-///
-/// The collection will unregister any contained signatures with the registry
-/// when dropped.
-#[derive(Debug)]
-pub struct SignatureCollection {
-    registry: Arc<RwLock<SignatureRegistryInner>>,
-    signatures: PrimaryMap<SignatureIndex, VMSharedSignatureIndex>,
-    reverse_signatures: HashMap<VMSharedSignatureIndex, SignatureIndex>,
-}
-
-impl SignatureCollection {
-    /// Creates a signature collection for a module given the module's signatures.
-    pub fn new_for_module(registry: &SignatureRegistry, types: &ModuleTypes) -> Self {
-        let signatures = registry.0.write().unwrap().register_for_module(types);
-        let reverse_signatures = signatures.iter().map(|(k, v)| (*v, k)).collect();
-
-        Self {
-            registry: registry.0.clone(),
-            signatures,
-            reverse_signatures,
-        }
-    }
-
-    /// Treats the signature collection as a map from a module signature index to
-    /// registered shared signature indexes.
-    ///
-    /// This is used for looking up module shared signature indexes during module
-    /// instantiation.
-    pub fn as_module_map(&self) -> &PrimaryMap<SignatureIndex, VMSharedSignatureIndex> {
-        &self.signatures
-    }
-
-    /// Gets the shared signature index given a module signature index.
-    #[inline]
-    pub fn shared_signature(&self, index: SignatureIndex) -> Option<VMSharedSignatureIndex> {
-        self.signatures.get(index).copied()
-    }
-
-    /// Get the module-local signature index for the given shared signature index.
-    pub fn local_signature(&self, index: VMSharedSignatureIndex) -> Option<SignatureIndex> {
-        self.reverse_signatures.get(&index).copied()
-    }
-}
-
-impl Drop for SignatureCollection {
-    fn drop(&mut self) {
-        if !self.signatures.is_empty() {
-            self.registry.write().unwrap().unregister_signatures(self);
-        }
-    }
-}
-
-#[derive(Debug)]
-struct RegistryEntry {
-    references: usize,
-    ty: WasmFuncType,
-}
-
-#[derive(Debug, Default)]
-struct SignatureRegistryInner {
-    map: HashMap<WasmFuncType, VMSharedSignatureIndex>,
-    entries: Vec<Option<RegistryEntry>>,
-    free: Vec<VMSharedSignatureIndex>,
-}
-
-impl SignatureRegistryInner {
-    fn register_for_module(
-        &mut self,
-        types: &ModuleTypes,
-    ) -> PrimaryMap<SignatureIndex, VMSharedSignatureIndex> {
-        let mut sigs = PrimaryMap::default();
-        for (idx, ty) in types.wasm_signatures() {
-            let b = sigs.push(self.register(ty));
-            assert_eq!(idx, b);
-        }
-        sigs
-    }
-
-    fn register(&mut self, ty: &WasmFuncType) -> VMSharedSignatureIndex {
-        let len = self.map.len();
-
-        let index = match self.map.entry(ty.clone()) {
-            Entry::Occupied(e) => *e.get(),
-            Entry::Vacant(e) => {
-                let (index, entry) = match self.free.pop() {
-                    Some(index) => (index, &mut self.entries[index.bits() as usize]),
-                    None => {
-                        // Keep `index_map` len under 2**32 -- VMSharedSignatureIndex::new(std::u32::MAX)
-                        // is reserved for VMSharedSignatureIndex::default().
-                        assert!(
-                            len < std::u32::MAX as usize,
-                            "Invariant check: index_map.len() < std::u32::MAX"
-                        );
-                        debug_assert_eq!(len, self.entries.len());
-
-                        let index = VMSharedSignatureIndex::new(u32::try_from(len).unwrap());
-                        self.entries.push(None);
-
-                        (index, self.entries.last_mut().unwrap())
-                    }
-                };
-
-                // The entry should be missing for one just allocated or
-                // taken from the free list
-                assert!(entry.is_none());
-
-                *entry = Some(RegistryEntry {
-                    references: 0,
-                    ty: ty.clone(),
-                });
-
-                *e.insert(index)
-            }
-        };
-
-        self.entries[index.bits() as usize]
-            .as_mut()
-            .unwrap()
-            .references += 1;
-
-        index
-    }
-
-    fn unregister_signatures(&mut self, collection: &SignatureCollection) {
-        for (_, index) in collection.signatures.iter() {
-            self.unregister_entry(*index, 1);
-        }
-    }
-
-    fn unregister_entry(&mut self, index: VMSharedSignatureIndex, count: usize) {
-        let removed = {
-            let entry = self.entries[index.bits() as usize].as_mut().unwrap();
-
-            debug_assert!(entry.references >= count);
-            entry.references -= count;
-
-            if entry.references == 0 {
-                self.map.remove(&entry.ty);
-                self.free.push(index);
-                true
-            } else {
-                false
-            }
-        };
-
-        if removed {
-            self.entries[index.bits() as usize] = None;
-        }
-    }
-}
-
-// `SignatureRegistryInner` implements `Drop` in debug builds to assert that
-// all signatures have been unregistered for the registry.
-#[cfg(debug_assertions)]
-impl Drop for SignatureRegistryInner {
-    fn drop(&mut self) {
-        assert!(
-            self.map.is_empty() && self.free.len() == self.entries.len(),
-            "signature registry not empty"
-        );
-    }
-}
-
-/// Implements a shared signature registry.
-///
-/// WebAssembly requires that the caller and callee signatures in an indirect
-/// call must match. To implement this efficiently, keep a registry of all
-/// signatures, shared by all instances, so that call sites can just do an
-/// index comparison.
-#[derive(Debug)]
-pub struct SignatureRegistry(Arc<RwLock<SignatureRegistryInner>>);
-
-impl SignatureRegistry {
-    /// Creates a new shared signature registry.
-    pub fn new() -> Self {
-        Self(Arc::new(RwLock::new(SignatureRegistryInner::default())))
-    }
-
-    /// Looks up a function type from a shared signature index.
-    pub fn lookup_type(&self, index: VMSharedSignatureIndex) -> Option<WasmFuncType> {
-        self.0
-            .read()
-            .unwrap()
-            .entries
-            .get(index.bits() as usize)
-            .and_then(|e| e.as_ref().map(|e| &e.ty).cloned())
-    }
-
-    /// Registers a single function with the collection.
-    ///
-    /// Returns the shared signature index for the function.
-    pub fn register(&self, ty: &WasmFuncType) -> VMSharedSignatureIndex {
-        self.0.write().unwrap().register(ty)
-    }
-
-    /// Registers a single function with the collection.
-    ///
-    /// Returns the shared signature index for the function.
-    pub unsafe fn unregister(&self, sig: VMSharedSignatureIndex) {
-        self.0.write().unwrap().unregister_entry(sig, 1)
-    }
-}

data/ext/cargo-vendor/wasmtime-20.0.2/src/runtime/stack.rs

@@ -1,73 +0,0 @@
-use std::{ops::Range, sync::Arc};
-
-use anyhow::Error;
-use wasmtime_fiber::{RuntimeFiberStack, RuntimeFiberStackCreator};
-
-/// A stack creator. Can be used to provide a stack creator to wasmtime
-/// which supplies stacks for async support.
-///
-/// # Safety
-///
-/// This trait is unsafe, as memory safety depends on a proper implementation
-/// of memory management. Stacks created by the StackCreator should always be
-/// treated as owned by an wasmtime instance, and any modification of them
-/// outside of wasmtime invoked routines is unsafe and may lead to corruption.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait StackCreator: Send + Sync {
-    /// Create a new `StackMemory` object with the specified size.
-    ///
-    /// The `size` parameter is the expected size of the stack without any guard pages.
-    ///
-    /// Note there should be at least one guard page of protected memory at the bottom
-    /// of the stack to catch potential stack overflow scenarios. Additionally, stacks should be
-    /// page aligned and zero filled.
-    fn new_stack(&self, size: usize) -> Result<Box<dyn StackMemory>, Error>;
-}
-
-#[derive(Clone)]
-pub(crate) struct StackCreatorProxy(pub Arc<dyn StackCreator>);
-
-unsafe impl RuntimeFiberStackCreator for StackCreatorProxy {
-    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error> {
-        let stack = self.0.new_stack(size)?;
-        Ok(Box::new(FiberStackProxy(stack)) as Box<dyn RuntimeFiberStack>)
-    }
-}
-
-/// A stack memory. This trait provides an interface for raw memory buffers
-/// which are used by wasmtime inside of stacks which wasmtime executes
-/// WebAssembly in for async support. By implementing this trait together
-/// with StackCreator, one can supply wasmtime with custom allocated host
-/// managed stacks.
-///
-/// # Safety
-///
-/// The memory should be page aligned and a multiple of page size.
-/// To prevent possible silent overflows, the memory should be protected by a
-/// guard page. Additionally the safety concerns explained in ['Memory'], for
-/// accessing the memory apply here as well.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait StackMemory: Send + Sync {
-    /// The top of the allocated stack.
-    ///
-    /// This address should be page aligned.
-    fn top(&self) -> *mut u8;
-    /// The range of where this stack resides in memory, excluding guard pages.
-    fn range(&self) -> Range<usize>;
-}
-
-pub(crate) struct FiberStackProxy(pub Box<dyn StackMemory>);
-
-unsafe impl RuntimeFiberStack for FiberStackProxy {
-    fn top(&self) -> *mut u8 {
-        self.0.top()
-    }
-
-    fn range(&self) -> Range<usize> {
-        self.0.range()
-    }
-}