Skip {enter,exit}-sync-call for "thread-transparent" adapters

Today, every sync adapter calls `enter-sync-call`, then does its lifting and
lowering of arguments and reesults, and then calls `exit-sync-call`
afterwards. The `{enter,exit}-sync-call` helpers save and restore the old
thread's TLS context and create the new thread's TLS context. For sync-to-sync
calls, we inline these helpers and do their work lazily via the
`VMDeferredThread` machinery. But even so, creating a lazy `VMDeferredThread`
can be pretty expensive if the adapter's callee is just doing like a single load
or store or has been boiled away into returning a constant value.

Therefore, this commit introduces an analysis to find "thread-transparent"
components. These are components that do not `canon lower` any component model
intrinsic to access the thread state, and therefore *cannot* read or write that
state. When we are compiling adapters whose callee is thread-transparent, we
don't even need to `{enter,exit}-sync-call` at all because the callee will not
read/write its thread state, so we don't need to save and restore the current
thread state, we can just leave it in place.

Author: fitzgen

crates/cranelift/src/compiler/component.rs

@@ -1189,7 +1189,7 @@ impl<'a> TrampolineCompiler<'a> {
             }
 
             if self.compiler.tunables.concurrency_support {
-                Some(self.enter_sync_call_inline(instance, def.instance))
+                Some(self.enter_sync_call_inline(def.instance))
             } else {
                 None
             }
