lib: rewrite AsyncLocalStorage without async_hooks

PR-URL: #48528
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>
Reviewed-By: Gerhard Stöbich <deb2001-github@yahoo.de>

Author: Stephen Belanger

benchmark/async_hooks/async-local-storage-getstore-nested-resources.js

@@ -38,9 +38,11 @@ function runInAsyncScopes(resourceCount, cb, i = 0) {
 
 functionmain({ n, resourceCount }){
 conststore=newAsyncLocalStorage();
-runInAsyncScopes(resourceCount,()=>{
-bench.start();
-runBenchmark(store,n);
-bench.end(n);
+store.run({},()=>{
+runInAsyncScopes(resourceCount,()=>{
+bench.start();
+runBenchmark(store,n);
+bench.end(n);
+});
 });
 }

benchmark/async_hooks/async-local-storage-getstore-nested-run.js

@@ -14,7 +14,7 @@ const { AsyncLocalStorage } = require('async_hooks');
  * - AsyncLocalStorage1.getStore()
  */
 constbench=common.createBenchmark(main,{
-sotrageCount: [1,10,100],
+storageCount: [1,10,100],
 n: [1e4],
 });
 
@@ -34,8 +34,8 @@ function runStores(stores, value, cb, idx = 0) {
 }
 }
 
-functionmain({ n,sotrageCount}){
-conststores=newArray(sotrageCount).fill(0).map(()=>newAsyncLocalStorage());
+functionmain({ n,storageCount}){
+conststores=newArray(storageCount).fill(0).map(()=>newAsyncLocalStorage());
 constcontextValue={};
 
 runStores(stores,contextValue,()=>{

doc/api/cli.md

@@ -876,6 +876,21 @@ and `"` are usable.
 It is possible to run code containing inline types by passing
 [`--experimental-strip-types`][].
 
+### `--experimental-async-context-frame`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Enables the use of AsyncLocalStorage backed by AsyncContextFrame rather than
+the default implementation which relies on async\_hooks. This new model is
+implemented very differently and so could have differences in how context data
+flows within the application. As such, it is presently recommended to be sure
+your application behaviour is unaffected by this change before using it in
+production.
+
 ### `--experimental-default-type=type`
 
 <!-- YAML
@@ -2942,6 +2957,7 @@ one is included in the list below.
 *`--enable-network-family-autoselection`
 *`--enable-source-maps`
 *`--experimental-abortcontroller`
+*`--experimental-async-context-frame`
 *`--experimental-default-type`
 *`--experimental-detect-module`
 *`--experimental-eventsource`

lib/async_hooks.js

@@ -10,7 +10,6 @@ const {
  NumberIsSafeInteger,
  ObjectDefineProperties,
  ObjectFreeze,
- ObjectIs,
  ReflectApply,
  Symbol,
 }=primordials;
@@ -30,6 +29,8 @@ const {
 }=require('internal/validators');
 constinternal_async_hooks=require('internal/async_hooks');
 
+constAsyncContextFrame=require('internal/async_context_frame');
+
 // Get functions
 // For userland AsyncResources, make sure to emit a destroy event when the
 // resource gets gced.
@@ -158,6 +159,7 @@ function createHook(fns) {
 // Embedder API //
 
 constdestroyedSymbol=Symbol('destroyed');
+constcontextFrameSymbol=Symbol('context_frame');
 
 classAsyncResource{
 constructor(type,opts=kEmptyObject){
@@ -177,6 +179,8 @@ class AsyncResource {
 thrownewERR_INVALID_ASYNC_ID('triggerAsyncId',triggerAsyncId);
 }
 
+this[contextFrameSymbol]=AsyncContextFrame.current();
+
 constasyncId=newAsyncId();
 this[async_id_symbol]=asyncId;
 this[trigger_async_id_symbol]=triggerAsyncId;
@@ -201,12 +205,12 @@ class AsyncResource {
 constasyncId=this[async_id_symbol];
 emitBefore(asyncId,this[trigger_async_id_symbol],this);
 
+constcontextFrame=this[contextFrameSymbol];
+constprior=AsyncContextFrame.exchange(contextFrame);
 try{
-constret=
-ReflectApply(fn,thisArg,args);
-
-returnret;
+returnReflectApply(fn,thisArg,args);
 }finally{
+AsyncContextFrame.set(prior);
 if(hasAsyncIdStack())
 emitAfter(asyncId);
 }
@@ -270,110 +274,15 @@ class AsyncResource {
 }
 }
 
-conststorageList=[];
-conststorageHook=createHook({
-init(asyncId,type,triggerAsyncId,resource){
-constcurrentResource=executionAsyncResource();
-// Value of currentResource is always a non null object
-for(leti=0;i<storageList.length;++i){
-storageList[i]._propagate(resource,currentResource,type);
-}
-},
-});
-
-classAsyncLocalStorage{
-constructor(){
-this.kResourceStore=Symbol('kResourceStore');
-this.enabled=false;
-}
-
-staticbind(fn){
-returnAsyncResource.bind(fn);
-}
-
-staticsnapshot(){
-returnAsyncLocalStorage.bind((cb, ...args)=>cb(...args));
-}
-
-disable(){
-if(this.enabled){
-this.enabled=false;
-// If this.enabled, the instance must be in storageList
-ArrayPrototypeSplice(storageList,
-ArrayPrototypeIndexOf(storageList,this),1);
-if(storageList.length===0){
-storageHook.disable();
-}
-}
-}
-
-_enable(){
-if(!this.enabled){
-this.enabled=true;
-ArrayPrototypePush(storageList,this);
-storageHook.enable();
-}
-}
-
-// Propagate the context from a parent resource to a child one
-_propagate(resource,triggerResource,type){
-conststore=triggerResource[this.kResourceStore];
-if(this.enabled){
-resource[this.kResourceStore]=store;
-}
-}
-
-enterWith(store){
-this._enable();
-constresource=executionAsyncResource();
-resource[this.kResourceStore]=store;
-}
-
-run(store,callback, ...args){
-// Avoid creation of an AsyncResource if store is already active
-if(ObjectIs(store,this.getStore())){
-returnReflectApply(callback,null,args);
-}
-
-this._enable();
-
-constresource=executionAsyncResource();
-constoldStore=resource[this.kResourceStore];
-
-resource[this.kResourceStore]=store;
-
-try{
-returnReflectApply(callback,null,args);
-}finally{
-resource[this.kResourceStore]=oldStore;
-}
-}
-
-exit(callback, ...args){
-if(!this.enabled){
-returnReflectApply(callback,null,args);
-}
-this.disable();
-try{
-returnReflectApply(callback,null,args);
-}finally{
-this._enable();
-}
-}
-
-getStore(){
-if(this.enabled){
-constresource=executionAsyncResource();
-returnresource[this.kResourceStore];
-}
-}
-}
-
 // Placing all exports down here because the exported classes won't export
 // otherwise.
 module.exports={
 // Public API
- AsyncLocalStorage,
+getAsyncLocalStorage(){
+returnAsyncContextFrame.enabled ?
+require('internal/async_local_storage/native') :
+require('internal/async_local_storage/async_hooks');
+},
  createHook,
  executionAsyncId,
  triggerAsyncId,

lib/internal/async_context_frame.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const{
+ getContinuationPreservedEmbedderData,
+ setContinuationPreservedEmbedderData,
+}=internalBinding('async_context_frame');
+
+letenabled_;
+
+classAsyncContextFrameextendsMap{
+constructor(store,data){
+super(AsyncContextFrame.current());
+this.set(store,data);
+}
+
+staticgetenabled(){
+enabled_??=require('internal/options')
+.getOptionValue('--experimental-async-context-frame');
+returnenabled_;
+}
+
+staticcurrent(){
+if(this.enabled){
+returngetContinuationPreservedEmbedderData();
+}
+}
+
+staticset(frame){
+if(this.enabled){
+setContinuationPreservedEmbedderData(frame);
+}
+}
+
+staticexchange(frame){
+constprior=this.current();
+this.set(frame);
+returnprior;
+}
+
+staticdisable(store){
+constframe=this.current();
+frame?.disable(store);
+}
+
+disable(store){
+this.delete(store);
+}
+}
+
+module.exports=AsyncContextFrame;