buffer: optimize createFromString

PR-URL: #54324
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: ronag

lib/buffer.js

@@ -57,7 +57,6 @@ const {
  byteLengthUtf8,
 compare: _compare,
  compareOffset,
- createFromString,
 fill: bindingFill,
 isAscii: bindingIsAscii,
 isUtf8: bindingIsUtf8,
@@ -148,11 +147,12 @@ const constants = ObjectDefineProperties({}, {
 });
 
 Buffer.poolSize=8*1024;
-letpoolSize,poolOffset,allocPool;
+letpoolSize,poolOffset,allocPool,allocBuffer;
 
 functioncreatePool(){
 poolSize=Buffer.poolSize;
-allocPool=createUnsafeBuffer(poolSize).buffer;
+allocBuffer=createUnsafeBuffer(poolSize);
+allocPool=allocBuffer.buffer;
 markAsUntransferable(allocPool);
 poolOffset=0;
 }
@@ -440,38 +440,49 @@ function allocate(size) {
 }
 
 functionfromStringFast(string,ops){
-constlength=ops.byteLength(string);
+constmaxLength=Buffer.poolSize>>>1;
 
-if(length>=(Buffer.poolSize>>>1))
-returncreateFromString(string,ops.encodingVal);
+letlength=string.length;// Min length
+
+if(length>=maxLength)
+returncreateFromString(string,ops);
+
+length*=4;// Max length (4 bytes per character)
+
+if(length>=maxLength)
+length=ops.byteLength(string);// Actual length
+
+if(length>=maxLength)
+returncreateFromString(string,ops,length);
 
 if(length>(poolSize-poolOffset))
 createPool();
-letb=newFastBuffer(allocPool,poolOffset,length);
-constactual=ops.write(b,string,0,length);
-if(actual!==length){
-// byteLength() may overestimate. That's a rare case, though.
-b=newFastBuffer(allocPool,poolOffset,actual);
-}
+
+constactual=ops.write(allocBuffer,string,poolOffset,length);
+constb=newFastBuffer(allocPool,poolOffset,actual);
+
 poolOffset+=actual;
 alignPool();
 returnb;
 }
 
+functioncreateFromString(string,ops,length=ops.byteLength(string)){
+constbuf=Buffer.allocUnsafeSlow(length);
+constactual=ops.write(buf,string,0,length);
+returnactual<length ? newFastBuffer(buf.buffer,0,actual) : buf;
+}
+
 functionfromString(string,encoding){
 letops;
-if(typeofencoding!=='string'||encoding.length===0){
-if(string.length===0)
-returnnewFastBuffer();
+if(!encoding||encoding==='utf8'){
 ops=encodingOps.utf8;
 }else{
 ops=getEncodingOps(encoding);
 if(ops===undefined)
 thrownewERR_UNKNOWN_ENCODING(encoding);
-if(string.length===0)
-returnnewFastBuffer();
 }
-returnfromStringFast(string,ops);
+
+returnstring.length===0 ? newFastBuffer() : fromStringFast(string,ops);
 }
 
 functionfromArrayBuffer(obj,byteOffset,length){

src/node_buffer.cc

@@ -529,17 +529,6 @@ MaybeLocal<Object> New(Environment* env,
 
 namespace {
 
-voidCreateFromString(const FunctionCallbackInfo<Value>& args) {
-CHECK(args[0]->IsString());
-CHECK(args[1]->IsInt32());
-
-enum encoding enc = static_cast<enum encoding>(args[1].As<Int32>()->Value());
- Local<Object> buf;
-if (New(args.GetIsolate(), args[0].As<String>(), enc).ToLocal(&buf))
- args.GetReturnValue().Set(buf);
-}
-
-
 template <encoding encoding>
 voidStringSlice(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
@@ -1422,7 +1411,6 @@ void Initialize(Local<Object> target,
 SetMethodNoSideEffect(context, target, "btoa", Btoa);
 
 SetMethod(context, target, "setBufferPrototype", SetBufferPrototype);
-SetMethodNoSideEffect(context, target, "createFromString", CreateFromString);
 
 SetFastMethodNoSideEffect(context,
  target,
@@ -1487,7 +1475,6 @@ void Initialize(Local<Object> target,
 
 voidRegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(SetBufferPrototype);
- registry->Register(CreateFromString);
 
  registry->Register(SlowByteLengthUtf8);
  registry->Register(fast_byte_length_utf8.GetTypeInfo());