Changeset 39088 in webkit

Timestamp:

Dec 7, 2008 5:29:53 PM (15 years ago)

Author:

Antti Koivisto

Message:

2008-12-07 Antti Koivisto <Antti Koivisto>

Reviewed by Darin Adler.

​https://bugs.webkit.org/show_bug.cgi?id=22717
Make CSS values use less memory

Share CSSPrimitiveValue objects for commonly used values including

• idents
• colors
• small integers

This reduces the amount CSSPrimitiveValue instances by > 80%.

• css/CSSPrimitiveValue.cpp: (WebCore::CSSPrimitiveValue::createIdentifier): (WebCore::CSSPrimitiveValue::createColor): (WebCore::CSSPrimitiveValue::create):
• css/CSSPrimitiveValue.h: (WebCore::CSSPrimitiveValue::create):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSPrimitiveValue.cpp (modified) (1 diff)
• css/CSSPrimitiveValue.h (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-12-07  Antti Koivisto  <antti@apple.com>
+
+        Reviewed by Darin Adler.
+
+        https://bugs.webkit.org/show_bug.cgi?id=22717
+        Make CSS values use less memory
+        
+        Share CSSPrimitiveValue objects for commonly used values including
+        - idents
+        - colors
+        - small integers
+        
+        This reduces the amount CSSPrimitiveValue instances by > 80%.
+
+        * css/CSSPrimitiveValue.cpp:
+        (WebCore::CSSPrimitiveValue::createIdentifier):
+        (WebCore::CSSPrimitiveValue::createColor):
+        (WebCore::CSSPrimitiveValue::create):
+        * css/CSSPrimitiveValue.h:
+        (WebCore::CSSPrimitiveValue::create):
+
 2008-12-07  Antti Koivisto  <antti@apple.com>
 

trunk/WebCore/css/CSSPrimitiveValue.cpp

@@ -41 +41 @@
 
 namespace WebCore {
+
+// A more stylish solution than sharing would be to turn CSSPrimitiveValue (or CSSValues in general) into non-virtual,
+// non-refcounted simple type with value semantics. In practice these sharing tricks get similar memory benefits 
+// with less need for refactoring.
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createIdentifier(int ident)
+{
+    static RefPtr<CSSPrimitiveValue>* identValueCache = new RefPtr<CSSPrimitiveValue>[numCSSValueKeywords];
+    if (ident >= 0 && ident < numCSSValueKeywords) {
+        RefPtr<CSSPrimitiveValue> primitiveValue;
+        if (!(primitiveValue = identValueCache[ident])) {
+            primitiveValue = adoptRef(new CSSPrimitiveValue(ident));
+            identValueCache[ident] = primitiveValue;
+        }
+        return primitiveValue.release();
+    } 
+    return adoptRef(new CSSPrimitiveValue(ident));
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createColor(unsigned rgbValue)
+{
+    typedef HashMap<unsigned, RefPtr<CSSPrimitiveValue> > ColorValueCache;
+    static ColorValueCache* colorValueCache = new ColorValueCache;
+    // These are the empty and deleted values of the hash table.
+    if (rgbValue == Color::transparent) {
+        static CSSPrimitiveValue* colorTransparent = new CSSPrimitiveValue(Color::transparent);
+        return colorTransparent;
+    }
+    if (rgbValue == Color::white) {
+        static CSSPrimitiveValue* colorWhite = new CSSPrimitiveValue(Color::white);
+        return colorWhite;
+    }
+    RefPtr<CSSPrimitiveValue> primitiveValue = colorValueCache->get(rgbValue);
+    if (primitiveValue)
+        return primitiveValue.release();
+    primitiveValue = adoptRef(new CSSPrimitiveValue(rgbValue));
+    // Just wipe out the cache and start rebuilding when it gets too big.
+    const int maxColorCacheSize = 512;
+    if (colorValueCache->size() >= maxColorCacheSize)
+        colorValueCache->clear();
+    colorValueCache->add(rgbValue, primitiveValue);
+    
+    return primitiveValue.release();
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(double value, UnitTypes type)
+{
+    // Small integers are very common. Try to share them.
+    const int cachedIntegerCount = 128;
+    // Other common primitive types have UnitTypes smaller than this.
+    const int maxCachedUnitType = CSS_PX;
+    typedef RefPtr<CSSPrimitiveValue>(* IntegerValueCache)[maxCachedUnitType + 1];
+    static IntegerValueCache integerValueCache = new RefPtr<CSSPrimitiveValue>[cachedIntegerCount][maxCachedUnitType + 1];
+    if (type <= CSS_PX && value >= 0 && value < cachedIntegerCount) {
+        int intValue = static_cast<int>(value);
+        if (value == intValue) {
+            RefPtr<CSSPrimitiveValue> primitiveValue;
+            if (!(primitiveValue = integerValueCache[intValue][type])) {
+                primitiveValue = adoptRef(new CSSPrimitiveValue(value, type));
+                integerValueCache[intValue][type] = primitiveValue;
+            }
+            return primitiveValue.release();
+        }
+    }
+
+    return adoptRef(new CSSPrimitiveValue(value, type));
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(const String& value, UnitTypes type)
+{
+    return adoptRef(new CSSPrimitiveValue(value, type));
+}
 
 static const char* valueOrPropertyName(int valueOrPropertyID)

trunk/WebCore/css/CSSPrimitiveValue.h

@@ -83 +83 @@
     };
 
-    static PassRefPtr<CSSPrimitiveValue> createIdentifier(int ident)
-    {
-        return adoptRef(new CSSPrimitiveValue(ident));
-    }
-    static PassRefPtr<CSSPrimitiveValue> createColor(unsigned rgbValue)
-    {
-        return adoptRef(new CSSPrimitiveValue(rgbValue));
-    }
+    static PassRefPtr<CSSPrimitiveValue> createIdentifier(int ident);
+    static PassRefPtr<CSSPrimitiveValue> createColor(unsigned rgbValue);
+    static PassRefPtr<CSSPrimitiveValue> create(double value, UnitTypes type);
+    static PassRefPtr<CSSPrimitiveValue> create(const String& value, UnitTypes type);
+    
     template<typename T> static PassRefPtr<CSSPrimitiveValue> create(T value)
     {
         return adoptRef(new CSSPrimitiveValue(value));
-    }
-    static PassRefPtr<CSSPrimitiveValue> create(double value, UnitTypes type)
-    {
-        return adoptRef(new CSSPrimitiveValue(value, type));
-    }
-    static PassRefPtr<CSSPrimitiveValue> create(const String& value, UnitTypes type)
-    {
-        return adoptRef(new CSSPrimitiveValue(value, type));
     }