lib: improve module loading performance

This commit improves module loading performance by at least ~25-35%
in the module-loader benchmarks.

Some optimization strategies include:
* Try-finally/try-catch isolation
* Replacing regular expressions with manual parsing
* Avoiding unnecessary string and array creation
* Avoiding constant recompilation of anonymous functions and
function definitions within functions

PR-URL: #5172
Reviewed-By: James M Snell <jasnell@gmail.com>

lib/fs.js

@@ -450,6 +450,42 @@ function tryToString(buf, encoding, callback) {
  callback(e, buf);
 }
 
+function tryStatSync(fd, isUserFd) {
+ var threw = true;
+ var st;
+ try {
+ st = fs.fstatSync(fd);
+ threw = false;
+ } finally {
+ if (threw && !isUserFd) fs.closeSync(fd);
+ }
+ return st;
+}
+
+function tryCreateBuffer(size, fd, isUserFd) {
+ var threw = true;
+ var buffer;
+ try {
+ buffer = Buffer.allocUnsafe(size);
+ threw = false;
+ } finally {
+ if (threw && !isUserFd) fs.closeSync(fd);
+ }
+ return buffer;
+}
+
+function tryReadSync(fd, isUserFd, buffer, pos, len) {
+ var threw = true;
+ var bytesRead;
+ try {
+ bytesRead = fs.readSync(fd, buffer, pos, len);
+ threw = false;
+ } finally {
+ if (threw && !isUserFd) fs.closeSync(fd);
+ }
+ return bytesRead;
+}
+
 fs.readFileSync = function(path, options) {
  if (!options) {
  options = { encoding: null, flag: 'r' };
@@ -466,57 +502,36 @@ fs.readFileSync = function(path, options) {
  var isUserFd = isFd(path); // file descriptor ownership
  var fd = isUserFd ? path : fs.openSync(path, flag, 0o666);
 
- var st;
- var size;
- var threw = true;
- try {
- st = fs.fstatSync(fd);
- size = st.isFile() ? st.size : 0;
- threw = false;
- } finally {
- if (threw && !isUserFd) fs.closeSync(fd);
- }
-
+ var st = tryStatSync(fd, isUserFd);
+ var size = st.isFile() ? st.size : 0;
  var pos = 0;
  var buffer; // single buffer with file data
  var buffers; // list for when size is unknown
 
  if (size === 0) {
  buffers = [];
  } else {
- threw = true;
- try {
- buffer = Buffer.allocUnsafe(size);
- threw = false;
- } finally {
- if (threw && !isUserFd) fs.closeSync(fd);
- }
+ buffer = tryCreateBuffer(size, fd, isUserFd);
  }
 
- var done = false;
  var bytesRead;
 
- while (!done) {
- threw = true;
- try {
- if (size !== 0) {
-  bytesRead = fs.readSync(fd, buffer, pos, size - pos);
-  } else {
-  // the kernel lies about many files.
-  // Go ahead and try to read some bytes.
-  buffer = Buffer.allocUnsafe(8192);
-  bytesRead = fs.readSync(fd, buffer, 0, 8192);
-  if (bytesRead) {
-  buffers.push(buffer.slice(0, bytesRead));
- }
+ if (size !== 0) {
+ do {
+  bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);
+ pos += bytesRead;
+ } while (bytesRead !== 0 && pos < size);
+ } else {
+ do {
+ // the kernel lies about many files.
+ // Go ahead and try to read some bytes.
+ buffer = Buffer.allocUnsafe(8192);
+ bytesRead = tryReadSync(fd, isUserFd, buffer, 0, 8192);
+ if (bytesRead !== 0) {
+ buffers.push(buffer.slice(0, bytesRead));
  }
- threw = false;
- } finally {
- if (threw && !isUserFd) fs.closeSync(fd);
- }
-
- pos += bytesRead;
- done = (bytesRead === 0) || (size !== 0 && pos >= size);
+ pos += bytesRead;
+ } while (bytesRead !== 0);
  }
 
  if (!isUserFd)

lib/internal/bootstrap_node.js

@@ -284,37 +284,45 @@
  };
  }
 
- function evalScript(name) {
- var Module = NativeModule.require('module');
- var path = NativeModule.require('path');
-
+ function tryGetCwd(path) {
+ var threw = true;
+ var cwd;
  try {
- var cwd = process.cwd();
- } catch (e) {
- // getcwd(3) can fail if the current working directory has been deleted.
- // Fall back to the directory name of the (absolute) executable path.
- // It's not really correct but what are the alternatives?
- cwd = path.dirname(process.execPath);
+ cwd = process.cwd();
+ threw = false;
+ } finally {
+ if (threw) {
+ // getcwd(3) can fail if the current working directory has been deleted.
+ // Fall back to the directory name of the (absolute) executable path.
+ // It's not really correct but what are the alternatives?
+ return path.dirname(process.execPath);
+ }
  }
+ return cwd;
+ }
+
+ function evalScript(name) {
+ const Module = NativeModule.require('module');
+ const path = NativeModule.require('path');
+ const cwd = tryGetCwd(path);
 
- var module = new Module(name);
+ const module = new Module(name);
  module.filename = path.join(cwd, name);
  module.paths = Module._nodeModulePaths(cwd);
- var script = process._eval;
- var body = script;
- script = `global.__filename = ${JSON.stringify(name)};\n` +
- 'global.exports = exports;\n' +
- 'global.module = module;\n' +
- 'global.__dirname = __dirname;\n' +
- 'global.require = require;\n' +
- 'return require("vm").runInThisContext(' +
- `${JSON.stringify(body)}, { filename: ` +
- `${JSON.stringify(name)}, displayErrors: true });\n`;
+ const body = process._eval;
+ const script = `global.__filename = ${JSON.stringify(name)};\n` +
+ 'global.exports = exports;\n' +
+ 'global.module = module;\n' +
+ 'global.__dirname = __dirname;\n' +
+ 'global.require = require;\n' +
+ 'return require("vm").runInThisContext(' +
+ `${JSON.stringify(body)}, { filename: ` +
+ `${JSON.stringify(name)}, displayErrors: true });\n`;
  // Defer evaluation for a tick. This is a workaround for deferred
  // events not firing when evaluating scripts from the command line,
  // see https://github.com/nodejs/node/issues/1600.
  process.nextTick(function() {
- var result = module._compile(script, `${name}-wrapper`);
+ const result = module._compile(script, `${name}-wrapper`);
  if (process._print_eval) console.log(result);
  });
  }

lib/internal/module.js

@@ -19,9 +19,11 @@ function makeRequireFunction() {
  }
  }
 
- require.resolve = function(request) {
+ function resolve(request) {
  return Module._resolveFilename(request, self);
- };
+ }
+
+ require.resolve = resolve;
 
  require.main = process.mainModule;