Upload Kmake

benchmark/buffers/buffer-atob.js

@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('node:assert');
+
+const bench = common.createBenchmark(main, {
+  size: [16, 32, 64, 128],
+  n: [1e6],
+});
+
+function main({ n, size }) {
+  const input = btoa('A'.repeat(size));
+  let out = 0;
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    out += atob(input).length;
+  }
+  bench.end(n);
+  assert.ok(out > 0);
+}

benchmark/buffers/buffer-base64-decode-wrapped.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  charsPerLine: [76],
+  linesCount: [8 << 16],
+  n: [32],
+});
+
+function main({ charsPerLine, linesCount, n }) {
+  const bytesCount = charsPerLine * linesCount / 4 * 3;
+
+  const line = `${'abcd'.repeat(charsPerLine / 4)}\n`;
+  const data = line.repeat(linesCount);
+  // eslint-disable-next-line node-core/no-unescaped-regexp-dot
+  data.match(/./);  // Flatten the string
+  const buffer = Buffer.alloc(bytesCount, line, 'base64');
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    buffer.base64Write(data, 0, bytesCount);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-base64-decode.js

@@ -0,0 +1,29 @@
+'use strict';
+const assert = require('assert');
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [32],
+  size: [8 << 20],
+});
+
+function main({ n, size }) {
+  const s = 'abcd'.repeat(size);
+  const encodedSize = s.length * 3 / 4;
+  // eslint-disable-next-line node-core/no-unescaped-regexp-dot
+  s.match(/./);  // Flatten string.
+  assert.strictEqual(s.length % 4, 0);
+  const b = Buffer.allocUnsafe(encodedSize);
+  b.write(s, 0, encodedSize, 'base64');
+
+  let tmp;
+
+  bench.start();
+
+  for (let i = 0; i < n; i += 1)
+    tmp = b.base64Write(s, 0, s.length);
+
+  bench.end(n);
+
+  assert.strictEqual(tmp, encodedSize);
+}

benchmark/buffers/buffer-base64-encode.js

@@ -0,0 +1,50 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  len: [64 * 1024 * 1024],
+  n: [32],
+}, {
+  test: { len: 256 },
+});
+
+function main({ n, len }) {
+  const b = Buffer.allocUnsafe(len);
+  let s = '';
+  let i;
+  for (i = 0; i < 256; ++i) s += String.fromCharCode(i);
+  for (i = 0; i < len; i += 256) b.write(s, i, 256, 'ascii');
+
+  let tmp;
+
+  bench.start();
+
+  for (i = 0; i < n; ++i)
+    tmp = b.toString('base64');
+
+  bench.end(n);
+
+  assert.strictEqual(typeof tmp, 'string');
+}

benchmark/buffers/buffer-base64url-decode.js

@@ -0,0 +1,29 @@
+'use strict';
+const assert = require('assert');
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [32],
+  size: [8 << 20],
+});
+
+function main({ n, size }) {
+  const s = 'abcd'.repeat(size);
+  const encodedSize = s.length * 3 / 4;
+  // eslint-disable-next-line node-core/no-unescaped-regexp-dot
+  s.match(/./);  // Flatten string.
+  assert.strictEqual(s.length % 4, 0);
+  const b = Buffer.allocUnsafe(encodedSize);
+  b.write(s, 0, encodedSize, 'base64url');
+
+  let tmp;
+
+  bench.start();
+
+  for (let i = 0; i < n; i += 1)
+    tmp = b.base64Write(s, 0, s.length);
+
+  bench.end(n);
+
+  assert.strictEqual(tmp, encodedSize);
+}

benchmark/buffers/buffer-base64url-encode.js

@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  len: [64 * 1024 * 1024],
+  n: [32],
+}, {
+  test: { len: 256 },
+});
+
+function main({ n, len }) {
+  const b = Buffer.allocUnsafe(len);
+  let s = '';
+  let i;
+  for (i = 0; i < 256; ++i) s += String.fromCharCode(i);
+  for (i = 0; i < len; i += 256) b.write(s, i, 256, 'ascii');
+
+  let tmp;
+
+  bench.start();
+
+  for (i = 0; i < n; ++i)
+    tmp = b.toString('base64url');
+
+  bench.end(n);
+
+  assert.strictEqual(typeof tmp, 'string');
+}

benchmark/buffers/buffer-btoa.js

@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('node:assert');
+
+const bench = common.createBenchmark(main, {
+  size: [16, 32, 64, 128, 256, 1024],
+  n: [1e6],
+});
+
+function main({ n, size }) {
+  const input = 'A'.repeat(size);
+  let out = 0;
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    out += btoa(input).length;
+  }
+  bench.end(n);
+  assert.ok(out > 0);
+}

