buffer: add fast api for isAscii & isUtf8

Author: anonrig

src/node_buffer.cc

@@ -1175,6 +1175,28 @@ void Swap64(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
+bool FastIsUtf8(v8::Local<v8::Value>,
+                const v8::FastApiTypedArray<uint8_t>& buffer) {
+  uint8_t* buffer_data;
+  CHECK(buffer.getStorageIfAligned(&buffer_data));
+  TRACK_V8_FAST_API_CALL("buffer.isUtf8");
+  return simdutf::validate_utf8(reinterpret_cast<const char*>(buffer_data),
+                                buffer.length());
+}
+
+static v8::CFunction fast_is_utf8(v8::CFunction::Make(FastIsUtf8));
+
+bool FastIsAscii(v8::Local<v8::Value>,
+                 const v8::FastApiTypedArray<uint8_t>& buffer) {
+  uint8_t* buffer_data;
+  CHECK(buffer.getStorageIfAligned(&buffer_data));
+  TRACK_V8_FAST_API_CALL("buffer.isAscii");
+  return simdutf::validate_ascii(reinterpret_cast<const char*>(buffer_data),
+                                 buffer.length());
+}
+
+static v8::CFunction fast_is_ascii(v8::CFunction::Make(FastIsAscii));
+
 static void IsUtf8(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK_EQ(args.Length(), 1);
@@ -1565,8 +1587,9 @@ void Initialize(Local<Object> target,
   SetMethod(context, target, "swap32", Swap32);
   SetMethod(context, target, "swap64", Swap64);
 
-  SetMethodNoSideEffect(context, target, "isUtf8", IsUtf8);
-  SetMethodNoSideEffect(context, target, "isAscii", IsAscii);
+  SetFastMethodNoSideEffect(context, target, "isUtf8", IsUtf8, &fast_is_utf8);
+  SetFastMethodNoSideEffect(
+      context, target, "isAscii", IsAscii, &fast_is_ascii);
 
   target
       ->Set(context,
@@ -1673,6 +1696,11 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
 
   registry->Register(Atob);
   registry->Register(Btoa);
+
+  registry->Register(FastIsUtf8);
+  registry->Register(fast_is_utf8.GetTypeInfo());
+  registry->Register(FastIsAscii);
+  registry->Register(fast_is_ascii.GetTypeInfo());
 }
 
 }  // namespace Buffer

src/node_external_reference.h

@@ -42,6 +42,8 @@ using CFunctionCallbackWithInt64 = void (*)(v8::Local<v8::Object> unused,
 using CFunctionCallbackWithBool = void (*)(v8::Local<v8::Object> unused,
                                            v8::Local<v8::Object> receiver,
                                            bool);
+using CFunctionFastIsUtf8 = bool (*)(
+    v8::Local<v8::Value>, const v8::FastApiTypedArray<uint8_t>& buffer);
 using CFunctionCallbackWithString =
     bool (*)(v8::Local<v8::Value>, const v8::FastOneByteString& input);
 using CFunctionCallbackWithStrings =
@@ -109,6 +111,7 @@ class ExternalReferenceRegistry {
   V(CFunctionCallbackValueReturnDoubleUnusedReceiver)                          \
   V(CFunctionCallbackWithInt64)                                                \
   V(CFunctionCallbackWithBool)                                                 \
+  V(CFunctionFastIsUtf8)                                                       \
   V(CFunctionCallbackWithString)                                               \
   V(CFunctionCallbackWithStrings)                                              \
   V(CFunctionCallbackWithTwoUint8Arrays)                                       \

test/parallel/test-buffer-isutf8-isascii-fast-api.js

@@ -0,0 +1,74 @@
+// Flags: --expose-internals --no-warnings --allow-natives-syntax
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+
+// Get direct access to the buffer validation methods
+const buffer = require('buffer');
+
+// Create test buffers
+const utf8Buffer = Buffer.from('Hello, 世界!');  // Valid UTF-8 with actual Unicode characters
+const asciiBuffer = Buffer.from('Hello, World!');  // Valid ASCII
+const nonUtf8Buffer = Buffer.from([0xFF, 0xFF, 0xFF]); // Invalid UTF-8
+const nonAsciiBuffer = Buffer.from([0x80, 0x90, 0xA0]); // Invalid ASCII
+
+// Test basic functionality for isUtf8
+assert.strictEqual(buffer.isUtf8(utf8Buffer), true);
+assert.strictEqual(buffer.isUtf8(nonUtf8Buffer), false);
+
+// Test basic functionality for isAscii
+assert.strictEqual(buffer.isAscii(asciiBuffer), true);
+assert.strictEqual(buffer.isAscii(nonAsciiBuffer), false);
+
+// Test detached buffers
+const detachedBuffer = new ArrayBuffer(10);
+try {
+  detachedBuffer.detach();
+} catch (e) {
+  console.log('Skipping detached buffer tests - detach not supported');
+}
+
+if (detachedBuffer.detached) {
+  const typedArray = new Uint8Array(detachedBuffer);
+
+  assert.throws(() => {
+    buffer.isUtf8(typedArray);
+  }, {
+    name: 'Error',
+    code: 'ERR_INVALID_STATE'
+  });
+
+  assert.throws(() => {
+    buffer.isAscii(typedArray);
+  }, {
+    name: 'Error',
+    code: 'ERR_INVALID_STATE'
+  });
+}
+
+// Test optimization and fast API paths
+function testFastPaths() {
+  // Test both valid and invalid cases to ensure both paths are optimized
+  buffer.isUtf8(utf8Buffer);
+  buffer.isUtf8(nonUtf8Buffer);
+  buffer.isAscii(asciiBuffer);
+  buffer.isAscii(nonAsciiBuffer);
+}
+
+// Since we want to optimize the C++ methods, we need to prepare them
+// through their JS wrappers
+eval('%PrepareFunctionForOptimization(buffer.isUtf8)');
+eval('%PrepareFunctionForOptimization(buffer.isAscii)');
+testFastPaths();
+eval('%OptimizeFunctionOnNextCall(buffer.isUtf8)');
+eval('%OptimizeFunctionOnNextCall(buffer.isAscii)');
+testFastPaths();
+
+// Verify fast API calls were made if running in debug mode
+if (common.isDebug) {
+  const { getV8FastApiCallCount } = internalBinding('debug');
+  assert.strictEqual(getV8FastApiCallCount('buffer.isUtf8'), 2); // Called twice in testFastPaths
+  assert.strictEqual(getV8FastApiCallCount('buffer.isAscii'), 2); // Called twice in testFastPaths
+}