ed7e36fbde00f7715977a9b91fab7b6eeabbb8da
[WebKit-https.git] / Source / bmalloc / bmalloc / IsoHeapImplInlines.h
1 /*
2  * Copyright (C) 2017-2018 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 #pragma once
27
28 #include "IsoHeapImpl.h"
29 #include "IsoTLSDeallocatorEntry.h"
30
31 namespace bmalloc {
32
33 template<typename Config>
34 IsoHeapImpl<Config>::IsoHeapImpl()
35     : lock(PerProcess<IsoTLSDeallocatorEntry<Config>>::get()->lock)
36     , m_inlineDirectory(*this)
37     , m_allocator(*this)
38 {
39     addToAllIsoHeaps();
40 }
41
42 template<typename Config>
43 EligibilityResult<Config> IsoHeapImpl<Config>::takeFirstEligible()
44 {
45     if (m_isInlineDirectoryEligible) {
46         EligibilityResult<Config> result = m_inlineDirectory.takeFirstEligible();
47         if (result.kind == EligibilityKind::Full)
48             m_isInlineDirectoryEligible = false;
49         else
50             return result;
51     }
52     
53     if (!m_firstEligibleDirectory) {
54         // If nothing is eligible, it can only be because we have no directories. It wouldn't be the end
55         // of the world if we broke this invariant. It would only mean that didBecomeEligible() would need
56         // a null check.
57         RELEASE_BASSERT(!m_headDirectory);
58         RELEASE_BASSERT(!m_tailDirectory);
59     }
60     
61     for (; m_firstEligibleDirectory; m_firstEligibleDirectory = m_firstEligibleDirectory->next) {
62         EligibilityResult<Config> result = m_firstEligibleDirectory->payload.takeFirstEligible();
63         if (result.kind != EligibilityKind::Full) {
64             m_directoryHighWatermark = std::max(m_directoryHighWatermark, m_firstEligibleDirectory->index());
65             return result;
66         }
67     }
68     
69     auto* newDirectory = new IsoDirectoryPage<Config>(*this, m_nextDirectoryPageIndex++);
70     if (m_headDirectory) {
71         m_tailDirectory->next = newDirectory;
72         m_tailDirectory = newDirectory;
73     } else {
74         RELEASE_BASSERT(!m_tailDirectory);
75         m_headDirectory = newDirectory;
76         m_tailDirectory = newDirectory;
77     }
78     m_directoryHighWatermark = newDirectory->index();
79     m_firstEligibleDirectory = newDirectory;
80     EligibilityResult<Config> result = newDirectory->payload.takeFirstEligible();
81     RELEASE_BASSERT(result.kind != EligibilityKind::Full);
82     return result;
83 }
84
85 template<typename Config>
86 void IsoHeapImpl<Config>::didBecomeEligible(IsoDirectory<Config, numPagesInInlineDirectory>* directory)
87 {
88     RELEASE_BASSERT(directory == &m_inlineDirectory);
89     m_isInlineDirectoryEligible = true;
90 }
91
92 template<typename Config>
93 void IsoHeapImpl<Config>::didBecomeEligible(IsoDirectory<Config, IsoDirectoryPage<Config>::numPages>* directory)
94 {
95     RELEASE_BASSERT(m_firstEligibleDirectory);
96     auto* directoryPage = IsoDirectoryPage<Config>::pageFor(directory);
97     if (directoryPage->index() < m_firstEligibleDirectory->index())
98         m_firstEligibleDirectory = directoryPage;
99 }
100
101 template<typename Config>
102 void IsoHeapImpl<Config>::scavenge(Vector<DeferredDecommit>& decommits)
103 {
104     std::lock_guard<Mutex> locker(this->lock);
105     forEachDirectory(
106         [&] (auto& directory) {
107             directory.scavenge(decommits);
108         });
109     m_directoryHighWatermark = 0;
110 }
111
112 template<typename Config>
113 void IsoHeapImpl<Config>::scavengeToHighWatermark(Vector<DeferredDecommit>& decommits)
114 {
115     std::lock_guard<Mutex> locker(this->lock);
116     if (!m_directoryHighWatermark)
117         m_inlineDirectory.scavengeToHighWatermark(decommits);
118     for (IsoDirectoryPage<Config>* page = m_headDirectory; page; page = page->next) {
119         if (page->index() >= m_directoryHighWatermark)
120             page->payload.scavengeToHighWatermark(decommits);
121     }
122     m_directoryHighWatermark = 0;
123 }
124
125 template<typename Config>
126 size_t IsoHeapImpl<Config>::freeableMemory()
127 {
128     return m_freeableMemory;
129 }
130
131 template<typename Config>
132 unsigned IsoHeapImpl<Config>::allocatorOffset()
133 {
134     return m_allocator.offset();
135 }
136
137 template<typename Config>
138 unsigned IsoHeapImpl<Config>::deallocatorOffset()
139 {
140     return PerProcess<IsoTLSDeallocatorEntry<Config>>::get()->offset();
141 }
142
143 template<typename Config>
144 unsigned IsoHeapImpl<Config>::numLiveObjects()
145 {
146     unsigned result = 0;
147     forEachLiveObject(
148         [&] (void*) {
149             result++;
150         });
151     return result;
152 }
153
154 template<typename Config>
155 unsigned IsoHeapImpl<Config>::numCommittedPages()
156 {
157     unsigned result = 0;
158     forEachCommittedPage(
159         [&] (IsoPage<Config>&) {
160             result++;
161         });
162     return result;
163 }
164
165 template<typename Config>
166 template<typename Func>
167 void IsoHeapImpl<Config>::forEachDirectory(const Func& func)
168 {
169     func(m_inlineDirectory);
170     for (IsoDirectoryPage<Config>* page = m_headDirectory; page; page = page->next)
171         func(page->payload);
172 }
173
174 template<typename Config>
175 template<typename Func>
176 void IsoHeapImpl<Config>::forEachCommittedPage(const Func& func)
177 {
178     forEachDirectory(
179         [&] (auto& directory) {
180             directory.forEachCommittedPage(func);
181         });
182 }
183
184 template<typename Config>
185 template<typename Func>
186 void IsoHeapImpl<Config>::forEachLiveObject(const Func& func)
187 {
188     forEachCommittedPage(
189         [&] (IsoPage<Config>& page) {
190             page.forEachLiveObject(func);
191         });
192 }
193
194 template<typename Config>
195 size_t IsoHeapImpl<Config>::footprint()
196 {
197 #if ENABLE_PHYSICAL_PAGE_MAP
198     RELEASE_BASSERT(m_footprint == m_physicalPageMap.footprint());
199 #endif
200     return m_footprint;
201 }
202
203 template<typename Config>
204 void IsoHeapImpl<Config>::didCommit(void* ptr, size_t bytes)
205 {
206     BUNUSED_PARAM(ptr);
207     m_footprint += bytes;
208 #if ENABLE_PHYSICAL_PAGE_MAP
209     m_physicalPageMap.commit(ptr, bytes);
210 #endif
211 }
212
213 template<typename Config>
214 void IsoHeapImpl<Config>::didDecommit(void* ptr, size_t bytes)
215 {
216     BUNUSED_PARAM(ptr);
217     m_footprint -= bytes;
218 #if ENABLE_PHYSICAL_PAGE_MAP
219     m_physicalPageMap.decommit(ptr, bytes);
220 #endif
221 }
222
223 template<typename Config>
224 void IsoHeapImpl<Config>::isNowFreeable(void* ptr, size_t bytes)
225 {
226     BUNUSED_PARAM(ptr);
227     m_freeableMemory += bytes;
228 }
229
230 template<typename Config>
231 void IsoHeapImpl<Config>::isNoLongerFreeable(void* ptr, size_t bytes)
232 {
233     BUNUSED_PARAM(ptr);
234     m_freeableMemory -= bytes;
235 }
236
237 } // namespace bmalloc
238