Skip scope resolution in LiftContext if possible

Extends skipping scope resolution introduced in the previous commit to also cover
the LiftContext used in sync calls.

Plus, inline a bunch of single-instantiation generics.

Relative to the previous commit, this reduces call overhead by another
31% for sync calls (46ns to 32ns), with async calls unchanged (both measured
in a Linux VM on an M5 Max MBP).

Author: tschneidereit

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

@@ -1812,6 +1812,7 @@ impl StoreOpaque {
     /// relatively expensive table manipulations. This would ideally be
     /// optimized to avoid the full allocation of a `HostTask` in at least some
     /// situations.
+    #[inline]
     pub(crate) fn host_task_create(
         &mut self,
         track_scope: bool,
@@ -1838,6 +1839,7 @@ impl StoreOpaque {
     /// This is used to update the current thread annotations within the store
     /// to ensure that it reflects the guest task, not the host task, since
     /// lowering may execute guest code.
+    #[inline]
     pub fn host_task_reenter_caller(&mut self) -> Result<()> {
         if !self.concurrency_support() {
             return Ok(());
@@ -1854,6 +1856,7 @@ 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`
+    #[inline]
     pub(crate) fn host_task_delete(
         &mut self,
         task: Option<TableId<HostTask>>,
@@ -2355,6 +2358,7 @@ impl StoreOpaque {
 
     /// Used by `ResourceTables` to record the scope of a borrow to get undone
     /// in the future.
+    #[inline]
     pub(crate) fn current_scope_id(&mut self) -> Result<Option<u32>> {
         if !self.concurrency_support() {
             return self.current_scope_id_not_concurrent();

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

@@ -359,6 +359,7 @@ where
 
     /// "Rust" entrypoint after panic-handling infrastructure is set up and raw
     /// arguments are translated to Rust types.
+    #[inline]
     fn entrypoint(
         &self,
         mut store: StoreContextMut<'_, T>,
@@ -394,7 +395,14 @@ where
                  when `component-model-async` feature disabled"
             );
         } else {
-            self.call_sync_lower(store.as_context_mut(), instance, ty, options, storage)?;
+            self.call_sync_lower(
+                store.as_context_mut(),
+                instance,
+                ty,
+                options,
+                storage,
+                track_scope,
+            )?;
             true
         };
 
@@ -417,15 +425,21 @@ where
     /// the `async` option when lowered. Note that the host function itself
     /// can still be async, in which case this will block here waiting for it
     /// to finish.
+    #[inline]
     fn call_sync_lower(
         &self,
         mut store: StoreContextMut<'_, T>,
         instance: Instance,
         ty: TypeFuncIndex,
         options: OptionsIndex,
         storage: &mut [MaybeUninit<ValRaw>],
+        track_scope: bool,
     ) -> Result<()> {
-        let mut lift = LiftContext::new(store.0.store_opaque_mut(), options, instance)?;
+        let mut lift = if track_scope {
+            LiftContext::new(store.0.store_opaque_mut(), options, instance)?
+        } else {
+            LiftContext::new_without_scope(store.0.store_opaque_mut(), options, instance)?
+        };
         let (params, rest) = self.load_params(&mut lift, ty, MAX_FLAT_PARAMS, storage)?;
 
         let ret = match self.run(store.as_context_mut(), params) {
@@ -533,6 +547,7 @@ where
     ///
     /// This will internally decide the ABI source of the parameters and use
     /// `storage` appropriately.
+    #[inline]
     fn load_params<'a>(
         &self,
         lift: &mut LiftContext<'_>,
@@ -568,6 +583,7 @@ where
     }
 
     /// Stores the result `ret` into `dst` which is calculated per the ABI.
+    #[inline]
     fn lower_result_and_exit_call(
         lower: &mut LowerContext<'_, T>,
         ty: TypeFuncIndex,

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

@@ -338,10 +338,36 @@ impl<'a> LiftContext<'a> {
         store: &'a mut StoreOpaque,
         options: OptionsIndex,
         instance_handle: Instance,
+    ) -> Result<LiftContext<'a>> {
+        Self::new_impl(store, options, instance_handle, true)
+    }
+
+    /// Same as [`Self::new`] but without resolving the current resource
+    /// scope, for calls whose signature statically cannot contain `borrow`
+    /// handles (the only consumers of the scope id).
+    #[inline]
+    pub(crate) fn new_without_scope(
+        store: &'a mut StoreOpaque,
+        options: OptionsIndex,
+        instance_handle: Instance,
+    ) -> Result<LiftContext<'a>> {
+        Self::new_impl(store, options, instance_handle, false)
+    }
+
+    #[inline]
+    fn new_impl(
+        store: &'a mut StoreOpaque,
+        options: OptionsIndex,
+        instance_handle: Instance,
+        want_scope: bool,
     ) -> Result<LiftContext<'a>> {
         let store_id = store.id();
         let hostcall_fuel = store.hostcall_fuel();
-        let current_scope_id = store.current_scope_id()?;
+        let current_scope_id = if want_scope {
+            store.current_scope_id()?
+        } else {
+            None
+        };
         // From `&mut StoreOpaque` provided the goal here is to project out
         // three different disjoint fields owned by the store: memory,
         // `CallContexts`, and `HandleTable`. There's no native API for that

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

@@ -218,6 +218,7 @@ impl StoreComponentInstanceId {
     /// # Panics
     ///
     /// Panics if `self` does not belong to `store`.
+    #[inline]
     pub(crate) fn get<'a>(&self, store: &'a StoreOpaque) -> &'a ComponentInstance {
         self.assert_belongs_to(store.id());
         store.component_instance(self.instance)
@@ -228,6 +229,7 @@ impl StoreComponentInstanceId {
     /// # Panics
     ///
     /// Panics if `self` does not belong to `store`.
+    #[inline]
     pub(crate) fn get_mut<'a>(&self, store: &'a mut StoreOpaque) -> Pin<&'a mut ComponentInstance> {
         self.from_data_get_mut(store.store_data_mut())
     }
@@ -356,6 +358,7 @@ impl StoreOpaque {
         support
     }
 
+    #[inline]
     pub(crate) fn lift_context_parts(
         &mut self,
         instance: Instance,
@@ -420,6 +423,7 @@ impl StoreOpaque {
         ))
     }
 
+    #[inline]
     pub(crate) fn enter_call_not_concurrent(&mut self) -> Result<()> {
         let state = match &mut self.component_data_mut().task_state {
             ComponentTaskState::NotConcurrent(state) => state,
@@ -430,6 +434,7 @@ impl StoreOpaque {
         Ok(())
     }
 
+    #[inline]
     pub(crate) fn exit_call_not_concurrent(&mut self) {
         let state = match &mut self.component_data_mut().task_state {
             ComponentTaskState::NotConcurrent(state) => state,
@@ -459,6 +464,7 @@ impl StoreOpaque {
         }
     }
 
+    #[inline]
     pub(crate) fn current_scope_id_not_concurrent(&mut self) -> Result<Option<u32>> {
         match &mut self.component_data_mut().task_state {
             ComponentTaskState::NotConcurrent(state) => match state.scopes.len().checked_sub(1) {