Refactor RegionTree

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PageMemory_h
 #define PageMemory_h
 
 #include "platform/heap/HeapPage.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/PageAllocator.h"
 
 #if OS(POSIX)
 #include <sys/mman.h>
 #include <unistd.h>
 #endif
 
 namespace blink {
 
+class RegionTree;
+class RegionTreeNode;
+
 class MemoryRegion {
     USING_FAST_MALLOC(MemoryRegion);
 public:
     MemoryRegion(Address base, size_t size)
         : m_base(base)
         , m_size(size)
     {
         ASSERT(size > 0);
     }
 
@@ skipping 35 matching lines @@
     {
         ASSERT(!m_inUse[index(page)]);
         m_inUse[index(page)] = true;
     }
 
     void markPageUnused(Address page)
     {
         m_inUse[index(page)] = false;
     }
 
-    static PageMemoryRegion* allocateLargePage(size_t size)
+    static PageMemoryRegion* allocateLargePage(size_t size, RegionTree* regionTree)
     {
-        return allocate(size, 1);
+        return allocate(size, 1, regionTree);
     }
 
-    static PageMemoryRegion* allocateNormalPages()
+    static PageMemoryRegion* allocateNormalPages(RegionTree* regionTree)
     {
-        return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion);
+        return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion, regionTree);
     }
 
     BasePage* pageFromAddress(Address address)
     {
         ASSERT(contains(address));
         if (!m_inUse[index(address)])
             return nullptr;
         if (m_isLargePage)
             return pageFromObject(base());
         return pageFromObject(address);
     }
 
 private:
-    PageMemoryRegion(Address base, size_t, unsigned numPages);
+    PageMemoryRegion(Address base, size_t, unsigned numPages, RegionTree*);
 
     unsigned index(Address address) const
     {
         ASSERT(contains(address));
         if (m_isLargePage)
             return 0;
         size_t offset = blinkPageAddress(address) - base();
         ASSERT(offset % blinkPageSize == 0);
         return offset / blinkPageSize;
     }
 
-    static PageMemoryRegion* allocate(size_t, unsigned numPages);
+    static PageMemoryRegion* allocate(size_t, unsigned numPages, RegionTree*);
 
     const bool m_isLargePage;
     // A thread owns a page, but not a region. Represent the in-use
     // bitmap such that thread non-interference comes for free.
     bool m_inUse[blinkPagesPerRegion];
     int m_numPages;
+    RegionTree* m_regionTree;
 };
 
 // A RegionTree is a simple binary search tree of PageMemoryRegions sorted
 // by base addresses.
 class RegionTree {
     USING_FAST_MALLOC(RegionTree);
 public:
-    explicit RegionTree(PageMemoryRegion* region)
+    RegionTree() : m_root(nullptr) { }
+
+    void add(PageMemoryRegion*);
+    void remove(PageMemoryRegion*);
+    PageMemoryRegion* lookup(Address);
+
+private:
+    Mutex m_mutex;
+    RegionTreeNode* m_root;
+};
+
+class RegionTreeNode {
+    USING_FAST_MALLOC(RegionTreeNode);
+public:
+    explicit RegionTreeNode(PageMemoryRegion* region)
         : m_region(region)
         , m_left(nullptr)
         , m_right(nullptr)
     {
     }
 
-    ~RegionTree()
+    ~RegionTreeNode()
     {
         delete m_left;
         delete m_right;
     }
 
-    PageMemoryRegion* lookup(Address);
-    static void add(RegionTree*, RegionTree**);
-    static void remove(PageMemoryRegion*, RegionTree**);
+    void addTo(RegionTreeNode** context);
 
 private:
     PageMemoryRegion* m_region;
-    RegionTree* m_left;
-    RegionTree* m_right;
+    RegionTreeNode* m_left;
+    RegionTreeNode* m_right;
 
-    static RegionTree* s_regionTree;
+    friend RegionTree;
 };
 
 // Representation of the memory used for a Blink heap page.
 //
 // The representation keeps track of two memory regions:
 //
 // 1. The virtual memory reserved from the system in order to be able
 //    to free all the virtual memory reserved.  Multiple PageMemory
 //    instances can share the same reserved memory region and
 //    therefore notify the reserved memory region on destruction so
@@ skipping 34 matching lines @@
     static PageMemory* setupPageMemoryInRegion(PageMemoryRegion*, size_t pageOffset, size_t payloadSize);
 
     // Allocate a virtual address space for one blink page with the
     // following layout:
     //
     //    [ guard os page | ... payload ... | guard os page ]
     //    ^---{ aligned to blink page size }
     //
     // The returned page memory region will be zeroed.
     //
-    static PageMemory* allocate(size_t payloadSize);
+    static PageMemory* allocate(size_t payloadSize, RegionTree*);
 
 private:
     PageMemory(PageMemoryRegion* reserved, const MemoryRegion& writable);
 
     PageMemoryRegion* m_reserved;
     MemoryRegion m_writable;
 };
 
 } // namespace blink
 
 #endif