Changeset 133975 in webkit

Timestamp:

Nov 8, 2012 5:12:47 PM (11 years ago)

Author:

oliver@apple.com

Message:

Improve effectiveness of function-level caching
​https://bugs.webkit.org/show_bug.cgi?id=101667

Reviewed by Filip Pizlo.

Added a random-eviction based cache for unlinked functions, and switch
UnlinkedFunctionExecutable's code references to Weak<>, thereby letting
us remove the explicit UnlinkedFunctionExecutable::clearCode() calls that
were being triggered by GC.

Refactored the random eviction part of the CodeCache into a separate data
structure so that I didn't have to duplicate the code again, and then used
that for the new function cache.

• bytecode/UnlinkedCodeBlock.cpp:

(JSC::UnlinkedFunctionExecutable::visitChildren):
(JSC::UnlinkedFunctionExecutable::codeBlockFor):

• bytecode/UnlinkedCodeBlock.h:

(JSC::UnlinkedFunctionExecutable::clearCodeForRecompilation):
(UnlinkedFunctionExecutable):

• debugger/Debugger.cpp:
• runtime/CodeCache.cpp:

(JSC::CodeCache::getCodeBlock):
(JSC::CodeCache::generateFunctionCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode):
(JSC::CodeCache::usedFunctionCode):
(JSC):

• runtime/Executable.cpp:

(JSC::FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling):
(JSC::FunctionExecutable::clearCode):

• runtime/Executable.h:

