Optimize non-ASCII string splitting with single-character search pattern

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2744 matching lines @@
     pos = reinterpret_cast<const char*>(
         memchr(pos, pattern, subject_end - pos));
     if (pos == NULL) return;
     indices->Add(static_cast<int>(pos - subject_start), zone);
     pos++;
     limit--;
   }
 }
 
 
+void FindTwoByteStringIndices(const Vector<const uc16> subject,
+                              uc16 pattern,
+                              ZoneList<int>* indices,
+                              unsigned int limit,
+                              Zone* zone) {
+  ASSERT(limit > 0);
+  const uc16* subject_start = subject.start();
+  const uc16* subject_end = subject_start + subject.length();
+  for (const uc16* pos = subject_start; pos < subject_end && limit > 0; pos++) {
+    if (*pos == pattern) {
+      indices->Add(static_cast<int>(pos - subject_start), zone);
+      limit--;
+    }
+  }
+}
+
+
 template <typename SubjectChar, typename PatternChar>
 void FindStringIndices(Isolate* isolate,
                        Vector<const SubjectChar> subject,
                        Vector<const PatternChar> pattern,
                        ZoneList<int>* indices,
                        unsigned int limit,
                        Zone* zone) {
   ASSERT(limit > 0);
   // Collect indices of pattern in subject.
   // Stop after finding at most limit values.
@@ skipping 43 matching lines @@
       } else {
         FindStringIndices(isolate,
                           subject_vector,
                           pattern_content.ToUC16Vector(),
                           indices,
                           limit,
                           zone);
       }
     } else {
       Vector<const uc16> subject_vector = subject_content.ToUC16Vector();
-      if (pattern_content.IsAscii()) {
-        FindStringIndices(isolate,
-                          subject_vector,
-                          pattern_content.ToAsciiVector(),
-                          indices,
-                          limit,
-                          zone);
+      if (pattern_content.Length() == 1) {
+        uc16 pattern_char = pattern_content.IsAscii() ?
+                            pattern_content.ToAsciiVector()[0] :
+                            pattern_content.ToUC16Vector()[0];
+        FindTwoByteStringIndices(subject_vector,
+                                 pattern_char,
+                                 indices,
+                                 limit,
+                                 zone);
+      } else if (pattern_content.IsAscii()) {
+          FindStringIndices(isolate,
+                            subject_vector,
+                            pattern_content.ToAsciiVector(),
+                            indices,
+                            limit,
+                            zone);

[Yang, 2012/11/26 08:45:30]

Since we are doing the IsAscii() check (implied in Length()) in any case,
couldn't we leave it with

if (pattern_content.IsAscii()) {
  Vector<const char> pattern_vector = pattern_content.ToAsciiVector();
  if (pattern_vector.length() == 1) {
    ...
  } else {
    ...
  }
} else {
  Vector<const uc16> pattern_vector = pattern_content.ToUC16Vector();
  if (pattern_vector.length() == 1) {
    ...
  } else {
    ...
  }
}

I know this is a bit more verbose, but this way we don't have to introduce
Length() and also avoid the redundant ascii check.

       } else {
         FindStringIndices(isolate,
                           subject_vector,
                           pattern_content.ToUC16Vector(),
                           indices,
                           limit,
                           zone);
       }
     }
   }
@@ skipping 10537 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal