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 55 matching lines @@
     BasePage* pageFromAddress(Address address)
     {
         ASSERT(contains(address));
         if (!m_inUse[index(address)])
             return nullptr;
         if (m_isLargePage)
             return pageFromObject(base());
         return pageFromObject(address);
     }
 
+    void setRegionTree(RegionTree* tree) { m_regionTree = tree; }
+    RegionTree* getRegionTree() const { return m_regionTree; }

[haraken, 2016/03/15 05:49:50]

Is this used?

[keishi, 2016/03/15 07:48:43]

Removed.

+
 private:
     PageMemoryRegion(Address base, size_t, unsigned numPages);
 
     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);
 
     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 46 matching lines @@
 private:
     PageMemory(PageMemoryRegion* reserved, const MemoryRegion& writable);
 
     PageMemoryRegion* m_reserved;
     MemoryRegion m_writable;
 };
 
 } // namespace blink
 
 #endif