bmalloc: Use a separate zone when using system malloc
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2017 23:39:09 +0000 (23:39 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2017 23:39:09 +0000 (23:39 +0000)
https://bugs.webkit.org/show_bug.cgi?id=167014

Reviewed by Filip Pizlo.

Harris asked for this so he could separate Safari and WebKit memory use
when doing memory analysis.

This patch adds an explicit DebugHeap class that contains all our
code for specialized allocation with debugging.

* bmalloc.xcodeproj/project.pbxproj:

* bmalloc/Allocator.cpp:
(bmalloc::Allocator::Allocator):
(bmalloc::Allocator::tryAllocate):
(bmalloc::Allocator::allocateImpl):
(bmalloc::Allocator::reallocate):
(bmalloc::Allocator::allocateSlowCase):
* bmalloc/Allocator.h: Forward to DebugHeap instead of inlining all the
code. This is required for our new interface, and it is also a nice
simplification that moves some not-very-important code out of the way.

* bmalloc/Deallocator.cpp:
(bmalloc::Deallocator::Deallocator):
(bmalloc::Deallocator::scavenge):
(bmalloc::Deallocator::deallocateSlowCase):
* bmalloc/Deallocator.h: Ditto.

* bmalloc/DebugHeap.cpp: Added.
(bmalloc::DebugHeap::DebugHeap):
(bmalloc::DebugHeap::malloc):
(bmalloc::DebugHeap::memalign):
(bmalloc::DebugHeap::realloc):
(bmalloc::DebugHeap::free):
* bmalloc/DebugHeap.h: Added. New class for overriding normal heap
behavior. Right now, it just adds a malloc zone and then forwards to
system malloc -- but we can add lots more kinds of debug heaps in the
future if we find them useful.

* bmalloc/Environment.cpp:
(bmalloc::Environment::Environment):
(bmalloc::Environment::computeIsDebugHeapEnabled):
(bmalloc::Environment::computeIsBmallocEnabled): Deleted.
* bmalloc/Environment.h:
(bmalloc::Environment::isDebugHeapEnabled):
(bmalloc::Environment::isBmallocEnabled): Deleted. Renamed everything to
reflect our new use of DebugHeap.

* bmalloc/Heap.cpp:
(bmalloc::Heap::Heap):
* bmalloc/Heap.h:
(bmalloc::Heap::debugHeap): Updated to use DebugHeap.
(bmalloc::Heap::environment): Deleted.

* bmalloc/bmalloc.h:
(bmalloc::api::isEnabled): Updated to use DebugHeap.

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

14 files changed:
Source/bmalloc/CMakeLists.txt
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc.xcodeproj/project.pbxproj
Source/bmalloc/bmalloc/Allocator.cpp
Source/bmalloc/bmalloc/Allocator.h
Source/bmalloc/bmalloc/Deallocator.cpp
Source/bmalloc/bmalloc/Deallocator.h
Source/bmalloc/bmalloc/DebugHeap.cpp [new file with mode: 0644]
Source/bmalloc/bmalloc/DebugHeap.h [new file with mode: 0644]
Source/bmalloc/bmalloc/Environment.cpp
Source/bmalloc/bmalloc/Environment.h
Source/bmalloc/bmalloc/Heap.cpp
Source/bmalloc/bmalloc/Heap.h
Source/bmalloc/bmalloc/bmalloc.h

index a3a04e7..7e3139a 100644 (file)
@@ -8,6 +8,7 @@ set(bmalloc_SOURCES
     bmalloc/Allocator.cpp
     bmalloc/Cache.cpp
     bmalloc/Deallocator.cpp
+    bmalloc/DebugHeap.cpp
     bmalloc/Environment.cpp
     bmalloc/Heap.cpp
     bmalloc/LargeMap.cpp
index e192be7..525dd6a 100644 (file)
@@ -1,3 +1,63 @@
+2017-01-13  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: Use a separate zone when using system malloc
+        https://bugs.webkit.org/show_bug.cgi?id=167014
+
+        Reviewed by Filip Pizlo.
+
+        Harris asked for this so he could separate Safari and WebKit memory use
+        when doing memory analysis.
+
+        This patch adds an explicit DebugHeap class that contains all our
+        code for specialized allocation with debugging.
+
+        * bmalloc.xcodeproj/project.pbxproj:
+
+        * bmalloc/Allocator.cpp:
+        (bmalloc::Allocator::Allocator):
+        (bmalloc::Allocator::tryAllocate):
+        (bmalloc::Allocator::allocateImpl):
+        (bmalloc::Allocator::reallocate):
+        (bmalloc::Allocator::allocateSlowCase):
+        * bmalloc/Allocator.h: Forward to DebugHeap instead of inlining all the
+        code. This is required for our new interface, and it is also a nice
+        simplification that moves some not-very-important code out of the way.
+
+        * bmalloc/Deallocator.cpp:
+        (bmalloc::Deallocator::Deallocator):
+        (bmalloc::Deallocator::scavenge):
+        (bmalloc::Deallocator::deallocateSlowCase):
+        * bmalloc/Deallocator.h: Ditto.
+
+        * bmalloc/DebugHeap.cpp: Added.
+        (bmalloc::DebugHeap::DebugHeap):
+        (bmalloc::DebugHeap::malloc):
+        (bmalloc::DebugHeap::memalign):
+        (bmalloc::DebugHeap::realloc):
+        (bmalloc::DebugHeap::free):
+        * bmalloc/DebugHeap.h: Added. New class for overriding normal heap
+        behavior. Right now, it just adds a malloc zone and then forwards to
+        system malloc -- but we can add lots more kinds of debug heaps in the
+        future if we find them useful.
+
+        * bmalloc/Environment.cpp:
+        (bmalloc::Environment::Environment):
+        (bmalloc::Environment::computeIsDebugHeapEnabled):
+        (bmalloc::Environment::computeIsBmallocEnabled): Deleted.
+        * bmalloc/Environment.h:
+        (bmalloc::Environment::isDebugHeapEnabled):
+        (bmalloc::Environment::isBmallocEnabled): Deleted. Renamed everything to
+        reflect our new use of DebugHeap.
+
+        * bmalloc/Heap.cpp:
+        (bmalloc::Heap::Heap):
+        * bmalloc/Heap.h:
+        (bmalloc::Heap::debugHeap): Updated to use DebugHeap.
+        (bmalloc::Heap::environment): Deleted. 
+
+        * bmalloc/bmalloc.h:
+        (bmalloc::api::isEnabled): Updated to use DebugHeap.
+
 2016-12-15  Myles C. Maxfield  <mmaxfield@apple.com>
 
         Sort Xcode project files
index 1023712..5fe52ba 100644 (file)
@@ -12,6 +12,8 @@
                140FA00319CE429C00FFD3C8 /* BumpRange.h in Headers */ = {isa = PBXBuildFile; fileRef = 140FA00219CE429C00FFD3C8 /* BumpRange.h */; settings = {ATTRIBUTES = (Private, ); }; };
                140FA00519CE4B6800FFD3C8 /* LineMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = 140FA00419CE4B6800FFD3C8 /* LineMetadata.h */; settings = {ATTRIBUTES = (Private, ); }; };
                141D9B001C8E51C0000ABBA0 /* List.h in Headers */ = {isa = PBXBuildFile; fileRef = 141D9AFF1C8E51C0000ABBA0 /* List.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               142B44361E2839E7001DA6E9 /* DebugHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 142B44341E2839E7001DA6E9 /* DebugHeap.cpp */; };
+               142B44371E2839E7001DA6E9 /* DebugHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 142B44351E2839E7001DA6E9 /* DebugHeap.h */; };
                143CB81C19022BC900B16A45 /* StaticMutex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 143CB81A19022BC900B16A45 /* StaticMutex.cpp */; };
                143CB81D19022BC900B16A45 /* StaticMutex.h in Headers */ = {isa = PBXBuildFile; fileRef = 143CB81B19022BC900B16A45 /* StaticMutex.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1440AFCB1A95261100837FAA /* Zone.h in Headers */ = {isa = PBXBuildFile; fileRef = 1440AFCA1A95261100837FAA /* Zone.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -81,6 +83,8 @@
                1417F65218BA88A00076FA3F /* AsyncTask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AsyncTask.h; path = bmalloc/AsyncTask.h; sourceTree = "<group>"; };
                141D9AFF1C8E51C0000ABBA0 /* List.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = List.h; path = bmalloc/List.h; sourceTree = "<group>"; };
                1421A87718EE462A00B4DD68 /* Algorithm.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Algorithm.h; path = bmalloc/Algorithm.h; sourceTree = "<group>"; };
+               142B44341E2839E7001DA6E9 /* DebugHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DebugHeap.cpp; path = bmalloc/DebugHeap.cpp; sourceTree = "<group>"; };
+               142B44351E2839E7001DA6E9 /* DebugHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DebugHeap.h; path = bmalloc/DebugHeap.h; sourceTree = "<group>"; };
                143CB81A19022BC900B16A45 /* StaticMutex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticMutex.cpp; path = bmalloc/StaticMutex.cpp; sourceTree = "<group>"; };
                143CB81B19022BC900B16A45 /* StaticMutex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StaticMutex.h; path = bmalloc/StaticMutex.h; sourceTree = "<group>"; };
                143E29ED18CAE90500FE8A0F /* SmallPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SmallPage.h; path = bmalloc/SmallPage.h; sourceTree = "<group>"; };
                        children = (
                                140FA00219CE429C00FFD3C8 /* BumpRange.h */,
                                147DC6E21CA5B70B00724E8D /* Chunk.h */,
+                               142B44341E2839E7001DA6E9 /* DebugHeap.cpp */,
+                               142B44351E2839E7001DA6E9 /* DebugHeap.h */,
                                14895D8F1A3A319C0006235D /* Environment.cpp */,
                                14895D901A3A319C0006235D /* Environment.h */,
                                14DA320E18875D9F007269E0 /* Heap.cpp */,
                                14DD78CA18F48D7500950702 /* Mutex.h in Headers */,
                                144BE11F1CA346520099C8C0 /* Object.h in Headers */,
                                14DD789318F48D0F00950702 /* ObjectType.h in Headers */,
+                               142B44371E2839E7001DA6E9 /* DebugHeap.h in Headers */,
                                14DD78CB18F48D7500950702 /* PerProcess.h in Headers */,
                                14DD78CC18F48D7500950702 /* PerThread.h in Headers */,
                                14DD78CD18F48D7500950702 /* Range.h in Headers */,
                                14F271C718EA3990008C152F /* Heap.cpp in Sources */,
                                144C07F41C7B70260051BB6A /* LargeMap.cpp in Sources */,
                                4426E2801C838EE0008EB042 /* Logging.cpp in Sources */,
+                               142B44361E2839E7001DA6E9 /* DebugHeap.cpp in Sources */,
                                14F271C818EA3990008C152F /* ObjectType.cpp in Sources */,
                                143CB81C19022BC900B16A45 /* StaticMutex.cpp in Sources */,
                                14F271C918EA3990008C152F /* VMHeap.cpp in Sources */,
index baf3876..9ac72d3 100644 (file)
@@ -27,6 +27,7 @@
 #include "BAssert.h"
 #include "Chunk.h"
 #include "Deallocator.h"
+#include "DebugHeap.h"
 #include "Heap.h"
 #include "PerProcess.h"
 #include "Sizes.h"
@@ -38,7 +39,7 @@ using namespace std;
 namespace bmalloc {
 
 Allocator::Allocator(Heap* heap, Deallocator& deallocator)
-    : m_isBmallocEnabled(heap->environment().isBmallocEnabled())
+    : m_debugHeap(heap->debugHeap())
     , m_deallocator(deallocator)
 {
     for (size_t sizeClass = 0; sizeClass < sizeClassCount; ++sizeClass)
@@ -52,8 +53,8 @@ Allocator::~Allocator()
 
 void* Allocator::tryAllocate(size_t size)
 {
-    if (!m_isBmallocEnabled)
-        return malloc(size);
+    if (m_debugHeap)
+        return m_debugHeap->malloc(size);
 
     if (size <= smallMax)
         return allocate(size);
@@ -78,15 +79,8 @@ void* Allocator::allocateImpl(size_t alignment, size_t size, bool crashOnFailure
 {
     BASSERT(isPowerOfTwo(alignment));
 
-    if (!m_isBmallocEnabled) {
-        void* result = nullptr;
-        if (posix_memalign(&result, alignment, size)) {
-            if (crashOnFailure)
-                BCRASH();
-            return nullptr;
-        }
-        return result;
-    }
+    if (m_debugHeap)
+        return m_debugHeap->memalign(alignment, size, crashOnFailure);
 
     if (!size)
         size = alignment;
@@ -103,12 +97,8 @@ void* Allocator::allocateImpl(size_t alignment, size_t size, bool crashOnFailure
 
 void* Allocator::reallocate(void* object, size_t newSize)
 {
-    if (!m_isBmallocEnabled) {
-        void* result = realloc(object, newSize);
-        if (!result)
-            BCRASH();
-        return result;
-    }
+    if (m_debugHeap)
+        return m_debugHeap->realloc(object, newSize);
 
     size_t oldSize = 0;
     switch (objectType(object)) {
@@ -193,12 +183,8 @@ NO_INLINE void* Allocator::allocateLogSizeClass(size_t size)
 
 void* Allocator::allocateSlowCase(size_t size)
 {
-    if (!m_isBmallocEnabled) {
-        void* result = malloc(size);
-        if (!result)
-            BCRASH();
-        return result;
-    }
+    if (m_debugHeap)
+        return m_debugHeap->malloc(size);
 
     if (size <= maskSizeClassMax) {
         size_t sizeClass = bmalloc::maskSizeClass(size);
index 2757f00..1d5022b 100644 (file)
@@ -32,6 +32,7 @@
 namespace bmalloc {
 
 class Deallocator;
+class DebugHeap;
 class Heap;
 
 // Per-cache object allocator.
@@ -64,7 +65,7 @@ private:
     std::array<BumpAllocator, sizeClassCount> m_bumpAllocators;
     std::array<BumpRangeCache, sizeClassCount> m_bumpRangeCaches;
 
-    bool m_isBmallocEnabled;
+    DebugHeap* m_debugHeap;
     Deallocator& m_deallocator;
 };
 
index c4fba11..56bb4d6 100644 (file)
@@ -26,6 +26,7 @@
 #include "BAssert.h"
 #include "Chunk.h"
 #include "Deallocator.h"
+#include "DebugHeap.h"
 #include "Heap.h"
 #include "Inline.h"
 #include "Object.h"
@@ -39,9 +40,9 @@ using namespace std;
 namespace bmalloc {
 
 Deallocator::Deallocator(Heap* heap)
-    : m_isBmallocEnabled(heap->environment().isBmallocEnabled())
+    : m_debugHeap(heap->debugHeap())
 {
-    if (!m_isBmallocEnabled) {
+    if (m_debugHeap) {
         // Fill the object log in order to disable the fast path.
         while (m_objectLog.size() != m_objectLog.capacity())
             m_objectLog.push(nullptr);
@@ -55,8 +56,10 @@ Deallocator::~Deallocator()
     
 void Deallocator::scavenge()
 {
-    if (m_isBmallocEnabled)
-        processObjectLog();
+    if (m_debugHeap)
+        return;
+
+    processObjectLog();
 }
 
 void Deallocator::processObjectLog(std::lock_guard<StaticMutex>& lock)
@@ -77,10 +80,8 @@ void Deallocator::processObjectLog()
 
 void Deallocator::deallocateSlowCase(void* object)
 {
-    if (!m_isBmallocEnabled) {
-        free(object);
-        return;
-    }
+    if (m_debugHeap)
+        return m_debugHeap->free(object);
 
     if (!object)
         return;
index 7fca956..00b116d 100644 (file)
@@ -31,6 +31,7 @@
 
 namespace bmalloc {
 
+class DebugHeap;
 class Heap;
 class StaticMutex;
 
@@ -52,7 +53,7 @@ private:
     void deallocateSlowCase(void*);
 
     FixedVector<void*, deallocatorLogCapacity> m_objectLog;
-    bool m_isBmallocEnabled;
+    DebugHeap* m_debugHeap;
 };
 
 inline bool Deallocator::deallocateFastCase(void* object)
diff --git a/Source/bmalloc/bmalloc/DebugHeap.cpp b/Source/bmalloc/bmalloc/DebugHeap.cpp
new file mode 100644 (file)
index 0000000..320d814
--- /dev/null
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2016 Apple 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "DebugHeap.h"
+#include "BAssert.h"
+#include "BPlatform.h"
+#include <thread>
+
+namespace bmalloc {
+    
+#if BOS(DARWIN)
+
+DebugHeap::DebugHeap(std::lock_guard<StaticMutex>&)
+    : m_zone(malloc_create_zone(0, 0))
+{
+    malloc_set_zone_name(m_zone, "WebKit Using System Malloc");
+}
+
+void* DebugHeap::malloc(size_t size)
+{
+    void* result = malloc_zone_malloc(m_zone, size);
+    if (!result)
+        BCRASH();
+    return result;
+}
+
+void* DebugHeap::memalign(size_t alignment, size_t size, bool crashOnFailure)
+{
+    void* result = malloc_zone_memalign(m_zone, alignment, size);
+    if (!result && crashOnFailure)
+        BCRASH();
+    return result;
+}
+
+void* DebugHeap::realloc(void* object, size_t size)
+{
+    void* result = malloc_zone_realloc(m_zone, object, size);
+    if (!result)
+        BCRASH();
+    return result;
+}
+
+void DebugHeap::free(void* object)
+{
+    malloc_zone_free(m_zone, object);
+}
+
+#else
+
+DebugHeap::DebugHeap(std::lock_guard<StaticMutex>&)
+{
+}
+
+void* DebugHeap::malloc(size_t size)
+{
+    void* result = ::malloc(size);
+    if (!result)
+        BCRASH();
+    return result;
+}
+
+void* DebugHeap::memalign(size_t alignment, size_t size, bool crashOnFailure)
+{
+    void* result;
+    if (posix_memalign(&result, alignment, size)) {
+        if (crashOnFailure)
+            BCRASH();
+        return nullptr;
+    }
+    return result;
+}
+
+void* DebugHeap::realloc(void* object, size_t size)
+{
+    void* result = ::realloc(object, size);
+    if (!result)
+        BCRASH();
+    return result;
+}
+
+void DebugHeap::free(void* object)
+{
+    ::free(object);
+}
+    
+#endif
+
+} // namespace bmalloc
diff --git a/Source/bmalloc/bmalloc/DebugHeap.h b/Source/bmalloc/bmalloc/DebugHeap.h
new file mode 100644 (file)
index 0000000..cda96d0
--- /dev/null
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 Apple 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#pragma once
+
+#include "StaticMutex.h"
+#include <mutex>
+#if BOS(DARWIN)
+#include <malloc/malloc.h>
+#endif
+
+namespace bmalloc {
+    
+class DebugHeap {
+public:
+    DebugHeap(std::lock_guard<StaticMutex>&);
+    
+    void* malloc(size_t);
+    void* memalign(size_t alignment, size_t, bool crashOnFailure);
+    void* realloc(void*, size_t);
+    void free(void*);
+
+private:
+#if BOS(DARWIN)
+    malloc_zone_t* m_zone;
+#endif
+};
+
+} // namespace bmalloc
index 0d95071..19e047f 100644 (file)
@@ -108,19 +108,19 @@ static bool isSanitizerEnabled()
 }
 
 Environment::Environment()
-    : m_isBmallocEnabled(computeIsBmallocEnabled())
+    : m_isDebugHeapEnabled(computeIsDebugHeapEnabled())
 {
 }
 
-bool Environment::computeIsBmallocEnabled()
+bool Environment::computeIsDebugHeapEnabled()
 {
     if (isMallocEnvironmentVariableSet())
-        return false;
+        return true;
     if (isLibgmallocEnabled())
-        return false;
+        return true;
     if (isSanitizerEnabled())
-        return false;
-    return true;
+        return true;
+    return false;
 }
 
 } // namespace bmalloc
index 887776d..3e46a43 100644 (file)
@@ -32,12 +32,12 @@ class Environment {
 public:
     Environment();
     
-    bool isBmallocEnabled() { return m_isBmallocEnabled; }
+    bool isDebugHeapEnabled() { return m_isDebugHeapEnabled; }
 
 private:
-    bool computeIsBmallocEnabled();
+    bool computeIsDebugHeapEnabled();
 
-    bool m_isBmallocEnabled;
+    bool m_isDebugHeapEnabled;
 };
 
 } // namespace bmalloc
index 0bb65e7..ccd23ff 100644 (file)
@@ -26,6 +26,7 @@
 #include "Heap.h"
 #include "BumpAllocator.h"
 #include "Chunk.h"
+#include "DebugHeap.h"
 #include "PerProcess.h"
 #include "SmallLine.h"
 #include "SmallPage.h"
@@ -37,12 +38,16 @@ Heap::Heap(std::lock_guard<StaticMutex>&)
     : m_vmPageSizePhysical(vmPageSizePhysical())
     , m_isAllocatingPages(false)
     , m_scavenger(*this, &Heap::concurrentScavenge)
+    , m_debugHeap(nullptr)
 {
     RELEASE_BASSERT(vmPageSizePhysical() >= smallPageSize);
     RELEASE_BASSERT(vmPageSize() >= vmPageSizePhysical());
 
     initializeLineMetadata();
     initializePageMetadata();
+    
+    if (m_environment.isDebugHeapEnabled())
+        m_debugHeap = PerProcess<DebugHeap>::get();
 }
 
 void Heap::initializeLineMetadata()
index b1ef75f..779011a 100644 (file)
@@ -46,13 +46,14 @@ namespace bmalloc {
 
 class BeginTag;
 class BumpAllocator;
+class DebugHeap;
 class EndTag;
 
 class Heap {
 public:
     Heap(std::lock_guard<StaticMutex>&);
     
-    Environment& environment() { return m_environment; }
+    DebugHeap* debugHeap() { return m_debugHeap; }
 
     void allocateSmallBumpRanges(std::lock_guard<StaticMutex>&, size_t sizeClass, BumpAllocator&, BumpRangeCache&);
     void derefSmallLine(std::lock_guard<StaticMutex>&, Object);
@@ -116,6 +117,7 @@ private:
     AsyncTask<Heap, decltype(&Heap::concurrentScavenge)> m_scavenger;
 
     Environment m_environment;
+    DebugHeap* m_debugHeap;
 
     VMHeap m_vmHeap;
 };
index 8a2a2c2..ed036da 100644 (file)
@@ -82,7 +82,7 @@ inline void scavenge()
 inline bool isEnabled()
 {
     std::unique_lock<StaticMutex> lock(PerProcess<Heap>::mutex());
-    return PerProcess<Heap>::getFastCase()->environment().isBmallocEnabled();
+    return !PerProcess<Heap>::getFastCase()->debugHeap();
 }
 
 } // namespace api