Changeset 47622 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

Aug 20, 2009, 10:41:54 PM (16 years ago)

Author:

[email protected]

Message:

Added a number => string cache.

Patch by Geoffrey Garen <​[email protected]> on 2009-08-20
Reviewed by Maciej Stachowiak.

1.07x faster on v8 (1.7x faster on v8-splay).
1.004x faster on SunSpider.

• runtime/JSCell.h: Moved JSValue::toString to JSString.h.
• runtime/JSGlobalData.h: Holds the cache.
• runtime/JSNumberCell.cpp:

(JSC::JSNumberCell::toString):
(JSC::JSNumberCell::toThisString): Removed -0 special case.
UString handles this now, since too many clients were
special-casing it.

• runtime/JSString.h:

(JSC::JSValue::toString): Use the cache when converting
an int or double to string.

• runtime/Operations.h:

(JSC::concatenateStrings): Call toString to take advantage
of the cache.

• runtime/SmallStrings.h:

(JSC::NumericStrings::add):
(JSC::NumericStrings::lookup): The cache.

• runtime/UString.cpp:

(JSC::UString::from): Added -0 special case mentioned above.
Removed appendNumeric because it's mutually exclusive with the
cache.

Location:

trunk/JavaScriptCore/runtime

Files:

• JSCell.h (modified) (1 diff)
• JSGlobalData.h (modified) (2 diffs)
• JSNumberCell.cpp (modified) (2 diffs)
• JSString.h (modified) (1 diff)
• NumericStrings.h (copied) (copied from trunk/JavaScriptCore/runtime/SmallStrings.h ) (2 diffs)
• Operations.h (modified) (1 diff)
• UString.cpp (modified) (2 diffs)
• UString.h (modified) (1 diff)

trunk/JavaScriptCore/runtime/JSCell.h

@@ -316 +316 @@
     }
 
-    inline UString JSValue::toString(ExecState* exec) const
-    {
-        if (isCell())
-            return asCell()->toString(exec);
-        if (isInt32())
-            return UString::from(asInt32());
-        if (isDouble())
-            return asDouble() == 0.0 ? "0" : UString::from(asDouble());
-        if (isTrue())
-            return "true";
-        if (isFalse())
-            return "false";
-        if (isNull())
-            return "null";
-        ASSERT(isUndefined());
-        return "undefined";
-    }
-
     inline bool JSValue::needsThisConversion() const
     {

trunk/JavaScriptCore/runtime/JSGlobalData.h

@@ -35 +35 @@
 #include "JSValue.h"
 #include "MarkStack.h"
+#include "NumericStrings.h"
 #include "SmallStrings.h"
 #include "TimeoutChecker.h"
@@ -115 +116 @@
         const MarkedArgumentBuffer* emptyList; // Lists are supposed to be allocated on the stack to have their elements properly marked, which is not the case here - but this list has nothing to mark.
         SmallStrings smallStrings;
+        NumericStrings numericStrings;
 
 #if ENABLE(ASSEMBLER)

trunk/JavaScriptCore/runtime/JSNumberCell.cpp

@@ -55 +55 @@
 UString JSNumberCell::toString(ExecState*) const
 {
-    if (m_value == 0.0) // +0.0 or -0.0
-        return "0";
     return UString::from(m_value);
 }
@@ -62 +60 @@
 UString JSNumberCell::toThisString(ExecState*) const
 {
-    if (m_value == 0.0) // +0.0 or -0.0
-        return "0";
     return UString::from(m_value);
 }

trunk/JavaScriptCore/runtime/JSString.h

@@ -212 +212 @@
     }
 
+    inline UString JSValue::toString(ExecState* exec) const
+    {
+        if (isString())
+            return static_cast<JSString*>(asCell())->value();
+        if (isInt32())
+            return exec->globalData().numericStrings.add(asInt32());
+        if (isDouble())
+            return exec->globalData().numericStrings.add(asDouble());
+        if (isTrue())
+            return "true";
+        if (isFalse())
+            return "false";
+        if (isNull())
+            return "null";
+        if (isUndefined())
+            return "undefined";
+        ASSERT(isCell());
+        return asCell()->toString(exec);
+    }
+
 } // namespace JSC
 

trunk/JavaScriptCore/runtime/NumericStrings.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2009 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24 +24 @@
  */
 
