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