vfs: hoist path normalization out of dispatch loop

VirtualFileSystem#shouldHandle was recomputing both
toNamespacedPath(resolve(mountPoint)) AND
toNamespacedPath(resolve(inputPath)) on every fs call, for every
active VFS. With N mounted layers this meant 2N path normalizations
per fs op against a real-filesystem path that no VFS owns.

Cache the normalized mount point on the VFS instance at mount time,
and add a shouldHandleNormalized fast path that takes an
already-normalized input. The setup.js dispatch helpers
(findVFSForStat / findVFSForRead / findVFSForExists / findVFSForPath /
findVFSWith / findVFSPackageJSON / legacyMainResolve /
getLayerForPath) now normalize the input once before the walk and
share it across every layer.

Benchmarked with benchmark/vfs/bench-fs-dispatch.js on a
real-filesystem target path under 0/1/2/5/10 mounted layers:

  op            layers=10 before   layers=10 after   speedup
  statSync           96k ops/s       278k ops/s       2.9x
  existsSync         99k ops/s       315k ops/s       3.2x
  accessSync         98k ops/s       309k ops/s       3.2x
  readFileSync       42k ops/s        99k ops/s       2.4x

Per-additional-layer cost drops from ~860 ns to ~80 ns for
stat/exists/access (and from ~1700 ns to ~200 ns for readFile).
The layers=0 (VFS not loaded) path is unaffected: vfsState.handlers
stays null and fs ops short-circuit on a single null check.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

lib/internal/vfs/file_system.js