benchmark/buffers/buffer-bytelength-buffer.js

@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+
+const bench = common.createBenchmark(main, {
+  len: [2, 16, 256], // x16
+  n: [4e6],
+});
+
+function main({ n, len }) {
+  const data = Buffer.alloc(len * 16, 'a');
+  const expected = Buffer.byteLength(data, 'buffer');
+  let changed = false;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const actual = Buffer.byteLength(data, 'buffer');
+    if (expected !== actual) { changed = true; }
+  }
+  bench.end(n);
+  if (changed) {
+    throw new Error('Result changed during iteration');
+  }
+}

benchmark/buffers/buffer-bytelength-string.js

@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+const bench = common.createBenchmark(main, {
+  type: ['one_byte', 'two_bytes', 'three_bytes',
+         'four_bytes', 'latin1'],
+  encoding: ['utf8', 'base64'],
+  repeat: [1, 2, 16, 256], // x16
+  n: [4e6],
+});
+
+// 16 chars each
+const chars = {
+  one_byte: 'hello brendan!!!',
+  two_bytes: 'ΰαβγδεζηθικλμνξο',
+  three_bytes: '挰挱挲挳挴挵挶挷挸挹挺挻挼挽挾挿',
+  four_bytes: '𠜎𠜱𠝹𠱓𠱸𠲖𠳏𠳕𠴕𠵼𠵿𠸎𠸏𠹷𠺝𠺢',
+  latin1: 'Un homme sage est supérieur à toutes ' +
+    'les insultes qui peuvent lui être adressées, et la meilleure réponse est la patience et la modération.',
+};
+
+function getInput(type, repeat, encoding) {
+  const original = (repeat === 1) ? chars[type] : chars[type].repeat(repeat);
+  if (encoding === 'base64') {
+    Buffer.from(original, 'utf8').toString('base64');
+  }
+  return original;
+}
+
+function main({ n, repeat, encoding, type }) {
+  const data = getInput(type, repeat, encoding);
+  const expected = Buffer.byteLength(data, encoding);
+  let changed = false;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const actual = Buffer.byteLength(data, encoding);
+    if (expected !== actual) { changed = true; }
+  }
+  bench.end(n);
+  if (changed) {
+    throw new Error('Result changed during iteration');
+  }
+}

benchmark/buffers/buffer-compare-instance-method.js

@@ -0,0 +1,59 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  size: [16, 512, 4096, 16386],
+  args: [1, 2, 5],
+  n: [1e6],
+});
+
+function main({ n, size, args }) {
+  const b0 = Buffer.alloc(size, 'a');
+  const b1 = Buffer.alloc(size, 'a');
+  const b0Len = b0.length;
+  const b1Len = b1.length;
+
+  b1[size - 1] = 'b'.charCodeAt(0);
+
+  switch (args) {
+    case 2:
+      b0.compare(b1, 0);
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        b0.compare(b1, 0);
+      }
+      bench.end(n);
+      break;
+    case 3:
+      b0.compare(b1, 0, b1Len);
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        b0.compare(b1, 0, b1Len);
+      }
+      bench.end(n);
+      break;
+    case 4:
+      b0.compare(b1, 0, b1Len, 0);
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        b0.compare(b1, 0, b1Len, 0);
+      }
+      bench.end(n);
+      break;
+    case 5:
+      b0.compare(b1, 0, b1Len, 0, b0Len);
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        b0.compare(b1, 0, b1Len, 0, b0Len);
+      }
+      bench.end(n);
+      break;
+    default:
+      b0.compare(b1);
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        b0.compare(b1);
+      }
+      bench.end(n);
+  }
+}

benchmark/buffers/buffer-compare-offset.js

@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  method: ['offset', 'slice'],
+  size: [16, 512, 4096, 16386],
+  n: [1e6],
+});
+
+function compareUsingSlice(b0, b1, len, iter) {
+  for (let i = 0; i < iter; i++)
+    Buffer.compare(b0.slice(1, len), b1.slice(1, len));
+}
+
+function compareUsingOffset(b0, b1, len, iter) {
+  for (let i = 0; i < iter; i++)
+    b0.compare(b1, 1, len, 1, len);
+}
+
+function main({ n, size, method }) {
+  const fn = method === 'slice' ? compareUsingSlice : compareUsingOffset;
+  bench.start();
+  fn(Buffer.alloc(size, 'a'),
+     Buffer.alloc(size, 'b'),
+     size >> 1,
+     n);
+  bench.end(n);
+}

benchmark/buffers/buffer-compare.js