(FunctionExecutable):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/UnlinkedCodeBlock.cpp (modified) (3 diffs)
• bytecode/UnlinkedCodeBlock.h (modified) (3 diffs)
• debugger/Debugger.cpp (modified) (1 diff)
• runtime/CodeCache.cpp (modified) (6 diffs)
• runtime/CodeCache.h (modified) (4 diffs)
• runtime/Executable.cpp (modified) (2 diffs)
• runtime/Executable.h (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2012-11-08  Oliver Hunt  <oliver@apple.com>
+
+        Improve effectiveness of function-level caching
+        https://bugs.webkit.org/show_bug.cgi?id=101667
+
+        Reviewed by Filip Pizlo.
+
+        Added a random-eviction based cache for unlinked functions, and switch
+        UnlinkedFunctionExecutable's code references to Weak<>, thereby letting
+        us remove the explicit UnlinkedFunctionExecutable::clearCode() calls that
+        were being triggered by GC.
+
+        Refactored the random eviction part of the CodeCache into a separate data
+        structure so that I didn't have to duplicate the code again, and then used
+        that for the new function cache.
+
+        * bytecode/UnlinkedCodeBlock.cpp:
+        (JSC::UnlinkedFunctionExecutable::visitChildren):
+        (JSC::UnlinkedFunctionExecutable::codeBlockFor):
+        * bytecode/UnlinkedCodeBlock.h:
+        (JSC::UnlinkedFunctionExecutable::clearCodeForRecompilation):
+        (UnlinkedFunctionExecutable):
+        * debugger/Debugger.cpp:
+        * runtime/CodeCache.cpp:
+        (JSC::CodeCache::getCodeBlock):
+        (JSC::CodeCache::generateFunctionCodeBlock):
+        (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
+        (JSC::CodeCache::usedFunctionCode):
+        (JSC):
+        * runtime/Executable.cpp:
+        (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling):
+        (JSC::FunctionExecutable::clearCode):
+        * runtime/Executable.h:
+        (FunctionExecutable):
+
 2012-11-07  Filip Pizlo  <fpizlo@apple.com>
 

trunk/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp

@@ -81 +81 @@
     ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
     Base::visitChildren(thisObject, visitor);
-    visitor.append(&thisObject->m_codeBlockForCall);
-    visitor.append(&thisObject->m_codeBlockForConstruct);
     visitor.append(&thisObject->m_nameValue);
     visitor.append(&thisObject->m_symbolTableForCall);
@@ -113 +111 @@
     switch (specializationKind) {
     case CodeForCall:
-        if (m_codeBlockForCall)
-            return m_codeBlockForCall.get();
+        if (UnlinkedFunctionCodeBlock* codeBlock = m_codeBlockForCall.get()) {
+            globalData.codeCache()->usedFunctionCode(globalData, codeBlock);
+            return codeBlock;
+        }
         break;
     case CodeForConstruct:
-        if (m_codeBlockForConstruct)
-            return m_codeBlockForConstruct.get();
+        if (UnlinkedFunctionCodeBlock* codeBlock = m_codeBlockForConstruct.get()) {
+            globalData.codeCache()->usedFunctionCode(globalData, codeBlock);
+            return codeBlock;
+        }
         break;
     }
@@ -129 +131 @@
     switch (specializationKind) {
     case CodeForCall:
-        m_codeBlockForCall.set(globalData, this, result);
+        m_codeBlockForCall = PassWeak<UnlinkedFunctionCodeBlock>(result);
         m_symbolTableForCall.set(globalData, this, result->symbolTable());
         break;
     case CodeForConstruct:
-        m_codeBlockForConstruct.set(globalData, this, result);
+        m_codeBlockForConstruct = PassWeak<UnlinkedFunctionCodeBlock>(result);
         m_symbolTableForConstruct.set(globalData, this, result->symbolTable());
         break;

trunk/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h

@@ -37 +37 @@
 #include "RegExp.h"
 #include "SpecialPointer.h"
+#include "Weak.h"
 
 #include <wtf/RefCountedArray.h>
@@ -109 +110 @@
     FunctionExecutable* link(JSGlobalData&, const SourceCode&, size_t lineOffset, size_t sourceOffset);
 
-    void clearCode()
+    void clearCodeForRecompilation()
     {
         m_symbolTableForCall.clear();
@@ -137 +138 @@
 private:
     UnlinkedFunctionExecutable(JSGlobalData*, Structure*, const SourceCode&, FunctionBodyNode*);
-    WriteBarrier<UnlinkedFunctionCodeBlock> m_codeBlockForCall;
-    WriteBarrier<UnlinkedFunctionCodeBlock> m_codeBlockForConstruct;
+    Weak<UnlinkedFunctionCodeBlock> m_codeBlockForCall;
+    Weak<UnlinkedFunctionCodeBlock> m_codeBlockForConstruct;
 
     unsigned m_numCapturedVariables : 29;

trunk/Source/JavaScriptCore/debugger/Debugger.cpp

@@ -81 +81 @@
     ExecState* exec = function->scope()->globalObject()->JSGlobalObject::globalExec();
     executable->clearCodeIfNotCompiling();
-    executable->clearUnlinkedCodeIfNotCompiling();
+    executable->clearUnlinkedCodeForRecompilationIfNotCompiling();
     if (m_debugger == function->scope()->globalObject()->debugger())
         m_sourceProviders.add(executable->source().provider(), exec);

trunk/Source/JavaScriptCore/runtime/CodeCache.cpp

@@ -37 +37 @@
 
 CodeCache::CodeCache()
-    : m_randomGenerator(static_cast<uint32_t>(randomNumber() * UINT32_MAX))
 {
 }
@@ -68 +67 @@
     bool storeInCache = false;
     if (debuggerMode == DebuggerOff && profilerMode == ProfilerOff) {
-        CodeBlockIndicesMap::iterator result = m_cachedCodeBlockIndices.find(key);
-        if (result != m_cachedCodeBlockIndices.end()) {
-            UnlinkedCodeBlockType* unlinkedCode = jsCast<UnlinkedCodeBlockType*>(m_cachedCodeBlocks[result->value].second.get());
+        const Strong<UnlinkedCodeBlock>* result = m_cachedCodeBlocks.find(key);
+        if (result) {
+            UnlinkedCodeBlockType* unlinkedCode = jsCast<UnlinkedCodeBlockType*>(result->get());
             unsigned firstLine = source.firstLine() + unlinkedCode->firstLine();
             executable->recordParse(unlinkedCode->codeFeatures(), unlinkedCode->hasCapturedVariables(), firstLine, firstLine + unlinkedCode->lineCount());
@@ -92 +91 @@
         return 0;
 
-    if (storeInCache) {
-        size_t index = m_randomGenerator.getUint32() % kMaxCodeBlockEntries;
-        if (m_cachedCodeBlocks[index].second)
-            m_cachedCodeBlockIndices.remove(m_cachedCodeBlocks[index].first);
-        m_cachedCodeBlockIndices.set(key, index);
-        m_cachedCodeBlocks[index].second.set(globalData, unlinkedCode);
-        m_cachedCodeBlocks[index].first = key;
-    }
+    if (storeInCache)
+        m_cachedCodeBlocks.add(key, Strong<UnlinkedCodeBlock>(globalData, unlinkedCode));
 
     return unlinkedCode;
@@ -134 +127 @@
     if (error.m_type != ParserError::ErrorNone)
         return 0;
+    m_cachedFunctionCode.add(result, Strong<UnlinkedFunctionCodeBlock>(globalData, result));
     return result;
 }
@@ -150 +144 @@
 {
     GlobalFunctionKey key = makeGlobalFunctionKey(source, name.string());
-    GlobalFunctionIndicesMap::iterator result = m_cachedGlobalFunctionIndices.find(key);
-    if (result != m_cachedGlobalFunctionIndices.end())
-        return m_cachedGlobalFunctions[result->value].second.get();
+    const Strong<UnlinkedFunctionExecutable>* result = m_cachedGlobalFunctions.find(key);
+    if (result)
+        return result->get();
 
     RefPtr<ProgramNode> program = parse<ProgramNode>(&globalData, source, 0, Identifier(), JSParseNormal, JSParseProgramCode, error);
@@ -174 +168 @@
     functionExecutable->m_nameValue.set(globalData, functionExecutable, jsString(&globalData, name.string()));
 
-    size_t index = m_randomGenerator.getUint32() % kMaxGlobalFunctionEntries;
-    if (m_cachedGlobalFunctions[index].second)
-        m_cachedGlobalFunctionIndices.remove(m_cachedGlobalFunctions[index].first);
-    m_cachedGlobalFunctionIndices.set(key, index);
-    m_cachedGlobalFunctions[index].second.set(globalData, functionExecutable);
-    m_cachedGlobalFunctions[index].first = key;
-
+    m_cachedGlobalFunctions.add(key, Strong<UnlinkedFunctionExecutable>(globalData, functionExecutable));
     return functionExecutable;
 }
 
+void CodeCache::usedFunctionCode(JSGlobalData& globalData, UnlinkedFunctionCodeBlock* codeBlock)
+{
+    m_cachedFunctionCode.add(codeBlock, Strong<UnlinkedFunctionCodeBlock>(globalData, codeBlock));
 }
+
+}

trunk/Source/JavaScriptCore/runtime/CodeCache.h

@@ -35 +35 @@
 #include <wtf/Forward.h>
 #include <wtf/PassOwnPtr.h>
+#include <wtf/RandomNumber.h>
 #include <wtf/text/WTFString.h>
 
@@ -52 +53 @@
 class SourceProvider;
 
+template <typename KeyType, typename EntryType, int CacheSize> class Thingy {
+    typedef typename HashMap<KeyType, unsigned>::iterator iterator;
+public:
+    Thingy()
+    : m_randomGenerator((static_cast<uint32_t>(randomNumber() * UINT32_MAX)))
+    {
+    }
+    const EntryType* find(const KeyType& key)
+    {
+        iterator result = m_map.find(key);
+        if (result == m_map.end())
+            return 0;
+        return &m_data[result->value].second;
+    }
+    void add(const KeyType& key, const EntryType& value)
+    {
+        iterator result = m_map.find(key);
+        if (result != m_map.end()) {
+            m_data[result->value].second = value;
+            return;
+        }
+        size_t newIndex = m_randomGenerator.getUint32() % CacheSize;
+        if (m_data[newIndex].second)
+            m_map.remove(m_data[newIndex].first);
+        m_map.add(key, newIndex);
+        m_data[newIndex].first = key;
+        m_data[newIndex].second = value;
+        ASSERT(m_map.size() <= CacheSize);
+    }
+private:
+    HashMap<KeyType, unsigned> m_map;
+    FixedArray<std::pair<KeyType, EntryType>, CacheSize> m_data;
+    WeakRandom m_randomGenerator;
+};
+
 class CodeCache {
 public:
@@ -60 +96 @@
     UnlinkedFunctionCodeBlock* getFunctionCodeBlock(JSGlobalData&, UnlinkedFunctionExecutable*, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode, ParserError&);
     UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(JSGlobalData&, const Identifier&, const SourceCode&, ParserError&);
+    void usedFunctionCode(JSGlobalData&, UnlinkedFunctionCodeBlock*);
     ~CodeCache();
 
     enum CodeType { EvalType, ProgramType, FunctionType };
     typedef std::pair<String, unsigned> CodeBlockKey;
-    typedef HashMap<CodeBlockKey, unsigned> CodeBlockIndicesMap;
     typedef std::pair<String, String> GlobalFunctionKey;
-    typedef HashMap<GlobalFunctionKey, unsigned> GlobalFunctionIndicesMap;
 
 private:
@@ -75 +110 @@
     template <class UnlinkedCodeBlockType, class ExecutableType> inline UnlinkedCodeBlockType* getCodeBlock(JSGlobalData&, ExecutableType*, const SourceCode&, JSParserStrictness, DebuggerMode, ProfilerMode, ParserError&);
     CodeBlockKey makeCodeBlockKey(const SourceCode&, CodeType, JSParserStrictness);
-    CodeBlockIndicesMap m_cachedCodeBlockIndices;
     GlobalFunctionKey makeGlobalFunctionKey(const SourceCode&, const String&);
-    GlobalFunctionIndicesMap m_cachedGlobalFunctionIndices;
 
     enum {
         kMaxCodeBlockEntries = 1024,
-        kMaxGlobalFunctionEntries = 1024
+        kMaxGlobalFunctionEntries = 1024,
+        kMaxFunctionCodeBlocks = 1024
     };
 
-    FixedArray<std::pair<CodeBlockKey, Strong<UnlinkedCodeBlock> >, kMaxCodeBlockEntries> m_cachedCodeBlocks;
-    FixedArray<std::pair<GlobalFunctionKey, Strong<UnlinkedFunctionExecutable> >, kMaxGlobalFunctionEntries> m_cachedGlobalFunctions;
-    WeakRandom m_randomGenerator;
+    Thingy<CodeBlockKey, Strong<UnlinkedCodeBlock>, kMaxCodeBlockEntries> m_cachedCodeBlocks;
+    Thingy<GlobalFunctionKey, Strong<UnlinkedFunctionExecutable>, kMaxGlobalFunctionEntries> m_cachedGlobalFunctions;
+    Thingy<UnlinkedFunctionCodeBlock*, Strong<UnlinkedFunctionCodeBlock>, kMaxFunctionCodeBlocks> m_cachedFunctionCode;
 };
 

trunk/Source/JavaScriptCore/runtime/Executable.cpp

@@ -621 +621 @@
 }
 
-void FunctionExecutable::clearUnlinkedCodeIfNotCompiling()
+void FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling()
 {
     if (isCompiling())
         return;
-    m_unlinkedExecutable->clearCode();
+    m_unlinkedExecutable->clearCodeForRecompilation();
 }
 
@@ -632 +632 @@
     m_codeBlockForCall.clear();
     m_codeBlockForConstruct.clear();
-    m_unlinkedExecutable->clearCode();
     Base::clearCode();
 }

trunk/Source/JavaScriptCore/runtime/Executable.h

@@ -705 +705 @@
 
         void clearCodeIfNotCompiling();
-        void clearUnlinkedCodeIfNotCompiling();
+        void clearUnlinkedCodeForRecompilationIfNotCompiling();
         static void visitChildren(JSCell*, SlotVisitor&);
         static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue proto)