-#ifndef SmallStrings_h
-#define SmallStrings_h
+#ifndef NumericStrings_h
+#define NumericStrings_h
 
 #include "UString.h"
-#include <wtf/OwnPtr.h>
+#include <wtf/HashFunctions.h>
 
 namespace JSC {
 
-    class JSGlobalData;
-    class JSString;
-
-    class SmallStringsStorage;
-
-    class SmallStrings : public Noncopyable {
+    class NumericStrings {
     public:
-        SmallStrings();
-        ~SmallStrings();
-
-        JSString* emptyString(JSGlobalData* globalData)
+        UString add(double d)
         {
-            if (!m_emptyString)
-                createEmptyString(globalData);
-            return m_emptyString;
-        }
-        JSString* singleCharacterString(JSGlobalData* globalData, unsigned char character)
-        {
-            if (!m_singleCharacterStrings[character])
-                createSingleCharacterString(globalData, character);
-            return m_singleCharacterStrings[character];
+            CacheEntry<double>& entry = lookup(d);
+            if (d == entry.key && !entry.value.isNull())
+                return entry.value;
+            entry.key = d;
+            entry.value = UString::from(d);
+            return entry.value;
         }
 
-        UString::Rep* singleCharacterStringRep(unsigned char character);
-
-        void mark();
-
-        unsigned count() const;
+        UString add(int i)
+        {
+            CacheEntry<int>& entry = lookup(i);
+            if (i == entry.key && !entry.value.isNull())
+                return entry.value;
+            entry.key = i;
+            entry.value = UString::from(i);
+            return entry.value;
+        }
 
     private:
-        void createEmptyString(JSGlobalData*);
-        void createSingleCharacterString(JSGlobalData*, unsigned char);
+        static const size_t cacheSize = 64;
 
-        JSString* m_emptyString;
-        JSString* m_singleCharacterStrings[0x100];
-        OwnPtr<SmallStringsStorage> m_storage;
+        template<typename T>
+        struct CacheEntry {
+            T key;
+            UString value;
+        };
+
+        CacheEntry<double>& lookup(double d) { return doubleCache[WTF::FloatHash<double>::hash(d) & (cacheSize - 1)]; }
+        CacheEntry<int>& lookup(int i) { return intCache[WTF::IntHash<int>::hash(i) & (cacheSize - 1)]; }
+
+        CacheEntry<double> doubleCache[cacheSize];
+        CacheEntry<int> intCache[cacheSize];
     };
 
 } // namespace JSC
 
-#endif // SmallStrings_h
+#endif // NumericStrings_h

trunk/JavaScriptCore/runtime/Operations.h

@@ -309 +309 @@
         UString result(resultRep);
 
-        // Loop over the openards, writing them into the output buffer.
+        // Loop over the operands, writing them into the output buffer.
         for (unsigned i = 0; i < count; ++i) {
             JSValue v = strings[i].jsValue();
             if (LIKELY(v.isString()))
                 result.append(asString(v)->value());
-            else if (v.isInt32())
-                result.appendNumeric(v.asInt32());
-            else {
-                double d;
-                if (v.getNumber(d))
-                    result.appendNumeric(d);
-                else
-                    result.append(v.toString(callFrame));
-            }
+            else
+                result.append(v.toString(callFrame));
         }
 

trunk/JavaScriptCore/runtime/UString.cpp

@@ -1028 +1028 @@
     if (isnan(d))
         return "NaN";
+    if (!d)
+        return "0"; // -0 -> "0"
 
     char buf[80];
@@ -1210 +1212 @@
 }
 
-UString& UString::appendNumeric(int i)
-{
-    m_rep = concatenate(rep(), i);
-    return *this;
-}
-
-UString& UString::appendNumeric(double d)
-{
-    m_rep = concatenate(rep(), d);
-    return *this;
-}
-
 UString& UString::append(const char* t)
 {

trunk/JavaScriptCore/runtime/UString.h

@@ -288 +288 @@
         UString& append(char c) { return append(static_cast<UChar>(static_cast<unsigned char>(c))); }
         UString& append(const UChar*, int size);
-        UString& appendNumeric(int);
-        UString& appendNumeric(double);
 
         bool getCString(CStringBuffer&) const;