runtime: Cache asc_type_id results on ValidModule

Every WASM heap allocation (API version > 0.0.4) called asc_type_id(),
which did a call_async into the WASM module for a trivial idof<T>()
switch. The result is deterministic per compiled module, yet every
allocation paid ~200-500ns of call_async overhead (fiber creation, epoch
checking, context switching).

Cache the results on ValidModule using a parking_lot::RwLock<HashMap>,
so after the first trigger warms the cache, all subsequent lookups are
cheap read-lock hits. Lock guards never span .await points.

Author: lutter

graph/src/runtime/mod.rs

@@ -157,7 +157,7 @@ impl_asc_type!(u8, u16, u32, u64, i8, i32, i64, f32, f64);
 /// 3. Once defined, items and their discriminants cannot be changed, as this would break running
 ///    subgraphs compiled in previous versions of this representation.
 #[repr(u32)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum IndexForAscTypeId {
     // Ethereum type IDs
     String = 0,

runtime/test/src/test.rs

@@ -401,7 +401,7 @@ async fn json_conversions_v0_0_4() {
 
 #[graph::test]
 async fn json_conversions_v0_0_5() {
-    test_json_conversions(API_VERSION_0_0_5, 2289897).await;
+    test_json_conversions(API_VERSION_0_0_5, 2214813).await;
 }
 
 async fn test_json_parsing(api_version: Version, gas_used: u64) {
@@ -766,7 +766,7 @@ async fn big_int_to_hex_v0_0_4() {
 
 #[graph::test]
 async fn big_int_to_hex_v0_0_5() {
-    test_big_int_to_hex(API_VERSION_0_0_5, 2858580).await;
+    test_big_int_to_hex(API_VERSION_0_0_5, 2565990).await;
 }
 
 async fn test_big_int_arithmetic(api_version: Version, gas_used: u64) {
@@ -832,7 +832,7 @@ async fn big_int_arithmetic_v0_0_4() {
 
 #[graph::test]
 async fn big_int_arithmetic_v0_0_5() {
-    test_big_int_arithmetic(API_VERSION_0_0_5, 7318364).await;
+    test_big_int_arithmetic(API_VERSION_0_0_5, 5256825).await;
 }
 
 async fn test_abort(api_version: Version, error_msg: &str) {
@@ -970,7 +970,7 @@ async fn data_source_create_v0_0_4() {
 
 #[graph::test]
 async fn data_source_create_v0_0_5() {
-    test_data_source_create(API_VERSION_0_0_5, 101450079).await;
+    test_data_source_create(API_VERSION_0_0_5, 101425051).await;
 }
 
 async fn test_ens_name_by_hash(api_version: Version) {
@@ -1827,5 +1827,5 @@ async fn yaml_parsing_v0_0_4() {
 
 #[graph::test]
 async fn yaml_parsing_v0_0_5() {
-    test_yaml_parsing(API_VERSION_0_0_5, 1053955992265).await;
+    test_yaml_parsing(API_VERSION_0_0_5, 1053946160531).await;
 }

runtime/test/src/test/abi.rs

@@ -117,7 +117,7 @@ async fn abi_array_v0_0_4() {
 
 #[graph::test]
 async fn abi_array_v0_0_5() {
-    test_abi_array(API_VERSION_0_0_5, 1636130).await;
+    test_abi_array(API_VERSION_0_0_5, 1561046).await;
 }
 
 async fn test_abi_subarray(api_version: Version) {

runtime/wasm/src/mapping.rs

@@ -7,10 +7,12 @@ use graph::data_source::{MappingTrigger, TriggerWithHandler};
 use graph::futures01::sync::mpsc;
 use graph::futures01::{Future as _, Stream as _};
 use graph::futures03::channel::oneshot::Sender;
+use graph::parking_lot::RwLock;
 use graph::prelude::*;
 use graph::runtime::gas::Gas;
+use graph::runtime::IndexForAscTypeId;
 use parity_wasm::elements::ExportEntry;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::panic::AssertUnwindSafe;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
@@ -248,6 +250,10 @@ pub struct ValidModule {
 
     // Used as a guard to terminate this task dependency.
     epoch_counter_abort_handle: Option<tokio::task::AbortHandle>,
+
+    /// Cache for asc_type_id results. Maps IndexForAscTypeId to their WASM runtime
+    /// type IDs. Populated lazily on first use; deterministic per compiled module.
+    asc_type_id_cache: RwLock<HashMap<IndexForAscTypeId, u32>>,
 }
 
 impl ValidModule {
@@ -355,8 +361,17 @@ impl ValidModule {
             start_function,
             timeout,
             epoch_counter_abort_handle,
+            asc_type_id_cache: RwLock::new(HashMap::new()),
         })
     }
+
+    pub fn get_cached_type_id(&self, idx: IndexForAscTypeId) -> Option<u32> {
+        self.asc_type_id_cache.read().get(&idx).copied()
+    }
+
+    pub fn cache_type_id(&self, idx: IndexForAscTypeId, type_id: u32) {
+        self.asc_type_id_cache.write().insert(idx, type_id);
+    }
 }
 
 impl Drop for ValidModule {

runtime/wasm/src/module/mod.rs

@@ -368,17 +368,29 @@ impl AscHeap for WasmInstanceContext<'_> {
         &mut self,
         type_id_index: IndexForAscTypeId,
     ) -> Result<u32, HostExportError> {
+        // Check the module-level cache. Lives on ValidModule (Arc-shared, persists
+        // across all triggers for this subgraph module).
+        if let Some(type_id) = self.as_ref().valid_module.get_cached_type_id(type_id_index) {
+            return Ok(type_id);
+        }
+
+        // Cache miss: call into WASM.
         let asc_heap = self.asc_heap().cheap_clone();
         let func = asc_heap.id_of_type.as_ref().unwrap();
-
-        // Unwrap ok because it's only called on correct apiVersion, look for AscPtr::generate_header
-        func.call_async(self.as_context_mut(), type_id_index as u32)
+        let type_id = func
+            .call_async(self.as_context_mut(), type_id_index as u32)
             .await
             .map_err(|trap| {
                 host_export_error_from_trap(
                     trap,
                     format!("Failed to call 'asc_type_id' with '{:?}'", type_id_index),
                 )
-            })
+            })?;
+
+        // Store for all future triggers.
+        self.as_ref()
+            .valid_module
+            .cache_type_id(type_id_index, type_id);
+        Ok(type_id)
     }
 }