async_hooks: add async local storage propagation benchmarks

Add micro-benchmarks to verify the performance degradation related to
the number of active `AsyncLocalStorage`s.
With these benchmarks, trying to improve the async context propagation
to be an O(1) operation, which is an operation more frequent compared
to `asyncLocalStorage.run` and `asyncLocalStorage.getStore`.
PR-URL: #46414
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gerhard Stöbich <deb2001-github@yahoo.de>
Reviewed-By: Minwoo Jung <nodecorelab@gmail.com>

Author: legendecas

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

@@ -0,0 +1,46 @@
+'use strict';
+constcommon=require('../common.js');
+const{ AsyncLocalStorage, AsyncResource }=require('async_hooks');
+
+/**
+ * This benchmark verifies the performance of
+ * `AsyncLocalStorage.getStore()` on propagation through async
+ * resource scopes.
+ *
+ * - AsyncLocalStorage.run()
+ * - AsyncResource.runInAsyncScope
+ * - AsyncResource.runInAsyncScope
+ * ...
+ * - AsyncResource.runInAsyncScope
+ * - AsyncLocalStorage.getStore()
+ */
+constbench=common.createBenchmark(main,{
+resourceCount: [10,100,1000],
+n: [1e4],
+});
+
+functionrunBenchmark(store,n){
+for(leti=0;i<n;i++){
+store.getStore();
+}
+}
+
+functionrunInAsyncScopes(resourceCount,cb,i=0){
+if(i===resourceCount){
+cb();
+}else{
+constresource=newAsyncResource('noop');
+resource.runInAsyncScope(()=>{
+runInAsyncScopes(resourceCount,cb,i+1);
+});
+}
+}
+
+functionmain({ n, resourceCount }){
+conststore=newAsyncLocalStorage();
+runInAsyncScopes(resourceCount,()=>{
+bench.start();
+runBenchmark(store,n);
+bench.end(n);
+});
+}

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

@@ -0,0 +1,46 @@
+'use strict';
+constcommon=require('../common.js');
+const{ AsyncLocalStorage }=require('async_hooks');
+
+/**
+ * This benchmark verifies the performance of
+ * `AsyncLocalStorage.getStore()` on multiple `AsyncLocalStorage` instances
+ * nested `AsyncLocalStorage.run()`s.
+ *
+ * - AsyncLocalStorage1.run()
+ * - AsyncLocalStorage2.run()
+ * ...
+ * - AsyncLocalStorageN.run()
+ * - AsyncLocalStorage1.getStore()
+ */
+constbench=common.createBenchmark(main,{
+sotrageCount: [1,10,100],
+n: [1e4],
+});
+
+functionrunBenchmark(store,n){
+for(letidx=0;idx<n;idx++){
+store.getStore();
+}
+}
+
+functionrunStores(stores,value,cb,idx=0){
+if(idx===stores.length){
+cb();
+}else{
+stores[idx].run(value,()=>{
+runStores(stores,value,cb,idx+1);
+});
+}
+}
+
+functionmain({ n, sotrageCount }){
+conststores=newArray(sotrageCount).fill(0).map(()=>newAsyncLocalStorage());
+constcontextValue={};
+
+runStores(stores,contextValue,()=>{
+bench.start();
+runBenchmark(stores[0],n);
+bench.end(n);
+});
+}

benchmark/async_hooks/async-local-storage-propagate-asyncresource.js

@@ -0,0 +1,46 @@
+'use strict';
+constcommon=require('../common.js');
+const{ AsyncLocalStorage, AsyncResource }=require('async_hooks');
+
+/**
+ * This benchmark verifies the performance degradation of
+ * async resource propagation on the increasing number of
+ * active `AsyncLocalStorage`s.
+ *
+ * - AsyncLocalStorage.run() * storageCount
+ * - new AsyncResource()
+ * - new AsyncResource()
+ * ...
+ * - N new Asyncresource()
+ */
+constbench=common.createBenchmark(main,{
+storageCount: [0,1,10,100],
+n: [1e3],
+});
+
+functionrunStores(stores,value,cb,idx=0){
+if(idx===stores.length){
+cb();
+}else{
+stores[idx].run(value,()=>{
+runStores(stores,value,cb,idx+1);
+});
+}
+}
+
+functionrunBenchmark(n){
+for(leti=0;i<n;i++){
+newAsyncResource('noop');
+}
+}
+
+functionmain({ n, storageCount }){
+conststores=newArray(storageCount).fill(0).map(()=>newAsyncLocalStorage());
+constcontextValue={};
+
+runStores(stores,contextValue,()=>{
+bench.start();
+runBenchmark(n);
+bench.end(n);
+});
+}

benchmark/async_hooks/async-local-storage-propagate-promise.js

@@ -0,0 +1,48 @@
+'use strict';
+constcommon=require('../common.js');
+const{ AsyncLocalStorage }=require('async_hooks');
+
+/**
+ * This benchmark verifies the performance degradation of
+ * async resource propagation on the increasing number of
+ * active `AsyncLocalStorage`s.
+ *
+ * - AsyncLocalStorage.run()
+ * - Promise
+ * - Promise
+ * ...
+ * - Promise
+ */
+constbench=common.createBenchmark(main,{
+storageCount: [0,1,10,100],
+n: [1e5],
+});
+
+functionrunStores(stores,value,cb,idx=0){
+if(idx===stores.length){
+cb();
+}else{
+stores[idx].run(value,()=>{
+runStores(stores,value,cb,idx+1);
+});
+}
+}
+
+asyncfunctionrunBenchmark(n){
+for(leti=0;i<n;i++){
+// Avoid creating additional ticks.
+awaitundefined;
+}
+}
+
+functionmain({ n, storageCount }){
+conststores=newArray(storageCount).fill(0).map(()=>newAsyncLocalStorage());
+constcontextValue={};
+
+runStores(stores,contextValue,()=>{
+bench.start();
+runBenchmark(n).then(()=>{
+bench.end(n);
+});
+});
+}