Skip resource-borrow scope tracking for borrow-free signatures

Precompute `TypeFunc::contains_borrow` at compile time and use it in
the hostcall entrypoint to skip `CallContext` scope push/pop and
`validate_scope_exit` when lending is statically impossible.

Relative to #13887, this reduces call overhead by
about 29% for sync calls, and about 9% for async calls (both measured
in a Linux VM on an M5 Max MBP): sync calls go from about 65ns to about
46ns, immediately ready async calls from 117ns to 106ns.

I'm not entirely sure why the win is so much less for async calls, but
there are more wins in future commits.

Author: tschneidereit

crates/environ/src/component/types.rs

@@ -585,6 +585,10 @@ pub struct TypeComponentInstance {
 pub struct TypeFunc {
     /// Whether or not this is an async function.
     pub async_: bool,
+    /// Whether any parameter (transitively) contains a `borrow` handle,
+    /// letting the runtime skip borrow-scope tracking when lending is
+    /// impossible. (Borrows are only valid in parameters, not results.)
+    pub contains_borrow: bool,
     /// Names of parameters.
     pub param_names: Vec<String>,
     /// Parameters to the function represented as a tuple.

crates/environ/src/component/types_builder.rs

@@ -230,16 +230,20 @@ impl ComponentTypesBuilder {
             .params
             .iter()
             .map(|(_name, ty)| self.valtype(types, ty))
-            .collect::<Result<_>>()?;
+            .collect::<Result<Vec<_>>>()?;
         let results = ty
             .result
             .iter()
             .map(|ty| self.valtype(types, ty))
             .collect::<Result<_>>()?;
-        let params = self.new_tuple_type(params);
+        let contains_borrow = params
+            .iter()
+            .any(|ty| self.ty_contains_borrow_resource(ty));
+        let params = self.new_tuple_type(params.into());
         let results = self.new_tuple_type(results);
         let ty = TypeFunc {
             async_: ty.async_,
+            contains_borrow,
             param_names,
             params,
             results,

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

@@ -1812,9 +1812,14 @@ impl StoreOpaque {
     /// relatively expensive table manipulations. This would ideally be
     /// optimized to avoid the full allocation of a `HostTask` in at least some
     /// situations.
-    pub(crate) fn host_task_create(&mut self) -> Result<Option<TableId<HostTask>>> {
+    pub(crate) fn host_task_create(&mut self, track_scope: bool) -> Result<Option<TableId<HostTask>>> {
         if !self.concurrency_support() {
-            self.enter_call_not_concurrent()?;
+            // Resource-borrow scope tracking is only needed when the
+            // function's parameters can actually contain `borrow` handles;
+            // this is precomputed per function type.
+            if track_scope {
+                self.enter_call_not_concurrent()?;
+            }
             return Ok(None);
         }
         let caller = self.current_guest_thread()?;
@@ -1846,14 +1851,20 @@ impl StoreOpaque {
     /// Note that this isn't invoked when the host is invoked asynchronously and
     /// the host isn't complete yet. In that situation the host task persists
     /// and will be cleaned up separately in `subtask_drop`
-    pub(crate) fn host_task_delete(&mut self, task: Option<TableId<HostTask>>) -> Result<()> {
+    pub(crate) fn host_task_delete(
+        &mut self,
+        task: Option<TableId<HostTask>>,
+        track_scope: bool,
+    ) -> Result<()> {
         match task {
             Some(task) => {
                 log::trace!("delete host task {task:?}");
                 self.concurrent_state_mut()?.delete(task)?;
             }
             None => {
-                self.exit_call_not_concurrent();
+                if track_scope {
+                    self.exit_call_not_concurrent();
+                }
             }
         }
         Ok(())

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

@@ -162,16 +162,22 @@ impl StoreOpaque {
         Ok(self.exit_call_not_concurrent())
     }
 
-    pub(crate) fn host_task_create(&mut self) -> Result<()> {
-        self.enter_call_not_concurrent()
+    pub(crate) fn host_task_create(&mut self, track_scope: bool) -> Result<()> {
+        if track_scope {
+            self.enter_call_not_concurrent()?;
+        }
+        Ok(())
     }
 
     pub(crate) fn host_task_reenter_caller(&mut self) -> Result<()> {
         Ok(())
     }
 
-    pub(crate) fn host_task_delete(&mut self, (): ()) -> Result<()> {
-        Ok(self.exit_call_not_concurrent())
+    pub(crate) fn host_task_delete(&mut self, (): (), track_scope: bool) -> Result<()> {
+        if track_scope {
+            self.exit_call_not_concurrent();
+        }
+        Ok(())
     }
 
     pub(crate) fn check_blocking(&mut self) -> crate::Result<()> {

crates/wasmtime/src/runtime/component/func/host.rs

@@ -369,6 +369,9 @@ where
     ) -> Result<()> {
         let vminstance = instance.id().get(store.0);
         let async_ = vminstance.component().env_component().options[options].async_;
+        // Skip resource-borrow scope tracking when the signature makes
+        // lending impossible (precomputed at compile time).
+        let track_scope = vminstance.component().types()[ty].contains_borrow;
 
         // If this is a synchronous-lower of a host-async function, then the
         // guest is blocking. Test, in the context of the guest task, if that's
@@ -378,7 +381,7 @@ where
         }
 
         // Enter the host by pushing a `HostTask` into the concurrent state.
-        let host_task = store.0.host_task_create()?;
+        let host_task = store.0.host_task_create(track_scope)?;
 
         let host_task_complete = if async_ {
             #[cfg(feature = "component-model-async")]
@@ -401,7 +404,7 @@ where
         // function transitively would have updated the current guest thread to
         // the caller of this host function.
         if host_task_complete {
-            store.0.host_task_delete(host_task)?;
+            store.0.host_task_delete(host_task, track_scope)?;
         }
 
         Ok(())
@@ -572,8 +575,11 @@ where
         dst: Destination<'_>,
     ) -> Result<()> {
         // Before lowering below semantically ensure that the caller has dropped
-        // all of its borrows and such.
-        lower.validate_scope_exit()?;
+        // all of its borrows and such. Skipped when the signature cannot
+        // contain borrows (in which case no scope was entered either).
+        if lower.types[ty].contains_borrow {
+            lower.validate_scope_exit()?;
+        }
 
         // At this point we're transitioning back to the caller task which means
         // that the current task needs to be updated. This will restore the