bmalloc: Pathological madvise churn on the free(malloc(x)) benchmark
[WebKit-https.git] / Source / bmalloc / bmalloc / Heap.h
1 /*
2  * Copyright (C) 2014, 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef Heap_h
27 #define Heap_h
28
29 #include "BumpRange.h"
30 #include "Environment.h"
31 #include "LineMetadata.h"
32 #include "MediumChunk.h"
33 #include "MediumLine.h"
34 #include "MediumPage.h"
35 #include "Mutex.h"
36 #include "SegregatedFreeList.h"
37 #include "SmallChunk.h"
38 #include "SmallLine.h"
39 #include "SmallPage.h"
40 #include "VMHeap.h"
41 #include "Vector.h"
42 #include <array>
43 #include <mutex>
44
45 namespace bmalloc {
46
47 class BeginTag;
48 class EndTag;
49
50 class Heap {
51 public:
52     Heap(std::lock_guard<StaticMutex>&);
53     
54     Environment& environment() { return m_environment; }
55
56     void refillSmallBumpRangeCache(std::lock_guard<StaticMutex>&, size_t sizeClass, BumpRangeCache&);
57     void derefSmallLine(std::lock_guard<StaticMutex>&, SmallLine*);
58
59     void refillMediumBumpRangeCache(std::lock_guard<StaticMutex>&, size_t sizeClass, BumpRangeCache&);
60     void derefMediumLine(std::lock_guard<StaticMutex>&, MediumLine*);
61
62     void* allocateLarge(std::lock_guard<StaticMutex>&, size_t);
63     void* allocateLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t, size_t unalignedSize);
64     void deallocateLarge(std::lock_guard<StaticMutex>&, void*);
65
66     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t);
67     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t);
68     Range findXLarge(std::lock_guard<StaticMutex>&, void*);
69     void deallocateXLarge(std::unique_lock<StaticMutex>&, void*);
70
71     void scavenge(std::unique_lock<StaticMutex>&, std::chrono::milliseconds sleepDuration);
72
73 private:
74     ~Heap() = delete;
75     
76     void initializeLineMetadata();
77
78     SmallPage* allocateSmallPage(std::lock_guard<StaticMutex>&, size_t sizeClass);
79     MediumPage* allocateMediumPage(std::lock_guard<StaticMutex>&, size_t sizeClass);
80
81     void deallocateSmallLine(std::lock_guard<StaticMutex>&, SmallLine*);
82     void deallocateMediumLine(std::lock_guard<StaticMutex>&, MediumLine*);
83
84     void* allocateLarge(std::lock_guard<StaticMutex>&, LargeObject&, size_t);
85     void deallocateLarge(std::lock_guard<StaticMutex>&, const LargeObject&);
86
87     void splitLarge(BeginTag*, size_t, EndTag*&, Range&);
88     void mergeLarge(BeginTag*&, EndTag*&, Range&);
89     void mergeLargeLeft(EndTag*&, BeginTag*&, Range&, bool& inVMHeap);
90     void mergeLargeRight(EndTag*&, BeginTag*&, Range&, bool& inVMHeap);
91     
92     void concurrentScavenge();
93     void scavengeSmallPages(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
94     void scavengeMediumPages(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
95     void scavengeLargeRanges(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
96
97     std::array<std::array<LineMetadata, SmallPage::lineCount>, smallMax / alignment> m_smallLineMetadata;
98     std::array<std::array<LineMetadata, MediumPage::lineCount>, mediumMax / alignment> m_mediumLineMetadata;
99
100     std::array<Vector<SmallPage*>, smallMax / alignment> m_smallPagesWithFreeLines;
101     std::array<Vector<MediumPage*>, mediumMax / alignment> m_mediumPagesWithFreeLines;
102
103     Vector<SmallPage*> m_smallPages;
104     Vector<MediumPage*> m_mediumPages;
105
106     SegregatedFreeList m_largeObjects;
107     Vector<Range> m_xLargeObjects;
108
109     bool m_isAllocatingPages;
110
111     Environment m_environment;
112
113     VMHeap m_vmHeap;
114     AsyncTask<Heap, decltype(&Heap::concurrentScavenge)> m_scavenger;
115 };
116
117 inline void Heap::derefSmallLine(std::lock_guard<StaticMutex>& lock, SmallLine* line)
118 {
119     if (!line->deref(lock))
120         return;
121     deallocateSmallLine(lock, line);
122 }
123
124 inline void Heap::derefMediumLine(std::lock_guard<StaticMutex>& lock, MediumLine* line)
125 {
126     if (!line->deref(lock))
127         return;
128     deallocateMediumLine(lock, line);
129 }
130
131 } // namespace bmalloc
132
133 #endif // Heap_h