use a single table per instance for resources, waitables, etc.

Per WebAssembly/component-model#513, the spec now puts
resources, waitables, waitable sets, subtasks, and error contexts in the same
table per instance.  This updates the implementation to match.

- Combine the `ResourceTable` and `StateTable` data structures into a single `HandleTable` structure

- Rename `ComponentInstance::instance_resource_tables` to `instance_handle_tables`

- Remove `ConcurrentState::waitable_tables` and `error_context_tables` in favor of the above

- Move various associated functions from `ConcurrentState` to `ComponentInstance` so they can access `instance_resource_tables`

While I was doing table-related things, I also updated `concurrent::Table::new`
to reserve the zero handle to mean "invalid".  This won't affect what the guest
sees in any way, but it allows us to use `TableId::new(0)` to invalidate
host-owned handles in e.g. `{Stream,Future}{Reader,Writer}::close`.

Fixes #11189

Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Author: dicej

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

@@ -1,11 +1,3 @@
-/// Error context reference count local to a given (sub)component
-///
-/// This reference count is localized to a single (sub)component,
-/// rather than the global cross-component count (i.e. that determines
-/// when a error context can be completely removed)
-#[repr(transparent)]
-pub struct LocalErrorContextRefCount(pub(crate) usize);
-
 /// Error context reference count across a [`ComponentInstance`]
 ///
 /// Contrasted to `LocalErrorContextRefCount`, this count is maintained

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

@@ -172,11 +172,16 @@ impl TableEntry {
 impl Table {
     /// Create an empty table
     pub fn new() -> Self {
-        Self {
+        let mut me = Self {
             entries: Vec::new(),
             free_head: None,
             debug: false,
-        }
+        };
+
+        // Reserve 0 as an invalid entry.
+        me.push(Tombstone).unwrap();
+
+        me
     }
 
     /// Returns whether or not this table is empty.

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

@@ -3,7 +3,7 @@ use crate::component::resources::{HostResourceData, HostResourceIndex, HostResou
 use crate::component::{Instance, ResourceType};
 use crate::prelude::*;
 use crate::runtime::vm::component::{
-    CallContexts, ComponentInstance, InstanceFlags, ResourceTable, ResourceTables,
+    CallContexts, ComponentInstance, HandleTable, InstanceFlags, ResourceTables,
 };
 use crate::runtime::vm::{VMFuncRef, VMMemoryDefinition};
 use crate::store::{StoreId, StoreOpaque};
@@ -473,7 +473,7 @@ pub struct LiftContext<'a> {
     instance: Pin<&'a mut ComponentInstance>,
     instance_handle: Instance,
 
-    host_table: &'a mut ResourceTable,
+    host_table: &'a mut HandleTable,
     host_resource_data: &'a mut HostResourceData,
 
     calls: &'a mut CallContexts,
@@ -490,7 +490,7 @@ impl<'a> LiftContext<'a> {
     ) -> LiftContext<'a> {
         // From `&mut StoreOpaque` provided the goal here is to project out
         // three different disjoint fields owned by the store: memory,
-        // `CallContexts`, and `ResourceTable`. There's no native API for that
+        // `CallContexts`, and `HandleTable`. There's no native API for that
         // so it's hacked around a bit. This unsafe pointer cast could be fixed
         // with more methods in more places, but it doesn't seem worth doing it
         // at this time.

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

@@ -395,7 +395,7 @@ pub struct StoreOpaque {
     /// and calls. These also interact with the `ResourceAny` type and its
     /// internal representation.
     #[cfg(feature = "component-model")]
-    component_host_table: vm::component::ResourceTable,
+    component_host_table: vm::component::HandleTable,
     #[cfg(feature = "component-model")]
     component_calls: vm::component::CallContexts,
     #[cfg(feature = "component-model")]
@@ -1957,7 +1957,7 @@ at https://bytecodealliance.org/security.
         &mut self,
     ) -> (
         &mut vm::component::CallContexts,
-        &mut vm::component::ResourceTable,
+        &mut vm::component::HandleTable,
         &mut crate::component::HostResourceData,
     ) {
         (
@@ -1984,7 +1984,7 @@ at https://bytecodealliance.org/security.
         instance: crate::component::Instance,
     ) -> (
         &mut vm::component::CallContexts,
-        &mut vm::component::ResourceTable,
+        &mut vm::component::HandleTable,
         &mut crate::component::HostResourceData,
         Pin<&mut vm::component::ComponentInstance>,
     ) {

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

@@ -31,14 +31,16 @@ use wasmtime_environ::{HostPtr, PrimaryMap, VMSharedTypeIndex};
 )]
 const INVALID_PTR: usize = 0xdead_dead_beef_beef_u64 as usize;
 
+mod handle_table;
 mod libcalls;
 mod resources;
 
+#[cfg(feature = "component-model-async")]
+pub use self::handle_table::{HandleKind, TransmitLocalState};
+pub use self::handle_table::{HandleTable, ResourceKind};
 #[cfg(feature = "component-model-async")]
 pub use self::resources::CallContext;
-pub use self::resources::{
-    CallContexts, ResourceTable, ResourceTables, TypedResource, TypedResourceIndex,
-};
+pub use self::resources::{CallContexts, ResourceTables, TypedResource, TypedResourceIndex};
 
 #[cfg(feature = "component-model-async")]
 use crate::component::concurrent;
@@ -78,11 +80,13 @@ pub struct ComponentInstance {
     // of the component can be thrown away (theoretically).
     component: Component,
 
-    /// State of resources for this component.
+    /// State of handles (e.g. resources, waitables, etc.) for this component.
     ///
-    /// This is paired with other information to create a `ResourceTables` which
-    /// is how this field is manipulated.
-    instance_resource_tables: PrimaryMap<RuntimeComponentInstanceIndex, ResourceTable>,
+    /// For resource handles, this is paired with other information to create a
+    /// `ResourceTables` and manipulated through that.  For other handles, this
+    /// is used directly to translate guest handles to host representations and
+    /// vice-versa.
+    instance_handle_tables: PrimaryMap<RuntimeComponentInstanceIndex, HandleTable>,
 
     /// State related to async for this component, e.g. futures, streams, tasks,
     /// etc.
@@ -273,16 +277,16 @@ impl ComponentInstance {
     ) -> OwnedComponentInstance {
         let offsets = VMComponentOffsets::new(HostPtr, component.env_component());
         let num_instances = component.env_component().num_runtime_component_instances;
-        let mut instance_resource_tables =
+        let mut instance_handle_tables =
             PrimaryMap::with_capacity(num_instances.try_into().unwrap());
         for _ in 0..num_instances {
-            instance_resource_tables.push(ResourceTable::default());
+            instance_handle_tables.push(HandleTable::default());
         }
 
         let mut ret = OwnedInstance::new(ComponentInstance {
             id,
             offsets,
-            instance_resource_tables,
+            instance_handle_tables,
             instances: PrimaryMap::with_capacity(
                 component
                     .env_component()
@@ -734,14 +738,14 @@ impl ComponentInstance {
     pub fn guest_tables(
         self: Pin<&mut Self>,
     ) -> (
-        &mut PrimaryMap<RuntimeComponentInstanceIndex, ResourceTable>,
+        &mut PrimaryMap<RuntimeComponentInstanceIndex, HandleTable>,
         &ComponentTypes,
     ) {
         // safety: we've chosen the `pin` guarantee of `self` to not apply to
         // the map returned.
         unsafe {
             let me = self.get_unchecked_mut();
-            (&mut me.instance_resource_tables, me.component.types())
+            (&mut me.instance_handle_tables, me.component.types())
         }
     }