[JSC] Use fastMalloc / fastFree for STL containers
authorutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 9 Jul 2017 12:22:58 +0000 (12:22 +0000)
committerutatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 9 Jul 2017 12:22:58 +0000 (12:22 +0000)
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!=):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@219281 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/dfg/DFGGraph.h
Source/JavaScriptCore/dfg/DFGIntegerCheckCombiningPhase.cpp
Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
Source/JavaScriptCore/runtime/FunctionHasExecutedCache.h
Source/JavaScriptCore/runtime/TypeLocationCache.h
Source/WTF/ChangeLog
Source/WTF/wtf/FastMalloc.h

index dd49d12..038c584 100644 (file)
@@ -1,3 +1,28 @@
+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>
 
         Drop NOSNIFF compile flag
index e7e2906..66ca511 100644 (file)
@@ -997,7 +997,7 @@ public:
     HashMap<const StringImpl*, String> m_copiedStrings;
 
 #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
     
index fc417d7..5d1cbc7 100644 (file)
@@ -396,7 +396,7 @@ private:
                 nodeIndex, origin, jsNumber(addend), source.useKind()));
     }
     
-    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;
     
     InsertionSet m_insertionSet;
index da6a8a9..d2cc23a 100644 (file)
@@ -11849,7 +11849,8 @@ private:
         StringJumpTable& table = codeBlock()->stringSwitchJumpTable(data->switchTableIndex);
         
         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
             // following DFG IR transformation would be invalid.
index 2c2521c..bba9043 100644 (file)
@@ -53,9 +53,9 @@ public:
     void removeUnexecutedRange(intptr_t id, unsigned start, unsigned end);
     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;
 };
 
index 008ef73..d948411 100644 (file)
@@ -27,6 +27,7 @@
 
 #include "TypeLocation.h"
 #include <unordered_map>
+#include <wtf/FastMalloc.h>
 #include <wtf/HashMethod.h>
 
 namespace JSC {
@@ -57,8 +58,8 @@ public:
     };
 
     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;
 };
 
index 0211a20..6ff5909 100644 (file)
@@ -1,3 +1,17 @@
+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>
 
         [WK2] Use a rolling 30-day uptime for processing statistics
index 525f9cb..d110fa2 100644 (file)
@@ -104,6 +104,32 @@ template<typename T> inline bool TryMallocReturnValue::getValue(T*& data)
     return data;
 }
 
+// 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
 
 #if !defined(NDEBUG)
@@ -125,6 +151,7 @@ using WTF::tryFastMalloc;
 using WTF::tryFastZeroedMalloc;
 using WTF::fastAlignedMalloc;
 using WTF::fastAlignedFree;
+using WTF::FastAllocator;
 
 #if COMPILER(GCC_OR_CLANG) && OS(DARWIN)
 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))