Changeset 219281 in webkit

Timestamp:

Jul 9, 2017, 5:22:58 AM (8 years ago)

Author:

Yusuke Suzuki

Message:

[JSC] Use fastMalloc / fastFree for STL containers
​https://bugs.webkit.org/show_bug.cgi?id=174297

Reviewed by Sam Weinig.

Source/JavaScriptCore:

In some places, we intentionally use STL containers over WTF containers.
For example, we sometimes use std::unordered_{set,map} instead of WTF::Hash{Set,Map}
because we do not have effective empty / deleted representations in the space of key's value.
But just using STL container means using libc's malloc instead of our fast malloc (bmalloc if it is enabled).

We introduce WTF::FastAllocator. This is C++ allocator implementation using fastMalloc and fastFree.
We specify this allocator to STL containers' template parameter to allocate memory from fastMalloc.

This WTF::FastAllocator gives us a chance to use STL containers if it is necessary
without compromising memory allocation throughput.

• dfg/DFGGraph.h:
• dfg/DFGIntegerCheckCombiningPhase.cpp:
• ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::switchStringSlow):

• runtime/FunctionHasExecutedCache.h:
• runtime/TypeLocationCache.h:

Source/WTF:

• wtf/FastMalloc.h:

(WTF::FastAllocator::FastAllocator):
(WTF::FastAllocator::allocate):
(WTF::FastAllocator::deallocate):
(WTF::FastAllocator::operator==):
(WTF::FastAllocator::operator!=):

Location:

trunk/Source

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/dfg/DFGGraph.h (modified) (1 diff)
• JavaScriptCore/dfg/DFGIntegerCheckCombiningPhase.cpp (modified) (1 diff)
• JavaScriptCore/ftl/FTLLowerDFGToB3.cpp (modified) (1 diff)
• JavaScriptCore/runtime/FunctionHasExecutedCache.h (modified) (1 diff)
• JavaScriptCore/runtime/TypeLocationCache.h (modified) (2 diffs)
• WTF/ChangeLog (modified) (1 diff)
• WTF/wtf/FastMalloc.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2017-07-09  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        [JSC] Use fastMalloc / fastFree for STL containers
+        https://bugs.webkit.org/show_bug.cgi?id=174297
+
+        Reviewed by Sam Weinig.
+
+        In some places, we intentionally use STL containers over WTF containers.
+        For example, we sometimes use std::unordered_{set,map} instead of WTF::Hash{Set,Map}
+        because we do not have effective empty / deleted representations in the space of key's value.
+        But just using STL container means using libc's malloc instead of our fast malloc (bmalloc if it is enabled).
+
+        We introduce WTF::FastAllocator. This is C++ allocator implementation using fastMalloc and fastFree.
+        We specify this allocator to STL containers' template parameter to allocate memory from fastMalloc.
+
+        This WTF::FastAllocator gives us a chance to use STL containers if it is necessary
+        without compromising memory allocation throughput.
+
+        * dfg/DFGGraph.h:
+        * dfg/DFGIntegerCheckCombiningPhase.cpp:
+        * ftl/FTLLowerDFGToB3.cpp:
+        (JSC::FTL::DFG::LowerDFGToB3::switchStringSlow):
+        * runtime/FunctionHasExecutedCache.h:
+        * runtime/TypeLocationCache.h:
+
 2017-07-08  Yusuke Suzuki  <utatane.tea@gmail.com>
 

trunk/Source/JavaScriptCore/dfg/DFGGraph.h

@@ -998 +998 @@
 
 #if USE(JSVALUE32_64)
-    std::unordered_map<int64_t, double*> m_doubleConstantsMap;
+    std::unordered_map<int64_t, double*, std::hash<int64_t>, std::equal_to<int64_t>, FastAllocator<std::pair<const int64_t, double*>>> m_doubleConstantsMap;
     std::unique_ptr<Bag<double>> m_doubleConstants;
 #endif

trunk/Source/JavaScriptCore/dfg/DFGIntegerCheckCombiningPhase.cpp

@@ -397 +397 @@
     }
     
-    typedef std::unordered_map<RangeKey, Range, HashMethod<RangeKey>> RangeMap;
+    using RangeMap = std::unordered_map<RangeKey, Range, HashMethod<RangeKey>, std::equal_to<RangeKey>, FastAllocator<std::pair<const RangeKey, Range>>>;
     RangeMap m_map;
     

trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

@@ -11850 +11850 @@
         
         Vector<SwitchCase> cases;
-        std::unordered_set<int32_t> alreadyHandled; // These may be negative, or zero, or probably other stuff, too. We don't want to mess with HashSet's corner cases and we don't really care about throughput here.
+        // These may be negative, or zero, or probably other stuff, too. We don't want to mess with HashSet's corner cases and we don't really care about throughput here.
+        std::unordered_set<int32_t, std::hash<int32_t>, std::equal_to<int32_t>, FastAllocator<int32_t>> alreadyHandled;
         for (unsigned i = 0; i < data->cases.size(); ++i) {
             // FIXME: The fact that we're using the bytecode's switch table means that the

trunk/Source/JavaScriptCore/runtime/FunctionHasExecutedCache.h

@@ -54 +54 @@
     Vector<std::tuple<bool, unsigned, unsigned>> getFunctionRanges(intptr_t id);
 
-private:     
-    typedef std::unordered_map<FunctionRange, bool, HashMethod<FunctionRange>> RangeMap;
-    typedef std::unordered_map<intptr_t, RangeMap> SourceIDToRangeMap;
+private:
+    using RangeMap = std::unordered_map<FunctionRange, bool, HashMethod<FunctionRange>, std::equal_to<FunctionRange>, FastAllocator<std::pair<const FunctionRange, bool>>>;
+    using SourceIDToRangeMap = std::unordered_map<intptr_t, RangeMap, std::hash<intptr_t>, std::equal_to<intptr_t>, FastAllocator<std::pair<const intptr_t, RangeMap>>>;
     SourceIDToRangeMap m_rangeMap;
 };

trunk/Source/JavaScriptCore/runtime/TypeLocationCache.h

@@ -28 +28 @@
 #include "TypeLocation.h"
 #include <unordered_map>
+#include <wtf/FastMalloc.h>
 #include <wtf/HashMethod.h>
 
@@ -58 +59 @@
 
     std::pair<TypeLocation*, bool> getTypeLocation(GlobalVariableID, intptr_t, unsigned start, unsigned end, RefPtr<TypeSet>&&, VM*);
-private:     
-    typedef std::unordered_map<LocationKey, TypeLocation*, HashMethod<LocationKey>> LocationMap;
+private:
+    using LocationMap = std::unordered_map<LocationKey, TypeLocation*, HashMethod<LocationKey>, std::equal_to<LocationKey>, FastAllocator<std::pair<const LocationKey, TypeLocation*>>>;
     LocationMap m_locationMap;
 };

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2017-07-09  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        [JSC] Use fastMalloc / fastFree for STL containers
+        https://bugs.webkit.org/show_bug.cgi?id=174297
+
+        Reviewed by Sam Weinig.
+
+        * wtf/FastMalloc.h:
+        (WTF::FastAllocator::FastAllocator):
+        (WTF::FastAllocator::allocate):
+        (WTF::FastAllocator::deallocate):
+        (WTF::FastAllocator::operator==):
+        (WTF::FastAllocator::operator!=):
+
 2017-07-07  Brent Fulgham  <bfulgham@apple.com>
 

trunk/Source/WTF/wtf/FastMalloc.h

@@ -105 +105 @@
 }
 
+// C++ STL allocator implementation. You can integrate fastMalloc into STL containers.
+// e.g. std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>, FastAllocator<std::pair<const Key, Value>>>.
+template<typename T>
+class FastAllocator {
+public:
+    using value_type = T;
+
+    FastAllocator() = default;
+
+    template<typename U> FastAllocator(const FastAllocator<U>&) { }
+
+    T* allocate(size_t count)
+    {
+        return reinterpret_cast<T*>(fastMalloc(sizeof(T) * count));
+    }
+
+    void deallocate(T* pointer, size_t)
+    {
+        fastFree(pointer);
+    }
+
+    template<typename U> bool operator==(const FastAllocator<U>&) { return true; }
+
+    template<typename U> bool operator!=(const FastAllocator<U>&) { return false; }
+};
+
 } // namespace WTF
 
@@ -126 +152 @@
 using WTF::fastAlignedMalloc;
 using WTF::fastAlignedFree;
+using WTF::FastAllocator;
 
 #if COMPILER(GCC_OR_CLANG) && OS(DARWIN)