@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  size: [16, 512, 4096, 16386],
+  n: [1e6],
+});
+
+function main({ n, size }) {
+  const b0 = Buffer.alloc(size, 'a');
+  const b1 = Buffer.alloc(size, 'a');
+
+  b1[size - 1] = 'b'.charCodeAt(0);
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    Buffer.compare(b0, b1);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-concat-fill.js

@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  extraSize: [1, 256, 4 * 256],
+  n: [8e5],
+});
+
+function main({ n, extraSize }) {
+  const pieces = 4;
+  const pieceSize = 256;
+
+  const list = Array.from({ length: pieces })
+    .fill(Buffer.allocUnsafe(pieceSize));
+
+  const totalLength = (pieces * pieceSize) + extraSize;
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    Buffer.concat(list, totalLength);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-concat.js

@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  pieces: [4, 16],
+  pieceSize: [1, 16, 256],
+  withTotalLength: [0, 1],
+  n: [8e5],
+});
+
+function main({ n, pieces, pieceSize, withTotalLength }) {
+  const list = Array.from({ length: pieces })
+    .fill(Buffer.allocUnsafe(pieceSize));
+
+  const totalLength = withTotalLength ? pieces * pieceSize : undefined;
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    Buffer.concat(list, totalLength);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-copy.js

@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  bytes: [8, 128, 1024],
+  partial: ['true', 'false'],
+  n: [6e6],
+});
+
+function main({ n, bytes, partial }) {
+  const source = Buffer.allocUnsafe(bytes);
+  const target = Buffer.allocUnsafe(bytes);
+  const sourceStart = (partial === 'true' ? Math.floor(bytes / 2) : 0);
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    source.copy(target, 0, sourceStart);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-creation.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+const bench = common.createBenchmark(main, {
+  type: [
+    'fast-alloc',
+    'fast-alloc-fill',
+    'fast-allocUnsafe',
+    'slow-allocUnsafe',
+  ],
+  len: [10, 1024, 4096, 8192],
+  n: [6e5],
+});
+
+function main({ len, n, type }) {
+  let fn, i;
+  switch (type) {
+    case 'fast-alloc':
+      fn = Buffer.alloc;
+      break;
+    case 'fast-alloc-fill':
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.alloc(len, 0);
+      }
+      bench.end(n);
+      return;
+    case 'fast-allocUnsafe':
+      fn = Buffer.allocUnsafe;
+      break;
+    case 'slow-allocUnsafe':
+      fn = Buffer.allocUnsafeSlow;
+      break;
+    default:
+      assert.fail('Should not get here');
+  }
+
+  bench.start();
+  for (i = 0; i < n; i++) {
+    fn(len);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-equals.js

@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  size: [0, 512, 16386],
+  difflen: ['true', 'false'],
+  n: [1e6],
+});
+
+function main({ n, size, difflen }) {
+  const b0 = Buffer.alloc(size, 'a');
+  const b1 = Buffer.alloc(size + (difflen === 'true' ? 1 : 0), 'a');
+
+  if (b1.length > 0)
+    b1[b1.length - 1] = 'b'.charCodeAt(0);
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    b0.equals(b1);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-fill.js

@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  type: [
+    'fill(0)',
+    'fill("")',
+    'fill(100)',
+    'fill(400)',
+    'fill("t")',
+    'fill("test")',
+    'fill("t", "utf8")',
+    'fill("t", 0, "utf8")',
+    'fill("t", 0)',
+    'fill(Buffer.alloc(1), 0)',
+  ],
+  size: [2 ** 13, 2 ** 16],
+  n: [2e4],
+});
+
+function main({ n, type, size }) {
+  const buffer = Buffer.allocUnsafe(size);
+  const testFunction = new Function('b', `
+    for (var i = 0; i < ${n}; i++) {
+      b.${type};
+    }
+  `);
+  bench.start();
+  testFunction(buffer);
+  bench.end(n);
+}

