Changeset 262362 in webkit

Timestamp:

May 31, 2020 7:56:06 AM (4 years ago)

Author:

msaboff@apple.com

Message:

Consider a Thread Specific Cache for AssemblerBuffers
​https://bugs.webkit.org/show_bug.cgi?id=212562

Reviewed by Filip Pizlo.

This patch creates a thread local cache of AssemblerData in the hopes that it will reduce
memory allocation churn. The cache is cleared when a thread is destroyed.
If an AssemblerData is destroyed in another thread, its storage is cached by the
destroying thread.

Made a few changes described below to facilite the swap as well as returning a
clear()'ed AssemblerData back to its original state.

Reviewed by Filip Pizlo.

• assembler/AssemblerBuffer.cpp:

(JSC::threadSpecificAssemblerData):
(JSC::clearAssembleDataThreadSpecificCache):

• assembler/AssemblerBuffer.h:

(JSC::AssemblerData::AssemblerData):
(JSC::AssemblerData::operator=):
The copy constructor and assignment operator now perform complete AssemblerBuffer swaps.

(JSC::AssemblerData::takeBufferIfLarger):
A new method that will conditionally copy the enclosed buffer of the argument to "this"
if the argument's buffer is larger than the current buffer of "this".

(JSC::AssemblerData::~AssemblerData):
(JSC::AssemblerData::clear):
The destructor now calls clear which has been changed to reset the buffer to one with
inline capacity.

(JSC::AssemblerBuffer::AssemblerBuffer):
Take the cached out of line buffer if there is one.

(JSC::AssemblerBuffer::~AssemblerBuffer):
Cache the enclosed out of line buffer if it is larger than the currently cached one.

(JSC::AssemblerBuffer::getThreadSpecificAssemblerData):

• dfg/DFGWorklist.cpp:
• jit/JITWorklist.cpp:
• wasm/WasmWorklist.cpp:

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• assembler/AssemblerBuffer.cpp (modified) (1 diff)
• assembler/AssemblerBuffer.h (modified) (5 diffs)
• dfg/DFGWorklist.cpp (modified) (1 diff)
• jit/JITWorklist.cpp (modified) (1 diff)
• wasm/WasmWorklist.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2020-05-31  Michael Saboff  <msaboff@apple.com>
+
+        Consider a Thread Specific Cache for AssemblerBuffers
+        https://bugs.webkit.org/show_bug.cgi?id=212562
+
+        Reviewed by Filip Pizlo.
+
+        This patch creates a thread local cache of AssemblerData in the hopes that it will reduce
+        memory allocation churn.  The cache is cleared when a thread is destroyed.
+        If an AssemblerData is destroyed in another thread, its storage is cached by the
+        destroying thread.
+
+        Made a few changes described below to facilite the swap as well as returning a
+        clear()'ed AssemblerData back to its original state.
+
+        Reviewed by Filip Pizlo.
+
+        * assembler/AssemblerBuffer.cpp:
+        (JSC::threadSpecificAssemblerData):
+        (JSC::clearAssembleDataThreadSpecificCache):
+        * assembler/AssemblerBuffer.h:
+
+        (JSC::AssemblerData::AssemblerData):
+        (JSC::AssemblerData::operator=):
+        The copy constructor and assignment operator now perform complete AssemblerBuffer swaps.
+
+        (JSC::AssemblerData::takeBufferIfLarger):
+        A new method that will conditionally copy the enclosed buffer of the argument to "this"
+        if the argument's buffer is larger than the current buffer of "this".
+
+        (JSC::AssemblerData::~AssemblerData):
+        (JSC::AssemblerData::clear):
+        The destructor now calls clear which has been changed to reset the buffer to one with
+        inline capacity.
+
+        (JSC::AssemblerBuffer::AssemblerBuffer):
+        Take the cached out of line buffer if there is one.
+
+        (JSC::AssemblerBuffer::~AssemblerBuffer):
+        Cache the enclosed out of line buffer if it is larger than the currently cached one.
+
+        (JSC::AssemblerBuffer::getThreadSpecificAssemblerData):
+        * dfg/DFGWorklist.cpp:
+        * jit/JITWorklist.cpp:
+        * wasm/WasmWorklist.cpp:
+
 2020-05-31  Mark Lam  <mark.lam@apple.com>
 

trunk/Source/JavaScriptCore/assembler/AssemblerBuffer.cpp

@@ -31 +31 @@
 DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AssemblerData);
 