@@ -42,6 +42,10 @@ let debug = require('internal/util/debuglog').debuglog('vfs', (fn) => {
 // Private symbols
 const kProvider = Symbol('kProvider');
 const kMountPoint = Symbol('kMountPoint');
+// Cached `normalizeMountedPath(kMountPoint)` so the hot dispatch path
+// (shouldHandle) does not recompute toNamespacedPath(resolve(...)) on
+// every fs call. Set at mount time, cleared at unmount.
+const kNormalizedMountPoint = Symbol('kNormalizedMountPoint');
 const kMounted = Symbol('kMounted');
 const kPromises = Symbol('kPromises');
 const kLayerId = Symbol('kLayerId');
@@ -119,6 +123,7 @@ class VirtualFileSystem {
 
     this[kProvider] = provider ?? new MemoryProvider();
     this[kMountPoint] = null;
+    this[kNormalizedMountPoint] = null;
     this[kMounted] = false;
     this[kPromises] = null; // Lazy-initialized
     this[kLayerId] = nextLayerId++;
@@ -180,6 +185,7 @@ class VirtualFileSystem {
       throw new ERR_INVALID_STATE('VFS is already mounted');
     }
     this[kMountPoint] = resolvePath(prefix);
+    this[kNormalizedMountPoint] = normalizeMountedPath(this[kMountPoint]);
     this[kMounted] = true;
     debug('mount %s', this[kMountPoint]);
     loadVfsSetup();
@@ -195,6 +201,7 @@ class VirtualFileSystem {
     loadVfsSetup();
     deregisterVFS(this);
     this[kMountPoint] = null;
+    this[kNormalizedMountPoint] = null;
     this[kMounted] = false;
   }
 
@@ -214,12 +221,27 @@ class VirtualFileSystem {
    * @returns {boolean}
    */
   shouldHandle(inputPath) {
-    if (!this[kMounted] || !this[kMountPoint]) {
+    const mountPoint = this[kNormalizedMountPoint];
+    if (mountPoint === null) {
       return false;
     }
-    const normalized = normalizeMountedPath(inputPath);
-    const mountPoint = normalizeMountedPath(this[kMountPoint]);
-    return isUnderMountPoint(normalized, mountPoint);
+    return isUnderMountPoint(normalizeMountedPath(inputPath), mountPoint);
+  }
+
+  /**
+   * Fast path used by the VFS dispatch loops, which can normalize the
+   * input path once and reuse the result across every active VFS. Saves
+   * an O(N) path.resolve()+toNamespacedPath() per fs call.
+   * @param {string} normalizedInput A path already passed through
+   *   normalizeMountedPath.
+   * @returns {boolean}
+   */
+  shouldHandleNormalized(normalizedInput) {
+    const mountPoint = this[kNormalizedMountPoint];
+    if (mountPoint === null) {
+      return false;
+    }
+    return isUnderMountPoint(normalizedInput, mountPoint);
   }
 
   /**
@@ -280,9 +302,9 @@ class VirtualFileSystem {
    * @returns {string}
    */
   #toProviderPath(inputPath) {
-    if (this[kMounted] && this[kMountPoint]) {
+    const mountPoint = this[kNormalizedMountPoint];
+    if (mountPoint !== null) {
       const resolved = normalizeMountedPath(inputPath);
-      const mountPoint = normalizeMountedPath(this[kMountPoint]);
       if (!isUnderMountPoint(resolved, mountPoint)) {
         throw createENOENT('open', inputPath);
       }
@@ -1359,4 +1381,5 @@ class VirtualFileSystem {
 
 module.exports = {
   VirtualFileSystem,
+  normalizeMountedPath,
 };

lib/internal/vfs/setup.js

@@ -32,6 +32,7 @@ const {
   },
 } = require('internal/errors');
 const { createENOENT, createEXDEV } = require('internal/vfs/errors');
+const { normalizeMountedPath } = require('internal/vfs/file_system');
 const { getVirtualFd, closeVirtualFd } = require('internal/vfs/fd');
 const { assertEncoding, setVfsHandlers } = require('internal/fs/utils');
 const permission = require('internal/process/permission');
@@ -241,9 +242,11 @@ function vfsStat(vfs, filePath) {
  * @returns {{ vfs: object, result: number }|null}
  */
 function findVFSForStat(filename) {
+  if (activeVFSList.length === 0) return null;
+  const normalized = normalizeMountedPath(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(filename)) {
+    if (vfs.shouldHandleNormalized(normalized)) {
       vfs.recordOwnedFilename(filename);
       return { vfs, result: vfsStat(vfs, filename) };
     }
@@ -258,9 +261,11 @@ function findVFSForStat(filename) {
  * @returns {{ vfs: object, content: Buffer|string }|null}
  */
 function findVFSForRead(filename, options) {
+  if (activeVFSList.length === 0) return null;
+  const normalized = normalizeMountedPath(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(filename)) {
+    if (vfs.shouldHandleNormalized(normalized)) {
       vfs.recordOwnedFilename(filename);
       if (vfs.existsSync(filename) && vfsStat(vfs, filename) === 0) {
         return { vfs, content: vfs.readFileSync(filename, options) };
@@ -357,9 +362,10 @@ function findVFSPackageJSON(startPath) {
     }
     const pjsonPath = join(currentDir, 'package.json');
     sentinel = pjsonPath;
+    const normalizedPjsonPath = normalizeMountedPath(pjsonPath);
     for (let i = 0; i < activeVFSList.length; i++) {
       const vfs = activeVFSList[i];
-      if (vfs.shouldHandle(pjsonPath) && vfsStat(vfs, pjsonPath) === 0) {
+      if (vfs.shouldHandleNormalized(normalizedPjsonPath) && vfsStat(vfs, pjsonPath) === 0) {
         try {
           const content = vfs.readFileSync(pjsonPath, 'utf8');
           const parsed = JSONParse(content);
@@ -376,19 +382,23 @@ function findVFSPackageJSON(startPath) {
 }
 
 function findVFSForExists(filename) {
+  if (activeVFSList.length === 0) return null;
+  const normalized = normalizeMountedPath(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(filename)) {
+    if (vfs.shouldHandleNormalized(normalized)) {
       return { vfs, exists: vfs.existsSync(filename) };
     }
   }
   return null;
 }
 
 function findVFSForPath(filename) {
+  if (activeVFSList.length === 0) return null;
+  const normalized = normalizeMountedPath(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(filename)) {
+    if (vfs.shouldHandleNormalized(normalized)) {
       return { vfs, normalized: filename };
     }
   }
@@ -397,9 +407,11 @@ function findVFSForPath(filename) {
 
 // Sync read: check exists first, fall through to ENOENT for mounted VFS.
 function findVFSWith(filename, syscall, fn) {
+  if (activeVFSList.length === 0) return undefined;
+  const normalized = normalizeMountedPath(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(filename)) {
+    if (vfs.shouldHandleNormalized(normalized)) {
       vfs.recordOwnedFilename(filename);
       if (vfs.existsSync(filename)) {
         return fn(vfs, filename);
@@ -961,9 +973,11 @@ function installModuleLoaderOverrides() {
       return findVFSWith(filename, 'realpath', (vfs, n) => vfs.realpathSync(n));
     },
     legacyMainResolve(pkgPath, main, base) {
+      if (activeVFSList.length === 0) return undefined;
+      const normalizedPkg = normalizeMountedPath(pkgPath);
       let handled = false;
       for (let i = 0; i < activeVFSList.length; i++) {
-        if (activeVFSList[i].shouldHandle(pkgPath)) {
+        if (activeVFSList[i].shouldHandleNormalized(normalizedPkg)) {
           handled = true;
           break;
         }
@@ -1023,9 +1037,11 @@ function installModuleLoaderOverrides() {
       return 0; // EXTENSIONLESS_FORMAT_JAVASCRIPT
     },
     getLayerForPath(filename) {
+      if (activeVFSList.length === 0) return undefined;
+      const normalized = normalizeMountedPath(filename);
       for (let i = 0; i < activeVFSList.length; i++) {
         const vfs = activeVFSList[i];
-        if (vfs.shouldHandle(filename)) return vfs.layerId;
+        if (vfs.shouldHandleNormalized(normalized)) return vfs.layerId;
       }
       return undefined;
     },