buffer: improve performance of multiple Buffer operations

Optimize several Buffer operations:

- Buffer.copyBytesFrom(): avoid intermediate TypedArray slice by
  calculating byte offsets directly
- Buffer.prototype.toString('hex'): use V8 Uint8Array.prototype.toHex()
  builtin for faster hex encoding (+10-30%)
- Buffer.prototype.fill(): add ASCII single-char fast path using
  numeric fill instead of string encoding pipeline
- ASCII indexOf: call indexOfString directly instead of creating an
  intermediate Buffer via fromStringFast
- swap16/32/64: add V8 Fast API C++ functions for the native code
  path, return this from JS side to enable void fast path
- fromArrayLike: cache obj.length in local variable

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: thisalihassan

benchmark/buffers/buffer-bytelength-string.js

@@ -4,7 +4,7 @@ const common = require('../common');
 const bench = common.createBenchmark(main, {
   type: ['one_byte', 'two_bytes', 'three_bytes',
          'four_bytes', 'latin1'],
-  encoding: ['utf8', 'base64'],
+  encoding: ['utf8', 'base64', 'latin1', 'hex'],
   repeat: [1, 2, 16, 256], // x16
   n: [4e6],
 });

benchmark/buffers/buffer-copy-bytes-from.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  type: ['Uint8Array', 'Uint16Array', 'Uint32Array', 'Float64Array'],
+  len: [64, 256, 2048],
+  partial: ['none', 'offset', 'offset-length'],
+  n: [6e5],
+});
+
+function main({ n, len, type, partial }) {
+  const TypedArrayCtor = globalThis[type];
+  const src = new TypedArrayCtor(len);
+  for (let i = 0; i < len; i++) src[i] = i;
+
+  let offset;
+  let length;
+  if (partial === 'offset') {
+    offset = len >>> 2;
+  } else if (partial === 'offset-length') {
+    offset = len >>> 2;
+    length = len >>> 1;
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    Buffer.copyBytesFrom(src, offset, length);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-fill.js

@@ -10,6 +10,7 @@ const bench = common.createBenchmark(main, {
     'fill("t")',
     'fill("test")',
     'fill("t", "utf8")',
+    'fill("t", "ascii")',
     'fill("t", 0, "utf8")',
     'fill("t", 0)',
     'fill(Buffer.alloc(1), 0)',

benchmark/buffers/buffer-indexof.js

@@ -19,7 +19,7 @@ const searchStrings = [
 
 const bench = common.createBenchmark(main, {
   search: searchStrings,
-  encoding: ['undefined', 'utf8', 'ucs2'],
+  encoding: ['undefined', 'utf8', 'ascii', 'latin1', 'ucs2'],
   type: ['buffer', 'string'],
   n: [5e4],
 }, {

benchmark/buffers/buffer-tostring.js

@@ -3,7 +3,7 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  encoding: ['', 'utf8', 'ascii', 'latin1', 'hex', 'UCS-2'],
+  encoding: ['', 'utf8', 'ascii', 'latin1', 'hex', 'base64', 'base64url', 'UCS-2'],
   args: [0, 1, 3],
   len: [1, 64, 1024],
   n: [1e6],

lib/buffer.js

@@ -50,10 +50,21 @@ const {
   TypedArrayPrototypeGetByteOffset,
   TypedArrayPrototypeGetLength,
   TypedArrayPrototypeSet,
-  TypedArrayPrototypeSlice,
   Uint8Array,
+  Uint8ArrayPrototype,
+  uncurryThis,
 } = primordials;
 
+// V8 shipping feature (toHex) is installed by
+// InitializeExperimentalGlobal(), which is skipped during snapshot creation
+// TODO: Remove this once V8 shipping feature (toHex) is available.
+let Uint8ArrayPrototypeToHex;
+function ensureUint8ArrayToHex() {
+  if (Uint8ArrayPrototypeToHex === undefined) {
+    Uint8ArrayPrototypeToHex = uncurryThis(Uint8ArrayPrototype.toHex);
+  }
+}
+
 const {
   byteLengthUtf8,
   compare: _compare,
@@ -382,28 +393,41 @@ Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
     return new FastBuffer();
   }
 
+  const byteLength = TypedArrayPrototypeGetByteLength(view);
+
   if (offset !== undefined || length !== undefined) {
     if (offset !== undefined) {
       validateInteger(offset, 'offset', 0);
       if (offset >= viewLength) return new FastBuffer();
     } else {
       offset = 0;
     }
+
     let end;
     if (length !== undefined) {
       validateInteger(length, 'length', 0);
-      end = offset + length;
+      end = MathMin(offset + length, viewLength);
     } else {
       end = viewLength;
     }
 
-    view = TypedArrayPrototypeSlice(view, offset, end);
+    if (end <= offset) return new FastBuffer();
+
+    const elementSize = byteLength / viewLength;
+    const srcByteOffset = TypedArrayPrototypeGetByteOffset(view) +
+                          offset * elementSize;
+    const srcByteLength = (end - offset) * elementSize;
+
+    return fromArrayLike(new Uint8Array(
+      TypedArrayPrototypeGetBuffer(view),
+      srcByteOffset,
+      srcByteLength));
   }
 
   return fromArrayLike(new Uint8Array(
     TypedArrayPrototypeGetBuffer(view),
     TypedArrayPrototypeGetByteOffset(view),
-    TypedArrayPrototypeGetByteLength(view)));
+    byteLength));
 };
 
 // Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
@@ -550,14 +574,15 @@ function fromArrayBuffer(obj, byteOffset, length) {
 }
 
 function fromArrayLike(obj) {
-  if (obj.length <= 0)
+  const len = obj.length;
+  if (len <= 0)
     return new FastBuffer();
-  if (obj.length < (Buffer.poolSize >>> 1)) {
-    if (obj.length > (poolSize - poolOffset))
+  if (len < (Buffer.poolSize >>> 1)) {
+    if (len > (poolSize - poolOffset))
       createPool();
-    const b = new FastBuffer(allocPool, poolOffset, obj.length);
+    const b = new FastBuffer(allocPool, poolOffset, len);
     TypedArrayPrototypeSet(b, obj, 0);
-    poolOffset += obj.length;
+    poolOffset += len;
     alignPool();
     return b;
   }
@@ -657,6 +682,14 @@ function base64ByteLength(str, bytes) {
   return (bytes * 3) >>> 2;
 }
 
+function hexSliceToHex(buf, start, end) {
+  ensureUint8ArrayToHex();
+  return Uint8ArrayPrototypeToHex(
+    new Uint8Array(TypedArrayPrototypeGetBuffer(buf),
+                   TypedArrayPrototypeGetByteOffset(buf) + start,
+                   end - start));
+}
+
 const encodingOps = {
   utf8: {
     encoding: 'utf8',
@@ -701,11 +734,7 @@ const encodingOps = {
     write: asciiWrite,
     slice: asciiSlice,
     indexOf: (buf, val, byteOffset, dir) =>
-      indexOfBuffer(buf,
-                    fromStringFast(val, encodingOps.ascii),
-                    byteOffset,
-                    encodingsMap.ascii,
-                    dir),
+      indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir),
   },
   base64: {
     encoding: 'base64',
@@ -738,7 +767,7 @@ const encodingOps = {
     encodingVal: encodingsMap.hex,
     byteLength: (string) => string.length >>> 1,
     write: hexWrite,
-    slice: hexSlice,
+    slice: hexSliceToHex,
     indexOf: (buf, val, byteOffset, dir) =>
       indexOfBuffer(buf,
                     fromStringFast(val, encodingOps.hex),
@@ -1087,7 +1116,7 @@ function _fill(buf, value, offset, end, encoding) {
       value = 0;
     } else if (value.length === 1) {
       // Fast path: If `value` fits into a single byte, use that numeric value.
-      if (normalizedEncoding === 'utf8') {
+      if (normalizedEncoding === 'utf8' || normalizedEncoding === 'ascii') {
         const code = StringPrototypeCharCodeAt(value, 0);
         if (code < 128) {
           value = code;
@@ -1137,29 +1166,30 @@ function _fill(buf, value, offset, end, encoding) {
 }
 
 Buffer.prototype.write = function write(string, offset, length, encoding) {
+  const len = this.length;
   // Buffer#write(string);
   if (offset === undefined) {
-    return utf8Write(this, string, 0, this.length);
+    return utf8Write(this, string, 0, len);
   }
   // Buffer#write(string, encoding)
   if (length === undefined && typeof offset === 'string') {
     encoding = offset;
-    length = this.length;
+    length = len;
     offset = 0;
 
   // Buffer#write(string, offset[, length][, encoding])
   } else {
-    validateOffset(offset, 'offset', 0, this.length);
+    validateOffset(offset, 'offset', 0, len);
 
-    const remaining = this.length - offset;
+    const remaining = len - offset;
 
     if (length === undefined) {
       length = remaining;
     } else if (typeof length === 'string') {
       encoding = length;
       length = remaining;
     } else {
-      validateOffset(length, 'length', 0, this.length);
+      validateOffset(length, 'length', 0, len);
       if (length > remaining)
         length = remaining;
     }
@@ -1177,9 +1207,10 @@ Buffer.prototype.write = function write(string, offset, length, encoding) {
 };
 
 Buffer.prototype.toJSON = function toJSON() {
-  if (this.length > 0) {
-    const data = new Array(this.length);
-    for (let i = 0; i < this.length; ++i)
+  const len = this.length;
+  if (len > 0) {
+    const data = new Array(len);
+    for (let i = 0; i < len; ++i)
       data[i] = this[i];
     return { type: 'Buffer', data };
   }
@@ -1233,7 +1264,8 @@ Buffer.prototype.swap16 = function swap16() {
       swap(this, i, i + 1);
     return this;
   }
-  return _swap16(this);
+  _swap16(this);
+  return this;
 };
 
 Buffer.prototype.swap32 = function swap32() {
@@ -1250,7 +1282,8 @@ Buffer.prototype.swap32 = function swap32() {
     }
     return this;
   }
-  return _swap32(this);
+  _swap32(this);
+  return this;
 };
 
 Buffer.prototype.swap64 = function swap64() {
@@ -1269,7 +1302,8 @@ Buffer.prototype.swap64 = function swap64() {
     }
     return this;
   }
-  return _swap64(this);
+  _swap64(this);
+  return this;
 };
 
 Buffer.prototype.toLocaleString = Buffer.prototype.toString;

src/node_buffer.cc

@@ -1207,6 +1207,17 @@ void Swap16(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
+void FastSwap16(Local<Value> receiver,
+                Local<Value> buffer_obj,
+                // NOLINTNEXTLINE(runtime/references)
+                FastApiCallbackOptions& options) {
+  HandleScope scope(options.isolate);
+  ArrayBufferViewContents<char> buffer(buffer_obj);
+  CHECK(nbytes::SwapBytes16(const_cast<char*>(buffer.data()),
+                            buffer.length()));
+}
+
+static CFunction fast_swap16(CFunction::Make(FastSwap16));
 
 void Swap32(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1216,6 +1227,17 @@ void Swap32(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
+void FastSwap32(Local<Value> receiver,
+                Local<Value> buffer_obj,
+                // NOLINTNEXTLINE(runtime/references)
+                FastApiCallbackOptions& options) {
+  HandleScope scope(options.isolate);
+  ArrayBufferViewContents<char> buffer(buffer_obj);
+  CHECK(nbytes::SwapBytes32(const_cast<char*>(buffer.data()),
+                            buffer.length()));
+}
+
+static CFunction fast_swap32(CFunction::Make(FastSwap32));
 
 void Swap64(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1225,6 +1247,18 @@ void Swap64(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
+void FastSwap64(Local<Value> receiver,
+                Local<Value> buffer_obj,
+                // NOLINTNEXTLINE(runtime/references)
+                FastApiCallbackOptions& options) {
+  HandleScope scope(options.isolate);
+  ArrayBufferViewContents<char> buffer(buffer_obj);
+  CHECK(nbytes::SwapBytes64(const_cast<char*>(buffer.data()),
+                            buffer.length()));
+}
+
+static CFunction fast_swap64(CFunction::Make(FastSwap64));
+
 static void IsUtf8(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK_EQ(args.Length(), 1);
@@ -1622,9 +1656,9 @@ void Initialize(Local<Object> target,
   SetMethodNoSideEffect(
       context, target, "createUnsafeArrayBuffer", CreateUnsafeArrayBuffer);
 
-  SetMethod(context, target, "swap16", Swap16);
-  SetMethod(context, target, "swap32", Swap32);
-  SetMethod(context, target, "swap64", Swap64);
+  SetFastMethod(context, target, "swap16", Swap16, &fast_swap16);
+  SetFastMethod(context, target, "swap32", Swap32, &fast_swap32);
+  SetFastMethod(context, target, "swap64", Swap64, &fast_swap64);
 
   SetMethodNoSideEffect(context, target, "isUtf8", IsUtf8);
   SetMethodNoSideEffect(context, target, "isAscii", IsAscii);
@@ -1693,8 +1727,11 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(IndexOfString);
 
   registry->Register(Swap16);
+  registry->Register(fast_swap16);
   registry->Register(Swap32);
+  registry->Register(fast_swap32);
   registry->Register(Swap64);
+  registry->Register(fast_swap64);
 
   registry->Register(IsUtf8);
   registry->Register(IsAscii);