benchmark/buffers/buffer-from.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+const bench = common.createBenchmark(main, {
+  source: [
+    'array',
+    'arraybuffer',
+    'arraybuffer-middle',
+    'buffer',
+    'string',
+    'string-utf8',
+    'string-base64',
+    'object',
+    'uint8array',
+    'uint16array',
+  ],
+  len: [100, 2048],
+  n: [8e5],
+});
+
+function main({ len, n, source }) {
+  let i = 0;
+
+  switch (source) {
+    case 'array': {
+      const array = new Array(len).fill(42);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(array);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'arraybuffer': {
+      const arrayBuf = new ArrayBuffer(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(arrayBuf);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'arraybuffer-middle': {
+      const arrayBuf = new ArrayBuffer(len);
+      const offset = ~~(len / 4);
+      const length = ~~(len / 2);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(arrayBuf, offset, length);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'buffer': {
+      const buffer = Buffer.allocUnsafe(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(buffer);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'uint8array': {
+      const uint8array = new Uint8Array(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(uint8array);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'uint16array': {
+      const uint16array = new Uint16Array(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(uint16array);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'string': {
+      const str = 'a'.repeat(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(str);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'string-utf8': {
+      const str = 'a'.repeat(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(str, 'utf8');
+      }
+      bench.end(n);
+      break;
+    }
+    case 'string-base64': {
+      const str = 'a'.repeat(len);
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(str, 'base64');
+      }
+      bench.end(n);
+      break;
+    }
+    case 'object': {
+      const obj = { length: null }; // Results in a new, empty Buffer
+      bench.start();
+      for (i = 0; i < n; i++) {
+        Buffer.from(obj);
+      }
+      bench.end(n);
+      break;
+    }
+    default:
+      assert.fail('Should not get here');
+  }
+}

benchmark/buffers/buffer-hex-decode.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  len: [64, 1024],
+  n: [1e6],
+});
+
+function main({ len, n }) {
+  const buf = Buffer.alloc(len);
+
+  for (let i = 0; i < buf.length; i++)
+    buf[i] = i & 0xff;
+
+  const plain = buf;
+
+  bench.start();
+
+  let tmp;
+
+  for (let i = 0; i < n; i += 1)
+    tmp = plain.toString('hex');
+
+  bench.end(n);
+
+  assert.strictEqual(typeof tmp, 'string');
+}

benchmark/buffers/buffer-hex-encode.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  len: [64, 1024],
+  n: [1e6],
+});
+
+function main({ len, n }) {
+  const buf = Buffer.alloc(len);
+
+  for (let i = 0; i < buf.length; i++)
+    buf[i] = i & 0xff;
+
+  const hex = buf.toString('hex');
+  let tmp;
+
+  bench.start();
+
+  for (let i = 0; i < n; i += 1)
+    tmp = Buffer.from(hex, 'hex');
+
+  bench.end(n);
+
+  assert.strictEqual(typeof tmp, 'object');
+}

benchmark/buffers/buffer-indexof-number.js

@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common.js');
+const fs = require('fs');
+const path = require('path');
+
+const bench = common.createBenchmark(main, {
+  value: ['@'.charCodeAt(0)],
+  n: [1e6],
+});
+
+function main({ n, value }) {
+  const aliceBuffer = fs.readFileSync(
+    path.resolve(__dirname, '../fixtures/alice.html'),
+  );
+
+  let count = 0;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    count += aliceBuffer.indexOf(value, 0, undefined);
+  }
+  bench.end(n);
+  return count;
+}

benchmark/buffers/buffer-indexof.js

@@ -0,0 +1,54 @@
+'use strict';
+const common = require('../common.js');
+const fs = require('fs');
+const path = require('path');
+
+const searchStrings = [
+  '@',
+  'SQ',
+  '--l',
+  'Alice',
+  'Gryphon',
+  'Ou est ma chatte?',
+  'found it very',
+  'neighbouring pool',
+  'aaaaaaaaaaaaaaaaa',
+  'venture to go near the house till she had brought herself down to',
+  '</i> to the Caterpillar',
+];
+
+const bench = common.createBenchmark(main, {
+  search: searchStrings,
+  encoding: ['undefined', 'utf8', 'ucs2'],
+  type: ['buffer', 'string'],
+  n: [5e4],
+}, {
+  combinationFilter: (p) => {
+    return (p.type === 'buffer' && p.encoding === 'undefined') ||
+           (p.type !== 'buffer' && p.encoding !== 'undefined');
+  },
+});
+
+function main({ n, search, encoding, type }) {
+  let aliceBuffer = fs.readFileSync(
+    path.resolve(__dirname, '../fixtures/alice.html'),
+  );
+
+  if (encoding === 'undefined') {
+    encoding = undefined;
+  }
+
+  if (encoding === 'ucs2') {
+    aliceBuffer = Buffer.from(aliceBuffer.toString(), encoding);
+  }
+
+  if (type === 'buffer') {
+    search = Buffer.from(Buffer.from(search).toString(), encoding);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    aliceBuffer.indexOf(search, 0, encoding);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-isascii.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common.js');
+const buffer = require('node:buffer');
+const assert = require('node:assert');
+
+const bench = common.createBenchmark(main, {
+  n: [2e7],
+  length: ['short', 'long'],
+  input: ['hello world'],
+});
+
+
+function main({ n, input }) {
+  const normalizedInput = input === 'short' ? input : input.repeat(200);
+  const encoder = new TextEncoder();
+  const buff = encoder.encode(normalizedInput);
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    assert.ok(buffer.isAscii(buff));
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-isutf8.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common.js');
+const buffer = require('node:buffer');
+const assert = require('node:assert');
+
+const bench = common.createBenchmark(main, {
+  n: [2e7],
+  length: ['short', 'long'],
+  input: ['regular string', '∀x∈ℝ: ⌈x⌉ = −⌊−x⌋'],
+});
+
+
+function main({ n, input, length }) {
+  const normalizedInput = length === 'short' ? input : input.repeat(300);
+  const encoder = new TextEncoder();
+  const buff = encoder.encode(normalizedInput);
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    assert.ok(buffer.isUtf8(buff));
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-iterate.js

@@ -0,0 +1,58 @@
+'use strict';
+const SlowBuffer = require('buffer').SlowBuffer;
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  size: [512, 4096, 16386],
+  type: ['fast'],
+  method: ['for', 'forOf', 'iterator'],
+  n: [1e3],
+});
+
+const methods = {
+  'for': benchFor,
+  'forOf': benchForOf,
+  'iterator': benchIterator,
+};
+
+function main({ size, type, method, n }) {
+  const buffer = type === 'fast' ?
+    Buffer.alloc(size) :
+    SlowBuffer(size).fill(0);
+
+  const fn = methods[method];
+
+  bench.start();
+  fn(buffer, n);
+  bench.end(n);
+}
+
+function benchFor(buffer, n) {
+  for (let k = 0; k < n; k++) {
+    for (let i = 0; i < buffer.length; i++) {
+      assert.strictEqual(buffer[i], 0);
+    }
+  }
+}
+
+function benchForOf(buffer, n) {
+  for (let k = 0; k < n; k++) {
+    for (const b of buffer) {
+      assert.strictEqual(b, 0);
+    }
+  }
+}
+
+function benchIterator(buffer, n) {
+  for (let k = 0; k < n; k++) {
+    const iter = buffer[Symbol.iterator]();
+    let cur = iter.next();
+
+    while (!cur.done) {
+      assert.strictEqual(cur.value, 0);
+      cur = iter.next();
+    }
+
+  }
+}

benchmark/buffers/buffer-normalize-encoding.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  encoding: [
+    'ascii',
+    'base64',
+    'BASE64',
+    'binary',
+    'hex',
+    'HEX',
+    'latin1',
+    'LATIN1',
+    'UCS-2',
+    'UCS2',
+    'utf-16le',
+    'UTF-16LE',
+    'utf-8',
+    'utf16le',
+    'UTF16LE',
+    'utf8',
+    'UTF8',
+  ],
+  n: [1e6],
+}, {
+  flags: ['--expose-internals'],
+});
+
+function main({ encoding, n }) {
+  const { normalizeEncoding } = require('internal/util');
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    normalizeEncoding(encoding);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-read-float.js

@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  type: ['Double', 'Float'],
+  endian: ['LE'],
+  value: ['zero', 'big', 'small', 'inf', 'nan'],
+  n: [1e6],
+});
+
+function main({ n, type, endian, value }) {
+  const buff = Buffer.alloc(8);
+  const fn = `read${type}${endian}`;
+  const values = {
+    Double: {
+      zero: 0,
+      big: 2 ** 1023,
+      small: 2 ** -1074,
+      inf: Infinity,
+      nan: NaN,
+    },
+    Float: {
+      zero: 0,
+      big: 2 ** 127,
+      small: 2 ** -149,
+      inf: Infinity,
+      nan: NaN,
+    },
+  };
+
+  buff[`write${type}${endian}`](values[type][value], 0);
+
+  bench.start();
+  for (let i = 0; i !== n; i++) {
+    buff[fn](0);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-read-with-byteLength.js

@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common.js');
+
+const types = [
+  'IntBE',
+  'IntLE',
+  'UIntBE',
+  'UIntLE',
+];
+
+const bench = common.createBenchmark(main, {
+  buffer: ['fast'],
+  type: types,
+  n: [1e6],
+  byteLength: [1, 2, 3, 4, 5, 6],
+});
+
+function main({ n, buf, type, byteLength }) {
+  const buff = buf === 'fast' ?
+    Buffer.alloc(8) :
+    require('buffer').SlowBuffer(8);
+  const fn = `read${type}`;
+
+  buff.writeDoubleLE(0, 0);
+  bench.start();
+  for (let i = 0; i !== n; i++) {
+    buff[fn](0, byteLength);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-read.js

@@ -0,0 +1,40 @@
+'use strict';
+const common = require('../common.js');
+
+const types = [
+  'BigUInt64LE',
+  'BigUInt64BE',
+  'BigInt64LE',
+  'BigInt64BE',
+  'UInt8',
+  'UInt16LE',
+  'UInt16BE',
+  'UInt32LE',
+  'UInt32BE',
+  'Int8',
+  'Int16LE',
+  'Int16BE',
+  'Int32LE',
+  'Int32BE',
+];
+
+const bench = common.createBenchmark(main, {
+  buffer: ['fast'],
+  type: types,
+  n: [1e6],
+});
+
+function main({ n, buf, type }) {
+  const buff = buf === 'fast' ?
+    Buffer.alloc(8) :
+    require('buffer').SlowBuffer(8);
+  const fn = `read${type}`;
+
+  buff.writeDoubleLE(0, 0);
+  bench.start();
+
+  for (let i = 0; i !== n; i++) {
+    buff[fn](0);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-slice.js

@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common.js');
+const SlowBuffer = require('buffer').SlowBuffer;
+
+const bench = common.createBenchmark(main, {
+  type: ['fast', 'slow', 'subarray'],
+  n: [1e6],
+});
+
+const buf = Buffer.allocUnsafe(1024);
+const slowBuf = new SlowBuffer(1024);
+
+function main({ n, type }) {
+  const b = type === 'slow' ? slowBuf : buf;
+  const fn = type === 'subarray' ?
+    () => b.subarray(10, 256) :
+    () => b.slice(10, 256);
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    fn();
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-swap.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  aligned: ['true', 'false'],
+  method: ['swap16', 'swap32', 'swap64'/* , 'htons', 'htonl', 'htonll' */],
+  len: [64, 256, 768, 1024, 2056, 8192],
+  n: [1e6],
+}, {
+  test: { len: 16 },
+});
+
+// The htons and htonl methods below are used to benchmark the
+// performance difference between doing the byteswap in pure
+// javascript regardless of Buffer size as opposed to dropping
+// down to the native layer for larger Buffer sizes. Commented
+// out by default because they are slow for big buffers. If
+// re-evaluating the crossover point, uncomment those methods
+// and comment out their implementations in lib/buffer.js so
+// C++ version will always be used.
+
+function swap(b, n, m) {
+  const i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+}
+
+Buffer.prototype.htons = function htons() {
+  if (this.length % 2 !== 0)
+    throw new RangeError();
+  for (let i = 0; i < this.length; i += 2) {
+    swap(this, i, i + 1);
+  }
+  return this;
+};
+
+Buffer.prototype.htonl = function htonl() {
+  if (this.length % 4 !== 0)
+    throw new RangeError();
+  for (let i = 0; i < this.length; i += 4) {
+    swap(this, i, i + 3);
+    swap(this, i + 1, i + 2);
+  }
+  return this;
+};
+
+Buffer.prototype.htonll = function htonll() {
+  if (this.length % 8 !== 0)
+    throw new RangeError();
+  for (let i = 0; i < this.length; i += 8) {
+    swap(this, i, i + 7);
+    swap(this, i + 1, i + 6);
+    swap(this, i + 2, i + 5);
+    swap(this, i + 3, i + 4);
+  }
+  return this;
+};
+
+function createBuffer(len, aligned) {
+  len += aligned ? 0 : 1;
+  const buf = Buffer.allocUnsafe(len);
+  for (let i = 1; i <= len; i++)
+    buf[i - 1] = i;
+  return aligned ? buf : buf.slice(1);
+}
+
+function genMethod(method) {
+  const fnString = `
+      return function ${method}(n, buf) {
+        for (let i = 0; i <= n; i++)
+          buf.${method}();
+      }`;
+  return (new Function(fnString))();
+}
+
+function main({ method, len, n, aligned = 'true' }) {
+  const buf = createBuffer(len, aligned === 'true');
+  const bufferSwap = genMethod(method);
+
+  bufferSwap(n, buf);
+  bench.start();
+  bufferSwap(n, buf);
+  bench.end(n);
+}

benchmark/buffers/buffer-tojson.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e4],
+  len: [0, 256, 4 * 1024],
+});
+
+function main({ n, len }) {
+  const buf = Buffer.allocUnsafe(len);
+
+  bench.start();
+  for (let i = 0; i < n; ++i)
+    buf.toJSON();
+  bench.end(n);
+}

benchmark/buffers/buffer-tostring.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  encoding: ['', 'utf8', 'ascii', 'latin1', 'hex', 'UCS-2'],
+  args: [0, 1, 3],
+  len: [1, 64, 1024],
+  n: [1e6],
+}, {
+  combinationFilter: (p) => {
+    return (p.args === 0 && p.encoding === '') ||
+           (p.args !== 0 && p.encoding !== '');
+  },
+});
+
+function main({ encoding, args, len, n }) {
+  const buf = Buffer.alloc(len, 42);
+
+  if (encoding.length === 0)
+    encoding = undefined;
+
+  switch (args) {
+    case 1:
+      bench.start();
+      for (let i = 0; i < n; i += 1)
+        buf.toString(encoding);
+      bench.end(n);
+      break;
+    case 2:
+      bench.start();
+      for (let i = 0; i < n; i += 1)
+        buf.toString(encoding, 0);
+      bench.end(n);
+      break;
+    case 3:
+      bench.start();
+      for (let i = 0; i < n; i += 1)
+        buf.toString(encoding, 0, len);
+      bench.end(n);
+      break;
+    default:
+      bench.start();
+      for (let i = 0; i < n; i += 1)
+        buf.toString();
+      bench.end(n);
+      break;
+  }
+}

benchmark/buffers/buffer-transcode.js

@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('node:assert');
+const buffer = require('node:buffer');
+
+const hasIntl = !!process.config.variables.v8_enable_i18n_support;
+const encodings = ['latin1', 'ascii', 'ucs2', 'utf8'];
+
+if (!hasIntl) {
+  console.log('Skipping: `transcode` is only available on platforms that support i18n`');
+  process.exit(0);
+}
+
+const bench = common.createBenchmark(main, {
+  fromEncoding: encodings,
+  toEncoding: encodings,
+  length: [1, 10, 1000],
+  n: [1e5],
+}, {
+  combinationFilter(p) {
+    return !(p.fromEncoding === 'ucs2' && p.toEncoding === 'utf8');
+  },
+});
+
+function main({ n, fromEncoding, toEncoding, length }) {
+  const input = Buffer.from('a'.repeat(length));
+  let out = 0;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const dest = buffer.transcode(input, fromEncoding, toEncoding);
+    out += dest.buffer.byteLength;
+  }
+  bench.end(n);
+  assert.ok(out >= 0);
+}

benchmark/buffers/buffer-write-string-short.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  encoding: [
+    'utf8', 'ascii', 'latin1',
+  ],
+  len: [1, 8, 16, 32],
+  n: [1e6],
+});
+
+function main({ len, n, encoding }) {
+  const buf = Buffer.allocUnsafe(len);
+  const string = Buffer.from('a'.repeat(len)).toString();
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    buf.write(string, 0, encoding);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-write-string.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  encoding: [
+    '', 'utf8', 'ascii', 'hex', 'utf16le', 'latin1',
+  ],
+  args: [ '', 'offset', 'offset+length' ],
+  len: [2048],
+  n: [1e6],
+});
+
+function main({ len, n, encoding, args }) {
+  let string;
+  let start = 0;
+  const buf = Buffer.allocUnsafe(len);
+
+  switch (args) {
+    case 'offset':
+      string = 'a'.repeat(Math.floor(len / 2));
+      start = len - string.length;
+      if (encoding) {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string, start, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string, start);
+        }
+        bench.end(n);
+      }
+      break;
+    case 'offset+length':
+      string = 'a'.repeat(len);
+      if (encoding) {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string, 0, buf.length, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string, 0, buf.length);
+        }
+        bench.end(n);
+      }
+      break;
+    default:
+      string = 'a'.repeat(len);
+      if (encoding) {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (let i = 0; i < n; ++i) {
+          buf.write(string);
+        }
+        bench.end(n);
+      }
+  }
+}

