perf(ext/node): write UTF-16LE buffers with V8

Author: joepjoosten

ext/node/lib.rs

@@ -224,6 +224,7 @@ deno_core::extension!(deno_node,
     ops::buffer::op_transcode,
     ops::buffer::op_node_buffer_compare,
     ops::buffer::op_node_buffer_compare_offset,
+    ops::buffer::op_node_buffer_write_utf16le,
     ops::constant::op_node_fs_constants,
     ops::buffer::op_node_encoding_slice,
     ops::dns::op_node_getaddrinfo,

ext/node/ops/buffer.rs

@@ -49,6 +49,52 @@ pub fn op_transcode(
   }
 }
 
+#[op2(fast)]
+#[number]
+pub fn op_node_buffer_write_utf16le(
+  scope: &mut v8::PinScope<'_, '_>,
+  string: v8::Local<v8::String>,
+  #[buffer] buffer: &mut [u8],
+  #[number] offset: usize,
+  #[number] length: usize,
+) -> usize {
+  let Some(buffer) = buffer.get_mut(offset..) else {
+    return 0;
+  };
+  // Write complete UTF-16 code units, not Unicode scalar values: lone
+  // surrogates and a surrogate pair split by the byte limit must be preserved.
+  let units = string.length().min(length.min(buffer.len()) / 2);
+  if units == 0 {
+    return 0;
+  }
+  let buffer = &mut buffer[..units * 2];
+
+  #[cfg(target_endian = "little")]
+  {
+    // SAFETY: u16 has no invalid bit patterns. align_to_mut checks alignment,
+    // and this uniquely borrowed slice contains exactly the writable bytes.
+    let (prefix, words, suffix) = unsafe { buffer.align_to_mut::<u16>() };
+    if prefix.is_empty() && suffix.is_empty() {
+      string.write_v2(scope, 0, words, v8::WriteFlags::empty());
+      return units * 2;
+    }
+  }
+
+  // Buffer slices and write offsets need not be u16-aligned. Use bounded stack
+  // storage for these writes (and for byte swapping on big-endian targets).
+  let mut scratch = [0u16; 1024];
+  let mut start = 0;
+  for bytes in buffer.chunks_mut(scratch.len() * 2) {
+    let words = &mut scratch[..bytes.len() / 2];
+    string.write_v2(scope, start, words, v8::WriteFlags::empty());
+    for (word, bytes) in words.iter().zip(bytes.chunks_exact_mut(2)) {
+      bytes.copy_from_slice(&word.to_le_bytes());
+    }
+    start += words.len() as u32;
+  }
+  units * 2
+}
+
 fn latin1_ascii_to_utf16le(source: &[u8]) -> Uint8Array {
   let mut result = Vec::with_capacity(source.len() * 2);
   for &byte in source {

ext/node/polyfills/internal/buffer.mjs

@@ -91,6 +91,7 @@ const {
   op_mark_as_untransferable,
   op_node_buffer_compare,
   op_node_buffer_compare_offset,
+  op_node_buffer_write_utf16le,
   op_node_call_is_from_dependency,
   op_node_encoding_slice,
   op_transcode,
@@ -1329,7 +1330,19 @@ Buffer.prototype.ucs2Slice = function ucs2Slice(offset, length) {
   return decodeUtf16le(this, offset, length);
 };
 
-Buffer.prototype.ucs2Write = function ucs2Write(string, offset, length) {
+Buffer.prototype.ucs2Write = function ucs2Write(
+  string,
+  offset = 0,
+  length = this.length - offset,
+) {
+  if (
+    typeof string === "string" &&
+    NumberIsInteger(offset) && offset >= 0 && offset <= this.length &&
+    NumberIsInteger(length) && length >= 0
+  ) {
+    return op_node_buffer_write_utf16le(string, this, offset, length);
+  }
+  // Preserve coercion/error behavior for direct calls with non-standard args.
   return blitBuffer(
     utf16leToBytes(string, this.length - offset),
     this,

tests/bench/buffer_utf16le.js

@@ -0,0 +1,61 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+import { Buffer } from "node:buffer";
+import { deepStrictEqual } from "node:assert";
+
+// deno bench tests/bench/buffer_utf16le.js
+// Run unchanged on baseline and candidate binaries. Both implementations return
+// newly allocated bytes; the write cases isolate conversion from allocation.
+let sink = 0;
+for (
+  const [corpus, phrase] of [
+    ["ascii", "Hello world! "],
+    ["latin1", "café déjà vu "],
+    ["utf16", "Hello λ 😀 漢字! "],
+  ]
+) {
+  for (const size of [32, 2048, 32768]) {
+    const text = phrase.repeat(Math.ceil(size / phrase.length)).slice(0, size);
+    const manual = () => {
+      const bytes = new Uint8Array(text.length * 2);
+      const view = new DataView(bytes.buffer);
+      for (let i = 0; i < text.length; i++) {
+        view.setUint16(i * 2, text.charCodeAt(i), true);
+      }
+      return bytes;
+    };
+    const expected = manual();
+    deepStrictEqual(new Uint8Array(Buffer.from(text, "utf16le")), expected);
+    const group = `${corpus}/${size * 2} bytes`;
+    Deno.bench({
+      name: `DataView ${group}`,
+      group,
+      baseline: true,
+      fn() {
+        const result = manual();
+        sink ^= result[sink % result.length];
+      },
+    });
+    Deno.bench({
+      name: `Buffer.from ${group}`,
+      group,
+      fn() {
+        const result = Buffer.from(text, "utf16le");
+        sink ^= result[sink % result.length];
+      },
+    });
+    for (const offset of [0, 1]) {
+      const target = Buffer.alloc(text.length * 2 + offset);
+      deepStrictEqual(
+        target.subarray(offset, offset + target.write(text, offset, "utf16le")),
+        Buffer.from(expected),
+      );
+      Deno.bench({
+        name: `Buffer.write offset=${offset} ${group}`,
+        group,
+        fn() {
+          sink ^= target.write(text, offset, "utf16le");
+        },
+      });
+    }
+  }
+}

tests/unit_node/buffer_test.ts

@@ -11,6 +11,105 @@ import { strictEqual } from "node:assert";
 
 const { MAX_STRING_LENGTH } = constants;
 
+Deno.test("[node/buffer] UTF-16LE encoding preserves every code unit", () => {
+  const aliases = ["utf16le", "utf-16le", "ucs2", "ucs-2"] as const;
+  for (let start = 0; start < 65536; start += 1024) {
+    const units = Array.from({ length: 1024 }, (_, i) => start + i);
+    const text = String.fromCharCode(...units);
+    const expected = Buffer.alloc(units.length * 2);
+    for (let i = 0; i < units.length; i++) {
+      expected[i * 2] = units[i] & 255;
+      expected[i * 2 + 1] = units[i] >>> 8;
+    }
+    for (const encoding of aliases) {
+      assertEquals(Buffer.from(text, encoding), expected);
+    }
+  }
+});
+
+Deno.test("[node/buffer] UTF-16LE writes respect byte limits and slice boundaries", () => {
+  for (
+    const text of [
+      "",
+      "ASCII",
+      "café",
+      "漢字",
+      "A\0B",
+      "\ud800",
+      "\udc00",
+      "😀X",
+    ]
+  ) {
+    for (let viewOffset = 0; viewOffset <= 2; viewOffset++) {
+      for (let offset = 0; offset <= 3; offset++) {
+        for (let length = 0; length <= text.length * 2 + 3; length++) {
+          const backing = Buffer.alloc(viewOffset + offset + length + 3, 0xaa);
+          const target = backing.subarray(viewOffset, backing.length - 2);
+          const expected = Buffer.alloc(backing.length, 0xaa);
+          const units = Math.min(text.length, Math.floor(length / 2));
+          for (let i = 0; i < units; i++) {
+            const code = text.charCodeAt(i);
+            expected[viewOffset + offset + i * 2] = code & 255;
+            expected[viewOffset + offset + i * 2 + 1] = code >>> 8;
+          }
+          assertEquals(
+            target.write(text, offset, length, "utf16le"),
+            units * 2,
+          );
+          assertEquals(backing, expected);
+        }
+      }
+    }
+  }
+});
+
+Deno.test("[node/buffer] UTF-16LE handles large and unaligned writes", () => {
+  const text = "ASCII café 漢字 😀\ud800\0".repeat(4096);
+  const expected = Buffer.alloc(text.length * 2);
+  for (let i = 0; i < text.length; i++) {
+    expected[i * 2] = text.charCodeAt(i) & 255;
+    expected[i * 2 + 1] = text.charCodeAt(i) >>> 8;
+  }
+  assertEquals(Buffer.from(text, "utf16le"), expected);
+  // Exercise multiple native scratch-buffer iterations and a final short chunk.
+  for (const offset of [0, 1, 2, 3]) {
+    const backing = Buffer.alloc(expected.length + offset + 1, 0xaa);
+    assertEquals(backing.write(text, offset, "utf16le"), expected.length);
+    assertEquals(backing.subarray(offset, offset + expected.length), expected);
+    assertEquals(backing.subarray(0, offset), Buffer.alloc(offset, 0xaa));
+    assertEquals(backing[backing.length - 1], 0xaa);
+  }
+});
+
+Deno.test("[node/buffer] UTF-16LE writes into shared backing stores", () => {
+  const backing = new SharedArrayBuffer(16);
+  const all = Buffer.from(backing);
+  all.fill(0xaa);
+  const target = Buffer.from(backing, 1, 9);
+  assertEquals(target.write("A😀\ud800", "utf16le"), 8);
+  assertEquals(
+    [...all],
+    [
+      0xaa,
+      0x41,
+      0,
+      0x3d,
+      0xd8,
+      0,
+      0xde,
+      0,
+      0xd8,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+    ],
+  );
+});
+
 Deno.test({
   name: "[node/buffer] alloc fails if size is not a number",
   fn() {