+#if ENABLE(ASSEMBLER)
+
+static ThreadSpecificAssemblerData* threadSpecificAssemblerDataPtr;
+
+ThreadSpecificAssemblerData& threadSpecificAssemblerData()
+{
+    static std::once_flag flag;
+    std::call_once(
+        flag,
+        [] () {
+            threadSpecificAssemblerDataPtr = new ThreadSpecificAssemblerData();
+        });
+    return *threadSpecificAssemblerDataPtr;
+}
+
+void clearAssembleDataThreadSpecificCache()
+{
+    auto& threadSpecific = threadSpecificAssemblerData();
+    if (threadSpecific.isSet())
+        threadSpecific->clear();
+}
+
+#endif // ENABLE(ASSEMBLER)
+
 } // namespace JSC

trunk/Source/JavaScriptCore/assembler/AssemblerBuffer.h

@@ -38 +38 @@
 #endif
 #include <wtf/StdLibExtras.h>
+#include <wtf/ThreadSpecific.h>
 #include <wtf/UnalignedAccess.h>
 
 namespace JSC {
+    class AssemblerData;
+
+    typedef ThreadSpecific<AssemblerData, WTF::CanBeGCThread::True> ThreadSpecificAssemblerData;
+
+    JS_EXPORT_PRIVATE ThreadSpecificAssemblerData& threadSpecificAssemblerData();
+    void clearAssembleDataThreadSpecificCache();
 
     class LinkBuffer;
@@ -100 +107 @@
             m_capacity = other.m_capacity;
 
-            other.m_buffer = nullptr;
-            other.m_capacity = 0;
+            other.m_buffer = other.m_inlineBuffer;
+            other.m_capacity = InlineCapacity;
         }
 
@@ -117 +124 @@
             m_capacity = other.m_capacity;
 
-            other.m_buffer = nullptr;
-            other.m_capacity = 0;
+            other.m_buffer = other.m_inlineBuffer;
+            other.m_capacity = InlineCapacity;
             return *this;
         }
 
-        ~AssemblerData()
-        {
+        void takeBufferIfLarger(AssemblerData&& other)
+        {
+            if (other.isInlineBuffer())
+                return;
+
+            if (m_capacity >= other.m_capacity)
+                return;
+
             if (m_buffer && !isInlineBuffer())
                 AssemblerDataMalloc::free(m_buffer);
+
+            m_buffer = other.m_buffer;
+            m_capacity = other.m_capacity;
+
+            other.m_buffer = other.m_inlineBuffer;
+            other.m_capacity = InlineCapacity;
+        }
+
+        ~AssemblerData()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            if (m_buffer && !isInlineBuffer()) {
+                AssemblerDataMalloc::free(m_buffer);
+                m_capacity = InlineCapacity;
+                m_buffer = m_inlineBuffer;
+            }
         }
 
@@ -178 +211 @@
             , m_index(0)
         {
+            auto& threadSpecific = getThreadSpecificAssemblerData();
+            m_storage.takeBufferIfLarger(WTFMove(*threadSpecific));
+        }
+
+        ~AssemblerBuffer()
+        {
+            auto& threadSpecific = getThreadSpecificAssemblerData();
+            threadSpecific->takeBufferIfLarger(WTFMove(m_storage));
         }
 
@@ -294 +335 @@
 
     protected:
+        ThreadSpecificAssemblerData& getThreadSpecificAssemblerData()
+        {
+            auto& threadSpecific = threadSpecificAssemblerData();
+
+            if (!threadSpecific.isSet()) {
+                void* ptr = static_cast<AssemblerData*>(threadSpecific);
+                new (ptr) AssemblerData();
+            }
+
+            return threadSpecific;
+        }
+        
         template<typename IntegralType>
         void putIntegral(IntegralType value)

trunk/Source/JavaScriptCore/dfg/DFGWorklist.cpp

@@ -159 +159 @@
         ASSERT(!m_plan);
         
+        clearAssembleDataThreadSpecificCache();
         m_compilationScope = nullptr;
         m_plan = nullptr;

trunk/Source/JavaScriptCore/jit/JITWorklist.cpp

@@ -145 +145 @@
         m_worklist.m_numAvailableThreads++;
         return WorkResult::Continue;
+    }
+
+    void threadIsStopping(const AbstractLocker&) final
+    {
+        clearAssembleDataThreadSpecificCache();
     }
 

trunk/Source/JavaScriptCore/wasm/WasmWorklist.cpp

@@ -121 +121 @@
     {
         clearLLIntThreadSpecificCache();
+        clearAssembleDataThreadSpecificCache();
     }