Implement lazy function pointer loading, based on HashMap

Author: Bromeon

godot-codegen/Cargo.toml

@@ -11,6 +11,7 @@ categories = ["game-engines", "graphics"]
 default = ["codegen-fmt"]
 codegen-fmt = []
 codegen-full = []
+codegen-lazy-fptrs = []
 double-precision = []
 custom-godot = ["godot-bindings/custom-godot"]
 experimental-godot-api = []

godot-codegen/src/central_generator.rs

@@ -39,20 +39,24 @@ struct NamedMethodTable {
     method_count: usize,
 }
 
+#[allow(dead_code)] // for lazy feature
 struct IndexedMethodTable {
     table_name: Ident,
     imports: TokenStream,
     ctor_parameters: TokenStream,
     pre_init_code: TokenStream,
     fptr_type: TokenStream,
     method_inits: Vec<MethodInit>,
+    lazy_key_type: TokenStream,
+    lazy_method_init: TokenStream,
     named_accessors: Vec<AccessorMethod>,
     class_count: usize,
     method_count: usize,
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+#[cfg_attr(feature = "codegen-lazy-fptrs", allow(dead_code))]
 struct MethodInit {
     method_init: TokenStream,
     index: usize,
@@ -69,6 +73,7 @@ impl ToTokens for MethodInit {
 struct AccessorMethod {
     name: Ident,
     index: usize,
+    lazy_key: TokenStream,
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -260,14 +265,17 @@ fn make_named_method_table(info: NamedMethodTable) -> TokenStream {
     }
 }
 
-fn make_indexed_method_table(info: IndexedMethodTable) -> TokenStream {
+#[cfg(not(feature = "codegen-lazy-fptrs"))]
+fn make_method_table(info: IndexedMethodTable) -> TokenStream {
     let IndexedMethodTable {
         table_name,
         imports,
         ctor_parameters,
         pre_init_code,
         fptr_type,
         mut method_inits,
+        lazy_key_type: _,
+        lazy_method_init: _,
         named_accessors,
         class_count,
         method_count,
@@ -334,6 +342,79 @@ fn make_indexed_method_table(info: IndexedMethodTable) -> TokenStream {
     }
 }
 
+#[cfg(feature = "codegen-lazy-fptrs")]
+fn make_method_table(info: IndexedMethodTable) -> TokenStream {
+    let IndexedMethodTable {
+        table_name,
+        imports,
+        ctor_parameters: _,
+        pre_init_code: _,
+        fptr_type,
+        method_inits: _,
+        lazy_key_type,
+        lazy_method_init,
+        named_accessors,
+        class_count,
+        method_count,
+    } = info;
+
+    // Editor table can be empty, if the Godot binary is compiled without editor.
+    let unused_attr = (method_count == 0).then(|| quote! { #[allow(unused_variables)] });
+    let named_method_api = make_named_accessors(&named_accessors, &fptr_type);
+
+    // Assumes that inits already have a trailing comma.
+    // This is necessary because some generators emit multiple lines (statements) per element.
+    quote! {
+        #imports
+        use crate::StringCache;
+        use std::collections::HashMap;
+        use std::cell::RefCell;
+
+        // Exists to be stored inside RefCell.
+        struct InnerTable {
+            // 'static because at this point, the interface and lifecycle tables are globally available.
+            string_cache: StringCache<'static>,
+            function_pointers: HashMap<#lazy_key_type, #fptr_type>,
+        }
+
+        // Note: get_method_bind and other function pointers could potentially be stored as fields in table, to avoid interface_fn!.
+        pub struct #table_name {
+            inner: RefCell<InnerTable>,
+        }
+
+        impl #table_name {
+            pub const CLASS_COUNT: usize = #class_count;
+            pub const METHOD_COUNT: usize = #method_count;
+
+            #unused_attr
+            pub fn load() -> Self {
+                // SAFETY: interface and lifecycle tables are initialized at this point, so we can get 'static references to them.
+                let (interface, lifecycle_table) = unsafe {
+                    (crate::get_interface(), crate::method_table())
+                };
+
+                Self {
+                    inner: RefCell::new(InnerTable {
+                        string_cache: StringCache::new(interface, lifecycle_table),
+                        function_pointers: HashMap::new(),
+                    }),
+                }
+            }
+
+            #[inline(always)]
+            pub fn fptr_by_key(&self, key: #lazy_key_type) -> #fptr_type {
+                let mut guard = self.inner.borrow_mut();
+                let inner = &mut *guard;
+                *inner.function_pointers.entry(key.clone()).or_insert_with(|| {
+                    #lazy_method_init
+                })
+            }
+
+            #named_method_api
+        }
+    }
+}
+
 pub(crate) fn generate_sys_builtin_methods_file(
     api: &ExtensionApi,
     builtin_types: &BuiltinTypeMap,
@@ -739,6 +820,18 @@ fn make_class_method_table(
         pre_init_code: TokenStream::new(), // late-init, depends on class string names
         fptr_type: quote! { crate::ClassMethodBind },
         method_inits: vec![],
+        lazy_key_type: quote! { crate::lazy_keys::ClassMethodKey },
+        lazy_method_init: quote! {
+            let get_method_bind = crate::interface_fn!(classdb_get_method_bind);
+            crate::load_class_method(
+                get_method_bind,
+                &mut inner.string_cache,
+                None,
+                key.class_name,
+                key.method_name,
+                key.hash
+            )
+        },
         named_accessors: vec![],
         class_count: 0,
         method_count: 0,
@@ -775,18 +868,33 @@ fn make_class_method_table(
         #( #class_sname_decls )*
     };
 
-    make_indexed_method_table(table)
+    make_method_table(table)
 }
 
 /// For index-based method tables, have select methods exposed by name for internal use.
 fn make_named_accessors(accessors: &[AccessorMethod], fptr: &TokenStream) -> TokenStream {
     let mut result_api = TokenStream::new();
 
-    for AccessorMethod { name, index } in accessors {
-        let code = quote! {
-            #[inline(always)]
-            pub fn #name(&self) -> #fptr {
-                self.fptr_by_index(#index)
+    for accessor in accessors {
+        let AccessorMethod {
+            name,
+            index,
+            lazy_key,
+        } = accessor;
+
+        let code = if cfg!(feature = "codegen-lazy-fptrs") {
+            quote! {
+                #[inline(always)]
+                pub fn #name(&self) -> #fptr {
+                    self.fptr_by_key(#lazy_key)
+                }
+            }
+        } else {
+            quote! {
+                #[inline(always)]
+                pub fn #name(&self) -> #fptr {
+                    self.fptr_by_index(#index)
+                }
             }
         };
 
@@ -813,6 +921,18 @@ fn make_builtin_method_table(
         },
         fptr_type: quote! { crate::BuiltinMethodBind },
         method_inits: vec![],
+        lazy_key_type: quote! { crate::lazy_keys::BuiltinMethodKey },
+        lazy_method_init: quote! {
+            let get_builtin_method = crate::interface_fn!(variant_get_ptr_builtin_method);
+            crate::load_builtin_method(
+                get_builtin_method,
+                &mut inner.string_cache,
+                key.variant_type.sys(),
+                key.variant_type_str,
+                key.method_name,
+                key.hash
+            )
+        },
         named_accessors: vec![],
         class_count: 0,
         method_count: 0,
@@ -828,7 +948,7 @@ fn make_builtin_method_table(
         table.class_count += 1;
     }
 
-    make_indexed_method_table(table)
+    make_method_table(table)
 }
 
 fn populate_class_methods(
@@ -856,9 +976,20 @@ fn populate_class_methods(
 
         // If requested, add a named accessor for this method.
         if special_cases::is_named_accessor_in_table(class_ty, &method.name) {
+            let class_name_str = class_ty.godot_ty.as_str();
+            let method_name_str = method.name.as_str();
+            let hash = method.hash.expect("hash present");
+
             table.named_accessors.push(AccessorMethod {
                 name: make_class_method_ptr_name(class_ty, method),
                 index,
+                lazy_key: quote! {
+                    crate::lazy_keys::ClassMethodKey {
+                        class_name: #class_name_str,
+                        method_name: #method_name_str,
+                        hash: #hash,
+                    }
+                },
             });
         }
     }
@@ -888,9 +1019,22 @@ fn populate_builtin_methods(
 
         // If requested, add a named accessor for this method.
         if special_cases::is_named_accessor_in_table(&builtin_ty, &method.name) {
+            let variant_type = &builtin_name.sys_variant_type;
+            let variant_type_str = &builtin_name.json_builtin_name;
+            let method_name_str = method.name.as_str();
+            let hash = method.hash.expect("hash present");
+
             table.named_accessors.push(AccessorMethod {
                 name: make_builtin_method_ptr_name(&builtin_ty, method),
                 index,
+                lazy_key: quote! {
+                    crate::lazy_keys::BuiltinMethodKey {
+                        variant_type: #variant_type,
+                        variant_type_str: #variant_type_str,
+                        method_name: #method_name_str,
+                        hash: #hash,
+                    }
+                },
             });
         }
     }
@@ -911,8 +1055,9 @@ fn make_class_method_init(
         )
     });
 
+    // Could reuse lazy key, but less code like this -> faster parsing.
     quote! {
-        crate::load_class_method(get_method_bind, string_names, #class_var, #class_name_str, #method_name_str, #hash),
+        crate::load_class_method(get_method_bind, string_names, Some(#class_var), #class_name_str, #method_name_str, #hash),
     }
 }
 
@@ -933,8 +1078,19 @@ fn make_builtin_method_init(
         )
     });
 
+    // Could reuse lazy key, but less code like this -> faster parsing.
     quote! {
-        {let _ = #index;crate::load_builtin_method(get_builtin_method, string_names, sys::#variant_type, #variant_type_str, #method_name_str, #hash)},
+        {
+            let _ = #index;
+            crate::load_builtin_method(
+                get_builtin_method,
+                string_names,
+                sys::#variant_type,
+                #variant_type_str,
+                #method_name_str,
+                #hash
+            )
+        },
     }
 }
 

godot-codegen/src/class_generator.rs

@@ -1055,7 +1055,7 @@ fn make_methods(
     let get_method_table = api_level.table_global_getter();
 
     let definitions = methods.iter().map(|method| {
-        make_method_definition(method, class_name, api_level, &get_method_table, ctx)
+        make_class_method_definition(method, class_name, api_level, &get_method_table, ctx)
     });
 
     FnDefinitions::expand(definitions)
@@ -1113,7 +1113,7 @@ fn make_special_builtin_methods(class_name: &TyName, _ctx: &Context) -> TokenStr
     }
 }
 
-fn make_method_definition(
+fn make_class_method_definition(
     method: &ClassMethod,
     class_name: &TyName,
     api_level: &ClassCodegenLevel,
@@ -1133,6 +1133,7 @@ fn make_method_definition(
         }
     }*/
 
+    let class_name_str = &class_name.godot_ty;
     let method_name_str = special_cases::maybe_renamed(class_name, &method.name);
 
     let receiver = make_receiver(
@@ -1153,9 +1154,22 @@ fn make_method_definition(
         quote! { Some(self.instance_id) }
     };
 
+    let fptr_access = if cfg!(feature = "codegen-lazy-fptrs") {
+        let hash = method.hash.expect("hash present for class method");
+        quote! {
+            fptr_by_key(sys::lazy_keys::ClassMethodKey {
+                class_name: #class_name_str,
+                method_name: #method_name_str,
+                hash: #hash,
+            })
+        }
+    } else {
+        quote! { fptr_by_index(#table_index) }
+    };
+
     let object_ptr = &receiver.ffi_arg;
     let ptrcall_invocation = quote! {
-        let method_bind = sys::#get_method_table().fptr_by_index(#table_index);
+        let method_bind = sys::#get_method_table().#fptr_access;
 
         <CallSig as PtrcallSignatureTuple>::out_class_ptrcall::<RetMarshal>(
             method_bind,
@@ -1167,7 +1181,7 @@ fn make_method_definition(
     };
 
     let varcall_invocation = quote! {
-        let method_bind = sys::#get_method_table().fptr_by_index(#table_index);
+        let method_bind = sys::#get_method_table().#fptr_access;
 
         <CallSig as VarcallSignatureTuple>::out_class_varcall(
             method_bind,
@@ -1215,16 +1229,32 @@ fn make_builtin_method_definition(
         .as_deref()
         .map(MethodReturn::from_type_no_meta);
 
-    let table_index = ctx.get_table_index(&MethodTableKey::BuiltinMethod {
-        builtin_ty: builtin_name.clone(),
-        method_name: method.name.clone(),
-    });
+    let fptr_access = if cfg!(feature = "codegen-lazy-fptrs") {
+        let variant_type = quote! { sys::VariantType::#builtin_name };
+        let variant_type_str = &builtin_name.godot_ty;
+        let hash = method.hash.expect("hash present for class method");
+
+        quote! {
+            fptr_by_key(sys::lazy_keys::BuiltinMethodKey {
+                variant_type: #variant_type,
+                variant_type_str: #variant_type_str,
+                method_name: #method_name_str,
+                hash: #hash,
+            })
+        }
+    } else {
+        let table_index = ctx.get_table_index(&MethodTableKey::BuiltinMethod {
+            builtin_ty: builtin_name.clone(),
+            method_name: method.name.clone(),
+        });
+        quote! { fptr_by_index(#table_index) }
+    };
 
     let receiver = make_receiver(method.is_static, method.is_const, quote! { self.sys_ptr });
     let object_ptr = &receiver.ffi_arg;
 
     let ptrcall_invocation = quote! {
-        let method_bind = sys::builtin_method_table().fptr_by_index(#table_index);
+        let method_bind = sys::builtin_method_table().#fptr_access;
 
         <CallSig as PtrcallSignatureTuple>::out_builtin_ptrcall::<RetMarshal>(
             method_bind,