fs: add c++ fast path for writeFileSync utf8

PR-URL: #49884 Reviewed-By: Yagiz Nizipli <[email protected]> Reviewed-By: Santiago Gimeno <[email protected]> Reviewed-By: Stephen Belanger <[email protected]> Reviewed-By: James M Snell <[email protected]>

Author: CanadaHonk

benchmark/fs/bench-writeFileSync.js

@@ -0,0 +1,43 @@
+'use strict';
+
+constcommon=require('../common.js');
+constfs=require('fs');
+consttmpdir=require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+// Some variants are commented out as they do not show a change and just slow
+constbench=common.createBenchmark(main,{
+encoding: ['utf8'],
+useFd: ['true','false'],
+length: [1024,102400,1024*1024],
+
+// useBuffer: ['true', 'false'],
+useBuffer: ['false'],
+
+// func: ['appendFile', 'writeFile'],
+func: ['writeFile'],
+
+n: [1e3],
+});
+
+functionmain({ n, func, encoding, length, useFd, useBuffer }){
+tmpdir.refresh();
+constenc=encoding==='undefined' ? undefined : encoding;
+constpath=tmpdir.resolve(`.writefilesync-file-${Date.now()}`);
+
+useFd=useFd==='true';
+constfile=useFd ? fs.openSync(path,'w') : path;
+
+letdata='a'.repeat(length);
+if(useBuffer==='true')data=Buffer.from(data,encoding);
+
+constfn=fs[func+'Sync'];
+
+bench.start();
+for(leti=0;i<n;++i){
+fn(file,data,enc);
+}
+bench.end(n);
+
+if(useFd)fs.closeSync(file);
+}

lib/fs.js

@@ -2341,6 +2341,19 @@ function writeFileSync(path, data, options){
 
 validateBoolean(flush,'options.flush');
 
+// C++ fast path for string data and UTF8 encoding
+if(typeofdata==='string'&&(options.encoding==='utf8'||options.encoding==='utf-8')){
+if(!isInt32(path)){
+path=pathModule.toNamespacedPath(getValidatedPath(path));
+}
+
+returnbinding.writeFileUtf8(
+path,data,
+stringToFlags(options.flag),
+parseFileMode(options.mode,'mode',0o666),
+);
+}
+
 if(!isArrayBufferView(data)){
 validateStringAfterArrayBufferView(data,'data');
 data=Buffer.from(data,options.encoding||'utf8');

src/node_file.cc

@@ -2327,6 +2327,84 @@ static void WriteString(const FunctionCallbackInfo<Value>& args){
  }
 }
 
+staticvoidWriteFileUtf8(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_EQ(args.Length(), 4);
+
+ BufferValue value(isolate, args[1]);
+CHECK_NOT_NULL(*value);
+
+CHECK(args[2]->IsInt32());
+constint flags = args[2].As<Int32>()->Value();
+
+CHECK(args[3]->IsInt32());
+constint mode = args[3].As<Int32>()->Value();
+
+ uv_file file;
+
+bool is_fd = args[0]->IsInt32();
+
+// Check for file descriptor
+if (is_fd){
+ file = args[0].As<Int32>()->Value();
+ } else{
+ BufferValue path(isolate, args[0]);
+CHECK_NOT_NULL(*path);
+if (CheckOpenPermissions(env, path, flags).IsNothing()) return;
+
+ FSReqWrapSync req_open("open", *path);
+
+FS_SYNC_TRACE_BEGIN(open);
+ file =
+SyncCallAndThrowOnError(env, &req_open, uv_fs_open, *path, flags, mode);
+FS_SYNC_TRACE_END(open);
+
+if (is_uv_error(file)){
+return;
+ }
+ }
+
+int bytesWritten = 0;
+uint32_t offset = 0;
+
+constsize_t length = value.length();
+uv_buf_t uvbuf = uv_buf_init(value.out(), length);
+
+FS_SYNC_TRACE_BEGIN(write);
+while (offset < length){
+ FSReqWrapSync req_write("write");
+ bytesWritten = SyncCallAndThrowOnError(
+ env, &req_write, uv_fs_write, file, &uvbuf, 1, -1);
+
+// Write errored out
+if (bytesWritten < 0){
+break;
+ }
+
+ offset += bytesWritten;
+DCHECK_LE(offset, length);
+ uvbuf.base += bytesWritten;
+ uvbuf.len -= bytesWritten;
+ }
+FS_SYNC_TRACE_END(write);
+
+if (!is_fd){
+ FSReqWrapSync req_close("close");
+
+FS_SYNC_TRACE_BEGIN(close);
+int result = SyncCallAndThrowOnError(env, &req_close, uv_fs_close, file);
+FS_SYNC_TRACE_END(close);
+
+if (is_uv_error(result)){
+return;
+ }
+ }
+}
 
 /*
  * Wrapper for read(2).
@@ -3169,6 +3247,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);
 
@@ -3289,6 +3368,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry){
  registry->Register(WriteBuffer);
  registry->Register(WriteBuffers);
  registry->Register(WriteString);
+ registry->Register(WriteFileUtf8);
  registry->Register(RealPath);
  registry->Register(CopyFile);
 

test/parallel/test-fs-sync-fd-leak.js

@@ -41,17 +41,34 @@ fs.writeSync = function(){
 thrownewError('BAM');
 };
 
+// Internal fast paths are pure C++, can't error inside write
+internalBinding('fs').writeFileUtf8=function(){
+// Fake close
+close_called++;
+thrownewError('BAM');
+};
+
 internalBinding('fs').fstat=function(){
 thrownewError('EBADF: bad file descriptor, fstat');
 };
 
 letclose_called=0;
 ensureThrows(function(){
+// Fast path: writeFileSync utf8
 fs.writeFileSync('dummy','xxx');
 },'BAM');
 ensureThrows(function(){
+// Non-fast path
+fs.writeFileSync('dummy','xxx',{encoding: 'base64'});
+},'BAM');
+ensureThrows(function(){
+// Fast path: writeFileSync utf8
 fs.appendFileSync('dummy','xxx');
 },'BAM');
+ensureThrows(function(){
+// Non-fast path
+fs.appendFileSync('dummy','xxx',{encoding: 'base64'});
+},'BAM');
 
 functionensureThrows(cb,message){
 letgot_exception=false;

typings/internalBinding/fs.d.ts

@@ -231,6 +231,9 @@ declare namespace InternalFSBinding{
 functionwriteString(fd: number,value: string,pos: unknown,encoding: unknown,usePromises: typeofkUsePromises): Promise<number>;
 
 functiongetFormatOfExtensionlessFile(url: string): ConstantsBinding['fs'];
+
+functionwriteFileUtf8(path: string,data: string,flag: number,mode: number): void;
+functionwriteFileUtf8(fd: number,data: string,flag: number,mode: number): void;
 }
 
 exportinterfaceFsBinding{