src: optimize utf-8 byte length calculation using simdutf

Author: mertcanaltin

src/node_buffer.cc

@@ -764,40 +764,30 @@ void SlowByteLengthUtf8(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   Local<String> source = args[0].As<String>();
 
-  static constexpr int kSmallStringThreshold = 128;
-  if (source->Length() <= kSmallStringThreshold) {
-    size_t result = source->Utf8LengthV2(isolate);
-    args.GetReturnValue().Set(static_cast<uint64_t>(result));
+  int length = source->Length();
+
+  if (source->IsOneByte()) {
+    args.GetReturnValue().Set(
+        static_cast<uint64_t>(source->Utf8LengthV2(isolate)));
     return;
   }
 
-  size_t utf8_length;
-
-  // Fast path for external one-byte strings (common case for ASCII/Latin1)
-  if (source->IsExternalOneByte()) {
-    auto ext = source->GetExternalOneByteStringResource();
-    utf8_length = simdutf::utf8_length_from_latin1(ext->data(), ext->length());
-    args.GetReturnValue().Set(static_cast<uint64_t>(utf8_length));
+  static constexpr int kSmallStringThreshold = 128;
+  if (length <= kSmallStringThreshold) {
+    args.GetReturnValue().Set(
+        static_cast<uint64_t>(source->Utf8LengthV2(isolate)));
     return;
   }
 
-  // For non-external strings, use ValueView
   String::ValueView view(isolate, source);
-  size_t length = view.length();
-
-  if (view.is_one_byte()) {
-    auto data = reinterpret_cast<const char*>(view.data8());
-    utf8_length = simdutf::utf8_length_from_latin1(data, length);
-  } else {
-    auto data = reinterpret_cast<const char16_t*>(view.data16());
-    if (simdutf::validate_utf16(data, length)) {
-      utf8_length = simdutf::utf8_length_from_utf16(data, length);
-    } else {
-      utf8_length = source->Utf8LengthV2(isolate);
-    }
+  auto data = reinterpret_cast<const char16_t*>(view.data16());
+  if (simdutf::validate_utf16(data, length)) {
+    args.GetReturnValue().Set(
+        static_cast<uint64_t>(simdutf::utf8_length_from_utf16(data, length)));
+    return;
   }
-
-  args.GetReturnValue().Set(static_cast<uint64_t>(utf8_length));
+  args.GetReturnValue().Set(
+      static_cast<uint64_t>(source->Utf8LengthV2(isolate)));
 }
 
 uint32_t FastByteLengthUtf8(
@@ -812,33 +802,16 @@ uint32_t FastByteLengthUtf8(
 
   int length = sourceStr->Length();
 
-  // For short inputs, use V8's path - function call overhead not worth it
-  static constexpr int kSmallStringThreshold = 128;
-  if (length <= kSmallStringThreshold) {
+  if (sourceStr->IsOneByte()) {
     return sourceStr->Utf8LengthV2(isolate);
   }
 
-  // Fast path for external one-byte strings (common case for ASCII/Latin1)
-  if (sourceStr->IsExternalOneByte()) {
-    auto ext = sourceStr->GetExternalOneByteStringResource();
-    return simdutf::utf8_length_from_latin1(ext->data(), ext->length());
-  }
-
-  // For one-byte (Latin1/ASCII) strings, V8 is already fast and ValueView
-  // creation has overhead. Use higher threshold before switching to simdutf.
-  static constexpr int kOneByteLargeThreshold = 1024;
-  if (sourceStr->IsOneByte() && length <= kOneByteLargeThreshold) {
+  static constexpr int kSmallStringThreshold = 128;
+  if (length <= kSmallStringThreshold) {
     return sourceStr->Utf8LengthV2(isolate);
   }
 
-  // For larger strings or two-byte strings, use ValueView + simdutf
   String::ValueView view(isolate, sourceStr);
-
-  if (view.is_one_byte()) {
-    auto data = reinterpret_cast<const char*>(view.data8());
-    return simdutf::utf8_length_from_latin1(data, length);
-  }
-
   auto data = reinterpret_cast<const char16_t*>(view.data16());
   if (simdutf::validate_utf16(data, length)) {
     return simdutf::utf8_length_from_utf16(data, length);