src: optimize utf-8 length calculation for small and large strings

Author: mertcanaltin

src/node_buffer.cc

@@ -761,9 +761,35 @@ void StringWrite(const FunctionCallbackInfo<Value>& args) {
 void SlowByteLengthUtf8(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsString());
 
-  // Fast case: avoid StringBytes on UTF8 string. Jump to v8.
-  size_t result = args[0].As<String>()->Utf8LengthV2(args.GetIsolate());
-  args.GetReturnValue().Set(static_cast<uint64_t>(result));
+  Isolate* isolate = args.GetIsolate();
+  Local<String> source = args[0].As<String>();
+
+  // For small strings, use V8's path for better performance
+  static constexpr int kSmallStringThreshold = 128;
+  if (source->Length() <= kSmallStringThreshold) {
+    size_t result = source->Utf8LengthV2(isolate);
+    args.GetReturnValue().Set(static_cast<uint64_t>(result));
+    return;
+  }
+
+  String::ValueView view(isolate, source);
+  size_t length = view.length();
+  size_t utf8_length;
+
+  if (view.is_one_byte()) {
+    auto data = reinterpret_cast<const char*>(view.data8());
+    simdutf::result result = simdutf::validate_ascii_with_errors(data, length);
+    if (result.error == simdutf::SUCCESS) {
+      utf8_length = length;  // Pure ASCII, length stays the same
+    } else {
+      utf8_length = simdutf::utf8_length_from_latin1(data, length);
+    }
+  } else {
+    auto data = reinterpret_cast<const char16_t*>(view.data16());
+    utf8_length = simdutf::utf8_length_from_utf16(data, length);
+  }
+
+  args.GetReturnValue().Set(static_cast<uint64_t>(utf8_length));
 }
 
 uint32_t FastByteLengthUtf8(
@@ -776,49 +802,28 @@ uint32_t FastByteLengthUtf8(
   CHECK(sourceValue->IsString());
   Local<String> sourceStr = sourceValue.As<String>();
 
-  if (!sourceStr->IsExternalOneByte()) {
+  // For short inputs, use V8's path - function call overhead not worth it
+  static constexpr int kSmallStringThreshold = 128;
+  if (sourceStr->Length() <= kSmallStringThreshold) {
     return sourceStr->Utf8LengthV2(isolate);
   }
-  auto source = sourceStr->GetExternalOneByteStringResource();
-  // For short inputs, the function call overhead to simdutf is maybe
-  // not worth it, reserve simdutf for long strings.
-  if (source->length() > 128) {
-    return simdutf::utf8_length_from_latin1(source->data(), source->length());
-  }
-
-  uint32_t length = source->length();
-  const auto input = reinterpret_cast<const uint8_t*>(source->data());
-
-  uint32_t answer = length;
-  uint32_t i = 0;
 
-  auto pop = [](uint64_t v) {
-    return static_cast<size_t>(((v >> 7) & UINT64_C(0x0101010101010101)) *
-                                   UINT64_C(0x0101010101010101) >>
-                               56);
-  };
+  // For large strings, use simdutf with String::ValueView for direct access
+  // This is ~6x faster for large strings
+  String::ValueView view(isolate, sourceStr);
+  size_t length = view.length();
 
-  for (; i + 32 <= length; i += 32) {
-    uint64_t v;
-    memcpy(&v, input + i, 8);
-    answer += pop(v);
-    memcpy(&v, input + i + 8, 8);
-    answer += pop(v);
-    memcpy(&v, input + i + 16, 8);
-    answer += pop(v);
-    memcpy(&v, input + i + 24, 8);
-    answer += pop(v);
-  }
-  for (; i + 8 <= length; i += 8) {
-    uint64_t v;
-    memcpy(&v, input + i, 8);
-    answer += pop(v);
-  }
-  for (; i + 1 <= length; i += 1) {
-    answer += input[i] >> 7;
+  if (view.is_one_byte()) {
+    auto data = reinterpret_cast<const char*>(view.data8());
+    simdutf::result result = simdutf::validate_ascii_with_errors(data, length);
+    if (result.error == simdutf::SUCCESS) {
+      return length;  // Pure ASCII, length stays the same
+    }
+    return simdutf::utf8_length_from_latin1(data, length);
   }
 
-  return answer;
+  auto data = reinterpret_cast<const char16_t*>(view.data16());
+  return simdutf::utf8_length_from_utf16(data, length);
 }
 
 static CFunction fast_byte_length_utf8(CFunction::Make(FastByteLengthUtf8));