Enable borrowing components and stores mutable at the same time (#11987)

* Use `OptionsIndex` more internally in components

This updates various runtimes bits for components to use `OptionsIndex`
more aggressively and ultimately deletes the old `Options` type. The
`Options` type is a heavyweight package of all possible options which is
effectively a duplication of what `OptionsIndex` points to, so that's
removed in favor of directly accessing options.

* Enable borrowing components and stores mutable at the same time

This commit adds a new, safe, function to the `Instance` type for
internal use in Wasmtime which enables simultaneously borrowing the
`Component`-within-the-`Instance` as well as the original store at the
same time. This is not possible to do in safe Rust when the store is
mutable and must be implemented with `unsafe` code.

The motivation for this commit is performance. In #11974 it was
discovered that the addition of a single `Arc::clone` was enough to
reduce throughput in the embedding by 20%. While `Arc::clone` is
generally cheap I can see how a "contended" `Arc::clone` could get quite
expensive. This particular benchmark was running multiple instances of
the same component across multiple threads which were all doing many
host calls. Each host call, after the refactoring of #10959, contained
an `Arc::clone` to the component itself. This in turn led to many
threads constantly incrementing/decrementing the `Arc::clone` count of
the same `Arc` instance.

At a high level this clone is not necessary. The component lives within
the store and cannot be mutated/deleted during execution. Safe Rust,
however, forbids access to the component and mutably using the store at
the same time. Thus, this helper function enters the picture. The goal
here is to remove the `Arc::clone` calls without requiring major surgery
or such to refactor the implementations of various functions throughout
Wasmtime. The `unsafe` block used to implement this function documents
more rationale as to why this should be safe.

* Update crates/wasmtime/src/runtime/component/instance.rs

Co-authored-by: Nick Fitzgerald <[email protected]>

---------

Co-authored-by: Nick Fitzgerald <[email protected]>

Author: alexcrichton

crates/environ/src/component/info.rs

@@ -540,6 +540,16 @@ pub struct CanonicalOptions {
     pub data_model: CanonicalOptionsDataModel,
 }
 
+impl CanonicalOptions {
+    /// Returns the memory referred to by these options, if any.
+    pub fn memory(&self) -> Option<RuntimeMemoryIndex> {
+        match self.data_model {
+            CanonicalOptionsDataModel::Gc {} => None,
+            CanonicalOptionsDataModel::LinearMemory(opts) => opts.memory,
+        }
+    }
+}
+
 /// Possible encodings of strings within the component model.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
 #[expect(missing_docs, reason = "self-describing variants")]

crates/wasmtime/src/runtime/component/concurrent.rs

@@ -50,7 +50,7 @@
 //! store.  This is equivalent to `StoreContextMut::spawn` but more convenient to use
 //! in host functions.
 
-use crate::component::func::{self, Func, Options};
+use crate::component::func::{self, Func};
 use crate::component::{HasData, HasSelf, Instance, Resource, ResourceTable, ResourceTableError};
 use crate::fiber::{self, StoreFiber, StoreFiberYield};
 use crate::store::{Store, StoreId, StoreInner, StoreOpaque, StoreToken};
@@ -2603,7 +2603,7 @@ impl Instance {
                     Some(memory) => {
                         let expected = lift.memory.map(|v| v.as_ptr()).unwrap_or(ptr::null_mut());
                         let actual = self.id().get(store).runtime_memory(memory);
-                        expected != actual
+                        expected != actual.as_ptr()
                     }
                     // Memory not specified, meaning it didn't need to be
                     // specified per validation, so not invalid.
@@ -3159,13 +3159,11 @@ impl Instance {
                         (ordinal, 0, result)
                     }
                 };
-                let options = Options::new_index(store, self, params.options);
-                let ptr = func::validate_inbounds::<(u32, u32)>(
-                    options.memory_mut(store),
-                    &ValRaw::u32(params.payload),
-                )?;
-                options.memory_mut(store)[ptr + 0..][..4].copy_from_slice(&handle.to_le_bytes());
-                options.memory_mut(store)[ptr + 4..][..4].copy_from_slice(&result.to_le_bytes());
+                let memory = self.options_memory_mut(store, params.options);
+                let ptr =
+                    func::validate_inbounds::<(u32, u32)>(memory, &ValRaw::u32(params.payload))?;
+                memory[ptr + 0..][..4].copy_from_slice(&handle.to_le_bytes());
+                memory[ptr + 4..][..4].copy_from_slice(&result.to_le_bytes());
                 Ok(ordinal)
             }
         };
@@ -4902,11 +4900,15 @@ pub(crate) fn prepare_call<T, R>(
     let (options, _flags, ty, raw_options) = handle.abi_info(store.0);
 
     let instance = handle.instance().id().get(store.0);
+    let options = &instance.component().env_component().options[options];
     let task_return_type = instance.component().types()[ty].results;
     let component_instance = raw_options.instance;
-    let callback = options.callback();
-    let memory = options.memory_raw().map(SendSyncPtr::new);
-    let string_encoding = options.string_encoding();
+    let callback = options.callback.map(|i| instance.runtime_callback(i));
+    let memory = options
+        .memory()
+        .map(|i| instance.runtime_memory(i))
+        .map(SendSyncPtr::new);
+    let string_encoding = options.string_encoding;
     let token = StoreToken::new(store.as_context_mut());
     let state = store.0.concurrent_state_mut();
 
@@ -5012,12 +5014,16 @@ fn queue_call0<T: 'static>(
     guest_thread: QualifiedThreadId,
     param_count: usize,
 ) -> Result<()> {
-    let (options, flags, _ty, raw_options) = handle.abi_info(store.0);
+    let (_options, flags, _ty, raw_options) = handle.abi_info(store.0);
     let is_concurrent = raw_options.async_;
+    let callback = raw_options.callback;
     let instance = handle.instance();
     let callee = handle.lifted_core_func(store.0);
-    let callback = options.callback();
     let post_return = handle.post_return_core_func(store.0);
+    let callback = callback.map(|i| {
+        let instance = instance.id().get(store.0);
+        SendSyncPtr::new(instance.runtime_callback(i))
+    });
 
     log::trace!("queueing call {guest_thread:?}");
 
@@ -5039,7 +5045,7 @@ fn queue_call0<T: 'static>(
             1,
             instance_flags,
             is_concurrent,
-            callback.map(SendSyncPtr::new),
+            callback,
             post_return.map(SendSyncPtr::new),
         )
     }