benchmark/buffers/buffer-write.js

@@ -0,0 +1,123 @@
+'use strict';
+const common = require('../common.js');
+
+const types = [
+  'BigUInt64LE',
+  'BigUInt64BE',
+  'BigInt64LE',
+  'BigInt64BE',
+  'UInt8',
+  'UInt16LE',
+  'UInt16BE',
+  'UInt32LE',
+  'UInt32BE',
+  'UIntLE',
+  'UIntBE',
+  'Int8',
+  'Int16LE',
+  'Int16BE',
+  'Int32LE',
+  'Int32BE',
+  'IntLE',
+  'IntBE',
+  'FloatLE',
+  'FloatBE',
+  'DoubleLE',
+  'DoubleBE',
+];
+
+const bench = common.createBenchmark(main, {
+  buffer: ['fast'],
+  type: types,
+  n: [1e6],
+});
+
+const INT8 = 0x7f;
+const INT16 = 0x7fff;
+const INT32 = 0x7fffffff;
+const INT48 = 0x7fffffffffff;
+const INT64 = 0x7fffffffffffffffn;
+const UINT8 = 0xff;
+const UINT16 = 0xffff;
+const UINT32 = 0xffffffff;
+const UINT64 = 0xffffffffffffffffn;
+
+const mod = {
+  writeBigInt64BE: INT64,
+  writeBigInt64LE: INT64,
+  writeBigUInt64BE: UINT64,
+  writeBigUInt64LE: UINT64,
+  writeInt8: INT8,
+  writeInt16BE: INT16,
+  writeInt16LE: INT16,
+  writeInt32BE: INT32,
+  writeInt32LE: INT32,
+  writeUInt8: UINT8,
+  writeUInt16BE: UINT16,
+  writeUInt16LE: UINT16,
+  writeUInt32BE: UINT32,
+  writeUInt32LE: UINT32,
+  writeUIntLE: INT8,
+  writeUIntBE: INT16,
+  writeIntLE: INT32,
+  writeIntBE: INT48,
+};
+
+const byteLength = {
+  writeUIntLE: 1,
+  writeUIntBE: 2,
+  writeIntLE: 4,
+  writeIntBE: 6,
+};
+
+function main({ n, buf, type }) {
+  const buff = buf === 'fast' ?
+    Buffer.alloc(8) :
+    require('buffer').SlowBuffer(8);
+  const fn = `write${type}`;
+
+  if (!/\d/.test(fn))
+    benchSpecialInt(buff, fn, n);
+  else if (/BigU?Int/.test(fn))
+    benchBigInt(buff, fn, BigInt(n));
+  else if (/Int/.test(fn))
+    benchInt(buff, fn, n);
+  else
+    benchFloat(buff, fn, n);
+}
+
+function benchBigInt(buff, fn, n) {
+  const m = mod[fn];
+  bench.start();
+  for (let i = 0n; i !== n; i++) {
+    buff[fn](i & m, 0);
+  }
+  bench.end(Number(n));
+}
+
+function benchInt(buff, fn, n) {
+  const m = mod[fn];
+  bench.start();
+  for (let i = 0; i !== n; i++) {
+    buff[fn](i & m, 0);
+  }
+  bench.end(n);
+}
+
+function benchSpecialInt(buff, fn, n) {
+  const m = mod[fn];
+  const byte = byteLength[fn];
+  bench.start();
+  for (let i = 0; i !== n; i++) {
+    buff[fn](i & m, 0, byte);
+  }
+  bench.end(n);
+}
+
+function benchFloat(buff, fn, n) {
+  bench.start();
+  for (let i = 0; i !== n; i++) {
+    buff[fn](i, 0);
+  }
+  bench.end(n);
+}

