fs: add c++ fast path for writeFileSync utf8

Author: CanadaHonk

benchmark/fs/bench-writeFileSync.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common.js');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+const bench = common.createBenchmark(main, {
+  encoding: ['utf8'],
+  hasFileDescriptor: ['true', 'false'],
+  stringLength: [1024, 4096, 65535],//, 1024 * 1024],
+  n: [1e3],
+});
+
+function main({ n, encoding, stringLength, hasFileDescriptor }) {
+  const enc = encoding === 'undefined' ? undefined : encoding;
+  const path = tmpdir.resolve(`.writefilesync-file-${process.pid}`);
+
+  const useFd = hasFileDescriptor === 'true';
+  const file = useFd ? fs.openSync(path, 'w') : path;
+
+  const data = 'a'.repeat(stringLength);
+
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    try {
+      fs.writeFileSync(file, data, enc);
+    } catch {
+      // do nothing
+    }
+  }
+  bench.end(n);
+
+  fs.unlinkSync(path);
+  if (useFd) fs.closeSync(file);
+}

lib/fs.js

@@ -2280,6 +2280,10 @@ function writeFile(path, data, options, callback) {
 function writeFileSync(path, data, options) {
   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
 
+  if (options.encoding === 'utf8' || options.encoding === 'utf-8') {
+    return syncFs.writeFileUtf8(path, data, options.flag, options.mode);
+  }
+
   if (!isArrayBufferView(data)) {
     validateStringAfterArrayBufferView(data, 'data');
     data = Buffer.from(data, options.encoding || 'utf8');

lib/internal/fs/sync.js

@@ -25,6 +25,13 @@ function readFileUtf8(path, flag) {
   return binding.readFileUtf8(path, stringToFlags(flag));
 }
 
+function writeFileUtf8(path, data, flag, mode) {
+  if (!isInt32(path)) {
+    path = pathModule.toNamespacedPath(getValidatedPath(path));
+  }
+  return binding.writeFileUtf8(path, data, stringToFlags(flag), mode);
+}
+
 function exists(path) {
   try {
     path = getValidatedPath(path);
@@ -90,6 +97,7 @@ function close(fd) {
 
 module.exports = {
   readFileUtf8,
+  writeFileUtf8,
   exists,
   access,
   copyFile,

src/node_file.cc

@@ -2480,6 +2480,63 @@ static void WriteString(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+static void WriteFileUtf8(const FunctionCallbackInfo<Value>& args) {
+  // Fast C++ path for fs.writeFileSync(path, data) with utf8 encoding
+  // (file, data, options.flag, options.mode)
+
+  Environment* env = Environment::GetCurrent(args);
+  auto isolate = env->isolate();
+
+  CHECK_GE(args.Length(), 4);
+
+  CHECK(args[2]->IsInt32());
+  const int flags = args[2].As<Int32>()->Value();
+
+  CHECK(args[3]->IsInt32());
+  const int mode = args[3].As<Int32>()->Value();
+
+  uv_file file;
+  uv_fs_t req;
+
+  bool is_fd = args[0]->IsInt32();
+
+  // Check for file descriptor
+  if (is_fd) {
+    file = args[0].As<Int32>()->Value();
+  } else {
+    BufferValue path(env->isolate(), args[0]);
+    CHECK_NOT_NULL(*path);
+    if (CheckOpenPermissions(env, path, flags).IsNothing()) return;
+
+    FS_SYNC_TRACE_BEGIN(open);
+    file = uv_fs_open(nullptr, &req, *path, flags, mode, nullptr);
+    FS_SYNC_TRACE_END(open);
+    if (req.result < 0) {
+      uv_fs_req_cleanup(&req);
+      // req will be cleaned up by scope leave.
+      return env->ThrowUVException(req.result, "open", nullptr, path.out());
+    }
+  }
+
+  auto defer_close = OnScopeLeave([file, is_fd, &req]() {
+    if (!is_fd) {
+      FS_SYNC_TRACE_BEGIN(close);
+      CHECK_EQ(0, uv_fs_close(nullptr, &req, file, nullptr));
+      FS_SYNC_TRACE_END(close);
+    }
+    uv_fs_req_cleanup(&req);
+  });
+
+  CHECK(args[1]->IsString());
+  node::Utf8Value value(isolate, args[1]);
+
+  uv_buf_t uvbuf = uv_buf_init(*value, value.length());
+
+  FS_SYNC_TRACE_BEGIN(write);
+  uv_fs_write(nullptr, &req, file, &uvbuf, 1, 0, nullptr);
+  FS_SYNC_TRACE_END(write);
+}
+
 
 /*
  * Wrapper for read(2).
@@ -3393,6 +3450,7 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "writeBuffer", WriteBuffer);
   SetMethod(isolate, target, "writeBuffers", WriteBuffers);
   SetMethod(isolate, target, "writeString", WriteString);
+  SetMethod(isolate, target, "writeFileUtf8", WriteFileUtf8);
   SetMethod(isolate, target, "realpath", RealPath);
   SetMethod(isolate, target, "copyFile", CopyFile);
   SetMethodNoSideEffect(isolate, target, "copyFileSync", CopyFileSync);
@@ -3518,6 +3576,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(WriteBuffer);
   registry->Register(WriteBuffers);
   registry->Register(WriteString);
+  registry->Register(WriteFileUtf8);
   registry->Register(RealPath);
   registry->Register(CopyFile);
   registry->Register(CopyFileSync);