Changeset 62148 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

Jun 29, 2010, 3:01:29 PM (15 years ago)

Author:

[email protected]

Message:

2010-06-29 Michael Saboff <​[email protected]>

Reviewed by Darin Adler.

Bug 41238 - RegExp performance slow on Dromaeo benchmark

Other javascript engines appear to cache prior results of regular
expression operations.

Suggest adding some sort of caching mechanism to regular expression
processing.

Added a single entry cache of match() results to RegExp class.

Also added performance improvements to UString == operator.
First check the impls for equality. Then get the length of
each of the non-null impls. Next check the sizes for equality.
Then check the data for the case of different impls that point
to the same data (most likely due to substrings from the beginning of
another string). Lastly we check the underlying data for equality.

• runtime/RegExp.cpp: (JSC::RegExp::RegExp): (JSC::RegExp::match):
• runtime/RegExp.h:
• runtime/UString.h: (JSC::operator==):

Location:

trunk/JavaScriptCore/runtime

Files:

• RegExp.cpp (modified) (4 diffs)
• RegExp.h (modified) (1 diff)
• UString.h (modified) (1 diff)

trunk/JavaScriptCore/runtime/RegExp.cpp

@@ -52 +52 @@
     , m_constructionError(0)
     , m_numSubpatterns(0)
+    , m_lastMatchStart(-1)
 {
     compile(globalData);
@@ -61 +62 @@
     , m_constructionError(0)
     , m_numSubpatterns(0)
+    , m_lastMatchStart(-1)
 {
     // NOTE: The global flag is handled on a case-by-case basis by functions like
@@ -110 +112 @@
         ovector->resize(0);
 
-    if (static_cast<unsigned>(startOffset) > s.size() || s.isNull())
+    if (static_cast<unsigned>(startOffset) > s.size() || s.isNull()) {
+        m_lastMatchString = UString();
+        m_lastMatchStart = -1;
+        m_lastOVector.shrink(0);
         return -1;
+    }
+    
+    // Perform check to see if this match call is the same as the last match invocation
+    // and if it is return the prior result.
+    if ((startOffset == m_lastMatchStart) && (s.rep() == m_lastMatchString.rep())) {
+        if (ovector)
+            *ovector = m_lastOVector;
+        
+        if (m_lastOVector.isEmpty())
+            return -1;
+
+        return m_lastOVector.at(0);
+    }
 
 #if ENABLE(YARR_JIT)
@@ -148 +166 @@
                 ovector->clear();
         }
+        
+        m_lastMatchString = s;
+        m_lastMatchStart = startOffset;
+
+        if (ovector)
+            m_lastOVector = *ovector;
+        else
+            m_lastOVector = nonReturnedOvector;
+
         return result;
     }
+
+    m_lastMatchString = UString();
+    m_lastMatchStart = -1;
+    m_lastOVector.shrink(0);
 
     return -1;

trunk/JavaScriptCore/runtime/RegExp.h

@@ -68 +68 @@
         const char* m_constructionError;
         unsigned m_numSubpatterns;
+        UString m_lastMatchString;
+        int m_lastMatchStart;
+        Vector<int, 32> m_lastOVector;
 
 #if ENABLE(YARR_JIT)

trunk/JavaScriptCore/runtime/UString.h

@@ -159 +159 @@
     ALWAYS_INLINE bool operator==(const UString& s1, const UString& s2)
     {
-        unsigned size = s1.size();
-        switch (size) {
-        case 0:
-            return !s2.size();
+        UString::Rep* rep1 = s1.rep();
+        UString::Rep* rep2 = s2.rep();
+        unsigned size1 = 0;
+        unsigned size2 = 0;
+
+        if (rep1 == rep2) // If they're the same rep, they're equal.
+            return true;
+        
+        if (rep1)
+            size1 = rep1->length();
+            
+        if (rep2)
+            size2 = rep2->length();
+            
+        if (size1 != size2) // If the lengths are not the same, we're done.
+            return false;
+        
+        if (!size1)
+            return true;
+        
+        // At this point we know 
+        //   (a) that the strings are the same length and
+        //   (b) that they are greater than zero length.
+        const UChar* d1 = rep1->characters();
+        const UChar* d2 = rep2->characters();
+        
+        if (d1 == d2) // Check to see if the data pointers are the same.
+            return true;
+        
+        // Do quick checks for sizes 1 and 2.
+        switch (size1) {
         case 1:
-            return s2.size() == 1 && s1.data()[0] == s2.data()[0];
-        case 2: {
-            if (s2.size() != 2)
-                return false;
-            const UChar* d1 = s1.data();
-            const UChar* d2 = s2.data();
+            return d1[0] == d2[0];
+        case 2:
             return (d1[0] == d2[0]) & (d1[1] == d2[1]);
-        }
         default:
-            return s2.size() == size && memcmp(s1.data(), s2.data(), size * sizeof(UChar)) == 0;
+            return memcmp(d1, d2, size1 * sizeof(UChar)) == 0;
         }
     }