fs: read small files in one thread pool round trip

fs.readFile(path) took four libuv thread pool round trips for a typical
small file -- open, fstat, read and close, each its own uv_fs request
with its own queue wait, completion callback and JS/C++ crossing -- and
fs.promises.readFile(path) did the same through a FileHandle. For the
small files applications read most, the round trips are the cost, and
each occupies a slot in the pool that concurrent dns.lookup(), fs and
crypto work is also queueing for.

Add ReadFileJob (an AsyncWrap + ThreadPoolWork) that performs
open + fstat + read-to-EOF + close as one pool task and reports the
whole content, or, when the file turns out to be larger than one chunk
(kReadFileBufferLength, 512 KiB), stops after fstat() and hands the fd
and size back so that the existing chunked reader continues unchanged
(large reads stay interleaved and abortable between chunks, and still
save the fstat round trip). fs.readFile() and fs.promises.readFile()
use it for path arguments without a user buffer; file descriptors,
FileHandles, options.buffer and an active VFS keep their paths.

Behavior is otherwise kept: same bytes for every size and encoding;
open failures report syscall 'open' with the path, read failures
'read'; permission errors are delivered through the callback/promise
as before; an abort that arrives while the read is in flight still
wins; the job is an FSREQCALLBACK resource for async_hooks; a handed
back fd is tracked exactly like one from a plain open().

Tests that asserted the internal open/fstat/read/close request chain,
used readFile() as a proxy for an fstat trace event, or injected
faults through FileHandle.prototype for path-based reads are adjusted
to keep testing what they test (a file just over one chunk where the
chain shape matters, fs.fstat() for the fstat trace, a larger file so
the FileHandle path is taken).

fs.readFile() of 4 KiB files at concurrency 64 goes from ~51k to ~306k
files per second, and a mixed stat/readFile/dns.lookup burst from ~66k
to ~312k operations per second.

Signed-off-by: Shelley Vohr <shelley.vohr@gmail.com>
PR-URL: #65327
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: codebytere

lib/fs.js

@@ -81,6 +81,7 @@ const {
 
 const {
   FSReqCallback,
+  ReadFileJob,
 } = binding;
 const { toPathIfFileURL } = require('internal/url');
 const {
@@ -98,6 +99,7 @@ const {
 const {
   constants: {
     kIoMaxLength,
+    kReadFileBufferLength,
     kMaxUserId,
   },
   copyObject,
@@ -428,10 +430,70 @@ function readFile(path, options, callback) {
     return;
 
   const flagsNumber = stringToFlags(options.flag, 'options.flag');
+  path = getValidatedPath(path);
+  if (options.buffer === undefined) {
+    // Open + fstat + read + close in one thread pool round trip for files of
+    // up to one chunk; larger files come back as an open fd + size and take
+    // the chunked reader below (readFileAfterOneShot). `true`: a handed-back
+    // fd will be closed through fs.close(), so track it as unmanaged.
+    const job = new ReadFileJob(path, flagsNumber, kReadFileBufferLength, true);
+    job.context = context;
+    job.ondone = readFileAfterOneShot;
+    const accessError = job.run(path);
+    if (accessError !== undefined) {
+      // Not scheduled: report it the way the request-based open() did.
+      callback(accessError);
+    }
+    return;
+  }
   const req = new FSReqCallback();
   req.context = context;
   req.oncomplete = readFileAfterOpen;
-  binding.open(getValidatedPath(path), flagsNumber, 0o666, req);
+  binding.open(path, flagsNumber, 0o666, req);
+}
+
+function readFileAfterOneShot(err, buffer, fd, size, closeErr) {
+  const context = this.context;
+  if (err) {
+    context.callback(err);
+    return;
+  }
+  if (fd !== -1) {
+    // (context.read() below performs the abort check for this case.)
+    // Larger than one chunk: continue exactly like after open + fstat.
+    context.fd = fd;
+    context.size = size;
+    if (size > kIoMaxLength) {
+      return context.close(new ERR_FS_FILE_TOO_LARGE(size));
+    }
+    try {
+      context.prepare();
+    } catch (err) {
+      return context.close(err);
+    }
+    context.read();
+    return;
+  }
+  if (closeErr) {
+    context.callback(closeErr);
+    return;
+  }
+  if (context.signal?.aborted) {
+    // An abort that arrived while the read was in flight wins, as it did when
+    // it was noticed between the open/fstat/read steps.
+    context.callback(new AbortError(undefined, { cause: context.signal.reason }));
+    return;
+  }
+  let result = buffer;
+  if (context.encoding) {
+    try {
+      result = buffer.toString(context.encoding);
+    } catch (err) {
+      context.callback(err);
+      return;
+    }
+  }
+  context.callback(null, result);
 }
 
 function tryStatSync(fd, isUserFd) {

lib/internal/fs/promises.js

@@ -1211,26 +1211,32 @@ async function readFileHandleWithUserBuffer(filehandle, options, size) {
   return encoding ? buffer.toString(encoding) : buffer.subarray(0, totalRead);
 }
 
-async function readFileHandle(filehandle, options) {
+async function readFileHandle(filehandle, options, knownRegularFileSize) {
   const signal = options?.signal;
   const encoding = options?.encoding;
   const decoder = encoding && new StringDecoder(encoding);
 
   checkAborted(signal);
 
-  const statFields = await PromisePrototypeThen(
-    binding.fstat(filehandle.fd, false, kUsePromises),
-    undefined,
-    handleErrorFromBinding,
-  );
-
-  checkAborted(signal);
-
   let size = 0;
   let length = 0;
-  if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
-    size = statFields[8/* size */];
+  if (knownRegularFileSize !== undefined) {
+    // Handed over by readFile() together with an already open fd.
+    size = knownRegularFileSize;
     length = encoding ? MathMin(size, kReadFileBufferLength) : size;
+  } else {
+    const statFields = await PromisePrototypeThen(
+      binding.fstat(filehandle.fd, false, kUsePromises),
+      undefined,
+      handleErrorFromBinding,
+    );
+
+    checkAborted(signal);
+
+    if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
+      size = statFields[8/* size */];
+      length = encoding ? MathMin(size, kReadFileBufferLength) : size;
+    }
   }
   if (length === 0) {
     length = kReadFileUnknownBufferLength;
@@ -2146,10 +2152,49 @@ async function readFile(path, options) {
 
   checkAborted(options.signal);
 
+  if (options.buffer === undefined && vfsState.handlers === null) {
+    // Open + fstat + read + close in one thread pool round trip for files of
+    // up to one chunk; larger files come back as an open fd + size and are
+    // read by readFileHandle() as before.
+    path = getValidatedPath(path);
+    const { 0: buffer, 1: fd, 2: size } = await readFileInOneRoundTrip(path, stringToFlags(flag));
+    if (fd === -1) {
+      checkAborted(options.signal);  // An abort during the read still wins.
+      return options.encoding ? buffer.toString(options.encoding) : buffer;
+    }
+    const filehandle = new FileHandle(new binding.FileHandle(fd));
+    return handleFdClose(readFileHandle(filehandle, options, size), filehandle.close);
+  }
+
   const fd = await open(path, flag, 0o666);
   return handleFdClose(readFileHandle(fd, options), fd.close);
 }
 
+/**
+ * @param {string|Buffer} path Validated path
+ * @param {number} flagsNumber
+ * @returns {Promise<[Buffer|undefined, number, number|undefined]>} [buffer, -1] or [undefined, fd, size]
+ */
+function readFileInOneRoundTrip(path, flagsNumber) {
+  return new Promise((resolve, reject) => {
+    const job = new binding.ReadFileJob(path, flagsNumber, kReadFileBufferLength);
+    job.ondone = (err, buffer, fd, size, closeErr) => {
+      const error = err ?? closeErr;
+      if (error != null) {
+        ErrorCaptureStackTrace(error, readFileInOneRoundTrip);
+        reject(error);
+      } else {
+        resolve([buffer, fd, size]);
+      }
+    };
+    const accessError = job.run(path);
+    if (accessError !== undefined) {
+      ErrorCaptureStackTrace(accessError, readFileInOneRoundTrip);
+      reject(accessError);
+    }
+  });
+}
+
 async function* _watch(filename, options = kEmptyObject) {
   const h = vfsState.handlers;
   if (h !== null) {