perf(core): make extension op tables const in static memory (#36696)

Author: bartlomieju

libs/core/extensions.rs

@@ -429,7 +429,10 @@ macro_rules! or {
 /// The following options are available for the [`extension`] macro:
 ///
 ///  * deps: a comma-separated list of module dependencies, eg: `deps = [ my_other_extension ]`
-///  * parameters: a comma-separated list of parameters and base traits, eg: `parameters = [ P: MyTrait ]`
+///  * parameters: a comma-separated list of parameters and base traits, eg: `parameters = [ P: MyTrait ]`.
+///    A generic extension's op table is a `const` in static memory just like a non-generic one's, but
+///    there is one such table per monomorphization, so instantiating the same extension with many
+///    different parameters multiplies the table in the binary.
 ///  * bounds: a comma-separated list of additional type bounds, eg: `bounds = [ P::MyAssociatedType: MyTrait ]`
 ///  * ops: a comma-separated list of [`OpDecl`]s to provide, eg: `ops = [ op_foo, op_bar ]`
 ///  * esm: a comma-separated list of ESM module filenames (see [`include_js_files`]), eg: `esm = [ dir "dir", "my_file.js" ]`
@@ -530,10 +533,19 @@ macro_rules! extension {
             const V: ::std::option::Option<&'static ::std::primitive::str> = $crate::or!($(::std::option::Option::Some($esm_entry_point))?, ::std::option::Option::None);
             V
           },
-          ops: ::std::borrow::Cow::Owned(vec![$($({
-            $( #[ $m ] )*
-            $( $op )::+ $( :: < $($op_param),* > )? ()
-          }),+)?]),
+          // The op declaration constructors are `const fn`, so the whole table
+          // is a compile-time constant living in static memory (see the
+          // `! __ops_table__` arms below). A generic extension gets one such
+          // table per monomorphization, via an associated const on a generic
+          // helper type.
+          ops: $crate::extension!(
+            ! __ops_table__
+            [ $( $( $param : $type )+ )? ]
+            [ $($({
+              $( #[ $m ] )*
+              $( $op )::+ $( :: < $($op_param),* > )? ()
+            }),+)? ]
+          ),
           objects: ::std::borrow::Cow::Borrowed(&[$($({
             $( $object )::+::DECL
           }),+)?]),
@@ -661,6 +673,40 @@ macro_rules! extension {
     $( $args.op_state_fn = ::std::option::Option::Some(::std::boxed::Box::new($state_fn)); )?
   };
 
+  // No type parameters: the op declarations are constant expressions, so the
+  // table is a `const` item in static memory and `Extension::ops` borrows it.
+  // `init_ops` then hands it to the realm as an `OpDeclStorage::Static` run,
+  // i.e. the realm keeps no copy of the decls at all.
+  (! __ops_table__ [] [ $( $decl:expr ),* $(,)? ]) => {
+    {
+      const OPS: &'static [$crate::OpDecl] = &[ $( $decl ),* ];
+      ::std::borrow::Cow::Borrowed(OPS)
+    }
+  };
+
+  // With type parameters: a plain `const` item inside `fn ext<P: ..>()` cannot
+  // name `P`, but an *associated* const on a generic type can name that type's
+  // own parameters. So the table becomes `__OpsTable::<P>::OPS`, which the
+  // compiler const-evaluates once per monomorphization and places in static
+  // memory — one static table per `P`, with `Extension::ops` borrowing the one
+  // that belongs to this instantiation. `init_ops` then hands it to the realm
+  // as an `OpDeclStorage::Static` run, exactly like the non-generic case.
+  (! __ops_table__ [ $( $param:ident : $type:ident )+ ] [ $( $decl:expr ),* $(,)? ]) => {
+    {
+      #[doc(hidden)]
+      #[allow(non_camel_case_types, dead_code, reason = "generated by macro")]
+      struct __OpsTable< $( $param : $type + 'static ),+ >(
+        ::std::marker::PhantomData<( $( $param, )+ )>,
+      );
+
+      impl< $( $param : $type + 'static ),+ > __OpsTable< $( $param ),+ > {
+        const OPS: &'static [$crate::OpDecl] = &[ $( $decl ),* ];
+      }
+
+      ::std::borrow::Cow::Borrowed(<__OpsTable< $( $param ),+ >>::OPS)
+    }
+  };
+
   (! __ops__ $ext:ident __eot__) => {
   };
 
@@ -1082,4 +1128,135 @@ mod tests {
     );
     assert_eq!("a", files[0].specifier);
   }
+
+  mod op_tables {
+    use std::borrow::Cow;
+
+    use crate::extension_set::init_ops;
+    use crate::op2;
+    use crate::ops::OpDeclStorage;
+    use crate::ops_builtin::op_void_async;
+    use crate::ops_builtin::op_void_sync;
+
+    pub trait TestParam {
+      const ID: u32;
+    }
+
+    /// Resembles the generic ops in `deno_node`/`deno_http`: the parameter is
+    /// named in the op's turbofish and reached through the op body.
+    #[op2(fast)]
+    fn op_generic_probe<P: TestParam + 'static>() -> u32 {
+      P::ID
+    }
+
+    crate::extension!(const_table_ext, ops = [op_void_sync, op_void_async],);
+
+    crate::extension!(
+      generic_table_ext,
+      parameters = [P: TestParam],
+      ops = [op_generic_probe<P>, op_void_sync],
+    );
+
+    /// Mirrors `deno_node`'s shape: several parameters, only some of which any
+    /// given op names, plus a parameter used by the options/state function.
+    #[op2(fast)]
+    fn op_generic_multi<A: TestParam + 'static, B: TestParam + 'static>() -> u32
+    {
+      A::ID + B::ID
+    }
+
+    crate::extension!(
+      generic_multi_ext,
+      parameters = [A: TestParam, B: TestParam],
+      ops = [
+        op_generic_multi<A, B>,
+        op_generic_probe<B>,
+        op_void_async,
+      ],
+      options = { marker: u32 },
+      state = |state, options| {
+        state.put(options.marker + A::ID + B::ID);
+      },
+    );
+
+    struct P1;
+    impl TestParam for P1 {
+      const ID: u32 = 1;
+    }
+
+    struct P2;
+    impl TestParam for P2 {
+      const ID: u32 = 2;
+    }
+
+    /// A non-generic extension's op table is a `const` in static memory, so
+    /// `Extension::ops` borrows it and the realm never copies the decls.
+    #[test]
+    fn non_generic_extension_table_is_static() {
+      let ext = const_table_ext::init();
+      assert!(matches!(ext.ops, Cow::Borrowed(_)));
+      assert_eq!(ext.ops.len(), 2);
+
+      // Two calls hand out the very same static allocation.
+      let a = const_table_ext::init();
+      let b = const_table_ext::init();
+      assert_eq!(a.ops.as_ptr(), b.ops.as_ptr());
+    }
+
+    /// ... and it reaches the realm as an `OpDeclStorage::Static` run.
+    #[test]
+    fn non_generic_extension_reaches_realm_as_static() {
+      let mut extensions = vec![const_table_ext::init()];
+      let (decls, _methods) = init_ops(&[], &mut extensions);
+      let ext_decls = decls
+        .iter()
+        .find(|d| d.len() == 2)
+        .expect("extension ops missing");
+      assert!(matches!(ext_decls, OpDeclStorage::Static(_)));
+    }
+
+    /// A generic extension's table is an associated const on a generic helper
+    /// type, so it is also a `const` in static memory — one per
+    /// monomorphization.
+    #[test]
+    fn generic_extension_table_is_static() {
+      let ext = generic_table_ext::init::<P1>();
+      assert!(matches!(ext.ops, Cow::Borrowed(_)));
+      assert_eq!(ext.ops.len(), 2);
+
+      // Two inits of the *same* monomorphization share one static allocation.
+      let a = generic_table_ext::init::<P1>();
+      let b = generic_table_ext::init::<P1>();
+      assert_eq!(a.ops.as_ptr(), b.ops.as_ptr());
+    }
+
+    /// Each monomorphization must get its own table: if they collapsed into
+    /// one, `generic_table_ext::init::<P2>()` would dispatch to `P1`'s ops.
+    #[test]
+    fn generic_extension_table_is_per_monomorphization() {
+      let p1 = generic_table_ext::init::<P1>();
+      let p2 = generic_table_ext::init::<P2>();
+      assert_ne!(p1.ops.as_ptr(), p2.ops.as_ptr());
+
+      let m11 = generic_multi_ext::init::<P1, P1>(0);
+      let m12 = generic_multi_ext::init::<P1, P2>(0);
+      let m12b = generic_multi_ext::init::<P1, P2>(0);
+      assert!(matches!(m11.ops, Cow::Borrowed(_)));
+      assert_ne!(m11.ops.as_ptr(), m12.ops.as_ptr());
+      assert_eq!(m12.ops.as_ptr(), m12b.ops.as_ptr());
+    }
+
+    /// ... and it reaches the realm as an `OpDeclStorage::Static` run, just
+    /// like a non-generic extension's table.
+    #[test]
+    fn generic_extension_reaches_realm_as_static() {
+      let mut extensions = vec![generic_table_ext::init::<P1>()];
+      let (decls, _methods) = init_ops(&[], &mut extensions);
+      let ext_decls = decls
+        .iter()
+        .find(|d| d.len() == 2)
+        .expect("extension ops missing");
+      assert!(matches!(ext_decls, OpDeclStorage::Static(_)));
+    }
+  }
 }

libs/core/ops.rs

@@ -280,11 +280,13 @@ pub struct OpCtxs {
 ///
 /// Declarations that already live in static memory (deno_core's `BUILTIN_OPS`,
 /// an extension's method tables, and any extension whose op table is
-/// `Cow::Borrowed`) are borrowed rather than copied into the realm. The owned
-/// variant covers the cases where a declaration genuinely cannot be static:
-/// extension middleware (`Extension::middleware`) rewrites decls at startup,
-/// `extension!` builds its op table with `Cow::Owned` at runtime, and method
-/// constructors get their name patched from the enclosing `OpMethodDecl`.
+/// `Cow::Borrowed` — which `extension!` emits for every extension, generic or
+/// not, a generic one getting one static table per monomorphization) are
+/// borrowed rather than copied into the realm. The owned variant covers the
+/// cases where a declaration genuinely cannot be static: extension middleware
+/// (`Extension::middleware`) rewrites decls at startup, `ops_fn` appends to
+/// the table, and method constructors get their name patched from the
+/// enclosing `OpMethodDecl`.
 pub enum OpDeclStorage {
   Static(&'static [OpDecl]),
   Owned(Vec<OpDecl>),