Changeset 55002 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

Feb 18, 2010, 10:23:25 PM (15 years ago)

Author:

[email protected]

Message:

2010-02-18 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

Improve interpreter getter performance
​https://bugs.webkit.org/show_bug.cgi?id=35138

Improve the performance of getter dispatch by making it possible
for the interpreter to cache the GetterSetter object lookup.

To do this we simply need to make PropertySlot aware of getters
as a potentially cacheable property, and record the base and this
objects for a getter access. This allows us to use more-or-less
identical code to that used by the normal get_by_id caching, with
the dispatch being the only actual difference.

I'm holding off of implementing this in the JIT until I do some
cleanup to try and making coding in the JIT not be as horrible
as it is currently.

• bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): (JSC::CodeBlock::derefStructures): (JSC::CodeBlock::refStructures):
• bytecode/Opcode.h:
• interpreter/Interpreter.cpp: (JSC::Interpreter::resolveGlobal): (JSC::Interpreter::tryCacheGetByID): (JSC::Interpreter::privateExecute):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass):
• jit/JITStubs.cpp: (JSC::JITThunks::tryCacheGetByID): (JSC::DEFINE_STUB_FUNCTION):
• runtime/JSObject.cpp: (JSC::JSObject::fillGetterPropertySlot):
• runtime/PropertySlot.cpp: (JSC::PropertySlot::functionGetter):
• runtime/PropertySlot.h: (JSC::PropertySlot::isGetter): (JSC::PropertySlot::isCacheable): (JSC::PropertySlot::isCacheableValue): (JSC::PropertySlot::setValueSlot): (JSC::PropertySlot::setGetterSlot): (JSC::PropertySlot::setCacheableGetterSlot): (JSC::PropertySlot::clearOffset): (JSC::PropertySlot::thisValue):

Location:

trunk/JavaScriptCore/runtime

Files:

• JSObject.cpp (modified) (1 diff)
• PropertySlot.cpp (modified) (1 diff)
• PropertySlot.h (modified) (5 diffs)

trunk/JavaScriptCore/runtime/JSObject.cpp

@@ -517 +517 @@
 NEVER_INLINE void JSObject::fillGetterPropertySlot(PropertySlot& slot, JSValue* location)
 {
-    if (JSObject* getterFunction = asGetterSetter(*location)->getter())
-        slot.setGetterSlot(getterFunction);
-    else
+    if (JSObject* getterFunction = asGetterSetter(*location)->getter()) {
+        if (!structure()->isDictionary())
+            slot.setCacheableGetterSlot(this, getterFunction, offsetForLocation(location));
+        else
+            slot.setGetterSlot(getterFunction);
+    } else
         slot.setUndefined();
 }

trunk/JavaScriptCore/runtime/PropertySlot.cpp

@@ -36 +36 @@
     CallType callType = slot.m_data.getterFunc->getCallData(callData);
     if (callType == CallTypeHost)
-        return callData.native.function(exec, slot.m_data.getterFunc, slot.slotBase(), exec->emptyList());
+        return callData.native.function(exec, slot.m_data.getterFunc, slot.thisValue(), exec->emptyList());
     ASSERT(callType == CallTypeJS);
     // FIXME: Can this be done more efficiently using the callData?
-    return asFunction(slot.m_data.getterFunc)->call(exec, slot.slotBase(), exec->emptyList());
+    return asFunction(slot.m_data.getterFunc)->call(exec, slot.thisValue(), exec->emptyList());
 }
 

trunk/JavaScriptCore/runtime/PropertySlot.h

@@ -72 +72 @@
         }
 
-        bool isCacheable() const { return m_offset != WTF::notFound; }
+        bool isGetter() const { return m_isGetter; }
+        bool isCacheable() const { return m_isCacheable; }
+        bool isCacheableValue() const { return m_isCacheable && !m_isGetter; }
         size_t cachedOffset() const
         {
@@ -103 +105 @@
             m_data.valueSlot = valueSlot;
             m_offset = offset;
+            m_isCacheable = true;
+            m_isGetter = false;
         }
         
@@ -140 +144 @@
             m_data.index = index;
         }
-        
+
         void setGetterSlot(JSObject* getterFunc)
+        {
+            ASSERT(getterFunc);
+            m_thisValue = m_slotBase;
+            m_getValue = functionGetter;
+            m_data.getterFunc = getterFunc;
+            m_isGetter = true;
+        }
+
+        void setCacheableGetterSlot(JSValue slotBase, JSObject* getterFunc, unsigned offset)
         {
             ASSERT(getterFunc);
             m_getValue = functionGetter;
+            m_thisValue = m_slotBase;
+            m_slotBase = slotBase;
             m_data.getterFunc = getterFunc;
-        }
-        
+            m_offset = offset;
+            m_isCacheable = true;
+            m_isGetter = true;
+        }
+
         void setUndefined()
         {
@@ -183 +201 @@
             // Clear offset even in release builds, in case this PropertySlot has been used before.
             // (For other data members, we don't need to clear anything because reuse would meaningfully overwrite them.)
-            m_offset = WTF::notFound;
+            m_offset = 0;
+            m_isCacheable = false;
+            m_isGetter = false;
         }
 
         unsigned index() const { return m_data.index; }
 
+        JSValue thisValue() const { return m_thisValue; }
     private:
         static JSValue functionGetter(ExecState*, const Identifier&, const PropertySlot&);
@@ -202 +223 @@
 
         JSValue m_value;
+        JSValue m_thisValue;
 
         size_t m_offset;
+        bool m_isCacheable : 1;
+        bool m_isGetter : 1;
     };