Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/HeapPage.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #ifndef HeapPage_h
 #define HeapPage_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/BlinkGC.h"
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/AddressSanitizer.h"
+#include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
 #include "wtf/ContainerAnnotations.h"
 #include "wtf/Forward.h"
 #include "wtf/PageAllocator.h"
 #include <stdint.h>
 
 namespace blink {
 
 const size_t blinkPageSizeLog2 = 17;
@@ skipping 108 matching lines @@
 // On free-list entries we reuse the dead bit to distinguish a normal free-list
 // entry from one that has been promptly freed.
 const size_t headerPromptlyFreedBitMask = headerFreedBitMask | headerDeadBitMask;
 const size_t largeObjectSizeInHeader = 0;
 const size_t gcInfoIndexForFreeListHeader = 0;
 const size_t nonLargeObjectPageSizeMax = 1 << 17;
 
 static_assert(nonLargeObjectPageSizeMax >= blinkPageSize, "max size supported by HeapObjectHeader must at least be blinkPageSize");
 
 class PLATFORM_EXPORT HeapObjectHeader {
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     // If gcInfoIndex is 0, this header is interpreted as a free list header.
     NO_SANITIZE_ADDRESS
     HeapObjectHeader(size_t size, size_t gcInfoIndex)
     {
 #if ENABLE(ASSERT)
         m_magic = magic;
 #endif
         // sizeof(HeapObjectHeader) must be equal to or smaller than
         // allocationGranurarity, because HeapObjectHeader is used as a header
@@ skipping 163 matching lines @@
 //   multiple objects in the page. An object whose size is smaller than
 //   |largeObjectSizeThreshold| is stored in NormalPage.
 //
 // - LargeObjectPage is a page that contains only one object. The object size
 //   is arbitrary. An object whose size is larger than |blinkPageSize| is stored
 //   as a single project in LargeObjectPage.
 //
 // Note: An object whose size is between |largeObjectSizeThreshold| and
 // |blinkPageSize| can go to either of NormalPage or LargeObjectPage.
 class BasePage {
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     BasePage(PageMemory*, BaseHeap*);
     virtual ~BasePage() { }
 
     void link(BasePage** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
     void unlink(BasePage** previousNext)
@@ skipping 206 matching lines @@
 // is a cache of 'pages' that have previously been determined to be wholly
 // outside of the heap.  The size of these pages must be smaller than the
 // allocation alignment of the heap pages.  We determine off-heap-ness by
 // rounding down the pointer to the nearest page and looking up the page in the
 // cache.  If there is a miss in the cache we can determine the status of the
 // pointer precisely using the heap RegionTree.
 //
 // The HeapDoesNotContainCache is a negative cache, so it must be flushed when
 // memory is added to the heap.
 class HeapDoesNotContainCache {
+    USING_FAST_MALLOC(HeapDoesNotContainCache);
 public:
-    HeapDoesNotContainCache()
-        : m_entries(adoptArrayPtr(new Address[HeapDoesNotContainCache::numberOfEntries]))
-        , m_hasEntries(false)
+    static HeapDoesNotContainCache* create()
     {
-        // Start by flushing the cache in a non-empty state to initialize all the cache entries.
-        for (int i = 0; i < numberOfEntries; ++i)
-            m_entries[i] = nullptr;
+        size_t size = sizeof(HeapDoesNotContainCache) + sizeof(Address) * HeapDoesNotContainCache::numberOfEntries;

[haraken, 2016/01/20 10:52:27]

Can we use a Vector?

[tasak, 2016/01/21 04:37:46]

Yes... but I think, it's too much, because m_entries is just an array.
m_entries' size will be never changed dynamically.

[haraken, 2016/01/21 04:52:57]

Then can we write something like:

class HeapDoesNotContainCache {
  Address m_entries[numberOfEntries];
};

?

(It looks a bit nasty to use a placement new.)

[tasak, 2016/01/26 02:54:45]

I see. Sure. Done.

+        HeapDoesNotContainCache* cache = static_cast<HeapDoesNotContainCache*>(WTF::Partitions::fastMalloc(size, "HeapDoesNotContainCache"));
+        return new (cache) HeapDoesNotContainCache(reinterpret_cast<Address*>(cache + 1));
     }
 
     void flush();
     bool isEmpty() { return !m_hasEntries; }
 
     // Perform a lookup in the cache.
     //
     // If lookup returns false, the argument address was not found in
     // the cache and it is unknown if the address is in the Blink
     // heap.
     //
     // If lookup returns true, the argument address was found in the
     // cache which means the address is not in the heap.
     PLATFORM_EXPORT bool lookup(Address);
 
     // Add an entry to the cache.
     PLATFORM_EXPORT void addEntry(Address);
 
 private:
+    HeapDoesNotContainCache() = delete;
+    HeapDoesNotContainCache(Address* entries)
+        : m_entries(entries)
+        , m_hasEntries(false)
+    {
+        // Start by flushing the cache in a non-empty state to initialize all the cache entries.
+        for (int i = 0; i < numberOfEntries; ++i)
+            m_entries[i] = nullptr;
+    }
+
     static const int numberOfEntriesLog2 = 12;
     static const int numberOfEntries = 1 << numberOfEntriesLog2;
 
     static size_t hash(Address);
 
-    WTF::OwnPtr<Address[]> m_entries;
+    Address* m_entries;
     bool m_hasEntries;
 };
 
 class FreeList {
+    DISALLOW_NEW();
 public:
     FreeList();
 
     void addToFreeList(Address, size_t);
     void clear();
 
     // Returns a bucket number for inserting a FreeListEntry of a given size.
     // All FreeListEntries in the given bucket, n, have size >= 2^n.
     static int bucketIndexForSize(size_t);
 
@@ skipping 15 matching lines @@
 };
 
 // Each thread has a number of thread heaps (e.g., Generic heaps,
 // typed heaps for Node, heaps for collection backings etc)
 // and BaseHeap represents each thread heap.
 //
 // BaseHeap is a parent class of NormalPageHeap and LargeObjectHeap.
 // NormalPageHeap represents a heap that contains NormalPages
 // and LargeObjectHeap represents a heap that contains LargeObjectPages.
 class PLATFORM_EXPORT BaseHeap {
+    USING_FAST_MALLOC(BaseHeap);
 public:
     BaseHeap(ThreadState*, int);
     virtual ~BaseHeap();
     void cleanupPages();
 
     void takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo&);
 #if ENABLE(ASSERT)
     BasePage* findPageFromAddress(Address);
 #endif
     virtual void takeFreelistSnapshot(const String& dumpBaseName) { }
@@ skipping 215 matching lines @@
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h