async_hooks: use resource stack for AsyncLocalStorage run

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

@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage } = require('async_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7]
+});
+
+async function run(store, n) {
+  for (let i = 0; i < n; i++) {
+    await new Promise((resolve) => store.run(i, resolve));
+  }
+}
+
+function main({ n }) {
+  const store = new AsyncLocalStorage();
+  bench.start();
+  run(store, n).then(() => {
+    bench.end(n);
+  });
+}

lib/async_hooks.js

@@ -263,11 +263,11 @@ const storageHook = createHook({
   }
 });
 
-const defaultAlsResourceOpts = { requireManualDestroy: true };
 class AsyncLocalStorage {
   constructor() {
     this.kResourceStore = Symbol('kResourceStore');
     this.enabled = false;
+    this._stack = [];
   }
 
   disable() {
@@ -309,14 +309,18 @@ class AsyncLocalStorage {
     if (ObjectIs(store, this.getStore())) {
       return ReflectApply(callback, null, args);
     }
-    const resource = new AsyncResource('AsyncLocalStorage',
-                                       defaultAlsResourceOpts);
-    // Calling emitDestroy before runInAsyncScope avoids a try/finally
-    // It is ok because emitDestroy only schedules calling the hook
-    return resource.emitDestroy().runInAsyncScope(() => {
-      this.enterWith(store);
+
+    this._enable();
+    this._stack.push(this.getStore());
+
+    const resource = executionAsyncResource();
+    resource[this.kResourceStore] = store;
+
+    try {
       return ReflectApply(callback, null, args);
-    });
+    } finally {
+      resource[this.kResourceStore] = this._stack.pop();
+    }
   }
 
   exit(callback, ...args) {

test/async-hooks/test-async-local-storage-run-resource.js

@@ -7,24 +7,20 @@ const {
 } = require('async_hooks');
 
 const asyncLocalStorage = new AsyncLocalStorage();
-
-const outerResource = executionAsyncResource();
+assert.strictEqual(asyncLocalStorage.getStore(), undefined);
 
 const store = new Map();
 asyncLocalStorage.run(store, () => {
   assert.strictEqual(asyncLocalStorage.getStore(), store);
-  const innerResource = executionAsyncResource();
-  assert.notStrictEqual(innerResource, outerResource);
   asyncLocalStorage.run(store, () => {
     assert.strictEqual(asyncLocalStorage.getStore(), store);
-    assert.strictEqual(executionAsyncResource(), innerResource);
     const otherStore = new Map();
     asyncLocalStorage.run(otherStore, () => {
       assert.strictEqual(asyncLocalStorage.getStore(), otherStore);
-      assert.notStrictEqual(executionAsyncResource(), innerResource);
-      assert.notStrictEqual(executionAsyncResource(), outerResource);
     });
+    assert.strictEqual(asyncLocalStorage.getStore(), store);
   });
+  assert.strictEqual(asyncLocalStorage.getStore(), store);
 });
 
-assert.strictEqual(executionAsyncResource(), outerResource);
+assert.strictEqual(asyncLocalStorage.getStore(), undefined);