@@ -1286,14 +1286,9 @@ impl<'a> TrampolineCompiler<'a> {
     /// otherwise do eagerly.
     fn enter_sync_call_inline(
         &mut self,
-        caller_instance: RuntimeComponentInstanceIndex,
         callee_instance: RuntimeComponentInstanceIndex,
     ) -> ir::StackSlot {
         let vmctx = self.caller_vmctx();
-        let caller_instance = self
-            .builder
-            .ins()
-            .iconst(ir::types::I32, i64::from(caller_instance.as_u32()));
         let callee_async = self.builder.ins().iconst(ir::types::I32, 0);
         let callee_instance = self
             .builder
@@ -1304,7 +1299,6 @@ impl<'a> TrampolineCompiler<'a> {
             &mut self.alias_regions,
             vmctx,
             crate::component_sync_call::EnterArgs {
-                caller_instance,
                 callee_async,
                 callee_instance,
             },

crates/cranelift/src/component_sync_call.rs

@@ -29,8 +29,6 @@ use wasmtime_environ::{GetPtrSize, NUM_COMPONENT_CONTEXT_SLOTS, PtrSize};
 /// `VMDeferredThread`, to be replayed by the host if it ever has to promote the
 /// deferred thread into a real one.
 pub struct EnterArgs {
-    /// The component instance performing the call.
-    pub caller_instance: ir::Value,
     /// Whether the callee is async-lifted, as an `i32` boolean.
     pub callee_async: ir::Value,
     /// The component instance being called into.
@@ -79,11 +77,6 @@ where
         .store(&mut builder.cursor(), slot_addr, parent);
 
     // Record the deferred `enter_sync_call` arguments.
-    alias_regions.vm_deferred_thread().caller_instance().store(
-        &mut builder.cursor(),
-        slot_addr,
-        args.caller_instance,
-    );
     alias_regions.vm_deferred_thread().callee_async().store(
         &mut builder.cursor(),
         slot_addr,

crates/cranelift/src/func_environ.rs

@@ -2076,18 +2076,17 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
     /// defers the heavyweight task bookkeeping the `enter_sync_call` libcall
     /// would otherwise do eagerly.
     ///
-    /// `real_call_args` is `[callee_vmctx, caller_vmctx, caller_instance,
-    /// callee_async, callee_instance]`.
+    /// `real_call_args` is `[callee_vmctx, caller_vmctx, callee_async,
+    /// callee_instance]`.
     fn lower_fact_enter_sync_call(&mut self, real_call_args: &[ir::Value]) -> CallRets {
         let vmctx = self.env.vmctx_val(&mut self.builder.cursor());
         let slot = crate::component_sync_call::enter(
             self.builder,
             &mut self.env.alias_regions,
             vmctx,
             crate::component_sync_call::EnterArgs {
-                caller_instance: real_call_args[2],
-                callee_async: real_call_args[3],
-                callee_instance: real_call_args[4],
+                callee_async: real_call_args[2],
+                callee_instance: real_call_args[3],
             },
         );
 

crates/environ/src/component.rs

@@ -97,7 +97,7 @@ macro_rules! foreach_builtin_component_function {
             resource_transfer_own(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
             resource_transfer_borrow(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
 
-            enter_sync_call(vmctx: vmctx, caller_instance: u32, callee_async: u32, callee_instance: u32) -> bool;
+            enter_sync_call(vmctx: vmctx, callee_async: u32, callee_instance: u32) -> bool;
             exit_sync_call(vmctx: vmctx) -> bool;
 
             #[cfg(feature = "component-model-async")]

crates/environ/src/component/dfg.rs

@@ -150,6 +150,9 @@ pub struct ComponentDfg {
     /// Interned map of id-to-`CanonicalOptions`, or all sets-of-options used by
     /// this component.
     pub options: Intern<OptionsId, CanonicalOptions>,
+
+    /// The thread-transparency analysis for this component.
+    pub transparency: ThreadTransparency,
 }
 
 /// Possible side effects that are possible with instantiating this component.

crates/environ/src/component/translate.rs

@@ -23,6 +23,8 @@ use wasmparser::{Chunk, ComponentExternName, Encoding, Parser, Payload, Validato
 mod adapt;
 pub use self::adapt::*;
 mod inline;
+mod thread_transparency;
+pub use self::thread_transparency::ThreadTransparency;
 
 /// Structure used to translate a component and parse it.
 pub struct Translator<'a, 'data> {

crates/environ/src/component/translate/adapt.rs

@@ -211,7 +211,14 @@ impl<'data> Translator<'_, 'data> {
             let mut names = Vec::with_capacity(adapter_module.adapters.len());
             for adapter in adapter_module.adapters.iter() {
                 let name = format!("adapter{}", adapter.as_u32());
-                module.adapt(&name, &component.adapters[*adapter]);
+                let adapter = &component.adapters[*adapter];
+                module.adapt(
+                    &name,
+                    adapter,
+                    component
+                        .transparency
+                        .adapter_is_transparent(self.types.types(), adapter),
+                );
                 names.push(name);
             }
             let wasm = module.encode();

crates/environ/src/component/translate/inline.rs

@@ -130,6 +130,7 @@ pub(super) fn run(
     // the root frame which are then used for recording the exports of the
     // component.
     inliner.result.num_runtime_component_instances += 1;
+    inliner.result.transparency.push_root_instance(index);
     let frame = InlinerFrame::new(index, result, ComponentClosure::default(), args, None);
     let resources_snapshot = types.resources_mut().clone();
     let mut frames = vec![(frame, resources_snapshot)];
@@ -185,8 +186,8 @@ struct Inliner<'a> {
 /// incrementally processed via the `initializers` list here. Note that the
 /// inliner frames are stored on the heap to avoid recursion based on user
 /// input.
-struct InlinerFrame<'a> {
-    instance: RuntimeComponentInstanceIndex,
+pub(super) struct InlinerFrame<'a> {
+    pub(super) instance: RuntimeComponentInstanceIndex,
 
     /// The remaining initializers to process when instantiating this component.
     initializers: std::slice::Iter<'a, LocalInitializer<'a>>,
@@ -215,7 +216,7 @@ struct InlinerFrame<'a> {
     modules: PrimaryMap<ModuleIndex, ModuleDef<'a>>,
 
     // component model index spaces
-    component_funcs: PrimaryMap<ComponentFuncIndex, ComponentFuncDef<'a>>,
+    pub(super) component_funcs: PrimaryMap<ComponentFuncIndex, ComponentFuncDef<'a>>,
     module_instances: PrimaryMap<ModuleInstanceIndex, ModuleInstanceDef<'a>>,
     component_instances: PrimaryMap<ComponentInstanceIndex, ComponentInstanceDef<'a>>,
     components: PrimaryMap<ComponentIndex, ComponentDef<'a>>,
@@ -258,7 +259,7 @@ struct ComponentClosure<'a> {
 /// values and so this is used to ensure that we primarily only deal with
 /// individual functions and modules instead of synthetic instances.
 #[derive(Clone, PartialEq, Hash, Eq)]
-struct ImportPath<'a> {
+pub(super) struct ImportPath<'a> {
     index: ImportIndex,
     path: Vec<Cow<'a, str>>,
 }
@@ -268,7 +269,7 @@ struct ImportPath<'a> {
 /// This is the "value" of an item defined within a component and is used to
 /// represent both imports and exports.
 #[derive(Clone)]
-enum ComponentItemDef<'a> {
+pub(super) enum ComponentItemDef<'a> {
     Component(ComponentDef<'a>),
     Instance(ComponentInstanceDef<'a>),
     Func(ComponentFuncDef<'a>),
@@ -277,7 +278,7 @@ enum ComponentItemDef<'a> {
 }
 
 #[derive(Clone)]
-enum ModuleDef<'a> {
+pub(super) enum ModuleDef<'a> {
     /// A core wasm module statically defined within the original component.
     ///
     /// The `StaticModuleIndex` indexes into the `static_modules` map in the
@@ -309,7 +310,7 @@ enum ModuleInstanceDef<'a> {
 }
 
 #[derive(Clone)]
-enum ComponentFuncDef<'a> {
+pub(super) enum ComponentFuncDef<'a> {
     /// A compile-time builtin intrinsic.
     UnsafeIntrinsic(UnsafeIntrinsic),
 
@@ -328,7 +329,7 @@ enum ComponentFuncDef<'a> {
 }
 
 #[derive(Clone)]
-enum ComponentInstanceDef<'a> {
+pub(super) enum ComponentInstanceDef<'a> {
     /// The `__wasmtime_intrinsics` instance that exports all of our
     /// compile-time builtin intrinsics.
     Intrinsics,
@@ -356,7 +357,7 @@ enum ComponentInstanceDef<'a> {
 }
 
 #[derive(Clone)]
-struct ComponentDef<'a> {
+pub(super) struct ComponentDef<'a> {
     index: StaticComponentIndex,
     closure: ComponentClosure<'a>,
 }
@@ -437,6 +438,11 @@ impl<'a> Inliner<'a> {
         use LocalInitializer::*;
 
         let (frame, _) = frames.last_mut().unwrap();
+
+        self.result
+            .transparency
+            .process_initializer(types, frame, initializer);
+
         match initializer {
             // When a component imports an item the actual definition of the
             // item is looked up here (not at runtime) via its name. The
@@ -1297,13 +1303,18 @@ impl<'a> Inliner<'a> {
                     self.result.num_runtime_component_instances,
                 );
                 self.result.num_runtime_component_instances += 1;
+                let args = args
+                    .iter()
+                    .map(|(name, item)| Ok((*name, frame.item(*item, types)?)))
+                    .collect::<Result<HashMap<_, _>>>()?;
+
+                self.result.transparency.push_instance(index, &args);
+
                 let frame = InlinerFrame::new(
                     index,
                     &self.nested_components[component.index],
                     component.closure.clone(),
-                    args.iter()
-                        .map(|(name, item)| Ok((*name, frame.item(*item, types)?)))
-                        .collect::<Result<_>>()?,
+                    args,
                     Some(*ty),
                 );
                 return Ok(Some(frame));