benchmark/buffers/buffer-zero.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  type: ['buffer', 'string'],
+});
+
+const zeroBuffer = Buffer.alloc(0);
+const zeroString = '';
+
+function main({ n, type }) {
+  const data = type === 'buffer' ? zeroBuffer : zeroString;
+
+  bench.start();
+  for (let i = 0; i < n; i++) Buffer.from(data);
+  bench.end(n);
+}

benchmark/buffers/dataview-set.js

@@ -0,0 +1,71 @@
+'use strict';
+const common = require('../common.js');
+
+const types = [
+  'Uint8',
+  'Uint16LE',
+  'Uint16BE',
+  'Uint32LE',
+  'Uint32BE',
+  'Int8',
+  'Int16LE',
+  'Int16BE',
+  'Int32LE',
+  'Int32BE',
+  'Float32LE',
+  'Float32BE',
+  'Float64LE',
+  'Float64BE',
+];
+
+const bench = common.createBenchmark(main, {
+  type: types,
+  n: [1e6],
+});
+
+const INT8 = 0x7f;
+const INT16 = 0x7fff;
+const INT32 = 0x7fffffff;
+const UINT8 = INT8 * 2;
+const UINT16 = INT16 * 2;
+const UINT32 = INT32 * 2;
+
+const mod = {
+  setInt8: INT8,
+  setInt16: INT16,
+  setInt32: INT32,
+  setUint8: UINT8,
+  setUint16: UINT16,
+  setUint32: UINT32,
+};
+
+function main({ n, type }) {
+  const ab = new ArrayBuffer(8);
+  const dv = new DataView(ab, 0, 8);
+  const le = /LE$/.test(type);
+  const fn = `set${type.replace(/[LB]E$/, '')}`;
+
+  if (/int/i.test(fn))
+    benchInt(dv, fn, n, le);
+  else
+    benchFloat(dv, fn, n, le);
+}
+
+function benchInt(dv, fn, len, le) {
+  const m = mod[fn];
+  const method = dv[fn];
+  bench.start();
+  for (let i = 0; i < len; i++) {
+    method.call(dv, 0, i % m, le);
+  }
+  bench.end(len);
+}
+
+function benchFloat(dv, fn, len, le) {
+  const method = dv[fn];
+  bench.start();
+  for (let i = 0; i < len; i++) {
+    method.call(dv, 0, i * 0.1, le);
+  }
+  bench.end(len);
+}