Certain WebProcesses should opt-out of the freezer.
[WebKit-https.git] / Source / bmalloc / ChangeLog
1 2019-03-21  Brady Eidson  <beidson@apple.com>
2
3         Certain WebProcesses should opt-out of the freezer.
4         <rdar://problem/42846139> and https://bugs.webkit.org/show_bug.cgi?id=196062
5
6         Reviewed by Andy Estes.
7
8         * bmalloc.xcodeproj/project.pbxproj:
9         * bmalloc/darwin/MemoryStatusSPI.h:
10
11 2019-03-19  Michael Catanzaro  <mcatanzaro@igalia.com>
12
13         Unreviewed, fix -Wformat warning
14         https://bugs.webkit.org/show_bug.cgi?id=195895
15         <rdar://problem/48517629>
16
17         * bmalloc/Scavenger.cpp:
18         (bmalloc::Scavenger::threadRunLoop):
19
20 2019-03-18  Michael Saboff  <msaboff@apple.com>
21
22         [BMalloc] Scavenger should react to recent memory activity
23         https://bugs.webkit.org/show_bug.cgi?id=195895
24
25         Reviewed by Geoffrey Garen.
26
27         This change adds a recently used bit to objects that are scavenged.  When an object is allocated, that bit is set.
28         When we scavenge, if the bit is set, we clear it.  If the bit was already clear, we decommit the object.  The timing
29         to scavenging has been changed as well.  We perform our first scavne almost immediately after bmalloc is initialized
30         (10ms later).  Subsequent scavenging is done as a multiple of the time it took to scavenge.  We bound this computed
31         time between a minimum and maximum.  Through empirical testing, the multiplier, minimum and maximum are
32         150x, 100ms and 10,000ms respectively.  For mini-mode, when the JIT is disabled, we use much more aggressive values of
33         50x, 25ms and 500ms.
34
35         Eliminated partial scavenging since this change allows for any scavenge to be partial or full based on recent use of
36         the objects on the various free lists.
37
38         * bmalloc/Chunk.h:
39         (bmalloc::Chunk::usedSinceLastScavenge):
40         (bmalloc::Chunk::clearUsedSinceLastScavenge):
41         (bmalloc::Chunk::setUsedSinceLastScavenge):
42         * bmalloc/Heap.cpp:
43         (bmalloc::Heap::scavenge):
44         (bmalloc::Heap::allocateSmallChunk):
45         (bmalloc::Heap::allocateSmallPage):
46         (bmalloc::Heap::splitAndAllocate):
47         (bmalloc::Heap::tryAllocateLarge):
48         (bmalloc::Heap::scavengeToHighWatermark): Deleted.
49         * bmalloc/Heap.h:
50         * bmalloc/IsoDirectory.h:
51         * bmalloc/IsoDirectoryInlines.h:
52         (bmalloc::passedNumPages>::takeFirstEligible):
53         (bmalloc::passedNumPages>::scavenge):
54         (bmalloc::passedNumPages>::scavengeToHighWatermark): Deleted.
55         * bmalloc/IsoHeapImpl.h:
56         * bmalloc/IsoHeapImplInlines.h:
57         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark): Deleted.
58         * bmalloc/LargeRange.h:
59         (bmalloc::LargeRange::LargeRange):
60         (bmalloc::LargeRange::usedSinceLastScavenge):
61         (bmalloc::LargeRange::clearUsedSinceLastScavenge):
62         (bmalloc::LargeRange::setUsedSinceLastScavenge):
63         (): Deleted.
64         * bmalloc/Scavenger.cpp:
65         (bmalloc::Scavenger::Scavenger):
66         (bmalloc::Scavenger::threadRunLoop):
67         (bmalloc::Scavenger::timeSinceLastPartialScavenge): Deleted.
68         (bmalloc::Scavenger::partialScavenge): Deleted.
69         * bmalloc/Scavenger.h:
70         * bmalloc/SmallPage.h:
71         (bmalloc::SmallPage::usedSinceLastScavenge):
72         (bmalloc::SmallPage::clearUsedSinceLastScavenge):
73         (bmalloc::SmallPage::setUsedSinceLastScavenge):
74
75 2019-03-14  Yusuke Suzuki  <ysuzuki@apple.com>
76
77         [bmalloc] Add StaticPerProcess for known types to save pages
78         https://bugs.webkit.org/show_bug.cgi?id=195691
79
80         Reviewed by Mark Lam.
81
82         As initial memory footprint of VM + JSGlobalObject becomes 488KB dirty size in fast malloc memory (w/ JSC_useJIT=0 and Malloc=1), pages for PerProcess is costly.
83         For example, under Malloc=1 mode, we still need to allocate PerProcess<DebugHeap> and PerProcess<Environment>. And sizeof(Environment) is only 1 (bool flag), and
84         sizeof(DebugHeap) is 120. But we are allocating 1 pages for them. Since page size in iOS is 16KB, this 121B consumes 16KB dirty memory, and it is not negligible
85         size if we keep in mind that the current fast malloc heap size is 488KB. Putting them into the __DATA section, close to the other mutable data, we can avoid allocating
86         this page.
87
88         This patch revives the SafePerProcess concept in r228107. We add "StaticPerProcess<T>", which allocates underlying storage statically in the __DATA section instead of
89         allocating it at runtime. And we use this StaticPerProcess<T> for types where (1) T is known a priori, and (2) sizeof(T) is not huge.
90
91         * bmalloc.xcodeproj/project.pbxproj:
92         * bmalloc/AllIsoHeaps.cpp:
93         * bmalloc/AllIsoHeaps.h:
94         * bmalloc/Allocator.cpp:
95         (bmalloc::Allocator::Allocator):
96         * bmalloc/Cache.cpp:
97         (bmalloc::Cache::Cache):
98         * bmalloc/CryptoRandom.cpp:
99         (bmalloc::cryptoRandom):
100         * bmalloc/Deallocator.cpp:
101         (bmalloc::Deallocator::Deallocator):
102         * bmalloc/DebugHeap.cpp:
103         * bmalloc/DebugHeap.h:
104         (bmalloc::DebugHeap::tryGet):
105         * bmalloc/Environment.cpp:
106         * bmalloc/Environment.h:
107         * bmalloc/Gigacage.cpp:
108         (Gigacage::Callback::Callback):
109         (Gigacage::Callback::function):
110         (bmalloc::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks):
111         (Gigacage::disablePrimitiveGigacage):
112         (Gigacage::addPrimitiveDisableCallback):
113         (Gigacage::removePrimitiveDisableCallback):
114         (Gigacage::shouldBeEnabled):
115         (Gigacage::bmalloc::Callback::Callback): Deleted.
116         (Gigacage::bmalloc::Callback::function): Deleted.
117         (Gigacage::bmalloc::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
118         * bmalloc/Heap.cpp:
119         (bmalloc::Heap::Heap):
120         (bmalloc::Heap::tryAllocateLarge):
121         * bmalloc/IsoDirectoryInlines.h:
122         (bmalloc::passedNumPages>::takeFirstEligible):
123         (bmalloc::passedNumPages>::didBecome):
124         * bmalloc/IsoHeapImpl.cpp:
125         (bmalloc::IsoHeapImplBase::addToAllIsoHeaps):
126         * bmalloc/IsoPage.cpp:
127         (bmalloc::IsoPageBase::allocatePageMemory):
128         * bmalloc/IsoTLS.cpp:
129         (bmalloc::IsoTLS::IsoTLS):
130         (bmalloc::IsoTLS::ensureEntries):
131         (bmalloc::IsoTLS::forEachEntry):
132         * bmalloc/IsoTLSEntry.cpp:
133         (bmalloc::IsoTLSEntry::IsoTLSEntry):
134         * bmalloc/IsoTLSInlines.h:
135         (bmalloc::IsoTLS::allocateSlow):
136         (bmalloc::IsoTLS::deallocateSlow):
137         * bmalloc/IsoTLSLayout.cpp:
138         * bmalloc/IsoTLSLayout.h:
139         * bmalloc/Scavenger.cpp:
140         (bmalloc::Scavenger::Scavenger):
141         (bmalloc::dumpStats):
142         (bmalloc::Scavenger::scavenge):
143         (bmalloc::Scavenger::partialScavenge):
144         (bmalloc::Scavenger::freeableMemory):
145         (bmalloc::Scavenger::footprint):
146         * bmalloc/Scavenger.h:
147         * bmalloc/StaticPerProcess.h: Added.
148         * bmalloc/VMHeap.cpp:
149         * bmalloc/VMHeap.h:
150         * bmalloc/Zone.h:
151         * bmalloc/bmalloc.cpp:
152         (bmalloc::api::scavenge):
153         (bmalloc::api::isEnabled):
154         (bmalloc::api::setScavengerThreadQOSClass):
155         (bmalloc::api::enableMiniMode):
156         * test/testbmalloc.cpp:
157         (assertEmptyPointerSet):
158         (assertHasObjects):
159         (assertHasOnlyObjects):
160         (assertClean):
161
162 2019-03-13  Yoshiaki Jitsukawa  <yoshiaki.jitsukawa@sony.com>
163
164         [bmalloc] Use MADV_FREE on FreeBSD
165         https://bugs.webkit.org/show_bug.cgi?id=195665
166
167         Reviewed by Geoffrey Garen.
168
169         * bmalloc/BPlatform.h:
170
171         Introduce BOS_FREEBSD, which is equivalent to WTF_OS_FREEBSD
172
173         * bmalloc/VMAllocate.h:
174         (bmalloc::vmDeallocatePhysicalPages):
175
176         Use MADV_FREE instead of MADV_DONTNEED if BOS(FREEBSD), since on FreeBSD,
177         unlike on Linux, MADV_DONTNEED doesn't let the OS discard the contents of
178         the pages.
179
180 2019-03-13  Sam Weinig  <sam@webkit.org>
181
182         Fix testbmalloc build
183         https://bugs.webkit.org/show_bug.cgi?id=195660
184
185         Reviewed by Geoffrey Garen.
186
187         * bmalloc.xcodeproj/project.pbxproj:
188         Link Foundation in when building testbmalloc. Since bmalloc requires Foundation, and is a static
189         library, all clients of bmalloc are required to link it themselves.
190         
191         * bmalloc/IsoPageInlines.h:
192         * bmalloc/StdLibExtras.h: Added.
193         (bmalloc::bitwise_cast):
194         Add bitwise_cast implementation, and use it in IsoPageInlines.h. It is a layering violation
195         to expect the one from WTF to be available, as seems to have been the case.
196
197 2019-03-12  Robin Morisset  <rmorisset@apple.com>
198
199         A lot more classes have padding that can be reduced by reordering their fields
200         https://bugs.webkit.org/show_bug.cgi?id=195579
201
202         Reviewed by Mark Lam.
203
204         * bmalloc/Heap.h:
205         * bmalloc/Scavenger.h:
206
207 2019-03-05  Yusuke Suzuki  <ysuzuki@apple.com>
208
209         [bmalloc] Bmalloc DebugHeap should have dump and scavenge features
210         https://bugs.webkit.org/show_bug.cgi?id=195305
211
212         Reviewed by Saam Barati.
213
214         As the same to bmalloc, bmalloc::DebugHeap should have scavenge feature to make it scavengable if we want.
215         We also add DebugHeap::dump feature which dumps system malloc data in the WebKit Malloc zone.
216
217         * bmalloc/DebugHeap.cpp:
218         (bmalloc::DebugHeap::scavenge):
219         (bmalloc::DebugHeap::dump):
220         * bmalloc/DebugHeap.h:
221         * bmalloc/bmalloc.cpp:
222         (bmalloc::api::scavenge):
223
224 2019-02-23  Keith Miller  <keith_miller@apple.com>
225
226         Add new mac target numbers
227         https://bugs.webkit.org/show_bug.cgi?id=194955
228
229         Reviewed by Tim Horton.
230
231         * Configurations/Base.xcconfig:
232         * Configurations/DebugRelease.xcconfig:
233
234 2019-02-19  Yusuke Suzuki  <ysuzuki@apple.com>
235
236         [bmalloc] bmalloc::Heap is allocated even though we use system malloc mode
237         https://bugs.webkit.org/show_bug.cgi?id=194836
238
239         Reviewed by Mark Lam.
240
241         Previously, bmalloc::Heap holds DebugHeap, and delegates allocation and deallocation to debug heap.
242         However, bmalloc::Heap is large. We would like to avoid initialization of bmalloc::Heap under the
243         system malloc mode.
244
245         This patch extracts out DebugHeap from bmalloc::Heap, and logically puts this in a boundary of
246         bmalloc::api. bmalloc::api delegates allocation and deallocation to DebugHeap if DebugHeap is enabled.
247         Otherwise, using bmalloc's usual mechanism. The challenge is that we would like to keep bmalloc fast
248         path fast.
249
250         1. For IsoHeaps, we use the similar techniques done in Cache. If the debug mode is enabled, we always go
251            to the slow path of the IsoHeap allocation, and keep IsoTLS::get() returning nullptr. In the slow path,
252            we just fallback to the usual bmalloc::api::tryMalloc implementation. This is efficient because bmalloc
253            continues using the fast path.
254
255         2. For the other APIs, like freeLargeVirtual, we just put DebugHeap check because this API itself takes fair
256            amount of time. Then debug heap check does not matter.
257
258         * bmalloc/Allocator.cpp:
259         (bmalloc::Allocator::reallocateImpl):
260         * bmalloc/Cache.cpp:
261         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
262         (bmalloc::Cache::allocateSlowCaseNullCache):
263         (bmalloc::Cache::deallocateSlowCaseNullCache):
264         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
265         (bmalloc::Cache::reallocateSlowCaseNullCache):
266         (): Deleted.
267         (bmalloc::debugHeap): Deleted.
268         * bmalloc/DebugHeap.cpp:
269         * bmalloc/DebugHeap.h:
270         (bmalloc::DebugHeap::tryGet):
271         * bmalloc/Heap.cpp:
272         (bmalloc::Heap::Heap):
273         (bmalloc::Heap::footprint):
274         (bmalloc::Heap::tryAllocateLarge):
275         (bmalloc::Heap::deallocateLarge):
276         * bmalloc/Heap.h:
277         (bmalloc::Heap::debugHeap): Deleted.
278         * bmalloc/IsoTLS.cpp:
279         (bmalloc::IsoTLS::IsoTLS):
280         (bmalloc::IsoTLS::isUsingDebugHeap): Deleted.
281         (bmalloc::IsoTLS::debugMalloc): Deleted.
282         (bmalloc::IsoTLS::debugFree): Deleted.
283         * bmalloc/IsoTLS.h:
284         * bmalloc/IsoTLSInlines.h:
285         (bmalloc::IsoTLS::allocateSlow):
286         (bmalloc::IsoTLS::deallocateSlow):
287         * bmalloc/ObjectType.cpp:
288         (bmalloc::objectType):
289         * bmalloc/ObjectType.h:
290         * bmalloc/Scavenger.cpp:
291         (bmalloc::Scavenger::Scavenger):
292         * bmalloc/bmalloc.cpp:
293         (bmalloc::api::tryLargeZeroedMemalignVirtual):
294         (bmalloc::api::freeLargeVirtual):
295         (bmalloc::api::scavenge):
296         (bmalloc::api::isEnabled):
297         (bmalloc::api::setScavengerThreadQOSClass):
298         (bmalloc::api::commitAlignedPhysical):
299         (bmalloc::api::decommitAlignedPhysical):
300         (bmalloc::api::enableMiniMode):
301
302 2019-02-20  Andy Estes  <aestes@apple.com>
303
304         [Xcode] Add SDKVariant.xcconfig to various Xcode projects
305         https://bugs.webkit.org/show_bug.cgi?id=194869
306
307         Rubber-stamped by Jer Noble.
308
309         * bmalloc.xcodeproj/project.pbxproj:
310
311 2019-02-20  Yusuke Suzuki  <ysuzuki@apple.com>
312
313         [bmalloc] DebugHeap::malloc does not have "try" version.
314         https://bugs.webkit.org/show_bug.cgi?id=194837
315
316         Reviewed by Mark Lam.
317
318         Since DebugHeap::malloc does not have "try" version, our tryAllocate implementation does not work well with DebugHeap.
319         This patch adds crashOnFailure flag to DebugHeap::malloc.
320
321         * bmalloc/Cache.cpp:
322         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
323         (bmalloc::Cache::allocateSlowCaseNullCache):
324         * bmalloc/DebugHeap.cpp:
325         (bmalloc::DebugHeap::malloc):
326         * bmalloc/DebugHeap.h:
327         * bmalloc/IsoTLS.cpp:
328         (bmalloc::IsoTLS::debugMalloc):
329
330 2019-02-20  Yusuke Suzuki  <ysuzuki@apple.com>
331
332         [bmalloc] bmalloc::Cache should not be instantiated if we are using system malloc
333         https://bugs.webkit.org/show_bug.cgi?id=194811
334
335         Reviewed by Mark Lam.
336
337         bmalloc::Cache is very large. It is 13KB. Since it exists per HeapKind, it takes 40KB.
338         But this is meaningless if we are under the system malloc mode by using "Malloc=1". We
339         found that it continues using so much dirty memory region even under the system malloc mode.
340         This patch avoids instantiation of bmalloc::Cache under the system malloc mode.
341
342         * bmalloc/Allocator.cpp:
343         (bmalloc::Allocator::Allocator):
344         (bmalloc::Allocator::tryAllocate):
345         (bmalloc::Allocator::allocateImpl):
346         (bmalloc::Allocator::reallocateImpl):
347         (bmalloc::Allocator::allocateSlowCase):
348         Allocator is a per Cache object. So we no longer need to keep m_debugHeap. If debug heap is enabled,
349         Allocator is never created.
350
351         * bmalloc/Allocator.h:
352         * bmalloc/Cache.cpp:
353         (bmalloc::debugHeap):
354         (bmalloc::Cache::Cache):
355         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
356         (bmalloc::Cache::allocateSlowCaseNullCache):
357         (bmalloc::Cache::deallocateSlowCaseNullCache):
358         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
359         (bmalloc::Cache::reallocateSlowCaseNullCache):
360         * bmalloc/Cache.h:
361         (bmalloc::Cache::tryAllocate):
362         (bmalloc::Cache::tryReallocate):
363         If the debug heap mode is enabled, we keep Cache::getFast() returning nullptr. And in the slow path case, we use debugHeap.
364         This makes bmalloc fast path fast, while we avoid Cache instantiation.
365
366         * bmalloc/Deallocator.cpp:
367         (bmalloc::Deallocator::Deallocator):
368         (bmalloc::Deallocator::scavenge):
369         (bmalloc::Deallocator::deallocateSlowCase):
370         * bmalloc/Deallocator.h:
371         Ditto for Deallocator.
372
373         * bmalloc/bmalloc.cpp:
374         (bmalloc::api::isEnabled):
375         We used `getFastCase()` for Heap. But it is basically wrong since we do not have any guarantee that someone already initializes
376         Heap when this is called. Previously, luckily, Cache is initialized, and Cache initialized Heap. But Cache initialization is removed
377         for system malloc mode and now PerProcess<PerHeapKind<Heap>>::getFastCase() returns nullptr at an early phase. This patch just uses
378         Environment::isDebugHeapEnabled() instead.
379
380 2019-02-20  Commit Queue  <commit-queue@webkit.org>
381
382         Unreviewed, rolling out r241789.
383         https://bugs.webkit.org/show_bug.cgi?id=194856
384
385         GuardMalloc crashes (Requested by yusukesuzuki on #webkit).
386
387         Reverted changeset:
388
389         "[bmalloc] bmalloc::Cache should not be instantiated if we are
390         using system malloc"
391         https://bugs.webkit.org/show_bug.cgi?id=194811
392         https://trac.webkit.org/changeset/241789
393
394 2019-02-19  Yusuke Suzuki  <ysuzuki@apple.com>
395
396         [bmalloc] bmalloc::Cache should not be instantiated if we are using system malloc
397         https://bugs.webkit.org/show_bug.cgi?id=194811
398
399         Reviewed by Mark Lam.
400
401         bmalloc::Cache is very large. It is 13KB. Since it exists per HeapKind, it takes 40KB.
402         But this is meaningless if we are under the system malloc mode by using "Malloc=1". We
403         found that it continues using so much dirty memory region even under the system malloc mode.
404         This patch avoids instantiation of bmalloc::Cache under the system malloc mode.
405
406         * bmalloc/Allocator.cpp:
407         (bmalloc::Allocator::Allocator):
408         (bmalloc::Allocator::tryAllocate):
409         (bmalloc::Allocator::allocateImpl):
410         (bmalloc::Allocator::reallocateImpl):
411         (bmalloc::Allocator::allocateSlowCase):
412         Allocator is a per Cache object. So we no longer need to keep m_debugHeap. If debug heap is enabled,
413         Allocator is never created.
414
415         * bmalloc/Allocator.h:
416         * bmalloc/Cache.cpp:
417         (bmalloc::debugHeap):
418         (bmalloc::Cache::Cache):
419         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
420         (bmalloc::Cache::allocateSlowCaseNullCache):
421         (bmalloc::Cache::deallocateSlowCaseNullCache):
422         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
423         (bmalloc::Cache::reallocateSlowCaseNullCache):
424         * bmalloc/Cache.h:
425         (bmalloc::Cache::tryAllocate):
426         (bmalloc::Cache::tryReallocate):
427         If the debug heap mode is enabled, we keep Cache::getFast() returning nullptr. And in the slow path case, we use debugHeap.
428         This makes bmalloc fast path fast, while we avoid Cache instantiation.
429
430         * bmalloc/Deallocator.cpp:
431         (bmalloc::Deallocator::Deallocator):
432         (bmalloc::Deallocator::scavenge):
433         (bmalloc::Deallocator::deallocateSlowCase):
434         * bmalloc/Deallocator.h:
435         Ditto for Deallocator.
436
437 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
438
439         [bmalloc] NSBundle-based application name check should be executed after debug-heap environment variable check
440         https://bugs.webkit.org/show_bug.cgi?id=194694
441
442         Reviewed by Mark Lam.
443
444         Interestingly, NSBundle allocates fair amount of memory and keeps it for a process-long time. For example, it
445         allocates global NSConcreteHashTable, which takes 2.5KB. This patch changes the order of gigacage-check, we
446         first check "Malloc=1" status, and then check the process name through NSBundle. This allows us to remove NSBundle
447         related allocation in JSC initialization in the system malloc mode.
448
449         * bmalloc/Gigacage.cpp:
450         (Gigacage::shouldBeEnabled):
451
452 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
453
454         [bmalloc] Do not start scavenger thread if we use system malloc
455         https://bugs.webkit.org/show_bug.cgi?id=194674
456
457         Reviewed by Mark Lam.
458
459         We always start the scavenger thread even if system malloc is used by the environment variable like "Malloc=1".
460         Because bmalloc allocation goes to the system malloc if "Malloc=1" is set, we do not need to scavenge. This patch
461         changes it not to start the scavenger thread.
462
463         * bmalloc/Scavenger.cpp:
464         (bmalloc::Scavenger::Scavenger):
465
466 2019-02-12  Commit Queue  <commit-queue@webkit.org>
467
468         Unreviewed, rolling out r241182.
469         https://bugs.webkit.org/show_bug.cgi?id=194547
470
471         causes a 2-3% Speedometer2 regression. (Requested by
472         keith_miller on #webkit).
473
474         Reverted changeset:
475
476         "bmalloc uses more memory on iOS compared to macOS due to
477         physical page size differences"
478         https://bugs.webkit.org/show_bug.cgi?id=192389
479         https://trac.webkit.org/changeset/241182
480
481 2019-02-07  Michael Saboff  <msaboff@apple.com>
482
483         bmalloc uses more memory on iOS compared to macOS due to physical page size differences
484         https://bugs.webkit.org/show_bug.cgi?id=192389
485
486         Reviewed by Geoffrey Garen.
487
488         Changed small line allocations to be in smallPageSize "virtual page" multiples instead of physical
489         page size increments for sizes less that the physical page size.  This required changing the small
490         page commit / decommit code to work in full physical page increments.  For page classes that are
491         physical page size and larger, there isn't any functional change.
492
493         When scavenging page classes smaller than the physical page size, we need to consider whether or
494         not the adjacent small pages on the same physical page are also free before decommiting that
495         containing page.  When we need to commit more memory, we commit the whole page, and add any
496         adjacent virtual pages that were fully committed as well.
497
498         * bmalloc/Chunk.h:
499         (bmalloc::forEachPage):
500         * bmalloc/Heap.cpp:
501         (bmalloc::Heap::initializeLineMetadata):
502         (bmalloc::Heap::initializePageMetadata):
503         (bmalloc::Heap::scavenge):
504         (bmalloc::__attribute__):
505         (bmalloc::Heap::commitSmallPagesInPhysicalPage):
506         (bmalloc::Heap::allocateSmallPage):
507         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
508         * bmalloc/Heap.h:
509         * bmalloc/SmallPage.h:
510         (bmalloc::SmallPage::refCount):
511
512 2019-01-18  Keith Miller  <keith_miller@apple.com>
513
514         gigacage slide should randomize both start and end
515         https://bugs.webkit.org/show_bug.cgi?id=193601
516
517         Reviewed by Yusuke Suzuki.
518
519         This patch makes it so that the gigacade slide has an arbitrary
520         distance from the end as well as the start. This is done by
521         picking a random size then based on that size picking an random
522         starting offset.
523
524         * bmalloc/Gigacage.h:
525         * bmalloc/Heap.cpp:
526         (bmalloc::Heap::Heap):
527
528 2019-01-18  Jer Noble  <jer.noble@apple.com>
529
530         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
531         https://bugs.webkit.org/show_bug.cgi?id=189553
532
533         Reviewed by Tim Horton.
534
535         * Configurations/Base.xcconfig:
536         * Configurations/SDKVariant.xcconfig: Added.
537
538 2019-01-18  Keith Miller  <keith_miller@apple.com>
539
540         Gigacages should start allocations from a slide
541         https://bugs.webkit.org/show_bug.cgi?id=193523
542
543         Reviewed by Mark Lam.
544
545         This patch makes it so that Gigacage Heaps slide the start of the
546         cage by some random amount. We still ensure that there is always
547         at least 4/2GB, on MacOS/iOS respectively, of VA space available
548         for allocation.
549
550         Also, this patch changes some macros into constants since macros
551         are the devil.
552
553         * bmalloc/Gigacage.cpp:
554         (Gigacage::bmalloc::protectGigacageBasePtrs):
555         (Gigacage::bmalloc::unprotectGigacageBasePtrs):
556         (Gigacage::bmalloc::runwaySize):
557         (Gigacage::ensureGigacage):
558         (Gigacage::shouldBeEnabled):
559         * bmalloc/Gigacage.h:
560         (Gigacage::name):
561         (Gigacage::gigacageSizeToMask):
562         (Gigacage::size):
563         (Gigacage::mask):
564         (Gigacage::basePtr):
565         (Gigacage::ensureGigacage):
566         (Gigacage::wasEnabled):
567         (Gigacage::isCaged):
568         (Gigacage::isEnabled):
569         (Gigacage::caged):
570         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
571         (Gigacage::canPrimitiveGigacageBeDisabled):
572         (Gigacage::disablePrimitiveGigacage):
573         (Gigacage::addPrimitiveDisableCallback):
574         (Gigacage::removePrimitiveDisableCallback):
575         * bmalloc/Heap.cpp:
576         (bmalloc::Heap::Heap):
577         * bmalloc/Sizes.h:
578         (bmalloc::Sizes::maskSizeClass):
579         (bmalloc::Sizes::maskObjectSize):
580         (bmalloc::Sizes::logSizeClass):
581         (bmalloc::Sizes::logObjectSize):
582         (bmalloc::Sizes::sizeClass):
583         (bmalloc::Sizes::objectSize):
584         (bmalloc::Sizes::pageSize):
585
586 2019-01-18  Matt Lewis  <jlewis3@apple.com>
587
588         Unreviewed, rolling out r240160.
589
590         This broke multiple internal builds.
591
592         Reverted changeset:
593
594         "Gigacages should start allocations from a slide"
595         https://bugs.webkit.org/show_bug.cgi?id=193523
596         https://trac.webkit.org/changeset/240160
597
598 2019-01-18  Keith Miller  <keith_miller@apple.com>
599
600         Gigacages should start allocations from a slide
601         https://bugs.webkit.org/show_bug.cgi?id=193523
602
603         Reviewed by Mark Lam.
604
605         This patch makes it so that Gigacage Heaps slide the start of the
606         cage by some random amount. We still ensure that there is always
607         at least 4/2GB, on MacOS/iOS respectively, of VA space available
608         for allocation.
609
610         Also, this patch changes some macros into constants since macros
611         are the devil.
612
613         * bmalloc/Gigacage.cpp:
614         (Gigacage::bmalloc::protectGigacageBasePtrs):
615         (Gigacage::bmalloc::unprotectGigacageBasePtrs):
616         (Gigacage::bmalloc::runwaySize):
617         (Gigacage::ensureGigacage):
618         (Gigacage::shouldBeEnabled):
619         * bmalloc/Gigacage.h:
620         (Gigacage::name):
621         (Gigacage::gigacageSizeToMask):
622         (Gigacage::size):
623         (Gigacage::mask):
624         (Gigacage::basePtr):
625         (Gigacage::ensureGigacage):
626         (Gigacage::wasEnabled):
627         (Gigacage::isCaged):
628         (Gigacage::caged):
629         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
630         (Gigacage::disablePrimitiveGigacage):
631         (Gigacage::addPrimitiveDisableCallback):
632         (Gigacage::removePrimitiveDisableCallback):
633         * bmalloc/Heap.cpp:
634         (bmalloc::Heap::Heap):
635         * bmalloc/Sizes.h:
636         (bmalloc::Sizes::maskSizeClass):
637         (bmalloc::Sizes::maskObjectSize):
638         (bmalloc::Sizes::logSizeClass):
639         (bmalloc::Sizes::logObjectSize):
640         (bmalloc::Sizes::sizeClass):
641         (bmalloc::Sizes::objectSize):
642         (bmalloc::Sizes::pageSize):
643
644 2019-01-17  Truitt Savell  <tsavell@apple.com>
645
646         Unreviewed, rolling out r240124.
647
648         This commit broke an internal build.
649
650         Reverted changeset:
651
652         "SDK_VARIANT build destinations should be separate from non-
653         SDK_VARIANT builds"
654         https://bugs.webkit.org/show_bug.cgi?id=189553
655         https://trac.webkit.org/changeset/240124
656
657 2019-01-17  Jer Noble  <jer.noble@apple.com>
658
659         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
660         https://bugs.webkit.org/show_bug.cgi?id=189553
661
662         Reviewed by Tim Horton.
663
664         * Configurations/Base.xcconfig:
665         * Configurations/SDKVariant.xcconfig: Added.
666
667 2019-01-16  Keith Miller  <keith_miller@apple.com>
668
669         bmalloc should use JSC VM tag for gigacage
670         https://bugs.webkit.org/show_bug.cgi?id=193496
671
672         Reviewed by Mark Lam.
673
674         This patch moves the VMTag info from WTF to bmalloc so that we can
675         tag gigacage memory with the unused JSC memory tag. The JSC memory
676         tag was previously used for wasm but since wasm is now allocated
677         out of the primitive cage it was unused.
678
679         * bmalloc.xcodeproj/project.pbxproj:
680         * bmalloc/BVMTags.h: Copied from Source/WTF/wtf/VMTags.h.
681         * bmalloc/Gigacage.cpp:
682         (Gigacage::ensureGigacage):
683         * bmalloc/VMAllocate.h:
684         (bmalloc::tryVMAllocate):
685         (bmalloc::vmZeroAndPurge):
686
687 2019-01-09  Mark Lam  <mark.lam@apple.com>
688
689         Gigacage disabling checks should handle the GIGACAGE_ALLOCATION_CAN_FAIL case properly.
690         https://bugs.webkit.org/show_bug.cgi?id=193292
691         <rdar://problem/46485450>
692
693         Reviewed by Yusuke Suzuki.
694
695         Previously, when GIGACAGE_ALLOCATION_CAN_FAIL is true, we allow the Gigacage to
696         be disabled if we fail to allocate memory for it.  However, Gigacage::primitiveGigacageDisabled()
697         still always assumes that the Gigacage is always enabled after ensureGigacage() is
698         called.
699
700         This patch updates Gigacage::primitiveGigacageDisabled() to allow the Gigacage to
701         already be disabled if GIGACAGE_ALLOCATION_CAN_FAIL is true and wasEnabled() is
702         false.
703
704         In this patch, we also put the wasEnabled flag in the 0th slot of the
705         g_gigacageBasePtrs buffer to ensure that it is also protected against writes just
706         like the Gigacage base pointers.
707
708         To achieve this, we do the following:
709         1. Added a reservedForFlags field in struct BasePtrs.
710         2. Added a ReservedForFlagsAndNotABasePtr Gigacage::Kind.
711         3. Added assertions to ensure that the BasePtrs::primitive is at the offset
712            matching the offset computed from Gigacage::Primitive.  Ditto for
713            BasePtrs::jsValue and Gigacage::JSValue.
714         4. Added assertions to ensure that Gigacage::ReservedForFlagsAndNotABasePtr is not
715            used for fetching a Gigacage base pointer.
716         5. Added RELEASE_BASSERT_NOT_REACHED() to implement such assertions in bmalloc.
717
718         No test added because this issue requires Gigacage allocation to fail in order to
719         manifest.  I've tested it manually by modifying the code locally to force an
720         allocation failure.
721
722         * bmalloc/BAssert.h:
723         * bmalloc/Gigacage.cpp:
724         (Gigacage::ensureGigacage):
725         (Gigacage::primitiveGigacageDisabled):
726         * bmalloc/Gigacage.h:
727         (Gigacage::wasEnabled):
728         (Gigacage::setWasEnabled):
729         (Gigacage::name):
730         (Gigacage::basePtr):
731         (Gigacage::size):
732         * bmalloc/HeapKind.h:
733         (bmalloc::heapKind):
734
735 2018-12-15  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
736
737         Unreviewed, suppress warnings in Linux
738
739         * bmalloc/Gigacage.cpp:
740
741 2018-12-14  Keith Miller  <keith_miller@apple.com>
742
743         Gigacage runway should immediately follow the primitive cage
744         https://bugs.webkit.org/show_bug.cgi?id=192733
745
746         Reviewed by Saam Barati.
747
748         This patch makes sure that the Gigacage runway is always
749         immediately after the primitive cage. Since writing outside the
750         primitive gigacage is likely to be more dangerous than the JSValue
751         cage. The ordering of the cages is still random however.
752
753         * bmalloc/Gigacage.cpp:
754         (Gigacage::ensureGigacage):
755
756 2018-12-13  Mark Lam  <mark.lam@apple.com>
757
758         Verify that tryLargeZeroedMemalignVirtual()'s aligned size and alignment values are valid.
759         https://bugs.webkit.org/show_bug.cgi?id=192682
760         <rdar://problem/37751522>
761
762         Reviewed by Saam Barati.
763
764         * bmalloc/bmalloc.cpp:
765         (bmalloc::api::tryLargeZeroedMemalignVirtual):
766
767 2018-11-21  Dominik Infuehr  <dinfuehr@igalia.com>
768
769         Enable JIT on ARM/Linux
770         https://bugs.webkit.org/show_bug.cgi?id=191548
771
772         Reviewed by Yusuke Suzuki.
773
774         * bmalloc/IsoPageInlines.h:
775         (bmalloc::IsoPage<Config>::startAllocating):
776
777 2018-11-01  Jiewen Tan  <jiewen_tan@apple.com>
778
779         Replace CommonRandom SPI with API
780         https://bugs.webkit.org/show_bug.cgi?id=191178
781         <rdar://problem/45722391>
782
783         Reviewed by Brent Fulgham.
784
785         * bmalloc/CryptoRandom.cpp:
786         (bmalloc::ARC4RandomNumberGenerator::stir):
787
788 2018-10-29  Mark Lam  <mark.lam@apple.com>
789
790         Correctly detect string overflow when using the 'Function' constructor.
791         https://bugs.webkit.org/show_bug.cgi?id=184883
792         <rdar://problem/36320331>
793
794         Reviewed by Saam Barati.
795
796         * bmalloc/Allocator.cpp:
797         (bmalloc::Allocator::reallocate):
798         (bmalloc::Allocator::tryReallocate):
799         (bmalloc::Allocator::reallocateImpl):
800         * bmalloc/Allocator.h:
801         * bmalloc/Cache.h:
802         (bmalloc::Cache::tryReallocate):
803         * bmalloc/DebugHeap.cpp:
804         (bmalloc::DebugHeap::realloc):
805         * bmalloc/DebugHeap.h:
806         * bmalloc/bmalloc.h:
807         (bmalloc::api::tryRealloc):
808
809 2018-10-25  Ross Kirsling  <ross.kirsling@sony.com>
810
811         Cleanup: inline constexpr is redundant as constexpr implies inline
812         https://bugs.webkit.org/show_bug.cgi?id=190819
813
814         Reviewed by Mark Lam.
815
816         * bmalloc/Algorithm.h:
817         (bmalloc::max):
818         (bmalloc::min):
819         (bmalloc::mask):
820         (bmalloc::test):
821         (bmalloc::isPowerOfTwo):
822         (bmalloc::roundDownToMultipleOf):
823         (bmalloc::sizeOf):
824         (bmalloc::bitCount):
825         (bmalloc::log2):
826         * bmalloc/Bits.h:
827         (bmalloc::bitsArrayLength):
828         * bmalloc/Sizes.h:
829         (bmalloc::Sizes::maskSizeClass):
830
831 2018-10-24  Alexey Proskuryakov  <ap@apple.com>
832
833         Add BPLATFORM(IOS_FAMILY)
834         https://bugs.webkit.org/show_bug.cgi?id=190878
835
836         Reviewed by Saam Barati.
837
838         * bmalloc/AvailableMemory.cpp:
839         (bmalloc::memorySizeAccordingToKernel):
840         (bmalloc::computeAvailableMemory):
841         * bmalloc/AvailableMemory.h:
842         (bmalloc::isUnderMemoryPressure):
843         * bmalloc/BPlatform.h:
844         * bmalloc/Gigacage.h:
845         * bmalloc/Logging.cpp:
846         (bmalloc::logVMFailure):
847         * bmalloc/VMAllocate.h:
848         (bmalloc::vmPageSizePhysical):
849         * bmalloc/bmalloc.h:
850         * bmalloc/darwin/MemoryStatusSPI.h:
851
852 2018-10-12  Ryan Haddad  <ryanhaddad@apple.com>
853
854         Unreviewed, rolling out r237063.
855
856         Caused layout test fast/dom/Window/window-postmessage-clone-
857         deep-array.html to fail on macOS and iOS Debug bots.
858
859         Reverted changeset:
860
861         "[JSC] Remove gcc warnings on mips and armv7"
862         https://bugs.webkit.org/show_bug.cgi?id=188598
863         https://trac.webkit.org/changeset/237063
864
865 2018-10-11  Guillaume Emont  <guijemont@igalia.com>
866
867         [JSC] Remove gcc warnings on mips and armv7
868         https://bugs.webkit.org/show_bug.cgi?id=188598
869
870         Reviewed by Mark Lam.
871
872         Add bitwise_cast (from WTF) and use it instead of reinterpret_cast in
873         a couple places where reinterpret_cast triggers a warning about
874         alignment even though we know that alignment is correct.
875
876         * bmalloc/Algorithm.h:
877         (bmalloc::bitwise_cast): Copied from WTF/wtf/StdLibextras.h
878         * bmalloc/IsoDirectoryPageInlines.h:
879         (bmalloc::IsoDirectoryPage<Config>::pageFor):
880         * bmalloc/IsoPageInlines.h:
881         (bmalloc::IsoPage<Config>::startAllocating):
882
883 2018-10-03  Dan Bernstein  <mitz@apple.com>
884
885         bmalloc part of [Xcode] Update some build settings as recommended by Xcode 10
886         https://bugs.webkit.org/show_bug.cgi?id=190250
887
888         Reviewed by Alex Christensen.
889
890         * Configurations/Base.xcconfig: Enabled CLANG_WARN_COMMA, CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS,
891           and CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF.
892
893         * bmalloc.xcodeproj/project.pbxproj: Let Xcode update LastUpgradeCheck.
894
895 2018-09-25  Alex Christensen  <achristensen@webkit.org>
896
897         Allow for suffixes to com.apple.WebKit.WebContent
898         https://bugs.webkit.org/show_bug.cgi?id=189972
899
900         Reviewed by Chris Dumez.
901
902         * bmalloc/ProcessCheck.mm:
903         (bmalloc::gigacageEnabledForProcess):
904
905 2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
906
907         Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
908         https://bugs.webkit.org/show_bug.cgi?id=189733
909
910         Reviewed by Michael Catanzaro.
911
912         * bmalloc/BCompiler.h:
913
914 2018-08-27  Keith Rollin  <krollin@apple.com>
915
916         Unreviewed build fix -- disable LTO for production builds
917
918         * Configurations/Base.xcconfig:
919
920 2018-08-27  Keith Rollin  <krollin@apple.com>
921
922         Build system support for LTO
923         https://bugs.webkit.org/show_bug.cgi?id=187785
924         <rdar://problem/42353132>
925
926         Reviewed by Dan Bernstein.
927
928         Update Base.xcconfig and DebugRelease.xcconfig to optionally enable
929         LTO.
930
931         * Configurations/Base.xcconfig:
932         * Configurations/DebugRelease.xcconfig:
933
934 2018-08-16  Tomas Popela  <tpopela@redhat.com>
935
936         bmalloc: Coverity scan issues
937         https://bugs.webkit.org/show_bug.cgi?id=186763
938
939         Reviewed by Saam Barati.
940
941         * bmalloc/DebugHeap.h: Initialize the m_pageSize variable.
942         * bmalloc/IsoTLS.cpp:
943         (bmalloc::IsoTLS::ensureEntries): Check the return value of
944         pthread_key_create return().
945         * bmalloc/VMAllocate.h:
946         (bmalloc::vmPageSize): Correctly check the return value of sysconf().
947
948 2018-07-27  Mark Lam  <mark.lam@apple.com>
949
950         Initialize bmalloc::DebugHeap::m_pageSize for non-Darwin builds.
951         https://bugs.webkit.org/show_bug.cgi?id=188132
952         <rdar://problem/40401599>
953
954         Reviewed by Saam Barati.
955
956         * bmalloc/DebugHeap.cpp:
957         (bmalloc::DebugHeap::DebugHeap):
958
959 2018-07-27  Saam Barati  <sbarati@apple.com>
960
961         Explicitly handle memlimit_active < 0
962         https://bugs.webkit.org/show_bug.cgi?id=188125
963
964         Reviewed by Mark Lam.
965
966         This may come up during development when someone wants the limit
967         to be "infinite".
968
969         * bmalloc/AvailableMemory.cpp:
970         (bmalloc::jetsamLimit):
971
972 2018-07-27  Saam Barati  <sbarati@apple.com>
973
974         Use SPI to compute the jetsam limit on iOS instead of hardcoding 840MB
975         https://bugs.webkit.org/show_bug.cgi?id=188091
976         <rdar://problem/42647697>
977
978         Reviewed by Simon Fraser.
979
980         We want bmalloc to dynamically adapt to the jetsam limit of the process
981         it's running in. WTF::ramSize() is based off bmalloc's availableMemory,
982         so it will now reflect the result of the real jetsam limit when we can
983         read it.
984         
985         Reading the jetsam limit requires an entitlement, so this patch opts in
986         the WebContent/Storage/Network processes. We fall back to 840MB (the
987         old hard coded value) when the SPI call fails (e.g, when we're in a
988         process without the proper entitlement).
989
990         * bmalloc.xcodeproj/project.pbxproj:
991         * bmalloc/AvailableMemory.cpp:
992         (bmalloc::jetsamLimit):
993         (bmalloc::computeAvailableMemory):
994         * bmalloc/darwin/MemoryStatusSPI.h: Added.
995
996 2018-07-24  Saam Barati  <sbarati@apple.com>
997
998         Revert back to using phys_footprint to calculate isUnderMemoryPressure()
999         https://bugs.webkit.org/show_bug.cgi?id=187919
1000         <rdar://problem/42552888>
1001
1002         Reviewed by Simon Fraser.
1003
1004         Currently on iOS, bmalloc will run the scavenger more frequently when it detects
1005         that the process is under memory pressure. However, it only uses bmalloc's
1006         own footprint as a percentage of the HW available memory to determine if
1007         the process is under memory pressure. This is a change I recently made
1008         in an effort to run the scavenger less when bmalloc wasn't contributing
1009         to the dirty footprint in the process. However, this fails to run the
1010         scavenger eagerly when the process in question has a heap split
1011         between a lot of dirty bmalloc memory as well as a lot of dirty memory
1012         from elsewhere. We also have evidence that we may have increased jetsams
1013         in the Web Content process. Since my original change was not a measurable
1014         speedup, this patch reverts isUnderMemoryPressure() to its previous
1015         behavior of using phys_footprint to determine if 75% of the available 
1016         HW memory is being used.
1017
1018         * bmalloc/AvailableMemory.cpp:
1019         (bmalloc::memoryStatus):
1020
1021 2019-07-12  Michael Saboff  <msaboff@apple.com>
1022
1023         Disable IsoHeaps when Gigacage is off
1024         https://bugs.webkit.org/show_bug.cgi?id=187160
1025
1026         Reviewed by Saam Barati.
1027
1028         Relanding change sets 233547 and 233550 with the added fix that Gigacage is also
1029         enabled for DumpRenderTree.
1030
1031         Updated determineMallocFallbackState to base enabling of Iso Heaps on Gigacage 
1032         being enabled.  We do this because if Gigacage is disabled, it may be due to lack
1033         of address space.
1034
1035         To work around a compiler issue uncovered by the change above, I added explicit
1036         instantiation of PerThread's static variables.  Defined the same explicit
1037         instantiated static variables with export scope in the new file PerThread.cpp
1038         to eliminate separate variables allocations in each linked framework / library.
1039
1040         * CMakeLists.txt:
1041         * bmalloc.xcodeproj/project.pbxproj:
1042         * bmalloc/IsoTLS.cpp:
1043         (bmalloc::IsoTLS::determineMallocFallbackState):
1044         * bmalloc/PerThread.cpp: Added.
1045         * bmalloc/PerThread.h:
1046         * bmalloc/ProcessCheck.mm:
1047         (bmalloc::gigacageEnabledForProcess):
1048
1049 2018-07-09  Commit Queue  <commit-queue@webkit.org>
1050
1051         Unreviewed, rolling out r233547 and r233550.
1052         https://bugs.webkit.org/show_bug.cgi?id=187497
1053
1054         Introduced flakiness for media/fullscreen-* tests on mac-wk1
1055         (Requested by ryanhaddad on #webkit).
1056
1057         Reverted changesets:
1058
1059         "Disable IsoHeaps when Gigacage is off"
1060         https://bugs.webkit.org/show_bug.cgi?id=187160
1061         https://trac.webkit.org/changeset/233547
1062
1063         "Build fix (r233547): Disable IsoHeaps when Gigacage is off"
1064         https://bugs.webkit.org/show_bug.cgi?id=187160
1065         https://trac.webkit.org/changeset/233550
1066
1067 2018-07-05  David Kilzer  <ddkilzer@apple.com>
1068
1069         Build fix (r233547): Disable IsoHeaps when Gigacage is off
1070         <https://webkit.org/b/187160>
1071
1072         * bmalloc/PerThread.cpp: Add #if !HAVE_PTHREAD_MACHDEP_H/#endif
1073         around variables only used when that macro is 0.  Include what
1074         you use: Cache.h and Heap.h.
1075         * bmalloc/PerThread.h: Include <memory> for std::once_flag.
1076
1077 2018-07-05  Michael Saboff  <msaboff@apple.com>
1078
1079         Disable IsoHeaps when Gigacage is off
1080         https://bugs.webkit.org/show_bug.cgi?id=187160
1081
1082         Reviewed by Saam Barati.
1083
1084         Updated determineMallocFallbackState to base enabling of Iso Heaps on Gigacage 
1085         being enabled.  We do this because if Gigacage is disabled, it may be due to lack
1086         of address space.
1087
1088         To work around a compiler issue uncovered by the change above, I added explicit
1089         instantiation of PerThread's static variables.  Defined the same explicit
1090         instantiated static variables with export scope in the new file PerThread.cpp
1091         to eliminate separate variables allocations in each linked framework / library.
1092
1093         * CMakeLists.txt:
1094         * bmalloc.xcodeproj/project.pbxproj:
1095         * bmalloc/IsoTLS.cpp:
1096         (bmalloc::IsoTLS::determineMallocFallbackState):
1097         * bmalloc/PerThread.cpp: Added.
1098         * bmalloc/PerThread.h:
1099
1100 2018-07-04  Tim Horton  <timothy_horton@apple.com>
1101
1102         Introduce PLATFORM(IOSMAC)
1103         https://bugs.webkit.org/show_bug.cgi?id=187315
1104
1105         Reviewed by Dan Bernstein.
1106
1107         * Configurations/Base.xcconfig:
1108
1109 2018-06-29  Ryan Haddad  <ryanhaddad@apple.com>
1110
1111         Unreviewed, rolling out r233347.
1112
1113         Causes crashes during WK1 tests.
1114
1115         Reverted changeset:
1116
1117         "Disable IsoHeaps when Gigacage is off"
1118         https://bugs.webkit.org/show_bug.cgi?id=187160
1119         https://trac.webkit.org/changeset/233347
1120
1121 2018-06-28  Michael Saboff  <msaboff@apple.com>
1122
1123         Disable IsoHeaps when Gigacage is off
1124         https://bugs.webkit.org/show_bug.cgi?id=187160
1125
1126         Reviewed by Saam Barati.
1127
1128         If Gigacage is disabled, it may be due to lack of address space.
1129         Therefore we should also turn off IsoHeaps since it uses more virtual
1130         address space as well.
1131
1132         * bmalloc/IsoTLS.cpp:
1133         (bmalloc::IsoTLS::determineMallocFallbackState):
1134
1135 2018-06-27  Simon Fraser  <simon.fraser@apple.com>
1136
1137         https://hackernoon.com/ uses lots of layer backing store
1138         https://bugs.webkit.org/show_bug.cgi?id=186909
1139         rdar://problem/40257540
1140
1141         Reviewed by Tim Horton.
1142         
1143         Drive-by typo fix.
1144
1145         * bmalloc/Scavenger.cpp:
1146         (bmalloc::dumpStats):
1147
1148 2018-06-26  Saam Barati  <sbarati@apple.com>
1149
1150         Unreviewed followup. Fix the watchos build after r233192.
1151
1152         This patch also correct the changelog entry below to have the correct
1153         bug and title info.
1154
1155         * bmalloc/ProcessCheck.mm:
1156
1157 2018-06-26  Saam Barati  <sbarati@apple.com>
1158
1159         Switch to system malloc on iOS when nano malloc is disabled
1160         https://bugs.webkit.org/show_bug.cgi?id=186322
1161         <rdar://problem/41140257>
1162
1163         Reviewed by Keith Miller.
1164
1165         We have evidence showing that processes with small heaps using the
1166         JS API are more space efficient when using system malloc. Our main
1167         hypothesis as to why this is, is that when dealing with small heaps,
1168         one malloc can be more efficient at optimizing memory usage than
1169         two mallocs.
1170
1171         * bmalloc/BPlatform.h:
1172         * bmalloc/Environment.cpp:
1173         (bmalloc::isNanoMallocEnabled):
1174         (bmalloc::Environment::computeIsDebugHeapEnabled):
1175         * bmalloc/ProcessCheck.h:
1176         (bmalloc::shouldProcessUnconditionallyUseBmalloc):
1177         * bmalloc/ProcessCheck.mm:
1178         (bmalloc::shouldProcessUnconditionallyUseBmalloc):
1179
1180 2018-06-24  Yusuke Suzuki  <utatane.tea@gmail.com>
1181
1182         [bmalloc][Linux] Remove static initializers for PerProcess<>::s_object
1183         https://bugs.webkit.org/show_bug.cgi?id=186966
1184
1185         Reviewed by Anders Carlsson.
1186
1187         chrome/tools/linux/dump-static-initializers.py can dump static initializers
1188         in the binary and we found that PerProcess<>::s_object initialization is done
1189         by static initializers in GCC + Linux environments. The example is the following.
1190
1191         Scavenger.cpp (initializer offset 0x38c210 size 0x3e)
1192             _GLOBAL__sub_I_Scavenger.cpp+0x1e
1193             _GLOBAL__sub_I_Scavenger.cpp+0x2d
1194             _GLOBAL__sub_I_Scavenger.cpp+0x3c
1195             _GLOBAL__sub_I_Scavenger.cpp+0xf
1196             guard variable for bmalloc::PerProcess<bmalloc::AllIsoHeaps>::s_object@@Base-0x3f0d8
1197             guard variable for bmalloc::PerProcess<bmalloc::Environment>::s_object@@Base-0x3f0e8
1198             guard variable for bmalloc::PerProcess<bmalloc::PerHeapKind<bmalloc::Heap> >::s_object@@Base-0x3c600
1199             guard variable for bmalloc::PerProcess<bmalloc::Scavenger>::s_object@@Base-0x38ce8
1200
1201         We can remove this by initializing `nullptr`, which leads to constexpr initialization.
1202         After this change, Linux JSCOnly libJavaScriptCore.so has no static initializers.
1203
1204         * bmalloc/PerProcess.h:
1205
1206 2018-06-09  Dan Bernstein  <mitz@apple.com>
1207
1208         [Xcode] Clean up and modernize some build setting definitions
1209         https://bugs.webkit.org/show_bug.cgi?id=186463
1210
1211         Reviewed by Sam Weinig.
1212
1213         * Configurations/Base.xcconfig: Removed definition for macOS 10.11.
1214         * Configurations/DebugRelease.xcconfig: Ditto.
1215
1216 2018-06-07  Darin Adler  <darin@apple.com>
1217
1218         [Cocoa] Turn on ARC for the single Objective-C++ source file in bmalloc
1219         https://bugs.webkit.org/show_bug.cgi?id=186398
1220
1221         Reviewed by Saam Barati.
1222
1223         * Configurations/Base.xcconfig: Turn on ARC.
1224         * bmalloc/ProcessCheck.mm:
1225         (bmalloc::gigacageEnabledForProcess): Removed the globals from this function,
1226         since it's only called once. If it was called more than once, we could optimize
1227         that with a single boolean global rather than two strings and two booleans.
1228
1229 2018-06-07  David Kilzer  <ddkilzer@apple.com>
1230
1231         bmalloc: Fix 'noreturn' warnings when compiling with -std=gnu++17
1232         <https://webkit.org/b/186400>
1233
1234         Reviewed by Saam Barati.
1235
1236         Fixes the following warnings when compiling with gnu++17:
1237
1238             Source/bmalloc/bmalloc/Scavenger.cpp:363:1: error: function 'threadRunLoop' could be declared with attribute 'noreturn' [-Werror,-Wmissing-noreturn]
1239             {
1240             ^
1241             Source/bmalloc/bmalloc/Scavenger.cpp:358:1: error: function 'threadEntryPoint' could be declared with attribute 'noreturn' [-Werror,-Wmissing-noreturn]
1242             {
1243             ^
1244
1245         * bmalloc/BCompiler.h:
1246         (BCOMPILER): Add support for the BCOMPILER() macro, then add
1247         BCOMPILER(GCC_OR_CLANG).  Taken from Source/WTF/wtf/Compiler.h.
1248         (BNO_RETURN): Implement 'norerturn' support using the new
1249         BCOMPILER() macros.  Taken from Source/WTF/wtf/Compiler.h.
1250         * bmalloc/Scavenger.cpp:
1251         (bmalloc::Scavenger::threadRunLoop): Remove the workaround that
1252         tricked older compilers into thinking the while() loop wasn't
1253         infinite.
1254         * bmalloc/Scavenger.h:
1255         (bmalloc::Scavenger::threadEntryPoint): Add BNO_RETURN attribute.
1256         (bmalloc::Scavenger::threadRunLoop): Ditto.
1257
1258 2018-05-29  Saam Barati  <sbarati@apple.com>
1259
1260         JSC should put bmalloc's scavenger into mini mode
1261         https://bugs.webkit.org/show_bug.cgi?id=185988
1262
1263         Reviewed by Michael Saboff.
1264
1265         We expose an API for putting bmalloc into mini mode. All that means now
1266         is that we'll run the scavenger more aggressively.
1267
1268         * bmalloc/Scavenger.cpp:
1269         (bmalloc::Scavenger::enableMiniMode):
1270         (bmalloc::Scavenger::threadRunLoop):
1271         * bmalloc/Scavenger.h:
1272         * bmalloc/Sizes.h:
1273         * bmalloc/bmalloc.cpp:
1274         (bmalloc::api::enableMiniMode):
1275         * bmalloc/bmalloc.h:
1276
1277 2018-05-29  Geoffrey Garen  <ggaren@apple.com>
1278
1279         Fixed the bmalloc build
1280         https://bugs.webkit.org/show_bug.cgi?id=186025
1281
1282         Reviewed by Sam Weinig.
1283
1284         * bmalloc.xcodeproj/project.pbxproj: Link Foundation because the 
1285         gigacage check needs it.
1286
1287 2018-05-23  Antti Koivisto  <antti@apple.com>
1288
1289         Increase the simulated memory size on PLATFORM(IOS_SIMULATOR) from 512MB to 1024MB
1290         https://bugs.webkit.org/show_bug.cgi?id=185908
1291
1292         Reviewed by Geoffrey Garen.
1293
1294         We don't support 512MB devices anymore. This will make the simulator behave more
1295         like a real device.
1296
1297         * bmalloc/AvailableMemory.cpp:
1298         (bmalloc::memorySizeAccordingToKernel):
1299
1300         Factor to a function.
1301         Don't use availableMemoryGuess for the simulator value as it is not a guess.
1302
1303         (bmalloc::computeAvailableMemory):
1304
1305         Apply the same adjustments to the simulated value too.
1306
1307 2018-05-22  Ryan Haddad  <ryanhaddad@apple.com>
1308
1309         Unreviewed, rolling out r232052.
1310
1311         Breaks internal builds.
1312
1313         Reverted changeset:
1314
1315         "Use more C++17"
1316         https://bugs.webkit.org/show_bug.cgi?id=185176
1317         https://trac.webkit.org/changeset/232052
1318
1319 2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
1320
1321         Define GIGACAGE_ALLOCATION_CAN_FAIL on Linux
1322         https://bugs.webkit.org/show_bug.cgi?id=183329
1323
1324         Reviewed by Michael Catanzaro.
1325
1326         We specify `GIGACAGE_ALLOCATION_CAN_FAIL 1` in Linux since
1327         Linux can fail to `mmap` if `vm.overcommit_memory = 2`.
1328         Users can enable Gigacage if users enable overcommit_memory.
1329
1330         * bmalloc/Gigacage.h:
1331
1332 2018-05-21  Yusuke Suzuki  <utatane.tea@gmail.com>
1333
1334         Use more C++17
1335         https://bugs.webkit.org/show_bug.cgi?id=185176
1336
1337         Reviewed by JF Bastien.
1338
1339         Add BNO_RETURN.
1340
1341         * Configurations/Base.xcconfig:
1342         * bmalloc/BCompiler.h:
1343         * bmalloc/Scavenger.h:
1344
1345 2018-05-06  Yusuke Suzuki  <utatane.tea@gmail.com>
1346
1347         [JSC] Remove "using namespace std;" from JSC, bmalloc, WTF
1348         https://bugs.webkit.org/show_bug.cgi?id=185362
1349
1350         Reviewed by Sam Weinig.
1351
1352         * bmalloc/Allocator.cpp:
1353         * bmalloc/Deallocator.cpp:
1354
1355 2018-05-03  Filip Pizlo  <fpizlo@apple.com>
1356
1357         Strings should not be allocated in a gigacage
1358         https://bugs.webkit.org/show_bug.cgi?id=185218
1359
1360         Reviewed by Saam Barati.
1361         
1362         This removes the string gigacage.
1363         
1364         Putting strings in a gigacage prevents read gadgets. The other things that get to be in gigacages
1365         are there to prevent read-write gadgets.
1366         
1367         Also, putting strings in a gigacage seems to have been a bigger regression than putting other
1368         things in gigacages.
1369         
1370         Therefore, to maximize the benefit/cost ratio of gigacages, we should evict strings from them. If
1371         we want to throw away perf for security, there are more beneficial things to sacrifice.
1372
1373         * bmalloc/Gigacage.h:
1374         (Gigacage::name):
1375         (Gigacage::basePtr):
1376         (Gigacage::size):
1377         (Gigacage::forEachKind):
1378         * bmalloc/HeapKind.h:
1379         (bmalloc::isGigacage):
1380         (bmalloc::gigacageKind):
1381         (bmalloc::heapKind):
1382         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
1383         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
1384
1385 2018-04-30  Yusuke Suzuki  <utatane.tea@gmail.com>
1386
1387         Use WordLock instead of std::mutex for Threading
1388         https://bugs.webkit.org/show_bug.cgi?id=185121
1389
1390         Reviewed by Geoffrey Garen.
1391
1392         Add constexpr to explicitly describe that bmalloc::Mutex constructor is constexpr.
1393
1394         * bmalloc/Mutex.h:
1395
1396 2018-04-23  Ting-Wei Lan  <lantw44@gmail.com>
1397
1398         Include stdio.h before using stderr
1399         https://bugs.webkit.org/show_bug.cgi?id=184872
1400
1401         Reviewed by Yusuke Suzuki.
1402
1403         * bmalloc/PerProcess.cpp:
1404         * bmalloc/Scavenger.cpp:
1405
1406 2018-04-21  Yusuke Suzuki  <utatane.tea@gmail.com>
1407
1408         Unreviewed, follow-up patch after r230474
1409         https://bugs.webkit.org/show_bug.cgi?id=166684
1410
1411         Add "JavaScriptCore" to Darwin name. And use short name "BMScavenger"
1412         for Linux since adding "JavaScriptCore" makes the name too long for Linux.
1413
1414         * bmalloc/Scavenger.cpp:
1415         (bmalloc::Scavenger::threadRunLoop):
1416
1417 2018-04-18  Jer Noble  <jer.noble@apple.com>
1418
1419         Don't put build products into WK_ALTERNATE_WEBKIT_SDK_PATH for engineering builds
1420         https://bugs.webkit.org/show_bug.cgi?id=184762
1421
1422         Reviewed by Dan Bernstein.
1423
1424         * Configurations/Base.xcconfig:
1425
1426 2018-04-20  Daniel Bates  <dabates@apple.com>
1427
1428         Remove code for compilers that did not support NSDMI for aggregates
1429         https://bugs.webkit.org/show_bug.cgi?id=184599
1430
1431         Reviewed by Per Arne Vollan.
1432
1433         Remove workaround for earlier Visual Studio versions that did not support non-static data
1434         member initializers (NSDMI) for aggregates. We have since updated all the build.webkit.org
1435         and EWS bots to a newer version that supports this feature.
1436
1437         * bmalloc/BPlatform.h:
1438         * bmalloc/List.h:
1439         (bmalloc::ListNode::ListNode): Deleted.
1440         (bmalloc::List::iterator::iterator): Deleted.
1441
1442 2018-04-19  David Kilzer  <ddkilzer@apple.com>
1443
1444         Enable Objective-C weak references
1445         <https://webkit.org/b/184789>
1446         <rdar://problem/39571716>
1447
1448         Reviewed by Dan Bernstein.
1449
1450         * Configurations/Base.xcconfig:
1451         (CLANG_ENABLE_OBJC_WEAK): Enable.
1452
1453 2018-04-12  Saam Barati  <sbarati@apple.com>
1454
1455         Lessen partial scavenge interval on x86-64
1456         https://bugs.webkit.org/show_bug.cgi?id=184577
1457
1458         Rubber-stamped by Filip Pizlo.
1459
1460         I initially made the scavenge interval longer because I had thought the
1461         shorter interval caused a JetStream regression. I was mistaken though.
1462         I was looking at the wrong commit range when analyzing perf data.
1463         
1464         This patch shortens the interval, but still keeps x86-64 50% longer than
1465         other architectures. We know that scavenging frequently on Mac is less
1466         important to overall system performance than it is on iOS.
1467
1468         * bmalloc/Scavenger.cpp:
1469         (bmalloc::Scavenger::threadRunLoop):
1470
1471 2018-04-12  Saam Barati  <sbarati@apple.com>
1472
1473         Raise the partial scavenge interval even more on x86-64
1474         https://bugs.webkit.org/show_bug.cgi?id=184551
1475
1476         Rubber-stamped by Filip Pizlo.
1477
1478         The JetStream regression didn't recover from my previous patch.
1479         This is another attempt to get it to recover perf.
1480
1481         * bmalloc/Scavenger.cpp:
1482         (bmalloc::Scavenger::threadRunLoop):
1483
1484 2018-04-11  Saam Barati  <sbarati@apple.com>
1485
1486         raise partial scavenge interval on x86-64
1487         https://bugs.webkit.org/show_bug.cgi?id=184521
1488
1489         Rubber-stamped by Filip Pizlo.
1490
1491         This patch is an attempt to recover the 1-3% JetStream regression
1492         my initial partial scavenging patch introduced on some Macs.
1493
1494         * bmalloc/Scavenger.cpp:
1495         (bmalloc::Scavenger::threadRunLoop):
1496
1497 2018-04-10  Saam Barati  <sbarati@apple.com>
1498
1499         IsoHeapImpl::scavenge* needs to grab the lock
1500         https://bugs.webkit.org/show_bug.cgi?id=184461
1501
1502         Reviewed by Filip Pizlo.
1503
1504         Another thread could be modifying the linked list that the scavenge* methods traverse.
1505
1506         * bmalloc/IsoHeapImplInlines.h:
1507         (bmalloc::IsoHeapImpl<Config>::scavenge):
1508         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark):
1509
1510 2018-04-10  Saam Barati  <sbarati@apple.com>
1511
1512         bmalloc should do partial scavenges more frequently
1513         https://bugs.webkit.org/show_bug.cgi?id=184176
1514
1515         Reviewed by Filip Pizlo.
1516
1517         This patch adds the ability for bmalloc to do a partial scavenge.
1518         bmalloc will now do a partial scavenge with some frequency even
1519         when the heap is growing.
1520         
1521         For Heap, this means tracking the high water mark of where the Heap
1522         has allocated since the last scavenge. Partial scavenging is just
1523         decommitting entries in the LargeMap that are past this high water
1524         mark. Because we allocate in first fit order out of LargeMap, tracking
1525         the high water mark is a good heuristic of how much memory a partial
1526         scavenge should decommit.
1527         
1528         For IsoHeaps, each IsoDirectory also keeps track of its high water mark
1529         for the furthest page it allocates into. Similar to Heap, we scavenge pages
1530         past that high water mark. IsoHeapImpl then tracks the high water mark
1531         for the IsoDirectory it allocates into. We then scavenge all directories 
1532         including and past the directory high water mark. This includes scavenging
1533         the inline directory when its the only thing we allocate out of since
1534         the last scavenge.
1535         
1536         This patch also adds some other capabilities to bmalloc:
1537         
1538         Heaps and IsoHeaps now track how much memory is freeable. Querying
1539         this number is now cheap.
1540         
1541         Heaps no longer hold the global lock when decommitting large ranges.
1542         Instead, that range is just marked as non eligible to be allocated.
1543         Then, without the lock held, the scavenger will decommit those ranges.
1544         Once this is done, the scavenger will then reacquire the lock and mark
1545         these ranges as eligible. This lessens lock contention between the
1546         scavenger and the allocation slow path since threads that are taking an
1547         allocation slow path can now allocate concurrently to the scavenger's
1548         decommits. The main consideration in adding this functionality is that
1549         a large allocation may fail while the scavenger is in the process of
1550         decommitting memory. When the Heap fails to allocate a large range when
1551         the scavenger is in the middle of a decommit, Heap will wait for the
1552         Scavenger to finish and then it will try to allocate a large range again.
1553         
1554         Decommitting from Heap now aggregates the ranges to decommit and tries to
1555         merge them together to lower the number of calls to vmDeallocatePhysicalPages.
1556         This is analogous to what IsoHeaps already do.
1557
1558         * bmalloc.xcodeproj/project.pbxproj:
1559         * bmalloc/Allocator.cpp:
1560         (bmalloc::Allocator::tryAllocate):
1561         (bmalloc::Allocator::allocateImpl):
1562         (bmalloc::Allocator::reallocate):
1563         (bmalloc::Allocator::refillAllocatorSlowCase):
1564         (bmalloc::Allocator::allocateLarge):
1565         * bmalloc/BulkDecommit.h: Added.
1566         (bmalloc::BulkDecommit::addEager):
1567         (bmalloc::BulkDecommit::addLazy):
1568         (bmalloc::BulkDecommit::processEager):
1569         (bmalloc::BulkDecommit::processLazy):
1570         (bmalloc::BulkDecommit::add):
1571         (bmalloc::BulkDecommit::process):
1572         * bmalloc/Deallocator.cpp:
1573         (bmalloc::Deallocator::scavenge):
1574         (bmalloc::Deallocator::processObjectLog):
1575         (bmalloc::Deallocator::deallocateSlowCase):
1576         * bmalloc/Deallocator.h:
1577         (bmalloc::Deallocator::lineCache):
1578         * bmalloc/Heap.cpp:
1579         (bmalloc::Heap::freeableMemory):
1580         (bmalloc::Heap::markAllLargeAsEligibile):
1581         (bmalloc::Heap::decommitLargeRange):
1582         (bmalloc::Heap::scavenge):
1583         (bmalloc::Heap::scavengeToHighWatermark):
1584         (bmalloc::Heap::deallocateLineCache):
1585         (bmalloc::Heap::allocateSmallChunk):
1586         (bmalloc::Heap::deallocateSmallChunk):
1587         (bmalloc::Heap::allocateSmallPage):
1588         (bmalloc::Heap::deallocateSmallLine):
1589         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
1590         (bmalloc::Heap::allocateSmallBumpRangesByObject):
1591         (bmalloc::Heap::splitAndAllocate):
1592         (bmalloc::Heap::tryAllocateLarge):
1593         (bmalloc::Heap::allocateLarge):
1594         (bmalloc::Heap::isLarge):
1595         (bmalloc::Heap::largeSize):
1596         (bmalloc::Heap::shrinkLarge):
1597         (bmalloc::Heap::deallocateLarge):
1598         (bmalloc::Heap::externalCommit):
1599         (bmalloc::Heap::externalDecommit):
1600         * bmalloc/Heap.h:
1601         (bmalloc::Heap::allocateSmallBumpRanges):
1602         (bmalloc::Heap::derefSmallLine):
1603         * bmalloc/IsoDirectory.h:
1604         * bmalloc/IsoDirectoryInlines.h:
1605         (bmalloc::passedNumPages>::takeFirstEligible):
1606         (bmalloc::passedNumPages>::didBecome):
1607         (bmalloc::passedNumPages>::didDecommit):
1608         (bmalloc::passedNumPages>::scavengePage):
1609         (bmalloc::passedNumPages>::scavenge):
1610         (bmalloc::passedNumPages>::scavengeToHighWatermark):
1611         (bmalloc::passedNumPages>::freeableMemory): Deleted.
1612         * bmalloc/IsoHeapImpl.h:
1613         * bmalloc/IsoHeapImplInlines.h:
1614         (bmalloc::IsoHeapImpl<Config>::takeFirstEligible):
1615         (bmalloc::IsoHeapImpl<Config>::scavenge):
1616         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark):
1617         (bmalloc::IsoHeapImpl<Config>::freeableMemory):
1618         (bmalloc::IsoHeapImpl<Config>::isNowFreeable):
1619         (bmalloc::IsoHeapImpl<Config>::isNoLongerFreeable):
1620         * bmalloc/LargeMap.cpp:
1621         (bmalloc::LargeMap::remove):
1622         (bmalloc::LargeMap::markAllAsEligibile):
1623         * bmalloc/LargeMap.h:
1624         (bmalloc::LargeMap::size):
1625         (bmalloc::LargeMap::at):
1626         * bmalloc/LargeRange.h:
1627         (bmalloc::LargeRange::setEligible):
1628         (bmalloc::LargeRange::isEligibile const):
1629         (bmalloc::canMerge):
1630         * bmalloc/ObjectType.cpp:
1631         (bmalloc::objectType):
1632         * bmalloc/Scavenger.cpp:
1633         (bmalloc::PrintTime::PrintTime):
1634         (bmalloc::PrintTime::~PrintTime):
1635         (bmalloc::PrintTime::print):
1636         (bmalloc::Scavenger::timeSinceLastFullScavenge):
1637         (bmalloc::Scavenger::timeSinceLastPartialScavenge):
1638         (bmalloc::Scavenger::scavenge):
1639         (bmalloc::Scavenger::partialScavenge):
1640         (bmalloc::Scavenger::freeableMemory):
1641         (bmalloc::Scavenger::threadRunLoop):
1642         * bmalloc/Scavenger.h:
1643         * bmalloc/SmallLine.h:
1644         (bmalloc::SmallLine::refCount):
1645         (bmalloc::SmallLine::ref):
1646         (bmalloc::SmallLine::deref):
1647         * bmalloc/SmallPage.h:
1648         (bmalloc::SmallPage::refCount):
1649         (bmalloc::SmallPage::hasFreeLines const):
1650         (bmalloc::SmallPage::setHasFreeLines):
1651         (bmalloc::SmallPage::ref):
1652         (bmalloc::SmallPage::deref):
1653         * bmalloc/bmalloc.cpp:
1654         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1655         (bmalloc::api::freeLargeVirtual):
1656
1657 2018-04-09  Yusuke Suzuki  <utatane.tea@gmail.com>
1658
1659         [bmalloc] Name Scavenger thread "bmalloc scavenger"
1660         https://bugs.webkit.org/show_bug.cgi?id=166684
1661
1662         Reviewed by Saam Barati.
1663
1664         We name the thread for bmalloc Scavenger "bmalloc scavenger".
1665         It is useful for debugging. In Linux environment, it will be
1666         shown in GDB.
1667
1668         * bmalloc/Scavenger.cpp:
1669         (bmalloc::Scavenger::threadRunLoop):
1670         (bmalloc::Scavenger::setName):
1671         * bmalloc/Scavenger.h:
1672
1673 2018-04-09  Michael Catanzaro  <mcatanzaro@igalia.com>
1674
1675         Rename UNUSED to BUNUSED
1676         https://bugs.webkit.org/show_bug.cgi?id=184093
1677
1678         Reviewed by Yusuke Suzuki.
1679
1680         * bmalloc/BAssert.h:
1681         * bmalloc/VMAllocate.h:
1682         (bmalloc::vmValidate):
1683         (bmalloc::vmValidatePhysical):
1684
1685 2018-04-08  Yusuke Suzuki  <utatane.tea@gmail.com>
1686
1687         Use alignas instead of compiler-specific attributes
1688         https://bugs.webkit.org/show_bug.cgi?id=183508
1689
1690         Reviewed by Mark Lam.
1691
1692         Use alignas for g_gigacageBasePtr. We also add reinterpret_cast to fix
1693         compile errors in ARMv7 and MIPS JSCOnly ports.
1694
1695         * bmalloc/Gigacage.cpp:
1696         * bmalloc/Gigacage.h:
1697         (Gigacage::basePtrs):
1698
1699 2018-04-06  Saam Barati  <sbarati@apple.com>
1700
1701         bmalloc virtual allocation API should not treat memory it vends as dirty with respect to how it drives the scavenger
1702         https://bugs.webkit.org/show_bug.cgi?id=184342
1703
1704         Reviewed by Mark Lam.
1705
1706         Currently, the only user of this API is Wasm. Ideally, Wasm would tell
1707         us exactly which page is dirtied. We should really do that at some point:
1708         https://bugs.webkit.org/show_bug.cgi?id=184207
1709         
1710         However, until we do that, it's better to treat none of the virtual memory
1711         we vend as dirty, versus what we do now, which is treat it all as dirty.
1712         This dirty memory tracking helps drive the scavenger, so on iOS, having the
1713         scavenger think its under memory pressure because of memory it can't free isn't
1714         useful.
1715
1716         * bmalloc/bmalloc.cpp:
1717         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1718         (bmalloc::api::freeLargeVirtual):
1719         * bmalloc/bmalloc.h:
1720
1721 2018-04-05  Saam Barati  <sbarati@apple.com>
1722
1723         IsoHeapImpl not IsoHeapImplBase should add itself to AllIsoHeaps
1724         https://bugs.webkit.org/show_bug.cgi?id=184174
1725
1726         Reviewed by Filip Pizlo.
1727
1728         Otherwise, another thread may see a non-fully formed IsoHeapImpl.
1729
1730         * bmalloc/IsoHeapImpl.cpp:
1731         (bmalloc::IsoHeapImplBase::IsoHeapImplBase):
1732         (bmalloc::IsoHeapImplBase::addToAllIsoHeaps):
1733         * bmalloc/IsoHeapImpl.h:
1734         * bmalloc/IsoHeapImplInlines.h:
1735         (bmalloc::IsoHeapImpl<Config>::IsoHeapImpl):
1736
1737 2018-04-05  Yusuke Suzuki  <utatane.tea@gmail.com>
1738
1739         bmalloc StaticMutex's constructor should be constexpr
1740         https://bugs.webkit.org/show_bug.cgi?id=180600
1741
1742         Reviewed by Mark Lam.
1743
1744         StaticMutex and Mutex can be unified. This patch changes std::atomic_flag in StaticMutex
1745         to std::atomic<bool> to add constexpr constructor to StaticMutex. Then, StaticMutex can
1746         be initialized in static storage without calling any static initializers.
1747         And we also rename StaticMutex to Mutex simply.
1748
1749         * CMakeLists.txt:
1750         * bmalloc.xcodeproj/project.pbxproj:
1751         * bmalloc/AllIsoHeaps.cpp:
1752         (bmalloc::AllIsoHeaps::AllIsoHeaps):
1753         * bmalloc/AllIsoHeaps.h:
1754         * bmalloc/Allocator.cpp:
1755         (bmalloc::Allocator::tryAllocate):
1756         (bmalloc::Allocator::allocateImpl):
1757         (bmalloc::Allocator::reallocate):
1758         (bmalloc::Allocator::refillAllocatorSlowCase):
1759         (bmalloc::Allocator::allocateLarge):
1760         * bmalloc/CryptoRandom.cpp:
1761         (bmalloc::ARC4RandomNumberGenerator::ARC4RandomNumberGenerator):
1762         * bmalloc/Deallocator.cpp:
1763         (bmalloc::Deallocator::scavenge):
1764         (bmalloc::Deallocator::processObjectLog):
1765         (bmalloc::Deallocator::deallocateSlowCase):
1766         * bmalloc/Deallocator.h:
1767         (bmalloc::Deallocator::lineCache):
1768         * bmalloc/DebugHeap.cpp:
1769         (bmalloc::DebugHeap::DebugHeap):
1770         * bmalloc/DebugHeap.h:
1771         * bmalloc/Environment.cpp:
1772         (bmalloc::Environment::Environment):
1773         * bmalloc/Environment.h:
1774         * bmalloc/Gigacage.cpp:
1775         (Gigacage::disablePrimitiveGigacage):
1776         (Gigacage::addPrimitiveDisableCallback):
1777         (Gigacage::removePrimitiveDisableCallback):
1778         * bmalloc/Heap.cpp:
1779         (bmalloc::Heap::Heap):
1780         (bmalloc::Heap::freeableMemory):
1781         (bmalloc::Heap::scavenge):
1782         (bmalloc::Heap::deallocateLineCache):
1783         (bmalloc::Heap::allocateSmallChunk):
1784         (bmalloc::Heap::allocateSmallPage):
1785         (bmalloc::Heap::deallocateSmallLine):
1786         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
1787         (bmalloc::Heap::allocateSmallBumpRangesByObject):
1788         (bmalloc::Heap::splitAndAllocate):
1789         (bmalloc::Heap::tryAllocateLarge):
1790         (bmalloc::Heap::allocateLarge):
1791         (bmalloc::Heap::isLarge):
1792         (bmalloc::Heap::largeSize):
1793         (bmalloc::Heap::shrinkLarge):
1794         (bmalloc::Heap::deallocateLarge):
1795         (bmalloc::Heap::externalCommit):
1796         (bmalloc::Heap::externalDecommit):
1797         * bmalloc/Heap.h:
1798         (bmalloc::Heap::mutex):
1799         (bmalloc::Heap::allocateSmallBumpRanges):
1800         (bmalloc::Heap::derefSmallLine):
1801         * bmalloc/IsoDeallocator.h:
1802         * bmalloc/IsoHeap.h:
1803         * bmalloc/IsoTLSDeallocatorEntry.h:
1804         * bmalloc/IsoTLSDeallocatorEntryInlines.h:
1805         (bmalloc::IsoTLSDeallocatorEntry<Config>::IsoTLSDeallocatorEntry):
1806         * bmalloc/IsoTLSInlines.h:
1807         (bmalloc::IsoTLS::ensureHeap):
1808         * bmalloc/IsoTLSLayout.cpp:
1809         (bmalloc::IsoTLSLayout::IsoTLSLayout):
1810         (bmalloc::IsoTLSLayout::add):
1811         * bmalloc/IsoTLSLayout.h:
1812         * bmalloc/Mutex.cpp: Renamed from Source/bmalloc/bmalloc/StaticMutex.cpp.
1813         (bmalloc::Mutex::lockSlowCase):
1814         * bmalloc/Mutex.h:
1815         (bmalloc::sleep):
1816         (bmalloc::waitUntilFalse):
1817         (bmalloc::Mutex::try_lock):
1818         (bmalloc::Mutex::lock):
1819         (bmalloc::Mutex::unlock):
1820         (bmalloc::Mutex::Mutex): Deleted.
1821         * bmalloc/ObjectType.cpp:
1822         (bmalloc::objectType):
1823         * bmalloc/PerProcess.cpp:
1824         (bmalloc::getPerProcessData):
1825         * bmalloc/PerProcess.h:
1826         (bmalloc::PerProcess::mutex):
1827         (bmalloc::PerProcess::getSlowCase):
1828         * bmalloc/Scavenger.cpp:
1829         (bmalloc::Scavenger::Scavenger):
1830         (bmalloc::Scavenger::scavenge):
1831         (bmalloc::Scavenger::freeableMemory):
1832         * bmalloc/Scavenger.h:
1833         * bmalloc/SmallLine.h:
1834         (bmalloc::SmallLine::refCount):
1835         (bmalloc::SmallLine::ref):
1836         (bmalloc::SmallLine::deref):
1837         * bmalloc/SmallPage.h:
1838         (bmalloc::SmallPage::refCount):
1839         (bmalloc::SmallPage::hasFreeLines const):
1840         (bmalloc::SmallPage::setHasFreeLines):
1841         (bmalloc::SmallPage::ref):
1842         (bmalloc::SmallPage::deref):
1843         * bmalloc/StaticMutex.h: Removed.
1844         * bmalloc/VMHeap.cpp:
1845         (bmalloc::VMHeap::VMHeap):
1846         * bmalloc/VMHeap.h:
1847         * bmalloc/Zone.cpp:
1848         (bmalloc::Zone::Zone):
1849         * bmalloc/Zone.h:
1850         * bmalloc/bmalloc.cpp:
1851         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1852         (bmalloc::api::freeLargeVirtual):
1853         (bmalloc::api::isEnabled):
1854         (bmalloc::api::setScavengerThreadQOSClass):
1855         * bmalloc/bmalloc.h:
1856
1857 2018-04-04  Konstantin Tokarev  <annulen@yandex.ru>
1858
1859         Enable Gigacage unconditionally when building JSCOnly on macOS (build fix)
1860         https://bugs.webkit.org/show_bug.cgi?id=184301
1861
1862         Reviewed by Yusuke Suzuki.
1863
1864         bmalloc/ProcessCheck.mm implements specific behavior for Mac and iOS ports,
1865         which is guarded with BPLATFORM(COCOA). if we don't enable BPLATFORM(MAC)
1866         or BPLATFORM(IOS) in JSCOnly, then BPLATFORM(COCOA) won't be defined
1867         as well, and code path from ProcessCheck.mm will not be taken.
1868
1869         * CMakeLists.txt: Exclude ProcessCheck.mm from port-independent file
1870         list.
1871         * PlatformMac.cmake: Build ProcessCheck.mm for Mac port.
1872         * bmalloc/BPlatform.h: Don't enable BPLATFORM(MAC) or BPLATFORM(IOS)
1873         when building JSCOnly port.
1874
1875 2018-04-03  Saam Barati  <sbarati@apple.com>
1876
1877         totalPhysicalSize calculation when splitting a range must account for double rounding effects
1878         https://bugs.webkit.org/show_bug.cgi?id=184275
1879
1880         Reviewed by Mark Lam.
1881
1882         The rounding error could happen when we split a range where the
1883         range's total physical size equals the range's total size. The
1884         rounding may cause the left size to lose a byte, and the right
1885         size to gain a byte. This caused the right side to be a byte
1886         large than its size.
1887
1888         * bmalloc/LargeRange.h:
1889         (bmalloc::LargeRange::LargeRange):
1890         (bmalloc::LargeRange::split const):
1891
1892 2018-04-02  Saam Barati  <sbarati@apple.com>
1893
1894         bmalloc should compute its own estimate of its footprint
1895         https://bugs.webkit.org/show_bug.cgi?id=184121
1896
1897         Reviewed by Filip Pizlo.
1898
1899         This patch makes it so that bmalloc keeps track of its own physical
1900         footprint.
1901         
1902         Doing this for IsoHeaps is trivial. It allocates/deallocates fixed
1903         page sizes at a time. IsoHeapImpl just updates a count every time
1904         a page is committed/decommitted.
1905         
1906         Making Heap keep its footprint was a bit trickier because of how
1907         LargeRange is constructed. Before this patch, LargeRange kept track
1908         of the amount of physical memory at the start of its range. This
1909         patch extends large range to also keep track of the total physical memory
1910         in the range just for footprint bookkeeping. This was needed to make
1911         Heap's footprint come close to resembling reality, because as we merge and split
1912         large ranges, the start physical size often becomes wildly inaccurate.
1913         The total physical size number stored in LargeRange is still just an
1914         estimate. It's possible that as ranges are split, that the total physical
1915         size split amongst the two ranges doesn't resemble reality. This can
1916         happen when the total physical size is really all in one end of the split,
1917         but we mark it as being proportionally split amongst the resulting two
1918         ranges. In practice, I did not notice this being a problem. The footprint
1919         estimate tracks reality very closely (in my testing, within less than 1MB for
1920         heaps with sizes upwards of 1GB). The other nice thing about total physical
1921         size is that even if it diverges from reality in terms of how memory is
1922         using up physical RAM, it stays internally consistent inside bmalloc's
1923         own data structures.
1924         
1925         The main oversight of this patch is how it deals with Wasm memory. All Wasm
1926         memory will be viewed by bmalloc as taking up physical space even when it
1927         may not be. Wasm memory starts off as taking up purely virtual pages. When a
1928         page is first accessed, only then will the OS page it in and cause it to use
1929         physical RAM. I opened a bug to come up with a solution to this problem:
1930         https://bugs.webkit.org/show_bug.cgi?id=184207
1931
1932         * bmalloc.xcodeproj/project.pbxproj:
1933         * bmalloc/AvailableMemory.cpp:
1934         (bmalloc::memoryStatus):
1935         * bmalloc/BPlatform.h:
1936         * bmalloc/Heap.cpp:
1937         (bmalloc::Heap::Heap):
1938         (bmalloc::Heap::freeableMemory):
1939         (bmalloc::Heap::footprint):
1940         (bmalloc::Heap::scavenge):
1941         (bmalloc::Heap::deallocateSmallChunk):
1942         (bmalloc::Heap::allocateSmallPage):
1943         (bmalloc::Heap::splitAndAllocate):
1944         (bmalloc::Heap::tryAllocateLarge):
1945         (bmalloc::Heap::shrinkLarge):
1946         (bmalloc::Heap::deallocateLarge):
1947         (bmalloc::Heap::externalCommit):
1948         (bmalloc::Heap::externalDecommit):
1949         * bmalloc/Heap.h:
1950         * bmalloc/IsoDirectory.h:
1951         * bmalloc/IsoDirectoryInlines.h:
1952         (bmalloc::passedNumPages>::takeFirstEligible):
1953         (bmalloc::passedNumPages>::didDecommit):
1954         (bmalloc::passedNumPages>::freeableMemory):
1955         * bmalloc/IsoHeapImpl.h:
1956         * bmalloc/IsoHeapImplInlines.h:
1957         (bmalloc::IsoHeapImpl<Config>::freeableMemory):
1958         (bmalloc::IsoHeapImpl<Config>::footprint):
1959         (bmalloc::IsoHeapImpl<Config>::didCommit):
1960         (bmalloc::IsoHeapImpl<Config>::didDecommit):
1961         * bmalloc/LargeRange.h:
1962         (bmalloc::LargeRange::LargeRange):
1963         (bmalloc::LargeRange::startPhysicalSize const):
1964         (bmalloc::LargeRange::setStartPhysicalSize):
1965         (bmalloc::LargeRange::totalPhysicalSize const):
1966         (bmalloc::LargeRange::setTotalPhysicalSize):
1967         (bmalloc::merge):
1968         (bmalloc::LargeRange::split const):
1969         (bmalloc::LargeRange::physicalSize const): Deleted.
1970         (bmalloc::LargeRange::setPhysicalSize): Deleted.
1971         * bmalloc/PhysicalPageMap.h: Added.
1972         This class is added for debugging purposes. It's useful when hacking
1973         on the code that calculates the footprint to use this map as a sanity
1974         check. It's just a simple implementation that has a set of all the committed pages.
1975
1976         (bmalloc::PhysicalPageMap::commit):
1977         (bmalloc::PhysicalPageMap::decommit):
1978         (bmalloc::PhysicalPageMap::footprint):
1979         (bmalloc::PhysicalPageMap::forEachPhysicalPage):
1980         * bmalloc/Scavenger.cpp:
1981         (bmalloc::dumpStats):
1982         (bmalloc::Scavenger::scavenge):
1983         (bmalloc::Scavenger::freeableMemory):
1984         This is here just for debugging for now. But we should implement an
1985         efficient version of this to use when driving when to run the
1986         scavenger.
1987
1988         (bmalloc::Scavenger::footprint):
1989         (bmalloc::Scavenger::threadRunLoop):
1990         * bmalloc/Scavenger.h:
1991         * bmalloc/VMAllocate.h:
1992         (bmalloc::physicalPageSizeSloppy):
1993         * bmalloc/VMHeap.cpp:
1994         (bmalloc::VMHeap::tryAllocateLargeChunk):
1995         * bmalloc/bmalloc.cpp:
1996         (bmalloc::api::commitAlignedPhysical):
1997         (bmalloc::api::decommitAlignedPhysical):
1998         * bmalloc/bmalloc.h:
1999
2000 2018-03-28  Commit Queue  <commit-queue@webkit.org>
2001
2002         Unreviewed, rolling out r230005.
2003         https://bugs.webkit.org/show_bug.cgi?id=184115
2004
2005         "it caused a huge regression on iOS" (Requested by saamyjoon
2006         on #webkit).
2007
2008         Reverted changeset:
2009
2010         "memoryStatus() is wrong in certain testing scenarios on iOS"
2011         https://bugs.webkit.org/show_bug.cgi?id=184050
2012         https://trac.webkit.org/changeset/230005
2013
2014 2018-03-27  Saam Barati  <sbarati@apple.com>
2015
2016         memoryStatus() is wrong in certain testing scenarios on iOS
2017         https://bugs.webkit.org/show_bug.cgi?id=184050
2018         <rdar://problem/37959258>
2019
2020         Rubber-stamped by Mark Lam.
2021
2022         This switches us from using "phys_footprint" to using "internal + compressed"
2023         when computing the dirty memory in the current process. There are iOS testing
2024         scenarios where phys_footprint doesn't give us a reliable answer. In my testing,
2025         "internal + compressed" tracks phys_footprint closely (when phys_footprint is
2026         working). They're usually within much less than 1% of each other. We're making
2027         this change to ensure testing in our iOS infrastructure is valid.
2028         
2029         I opened a bug to move back to phys_footprint when it's feasible:
2030         https://bugs.webkit.org/show_bug.cgi?id=184050
2031
2032         * bmalloc/AvailableMemory.cpp:
2033         (bmalloc::memoryStatus):
2034
2035 2018-03-20  Tim Horton  <timothy_horton@apple.com>
2036
2037         Add and adopt WK_PLATFORM_NAME and adjust default feature defines
2038         https://bugs.webkit.org/show_bug.cgi?id=183758
2039         <rdar://problem/38017644>
2040
2041         Reviewed by Dan Bernstein.
2042
2043         * Configurations/Base.xcconfig:
2044
2045 2018-03-16  Filip Pizlo  <fpizlo@apple.com>
2046
2047         Put the DOM in IsoHeaps
2048         https://bugs.webkit.org/show_bug.cgi?id=183546
2049
2050         Reviewed by Simon Fraser.
2051         
2052         Make it easy to runtime-disable IsoHeaps.
2053
2054         * bmalloc/Allocator.h:
2055         * bmalloc/IsoTLS.cpp:
2056         (bmalloc::IsoTLS::determineMallocFallbackState):
2057         * bmalloc/IsoTLS.h:
2058         * bmalloc/IsoTLSInlines.h:
2059         (bmalloc::IsoTLS::allocateSlow):
2060         (bmalloc::IsoTLS::deallocateSlow):
2061
2062 2018-03-16  Michael Catanzaro  <mcatanzaro@igalia.com>
2063
2064         Improve error message when Gigacage cannot allocate virtual memory
2065         https://bugs.webkit.org/show_bug.cgi?id=183329
2066
2067         Reviewed by Filip Pizlo.
2068
2069         We've discovered that Deja Dup monitor sets a virtual memory limit, breaking Gigacage. Since
2070         it runs in the background on a fresh out-of-the-box install of Ubuntu, this is not good.
2071         That will have to be fixed by Deja Dup, but there is concern that other applications might
2072         try this, or that users will set a virtual memory limit for the entire desktop session. Of
2073         particular concern is the possibility that users might have copypasted a ulimit line into
2074         a session startup script without understanding it. Let's try to make it slightly easier to
2075         understand what's going wrong.
2076
2077         * bmalloc/Gigacage.cpp:
2078         (Gigacage::ensureGigacage):
2079
2080 2018-03-13  Tim Horton  <timothy_horton@apple.com>
2081
2082         Add and adopt WK_ALTERNATE_FRAMEWORKS_DIR in WTF and bmalloc
2083         https://bugs.webkit.org/show_bug.cgi?id=183576
2084         <rdar://problem/38396766>
2085
2086         Reviewed by Dan Bernstein.
2087
2088         * Configurations/Base.xcconfig:
2089         * Configurations/bmalloc.xcconfig:
2090         * Configurations/mbmalloc.xcconfig:
2091
2092 2018-03-10  Filip Pizlo  <fpizlo@apple.com>
2093
2094         PerProcess<> should be safe by default
2095         https://bugs.webkit.org/show_bug.cgi?id=183545
2096
2097         Reviewed by Yusuke Suzuki.
2098         
2099         This makes PerProcess<> safe by default, so we don't need SafePerProcess<>.
2100         
2101         The new PerProcess<> design relies on a hash-consing mechanism for PerProcess<> storage based
2102         on the __PRETTY_FUNCTION__ from inside PerProcess<>, which captures the instantiated type in
2103         the string. Therefore, this can be used to runtime-coalesce PerProcess<> instances based on
2104         type.
2105         
2106         I expect this to be perf-neutral. It's an important prerequisite to more bmalloc work, since I
2107         don't want to have more PerProcess<> vs SafePerProcess<> bugs, and SafePerProcess<> can't be
2108         used for everything (I don't see how to use it for isoheaps).
2109
2110         * CMakeLists.txt:
2111         * bmalloc.xcodeproj/project.pbxproj:
2112         * bmalloc/Heap.cpp:
2113         (bmalloc::Heap::Heap):
2114         * bmalloc/IsoDirectoryInlines.h:
2115         (bmalloc::passedNumPages>::takeFirstEligible):
2116         (bmalloc::passedNumPages>::didBecome):
2117         * bmalloc/PerProcess.cpp: Added.
2118         (bmalloc::stringHash):
2119         (bmalloc::allocate):
2120         (bmalloc::getPerProcessData):
2121         * bmalloc/PerProcess.h:
2122         (bmalloc::PerProcess::mutex):
2123         (bmalloc::PerProcess::coalesce):
2124         (bmalloc::PerProcess::getSlowCase):
2125         (): Deleted.
2126         * bmalloc/Scavenger.cpp:
2127         * bmalloc/Scavenger.h:
2128         * bmalloc/bmalloc.cpp:
2129         (bmalloc::api::scavenge):
2130         (bmalloc::api::setScavengerThreadQOSClass):
2131
2132 2018-03-10  Commit Queue  <commit-queue@webkit.org>
2133
2134         Unreviewed, rolling out r229436.
2135         https://bugs.webkit.org/show_bug.cgi?id=183542
2136
2137         seems to have regressed wasm compile times by 10% (Requested
2138         by pizlo-mbp on #webkit).
2139
2140         Reverted changeset:
2141
2142         "bmalloc mutex should be adaptive"
2143         https://bugs.webkit.org/show_bug.cgi?id=177839
2144         https://trac.webkit.org/changeset/229436
2145
2146 2018-03-08  Filip Pizlo  <fpizlo@apple.com>
2147
2148         bmalloc mutex should be adaptive
2149         https://bugs.webkit.org/show_bug.cgi?id=177839
2150
2151         Reviewed by Michael Saboff.
2152         
2153         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
2154         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
2155         anything other than malloc.
2156
2157         Reland after failing to reproduce the WasmBench crash that caused it to get rolled out. Maybe that fixed
2158         itself somehow?
2159
2160         * bmalloc/Algorithm.h:
2161         (bmalloc::compareExchangeWeak):
2162         (bmalloc::compareExchangeStrong):
2163         * bmalloc/PerThread.h:
2164         * bmalloc/StaticMutex.cpp:
2165         (bmalloc::StaticMutex::lockSlow):
2166         (bmalloc::StaticMutex::unlockSlow):
2167         (bmalloc::StaticMutex::lockSlowCase): Deleted.
2168         * bmalloc/StaticMutex.h:
2169         (bmalloc::StaticMutex::try_lock):
2170         (bmalloc::StaticMutex::isLocked const):
2171         (bmalloc::StaticMutex::init):
2172         (bmalloc::StaticMutex::tryLock):
2173         (bmalloc::StaticMutex::lock):
2174         (bmalloc::StaticMutex::unlock):
2175         (bmalloc::sleep): Deleted.
2176         (bmalloc::waitUntilFalse): Deleted.
2177
2178 2018-02-16  Filip Pizlo  <fpizlo@apple.com>
2179
2180         Unreviewed, roll out r228306 (custom memcpy/memset) because the bots say that it was not a
2181         progression.
2182
2183         * bmalloc/Algorithm.h:
2184         (bmalloc::fastCopy): Deleted.
2185         (bmalloc::fastZeroFill): Deleted.
2186         * bmalloc/Allocator.cpp:
2187         (bmalloc::Allocator::reallocate):
2188         * bmalloc/Bits.h:
2189         (bmalloc::BitsWordOwner::operator=):
2190         (bmalloc::BitsWordOwner::clearAll):
2191         (bmalloc::BitsWordOwner::set):
2192         * bmalloc/IsoPageInlines.h:
2193         (bmalloc::IsoPage<Config>::IsoPage):
2194         * bmalloc/Vector.h:
2195         (bmalloc::Vector<T>::reallocateBuffer):
2196
2197 2018-02-09  Carlos Alberto Lopez Perez  <clopez@igalia.com>
2198
2199         Improve of string.h include after r228317.
2200         https://bugs.webkit.org/show_bug.cgi?id=182642
2201
2202         Reviewed by Mark Lam.
2203
2204         * bmalloc/Algorithm.h: Avoid an architecture-specific #include.
2205
2206 2018-02-09  Carlos Alberto Lopez Perez  <clopez@igalia.com>
2207
2208         Fix build for !BCPU(X86_64) after r228306
2209         https://bugs.webkit.org/show_bug.cgi?id=182563
2210
2211         Unreviewed build fix.
2212
2213         * bmalloc/Algorithm.h:
2214
2215 2018-02-08  Filip Pizlo  <fpizlo@apple.com>
2216
2217         Experiment with alternative implementation of memcpy/memset
2218         https://bugs.webkit.org/show_bug.cgi?id=182563
2219
2220         Reviewed by Michael Saboff and Mark Lam.
2221         
2222         Add a faster x86_64-specific implementation of memcpy and memset. Ideally, this would just be
2223         implemented in WTF, but we have to copy it into bmalloc since bmalloc sits below WTF on the
2224         stack.
2225
2226         * bmalloc/Algorithm.h:
2227         (bmalloc::fastCopy):
2228         (bmalloc::fastZeroFill):
2229         * bmalloc/Allocator.cpp:
2230         (bmalloc::Allocator::reallocate):
2231         * bmalloc/Bits.h:
2232         (bmalloc::BitsWordOwner::operator=):
2233         (bmalloc::BitsWordOwner::clearAll):
2234         (bmalloc::BitsWordOwner::set):
2235         * bmalloc/IsoPageInlines.h:
2236         (bmalloc::IsoPage<Config>::IsoPage):
2237         * bmalloc/Vector.h:
2238         (bmalloc::Vector<T>::reallocateBuffer):
2239
2240 2018-02-05  JF Bastien  <jfbastien@apple.com>
2241
2242         Gigacage: enable only for WebContent process and token executables
2243         https://bugs.webkit.org/show_bug.cgi?id=182457
2244         <rdar://problem/35875011>
2245
2246         Reviewed by Keith Miller.
2247
2248         Gigacage is a solid security improvement, but it's probably best
2249         to roll it out incrementally to the most valuable targets first
2250         and progressively try out more and more over time rather than
2251         outright enabling it everywhere. We've gotten some reports that it
2252         has some side-effects that weren't expected, so for now let's
2253         enable it for the WebContent process, JSC, and other executables
2254         we know, and then later we'll enable more gigacage uses.
2255
2256         For now I've chosen the following bundles:
2257
2258           - com.apple.WebKit.WebContent.Development
2259           - com.apple.WebKit.WebContent
2260           - com.apple.WebProcess
2261
2262         And the following processes:
2263
2264           - jsc
2265           - wasm
2266           - anything starting with "test", to match the JSC tests
2267
2268         I tried a different approach first, where I add a function to turn
2269         gigacage on or off and crash if gigacage is initialized without
2270         having been told what to do. Doing this in ChildProcess and a
2271         bunch of the process initialization methods isn't sufficient. I
2272         got MiniBrowser working, but some other builds use static globals
2273         which themselves use hash and string which are allocate with
2274         bmalloc and therefore which initialize gigacage before main is
2275         called and before the process gets a chance to opt in our out. It
2276         gets tricky with API calls too, because we have to do the right
2277         thing in any entry an API user could plausibly use, even the
2278         private ones, so I endend up having to initialize gigacage in e.g.
2279         WebPreferencesExperimentalFeatures.cpp.erb.
2280
2281         Another approach could be to create a free-for-all gigacage
2282         entitlement, and opt-in the processes we want..
2283
2284         As a follow-up we can also check that gigacage allocation always
2285         succeeds if it was allowed for that process. With my change I
2286         expect it to always succeed.
2287
2288         * CMakeLists.txt:
2289         * bmalloc.xcodeproj/project.pbxproj:
2290         * bmalloc/BPlatform.h:
2291         * bmalloc/Gigacage.cpp:
2292         (Gigacage::shouldBeEnabled):
2293         * bmalloc/ProcessCheck.h: Added.
2294         (bmalloc::gigacageEnabledForProcess):
2295         * bmalloc/ProcessCheck.mm: Added.
2296         (bmalloc::gigacageEnabledForProcess):
2297
2298 2018-02-05  Joseph Pecoraro  <pecoraro@apple.com>
2299
2300         Multiple bmalloc scavenger threads is unexpected
2301         https://bugs.webkit.org/show_bug.cgi?id=182474
2302         <rdar://problem/37175526>
2303
2304         Reviewed by Filip Pizlo.
2305
2306         * bmalloc/Heap.cpp:
2307         (bmalloc::Heap::Heap):
2308         * bmalloc/IsoDirectoryInlines.h:
2309         (bmalloc::passedNumPages>::takeFirstEligible):
2310         (bmalloc::passedNumPages>::didBecome):
2311         * bmalloc/bmalloc.cpp:
2312         (bmalloc::api::scavenge):
2313         (bmalloc::api::setScavengerThreadQOSClass):
2314         Switch to SafePerProcess for Scavenger to ensure one instance
2315         for the entire process.
2316
2317         * bmalloc/PerProcess.h:
2318         (bmalloc::PerProcess::get):
2319         (bmalloc::PerProcess::getFastCase):
2320         (bmalloc::PerProcess::getSlowCase):
2321         (bmalloc::SafePerProcess::get):
2322         (bmalloc::SafePerProcess::getFastCase):
2323         (bmalloc::SafePerProcess::getSlowCase):
2324         Duplicate the class with a version that can ensure
2325         single instances by requiring exporting symbols that
2326         can be created with macros.
2327
2328         * bmalloc/Scavenger.cpp:
2329         * bmalloc/Scavenger.h:
2330         Export symbols to ensure all images get the same instance.
2331
2332 2018-01-31  Saam Barati  <sbarati@apple.com>
2333
2334         Replace tryLargeMemalignVirtual with tryLargeZeroedMemalignVirtual and use it to allocate large zeroed memory in Wasm
2335         https://bugs.webkit.org/show_bug.cgi?id=182064
2336         <rdar://problem/36840132>
2337
2338         Reviewed by Geoffrey Garen.
2339
2340         This patch replaces the tryLargeMemalignVirtual API with tryLargeZeroedMemalignVirtual.
2341         By doing that, we're able to remove the AllocationKind enum. To zero the memory,
2342         tryLargeZeroedMemalignVirtual uses mmap(... MAP_ANON ...) over previously mmapped
2343         memory. This both purges the any resident memory for the virtual range and ensures
2344         that the pages in the range are zeroed. Most OSs should implement this by taking a
2345         page fault and zero filling on first access. Therefore, this API is returning pages
2346         that will result in page faults on first access. Hence, the name 'virtual' in the API.
2347         This API differs from the old API in that users of it need not call madvise themselves.
2348         The memory is ready to go.
2349
2350         * bmalloc.xcodeproj/project.pbxproj:
2351         * bmalloc/AllocationKind.h: Removed.
2352         * bmalloc/DebugHeap.cpp:
2353         (bmalloc::DebugHeap::memalignLarge):
2354         (bmalloc::DebugHeap::freeLarge):
2355         * bmalloc/DebugHeap.h:
2356         * bmalloc/Heap.cpp:
2357         (bmalloc::Heap::splitAndAllocate):
2358         (bmalloc::Heap::tryAllocateLarge):
2359         (bmalloc::Heap::allocateLarge):
2360         (bmalloc::Heap::shrinkLarge):
2361         (bmalloc::Heap::deallocateLarge):
2362         * bmalloc/Heap.h:
2363         * bmalloc/IsoPage.cpp:
2364         (bmalloc::IsoPageBase::allocatePageMemory):
2365         * bmalloc/VMAllocate.h:
2366         (bmalloc::vmZeroAndPurge):
2367         * bmalloc/VMHeap.cpp:
2368         (bmalloc::VMHeap::tryAllocateLargeChunk):
2369         * bmalloc/VMHeap.h:
2370         * bmalloc/bmalloc.cpp:
2371         (bmalloc::api::tryLargeZeroedMemalignVirtual):
2372         (bmalloc::api::freeLargeVirtual):
2373         (bmalloc::api::tryLargeMemalignVirtual): Deleted.
2374         * bmalloc/bmalloc.h:
2375
2376 2018-01-19  Keith Miller  <keith_miller@apple.com>
2377
2378         HaveInternalSDK includes should be "#include?"
2379         https://bugs.webkit.org/show_bug.cgi?id=179670
2380
2381         Reviewed by Dan Bernstein.
2382
2383         * Configurations/Base.xcconfig:
2384
2385 2018-01-18  Dan Bernstein  <mitz@apple.com>
2386
2387         [Xcode] Streamline and future-proof target-macOS-version-dependent build setting definitions
2388         https://bugs.webkit.org/show_bug.cgi?id=181803
2389
2390         Reviewed by Tim Horton.
2391
2392         * Configurations/Base.xcconfig: Updated.
2393         * Configurations/DebugRelease.xcconfig: Ditto.
2394
2395 2018-01-16  Michael Catanzaro  <mcatanzaro@igalia.com>
2396
2397         mbmalloc should only be built in developer mode
2398         https://bugs.webkit.org/show_bug.cgi?id=181654
2399
2400         Reviewed by Carlos Garcia Campos.
2401
2402         * CMakeLists.txt:
2403
2404 2018-01-15  Michael Catanzaro  <mcatanzaro@igalia.com>
2405
2406         Improve use of ExportMacros
2407         https://bugs.webkit.org/show_bug.cgi?id=181652
2408
2409         Reviewed by Konstantin Tokarev.
2410
2411         Disable BEXPORT on Linux ports.
2412
2413         * bmalloc/BExport.h: Check for BUSE(EXPORT_MACROS).
2414         * bmalloc/BPlatform.h: Add BUSE(EXPORT_MACROS) and define it on macOS and iOS.
2415
2416 2017-12-20  Ting-Wei Lan  <lantw44@gmail.com>
2417
2418         Include stdio.h before using stderr and _IONBF
2419         https://bugs.webkit.org/show_bug.cgi?id=181046
2420
2421         Reviewed by Alex Christensen.
2422
2423         * bmalloc/IsoTLS.cpp:
2424
2425 2017-12-14  David Kilzer  <ddkilzer@apple.com>
2426
2427         Enable -Wstrict-prototypes for WebKit
2428         <https://webkit.org/b/180757>
2429         <rdar://problem/36024132>
2430
2431         Rubber-stamped by Joseph Pecoraro.
2432
2433         * Configurations/Base.xcconfig:
2434         (CLANG_WARN_STRICT_PROTOTYPES): Add. Set to YES.
2435
2436 2017-12-14  Saam Barati  <sbarati@apple.com>
2437
2438         logVMFailure should not simulate crash on iOS
2439         https://bugs.webkit.org/show_bug.cgi?id=180790
2440
2441         Reviewed by JF Bastien.
2442
2443         The Gigacage allocation on iOS is expected to fail in certain circumstances. 
2444         Let's not simulate a crash on failure because since this is expected behavior.
2445
2446         * bmalloc/VMAllocate.h:
2447         (bmalloc::tryVMAllocate):
2448
2449 2017-12-11  Tim Horton  <timothy_horton@apple.com>
2450
2451         Stop using deprecated target conditional for simulator builds
2452         https://bugs.webkit.org/show_bug.cgi?id=180662
2453         <rdar://problem/35136156>
2454
2455         Reviewed by Simon Fraser.
2456
2457         * bmalloc/BPlatform.h:
2458
2459 2017-12-08  Saam Barati  <sbarati@apple.com>
2460
2461         Enable gigacage on iOS with a 32GB runway and ensure it doesn't break WasmBench
2462         https://bugs.webkit.org/show_bug.cgi?id=178557
2463
2464         Reviewed by Mark Lam.
2465
2466         * bmalloc/Algorithm.h:
2467         (bmalloc::isPowerOfTwo):
2468         * bmalloc/Gigacage.cpp:
2469         * bmalloc/Gigacage.h:
2470
2471 2017-12-05  Andy Estes  <aestes@apple.com>
2472
2473         [Darwin] Simplify use of TargetConditionals
2474         https://bugs.webkit.org/show_bug.cgi?id=180455
2475         <rdar://problem/35142971>
2476
2477         Reviewed by Tim Horton.
2478
2479         There's no need to check if TARGET_* macros are defined on Darwin platforms, since
2480         TargetConditionals.h always defines them. Also, we can simplify
2481         (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR) to TARGET_OS_IPHONE.
2482
2483         * bmalloc/BPlatform.h:
2484
2485 2017-12-05  Filip Pizlo  <fpizlo@apple.com>
2486
2487         bmalloc IsoHeap needs to allow a thread to deallocate some size for the first time
2488         https://bugs.webkit.org/show_bug.cgi?id=180443
2489
2490         Reviewed by Saam Barati.
2491
2492         It's true that we can expect a heap to already be initialized if we try to deallocate in it.  But it
2493         may not have its deallocator initialized on this thread yet.
2494         
2495         This is easily fixed by adding a null check on the deallocate path. That's probably not going to
2496         change perf at all. But doing that allows me to get rid of a lot of weird stuff I previously did to
2497         avoid that null check, like creating a dummy TLS in the DebugHeap case.
2498
2499         * bmalloc/IsoTLS.cpp:
2500         (bmalloc::IsoTLS::debugFree):
2501         (bmalloc::IsoTLS::deallocateSlow): Deleted.
2502         * bmalloc/IsoTLS.h:
2503         * bmalloc/IsoTLSInlines.h:
2504         (bmalloc::IsoTLS::allocateImpl):
2505         (bmalloc::IsoTLS::allocateSlow):
2506         (bmalloc::IsoTLS::deallocateImpl):
2507         (bmalloc::IsoTLS::deallocateSlow):
2508         (bmalloc::IsoTLS::ensureHeapAndEntries):
2509
2510 2017-12-01  Michael Saboff  <msaboff@apple.com>
2511
2512         Gigacage should not be enabled for ARM64_32
2513         https://bugs.webkit.org/show_bug.cgi?id=180265
2514
2515         Reviewed by Saam Barati.
2516
2517         Disabled Gigacage for ARM64_32.
2518         In the process, restructured Gigacage::shouldBeEnabled() with GIGACAGE_ENABLED set
2519         to 0 to avoid a dead code compiler warning.
2520
2521         * bmalloc/Gigacage.cpp:
2522         (Gigacage::shouldBeEnabled):
2523         * bmalloc/Gigacage.h:
2524
2525 2017-11-29  JF Bastien  <jfbastien@apple.com>
2526
2527         WTF / bmalloc: don't write to 0xbbadbeef when ASAN is looking
2528         https://bugs.webkit.org/show_bug.cgi?id=180175
2529
2530         Reviewed by Mark Lam.
2531
2532         ASAN knows that 0xbbadbeef is a bbad aaddress, and tells us so
2533         when we write to it, say in an assert. That creates bbad error
2534         reports where ASAN thinks we write to an invalid address, instead
2535         of thinking that we hit an assertion. In some cases, tooling that
2536         use fuzzers aggregate similar issues, and think that we just have
2537         the one bug and not a bunch of different asserts.
2538
2539         At the same time, bmalloc's version of CRASH just writes to
2540         0xbbadbeef and assumes that's invalid and will crash, which isn't
2541         necessarily true on non-Mac platforms. WTF's version then makes
2542         sure there's a crash, so bmalloc should do the same.
2543
2544         * bmalloc.xcodeproj/project.pbxproj:
2545         * bmalloc/BAssert.h:
2546         * bmalloc/BCompiler.h: Added.
2547         * bmalloc/BPlatform.h:
2548
2549 2017-11-27  Filip Pizlo  <fpizlo@apple.com>
2550
2551         Don't crash in forEachEntry when DebugHeap is enabled.
2552
2553         Unreviewed, fixing crashes on leaks bots by removing an assertion.
2554
2555         * bmalloc/IsoTLS.cpp:
2556         (bmalloc::IsoTLS::forEachEntry):
2557         * test/testbmalloc.cpp: Make this test work with DebugHeap so I can catch this kind of problem in the future.
2558
2559 2017-11-16  Filip Pizlo  <fpizlo@apple.com>
2560
2561         Isolated Heaps caused an increase in reported leaks on the bots
2562         https://bugs.webkit.org/show_bug.cgi?id=179463
2563
2564         Reviewed by Darin Adler.
2565         
2566         This fixes the way isoheaps interact with system tools:
2567         
2568         - Opts into the VMHeap API so that the leaks tool can find isoheap memory.
2569         
2570         - Opts into the DebugHeap/Environment APIs so that we turn off isoheap allocation if memory
2571           debugging options are in use.
2572
2573         * bmalloc.xcodeproj/project.pbxproj:
2574         * bmalloc/DebugHeap.h:
2575         * bmalloc/IsoHeap.h:
2576         * bmalloc/IsoPage.cpp: Added.
2577         (bmalloc::IsoPageBase::allocatePageMemory):
2578         * bmalloc/IsoPage.h:
2579         * bmalloc/IsoPageInlines.h:
2580         (bmalloc::IsoPage<Config>::tryCreate):
2581         * bmalloc/IsoTLS.cpp:
2582         (bmalloc::IsoTLS::deallocateSlow):
2583         (bmalloc::IsoTLS::ensureEntries):
2584         (bmalloc::IsoTLS::isUsingDebugHeap):
2585         (bmalloc::IsoTLS::debugMalloc):
2586         * bmalloc/IsoTLS.h:
2587         * bmalloc/IsoTLSInlines.h:
2588         (bmalloc::IsoTLS::allocate):
2589         (bmalloc::IsoTLS::deallocate):
2590         (bmalloc::IsoTLS::allocateImpl):
2591         (bmalloc::IsoTLS::allocateFast):
2592         (bmalloc::IsoTLS::allocateSlow):
2593         (bmalloc::IsoTLS::deallocateImpl):
2594         (bmalloc::IsoTLS::deallocateFast):
2595         (bmalloc::IsoTLS::ensureHeapAndEntries):
2596         (bmalloc::IsoTLS::allocator): Deleted.
2597         (bmalloc::IsoTLS::deallocator): Deleted.
2598         * bmalloc/bmalloc.cpp:
2599         (bmalloc::api::tryLargeMemalignVirtual):
2600         (bmalloc::api::freeLargeVirtual):
2601         (bmalloc::api::scavenge):
2602         (bmalloc::api::isEnabled):
2603         (bmalloc::api::setScavengerThreadQOSClass):
2604         * bmalloc/bmalloc.h:
2605         (bmalloc::api::tryLargeMemalignVirtual): Deleted.
2606         (bmalloc::api::freeLargeVirtual): Deleted.
2607         (bmalloc::api::scavenge): Deleted.
2608         (bmalloc::api::isEnabled): Deleted.
2609         (bmalloc::api::setScavengerThreadQOSClass): Deleted.
2610
2611 2017-11-14  Saam Barati  <sbarati@apple.com>
2612
2613         Make the gigacage runway 32GB
2614         https://bugs.webkit.org/show_bug.cgi?id=175062
2615
2616         Reviewed by Mark Lam.
2617
2618         Making the gigacage runway 32GB defends us against buffer overflows in the
2619         cage reaching memory outside the cage assuming indices are 32-bit unsigned
2620         integers and the type they're indexing into has size <= 8 bytes. This is
2621         exactly the case for many things in JSC. For example, butterfly access in
2622         JSC meet this criteria, as does typed array access.
2623         
2624         The 32GB comes from 8 * 2^32 = 32GB.
2625
2626         * bmalloc/Gigacage.cpp:
2627
2628 2017-11-08  Michael Catanzaro  <mcatanzaro@igalia.com>
2629
2630         Gigacage.cpp:44:46: warning: ‘*’ in boolean context, suggest ‘&&’ instead [-Wint-in-bool-context]
2631         https://bugs.webkit.org/show_bug.cgi?id=179427
2632
2633         Reviewed by Saam Barati.
2634
2635         Tweak the conditional to suppress the warning.
2636
2637         * bmalloc/Gigacage.cpp:
2638         (Gigacage::ensureGigacage):
2639
2640 2017-11-07  Saam Barati  <sbarati@apple.com>
2641
2642         We should PROT_NONE the Gigacage runway so OOB accesses crash
2643         https://bugs.webkit.org/show_bug.cgi?id=179392
2644
2645         Reviewed by Mark Lam.
2646
2647         If we assume that an attacker will exploit JSC and cause OOB accesses,
2648         we should make OOB accesses in the Gigacage runway crash.
2649
2650         * bmalloc/Gigacage.cpp:
2651         (Gigacage::ensureGigacage):
2652
2653 2017-10-31  Filip Pizlo  <fpizlo@apple.com>
2654
2655         bmalloc should support strictly type-segregated isolated heaps
2656         https://bugs.webkit.org/show_bug.cgi?id=178108
2657
2658         Reviewed by Saam Barati, Simon Fraser, and Ryosuke Niwa.
2659         
2660         This introduces a new allocation API in bmalloc called IsoHeap. An IsoHeap is templatized by
2661         type and created in static storage. When unused, it takes only a few words. When you do use
2662         it, each IsoHeap gets a bag of virtual pages unique to it. This prevents use-after-free bugs
2663         in one IsoHeap from affecting any other memory. At worst, two pointers of the same type will
2664         point to the same object even though they should not have.
2665         
2666         IsoHeaps allocate using a first-fit discipline that combines ideas from bmalloc and Riptide
2667         (the JSC GC):
2668         
2669         Like Riptide, it uses a bump'n'pop allocator. What Riptide calls blocks, IsoHeaps calls
2670         pages. Pages are collected into directories. Directories track pages using bitvectors, so
2671         that it's easy to quickly find a completely free page or one that has at least one free
2672         object. I think that the bump'n'pop allocator is as fast as the bmalloc Immix-style (page and
2673         line) allocator, but is better at allocating in holes. It's guaranteed to follow a first-fit
2674         discipline. However, the real reason why I wrote it that was is that this is what I'm more
2675         familiar with. This is a part of the design I want to revisit (bug 179278).
2676         
2677         Like bmalloc, it uses a deallocation log. This means that the internal IsoHeap data
2678         structures can be locked with a coarse-grained lock, since the deallocator only grabs it when
2679         flushing the log. Similarly, the allocator only grabs it when refilling the bump'n'pop
2680         FreeList.
2681         
2682         This adds a unit test for IsoHeaps. In this change, IsoHeaps are adopted only by WebCore's
2683         RenderObject.
2684         
2685         Note that despite the use of GC concepts, it's not a goal to make this code directly sharable
2686         with GC. The GC will probably have to do isolated heaps its own way (likely a special
2687         Subspace or something like that).
2688
2689         * bmalloc.xcodeproj/project.pbxproj:
2690         * bmalloc/Algorithm.h:
2691         (bmalloc::findBitInWord):
2692         * bmalloc/AllIsoHeaps.cpp: Added.
2693         (bmalloc::AllIsoHeaps::AllIsoHeaps):
2694         (bmalloc::AllIsoHeaps::add):
2695         (bmalloc::AllIsoHeaps::head):
2696         * bmalloc/AllIsoHeaps.h: Added.
2697         * bmalloc/AllIsoHeapsInlines.h: Added.
2698         (bmalloc::AllIsoHeaps::forEach):
2699         * bmalloc/BMalloced.h: Added.
2700         * bmalloc/Bits.h: Added.
2701         (bmalloc::bitsArrayLength):
2702         (bmalloc::BitsWordView::BitsWordView):
2703         (bmalloc::BitsWordView::numBits const):
2704         (bmalloc::BitsWordView::word const):
2705         (bmalloc::BitsWordOwner::BitsWordOwner):
2706         (bmalloc::BitsWordOwner::view const):
2707         (bmalloc::BitsWordOwner::operator=):
2708         (bmalloc::BitsWordOwner::setAll):
2709         (bmalloc::BitsWordOwner::clearAll):
2710         (bmalloc::BitsWordOwner::set):
2711         (bmalloc::BitsWordOwner::numBits const):
2712         (bmalloc::BitsWordOwner::arrayLength const):
2713         (bmalloc::BitsWordOwner::word const):
2714         (bmalloc::BitsWordOwner::word):
2715         (bmalloc::BitsWordOwner::words const):
2716         (bmalloc::BitsWordOwner::words):
2717         (bmalloc::BitsAndWords::BitsAndWords):
2718         (bmalloc::BitsAndWords::view const):
2719         (bmalloc::BitsAndWords::numBits const):
2720         (bmalloc::BitsAndWords::word const):
2721         (bmalloc::BitsOrWords::BitsOrWords):
2722         (bmalloc::BitsOrWords::view const):
2723         (bmalloc::BitsOrWords::numBits const):
2724         (bmalloc::BitsOrWords::word const):
2725         (bmalloc::BitsNotWords::BitsNotWords):
2726         (bmalloc::BitsNotWords::view const):
2727         (bmalloc::BitsNotWords::numBits const):
2728         (bmalloc::BitsNotWords::word const):
2729         (bmalloc::BitsImpl::BitsImpl):
2730         (bmalloc::BitsImpl::numBits const):
2731         (bmalloc::BitsImpl::size const):
2732         (bmalloc::BitsImpl::arrayLength const):
2733         (bmalloc::BitsImpl::operator== const):
2734         (bmalloc::BitsImpl::operator!= const):
2735         (bmalloc::BitsImpl::at const):
2736         (bmalloc::BitsImpl::operator[] const):
2737         (bmalloc::BitsImpl::isEmpty const):
2738         (bmalloc::BitsImpl::operator& const):
2739         (bmalloc::BitsImpl::operator| const):
2740         (bmalloc::BitsImpl::operator~ const):
2741         (bmalloc::BitsImpl::forEachSetBit const):
2742         (bmalloc::BitsImpl::forEachClearBit const):
2743         (bmalloc::BitsImpl::forEachBit const):
2744         (bmalloc::BitsImpl::findBit const):
2745         (bmalloc::BitsImpl::findSetBit const):
2746         (bmalloc::BitsImpl::findClearBit const):
2747         (bmalloc::BitsImpl::wordView const):
2748         (bmalloc::BitsImpl::atImpl const):
2749         (bmalloc::Bits::Bits):
2750         (bmalloc::Bits::operator=):
2751         (bmalloc::Bits::resize):
2752         (bmalloc::Bits::setAll):
2753         (bmalloc::Bits::clearAll):
2754         (bmalloc::Bits::setAndCheck):
2755         (bmalloc::Bits::operator|=):
2756         (bmalloc::Bits::operator&=):
2757         (bmalloc::Bits::at const):
2758         (bmalloc::Bits::operator[] const):
2759         (bmalloc::Bits::BitReference::BitReference):
2760         (bmalloc::Bits::BitReference::operator bool const):
2761         (bmalloc::Bits::BitReference::operator=):
2762         (bmalloc::Bits::at):
2763         (bmalloc::Bits::operator[]):
2764         * bmalloc/CryptoRandom.cpp: Replaced with Source/bmalloc/bmalloc/CryptoRandom.cpp.
2765         (bmalloc::cryptoRandom):
2766         * bmalloc/CryptoRandom.h: Replaced with Source/bmalloc/bmalloc/CryptoRandom.h.
2767         * bmalloc/DeferredDecommit.h: Added.
2768         * bmalloc/DeferredDecommitInlines.h: Added.
2769         (bmalloc::DeferredDecommit::DeferredDecommit):
2770         * bmalloc/DeferredTrigger.h: Added.
2771         (bmalloc::DeferredTrigger::DeferredTrigger):
2772         * bmalloc/DeferredTriggerInlines.h: Added.
2773         (bmalloc::DeferredTrigger<trigger>::didBecome):
2774         (bmalloc::DeferredTrigger<trigger>::handleDeferral):
2775         * bmalloc/EligibilityResult.h: Added.
2776         (bmalloc::EligibilityResult::EligibilityResult):
2777         * bmalloc/EligibilityResultInlines.h: Added.
2778         (bmalloc::EligibilityResult<Config>::EligibilityResult):
2779         * bmalloc/FixedVector.h:
2780         * bmalloc/FreeList.cpp: Added.
2781         (bmalloc::FreeList::FreeList):
2782         (bmalloc::FreeList::~FreeList):
2783         (bmalloc::FreeList::clear):
2784         (bmalloc::FreeList::initializeList):
2785         (bmalloc::FreeList::initializeBump):
2786         (bmalloc::FreeList::contains const):
2787         * bmalloc/FreeList.h: Added.
2788         (bmalloc::FreeCell::scramble):
2789         (bmalloc::FreeCell::descramble):
2790         (bmalloc::FreeCell::setNext):
2791         (bmalloc::FreeCell::next const):
2792         (bmalloc::FreeList::allocationWillFail const):
2793         (bmalloc::FreeList::allocationWillSucceed const):
2794         (bmalloc::FreeList::originalSize const):
2795         (bmalloc::FreeList::head const):
2796         * bmalloc/FreeListInlines.h: Added.
2797         (bmalloc::FreeList::allocate):
2798         (bmalloc::FreeList::forEach const):
2799         * bmalloc/IsoAllocator.h: Added.
2800         * bmalloc/IsoAllocatorInlines.h: Added.
2801         (bmalloc::IsoAllocator<Config>::IsoAllocator):
2802         (bmalloc::IsoAllocator<Config>::~IsoAllocator):
2803         (bmalloc::IsoAllocator<Config>::allocate):
2804         (bmalloc::IsoAllocator<Config>::allocateSlow):
2805         (bmalloc::IsoAllocator<Config>::scavenge):
2806         * bmalloc/IsoConfig.h: Added.
2807         * bmalloc/IsoDeallocator.h: Added.
2808         * bmalloc/IsoDeallocatorInlines.h: Added.
2809         (bmalloc::IsoDeallocator<Config>::IsoDeallocator):
2810         (bmalloc::IsoDeallocator<Config>::~IsoDeallocator):
2811         (bmalloc::IsoDeallocator<Config>::deallocate):
2812         (bmalloc::IsoDeallocator<Config>::scavenge):
2813         * bmalloc/IsoDirectory.h: Added.
2814         (bmalloc::IsoDirectoryBaseBase::IsoDirectoryBaseBase):
2815         (bmalloc::IsoDirectoryBaseBase::~IsoDirectoryBaseBase):
2816         (bmalloc::IsoDirectoryBase::heap):
2817         * bmalloc/IsoDirectoryInlines.h: Added.
2818         (bmalloc::IsoDirectoryBase<Config>::IsoDirectoryBase):
2819         (bmalloc::passedNumPages>::IsoDirectory):
2820         (bmalloc::passedNumPages>::takeFirstEligible):
2821         (bmalloc::passedNumPages>::didBecome):
2822         (bmalloc::passedNumPages>::didDecommit):
2823         (bmalloc::passedNumPages>::scavenge):
2824         (bmalloc::passedNumPages>::forEachCommittedPage):
2825         * bmalloc/IsoDirectoryPage.h: Added.
2826         (bmalloc::IsoDirectoryPage::index const):
2827         * bmalloc/IsoDirectoryPageInlines.h: Added.
2828         (bmalloc::IsoDirectoryPage<Config>::IsoDirectoryPage):
2829         (bmalloc::IsoDirectoryPage<Config>::pageFor):
2830         * bmalloc/IsoHeap.h: Added.
2831         (bmalloc::api::IsoHeap::allocatorOffset):
2832         (bmalloc::api::IsoHeap::setAllocatorOffset):
2833         (bmalloc::api::IsoHeap::deallocatorOffset):
2834         (bmalloc::api::IsoHeap::setDeallocatorOffset):
2835         * bmalloc/IsoHeapImpl.cpp: Added.
2836         (bmalloc::IsoHeapImplBase::IsoHeapImplBase):
2837         (bmalloc::IsoHeapImplBase::~IsoHeapImplBase):
2838         (bmalloc::IsoHeapImplBase::scavengeNow):
2839         (bmalloc::IsoHeapImplBase::finishScavenging):
2840         * bmalloc/IsoHeapImpl.h: Added.
2841         * bmalloc/IsoHeapImplInlines.h: Added.
2842         (bmalloc::IsoHeapImpl<Config>::IsoHeapImpl):
2843         (bmalloc::IsoHeapImpl<Config>::takeFirstEligible):
2844         (bmalloc::IsoHeapImpl<Config>::didBecomeEligible):
2845         (bmalloc::IsoHeapImpl<Config>::scavenge):
2846         (bmalloc::IsoHeapImpl<Config>::allocatorOffset):
2847         (bmalloc::IsoHeapImpl<Config>::deallocatorOffset):
2848         (bmalloc::IsoHeapImpl<Config>::numLiveObjects):
2849         (bmalloc::IsoHeapImpl<Config>::numCommittedPages):
2850         (bmalloc::IsoHeapImpl<Config>::forEachDirectory):
2851         (bmalloc::IsoHeapImpl<Config>::forEachCommittedPage):
2852         (bmalloc::IsoHeapImpl<Config>::forEachLiveObject):
2853         * bmalloc/IsoHeapInlines.h: Added.
2854         (bmalloc::api::IsoHeap<Type>::allocate):
2855         (bmalloc::api::IsoHeap<Type>::tryAllocate):
2856         (bmalloc::api::IsoHeap<Type>::deallocate):
2857         (bmalloc::api::IsoHeap<Type>::scavenge):
2858         (bmalloc::api::IsoHeap<Type>::isInitialized):
2859         (bmalloc::api::IsoHeap<Type>::impl):
2860         * bmalloc/IsoPage.h: Added.
2861         (bmalloc::IsoPage::index const):
2862         (bmalloc::IsoPage::directory):
2863         (bmalloc::IsoPage::isInUseForAllocation const):
2864         (bmalloc::IsoPage::indexOfFirstObject):
2865         * bmalloc/IsoPageInlines.h: Added.
2866         (bmalloc::IsoPage<Config>::tryCreate):
2867         (bmalloc::IsoPage<Config>::IsoPage):
2868         (bmalloc::IsoPage<Config>::free):
2869         (bmalloc::IsoPage<Config>::startAllocating):
2870         (bmalloc::IsoPage<Config>::stopAllocating):
2871         (bmalloc::IsoPage<Config>::forEachLiveObject):
2872         * bmalloc/IsoPageTrigger.h: Added.
2873         * bmalloc/IsoTLS.cpp: Added.
2874         (bmalloc::IsoTLS::scavenge):
2875         (bmalloc::IsoTLS::IsoTLS):
2876         (bmalloc::IsoTLS::ensureEntries):
2877         (bmalloc::IsoTLS::destructor):
2878         (bmalloc::IsoTLS::sizeForCapacity):
2879         (bmalloc::IsoTLS::capacityForSize):
2880         (bmalloc::IsoTLS::size):
2881         (bmalloc::IsoTLS::forEachEntry):
2882         * bmalloc/IsoTLS.h: Added.
2883         * bmalloc/IsoTLSAllocatorEntry.h: Added.
2884         * bmalloc/IsoTLSAllocatorEntryInlines.h: Added.
2885         (bmalloc::IsoTLSAllocatorEntry<Config>::IsoTLSAllocatorEntry):
2886         (bmalloc::IsoTLSAllocatorEntry<Config>::~IsoTLSAllocatorEntry):
2887         (bmalloc::IsoTLSAllocatorEntry<Config>::construct):
2888         * bmalloc/IsoTLSDeallocatorEntry.h: Added.
2889         * bmalloc/IsoTLSDeallocatorEntryInlines.h: Added.
2890         (bmalloc::IsoTLSDeallocatorEntry<Config>::IsoTLSDeallocatorEntry):
2891         (bmalloc::IsoTLSDeallocatorEntry<Config>::~IsoTLSDeallocatorEntry):
2892         (bmalloc::IsoTLSDeallocatorEntry<Config>::construct):
2893         * bmalloc/IsoTLSEntry.cpp: Added.
2894         (bmalloc::IsoTLSEntry::IsoTLSEntry):
2895         (bmalloc::IsoTLSEntry::~IsoTLSEntry):
2896         * bmalloc/IsoTLSEntry.h: Added.
2897         (bmalloc::IsoTLSEntry::offset const):
2898         (bmalloc::IsoTLSEntry::alignment const):
2899         (bmalloc::IsoTLSEntry::size const):
2900         (bmalloc::IsoTLSEntry::extent const):
2901         * bmalloc/IsoTLSEntryInlines.h: Added.
2902         (bmalloc::IsoTLSEntry::walkUpToInclusive):
2903         (bmalloc::DefaultIsoTLSEntry<EntryType>::DefaultIsoTLSEntry):
2904         (bmalloc::DefaultIsoTLSEntry<EntryType>::~DefaultIsoTLSEntry):
2905         (bmalloc::DefaultIsoTLSEntry<EntryType>::move):
2906         (bmalloc::DefaultIsoTLSEntry<EntryType>::destruct):
2907         (bmalloc::DefaultIsoTLSEntry<EntryType>::scavenge):
2908         * bmalloc/IsoTLSInlines.h: Added.
2909         (bmalloc::IsoTLS::allocate):
2910         (bmalloc::IsoTLS::deallocate):
2911         (bmalloc::IsoTLS::scavenge):
2912         (bmalloc::IsoTLS::allocator):
2913         (bmalloc::IsoTLS::deallocator):
2914         (bmalloc::IsoTLS::get):
2915         (bmalloc::IsoTLS::set):
2916         (bmalloc::IsoTLS::ensureHeap):
2917         (bmalloc::IsoTLS::ensureHeapAndEntries):
2918         * bmalloc/IsoTLSLayout.cpp: Added.
2919         (bmalloc::IsoTLSLayout::IsoTLSLayout):
2920         (bmalloc::IsoTLSLayout::add):
2921         * bmalloc/IsoTLSLayout.h: Added.
2922         (bmalloc::IsoTLSLayout::head const):
2923         * bmalloc/PerHeapKind.h:
2924         * bmalloc/PerProcess.h:
2925         (bmalloc::PerProcess<T>::getFastCase):
2926         * bmalloc/Scavenger.cpp:
2927         (bmalloc::Scavenger::scavenge):
2928         * bmalloc/Scavenger.h:
2929         * bmalloc/bmalloc.h:
2930         (bmalloc::api::scavengeThisThread):
2931         * test: Added.
2932         * test/testbmalloc.cpp: Added.
2933         (hiddenTruthBecauseNoReturnIsStupid):
2934         (usage):
2935         (assertEmptyPointerSet):
2936         (assertHasObjects):
2937         (assertHasOnlyObjects):
2938         (assertClean):
2939         (testIsoSimple):
2940         (testIsoSimpleScavengeBeforeDealloc):
2941         (testIsoFlipFlopFragmentedPages):
2942         (testIsoFlipFlopFragmentedPagesScavengeInMiddle):
2943         (BisoMalloced::BisoMalloced):
2944         (testBisoMalloced):
2945         (BisoMallocedInline::BisoMallocedInline):
2946         (testBisoMallocedInline):
2947         (run):
2948         (main):
2949
2950 2017-10-30  Zan Dobersek  <zdobersek@igalia.com>
2951
2952         [ARM64][Linux] Re-enable Gigacage
2953         https://bugs.webkit.org/show_bug.cgi?id=178130
2954
2955         Reviewed by Michael Catanzaro.
2956
2957         * bmalloc/Gigacage.h: Re-enable Gigacage on ARM64 Linux.
2958
2959 2017-10-25  Commit Queue  <commit-queue@webkit.org>
2960
2961         Unreviewed, rolling out r222945.
2962         https://bugs.webkit.org/show_bug.cgi?id=178818
2963
2964         "It made WasmBench crash" (Requested by saamyjoon on #webkit).
2965
2966         Reverted changeset:
2967
2968         "bmalloc mutex should be adaptive"
2969         https://bugs.webkit.org/show_bug.cgi?id=177839
2970         https://trac.webkit.org/changeset/222945
2971
2972 2017-10-24  Zan Dobersek  <zdobersek@igalia.com>
2973
2974         [Linux] Enable Gigacage in x64 Linux environment
2975         https://bugs.webkit.org/show_bug.cgi?id=177745
2976         <rdar://problem/34773148>
2977
2978         Reviewed by Yusuke Suzuki.
2979
2980         Re-enable Gigacage on x86_64 Linux platforms after it was disabled in 223877.
2981
2982         The cause for the revert was problems with huge coredumps being generated
2983         while Gigacage was enabled. The feature virtually allocates about 80GB of
2984         memory at the beginning of the process lifetime. This is not a problem in
2985         itself since the memory range is marked as not needed through madvise(),
2986         but all this memory was still included upon core dump generation on Linux.
2987         Since there are reasonable limits enforced upon core dumps, these were
2988         being truncated every time, not yielding any useful information.
2989
2990         To avoid this, on Linux, invocations of madvise() with the MADV_NORMAL and
2991         MADV_DONTNEED advice parameters should be accompanied with respectively
2992         matching MADV_DODUMP and MADV_DONTDUMP madvise() calls. This correctly
2993         avoids core-dumping any memory that's not yet been physically allocated.
2994
2995         * bmalloc/Gigacage.h:
2996         * bmalloc/VMAllocate.h:
2997         (bmalloc::vmDeallocatePhysicalPages):
2998         (bmalloc::vmAllocatePhysicalPages):
2999
3000 2017-10-24  David Kilzer  <ddkilzer@apple.com>
3001
3002         Need to pass non-nil argument to SimulateCrash() in bmalloc::logVMFailure()
3003         <https://webkit.org/b/178740>
3004         <rdar://problem/35154943>
3005
3006         Reviewed by Saam Barati.
3007
3008         * bmalloc/BPlatform.h:
3009         (BUNUSED_PARAM): Define macro.
3010         * bmalloc/Logging.cpp:
3011         (SimulateCrash): Change third argument of SimulateCrash() to
3012         CFStringRef since it's an NSString * in Objective-C.
3013         (bmalloc::logVMFailure): Create a CFStringRef to use as a
3014         description string.  Use new vmSize parameter to log size.
3015         * bmalloc/Logging.h:
3016         (bmalloc::logVMFailure): Update function signature to take a
3017         size_t parameter representing vmSize.
3018         * bmalloc/VMAllocate.h:
3019         (bmalloc::tryVMAllocate): Pass vmSize into logVMFailure().
3020
3021 2017-10-23  Michael Catanzaro  <mcatanzaro@igalia.com>
3022
3023         Unreviewed, roll out r222731
3024         https://bugs.webkit.org/show_bug.cgi?id=177745
3025         <rdar://problem/34773148>
3026
3027         Unfortunately Gigacage has broken core dump generation.
3028
3029         * bmalloc/Gigacage.h:
3030
3031 2017-10-23  Zan Dobersek  <zdobersek@igalia.com>
3032
3033         bmalloc::api::tryLargeMemalignVirtual() shouldn't assert on a failed allocation
3034         https://bugs.webkit.org/show_bug.cgi?id=178654
3035
3036         Reviewed by Geoffrey Garen.
3037
3038         * bmalloc/bmalloc.h:
3039         (bmalloc::api::tryLargeMemalignVirtual): Call Heap::tryAllocateLarge()
3040         instead of Heap::allocateLarge(). The former will return a null pointer
3041         upon a failed allocation, allowing the caller to fail gracefully just as
3042         the API entrypoint implies, while the latter currently provokes a crash
3043         in these circumstances.
3044
3045 2017-10-19  Saam Barati  <sbarati@apple.com>
3046
3047         Runtime disable gigacage on iOS because it broke WasmBench
3048         https://bugs.webkit.org/show_bug.cgi?id=178556
3049
3050         Reviewed by Keith Miller.
3051
3052         * bmalloc/Gigacage.cpp:
3053         (Gigacage::shouldBeEnabled):
3054
3055 2017-10-17  Filip Pizlo  <fpizlo@apple.com>
3056
3057         You can't vmDeallocate null
3058         <rdar://problem/35038926>
3059
3060         Reviewed by Michael Saboff.
3061         
3062         After failing allocation, we would try to deallocate the thing we failed to allocate. The fix is to
3063         not try to deallocate something that is obviously null.
3064
3065         * bmalloc/Gigacage.cpp:
3066         (Gigacage::ensureGigacage):
3067
3068 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3069
3070         Enable gigacage on iOS
3071         https://bugs.webkit.org/show_bug.cgi?id=177586
3072
3073         Reviewed by JF Bastien.
3074         
3075         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3076         allocation fails, we free all of the gigacages and turn off gigacage support.
3077         
3078         Roll this back in after discussion.
3079
3080         * CMakeLists.txt:
3081         * bmalloc.xcodeproj/project.pbxproj:
3082         * bmalloc/Cache.cpp:
3083         (bmalloc::Cache::scavenge):
3084         * bmalloc/Cache.h:
3085         (bmalloc::Cache::tryAllocate):
3086         (bmalloc::Cache::allocate):
3087         (bmalloc::Cache::deallocate):
3088         (bmalloc::Cache::reallocate):
3089         * bmalloc/Gigacage.cpp:
3090         (Gigacage::ensureGigacage):
3091         (Gigacage::runway):
3092         (Gigacage::totalSize):
3093         (Gigacage::shouldBeEnabled):
3094         (): Deleted.
3095         (Gigacage::Callback::Callback): Deleted.
3096         (Gigacage::Callback::function): Deleted.
3097         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3098         * bmalloc/Gigacage.h:
3099         (Gigacage::wasEnabled):
3100         (Gigacage::isEnabled):
3101         (Gigacage::runway): Deleted.
3102         (Gigacage::totalSize): Deleted.
3103         * bmalloc/HeapKind.cpp: Added.
3104         (bmalloc::isActiveHeapKind):
3105         (bmalloc::mapToActiveHeapKind):
3106         * bmalloc/HeapKind.h:
3107         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3108         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3109         * bmalloc/Scavenger.cpp:
3110         (bmalloc::Scavenger::scavenge):
3111         * bmalloc/bmalloc.h:
3112         (bmalloc::api::tryLargeMemalignVirtual):
3113         (bmalloc::api::freeLargeVirtual):
3114         (bmalloc::api::isEnabled):
3115
3116 2017-10-11  Commit Queue  <commit-queue@webkit.org>
3117
3118         Unreviewed, rolling out r223113 and r223121.
3119         https://bugs.webkit.org/show_bug.cgi?id=178182
3120
3121         Reintroduced 20% regression on Kraken (Requested by rniwa on
3122         #webkit).
3123
3124         Reverted changesets:
3125
3126         "Enable gigacage on iOS"
3127         https://bugs.webkit.org/show_bug.cgi?id=177586
3128         https://trac.webkit.org/changeset/223113
3129
3130         "Use one virtual allocation for all gigacages and their
3131         runways"
3132         https://bugs.webkit.org/show_bug.cgi?id=178050
3133         https://trac.webkit.org/changeset/223121
3134
3135 2017-10-07  Filip Pizlo  <fpizlo@apple.com>
3136
3137         Use one virtual allocation for all gigacages and their runways
3138         https://bugs.webkit.org/show_bug.cgi?id=178050
3139
3140         Reviewed by Saam Barati.
3141
3142         * bmalloc/Gigacage.cpp:
3143         (Gigacage::ensureGigacage):
3144         (Gigacage::runway): Deleted.
3145         (Gigacage::totalSize): Deleted.
3146         * bmalloc/Gigacage.h:
3147
3148 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3149
3150         Enable gigacage on iOS
3151         https://bugs.webkit.org/show_bug.cgi?id=177586
3152
3153         Reviewed by JF Bastien.
3154         
3155         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3156         allocation fails, we free all of the gigacages and turn off gigacage support.
3157         
3158         Reland this after confirming that the 20% Kraken regression was a one-bot fluke. Local testing on the
3159         same kind of system did not show the regression. Saam and I both tried independently.
3160
3161         * CMakeLists.txt:
3162         * bmalloc.xcodeproj/project.pbxproj:
3163         * bmalloc/Cache.cpp:
3164         (bmalloc::Cache::scavenge):
3165         * bmalloc/Cache.h:
3166         (bmalloc::Cache::tryAllocate):
3167         (bmalloc::Cache::allocate):
3168         (bmalloc::Cache::deallocate):
3169         (bmalloc::Cache::reallocate):
3170         * bmalloc/Gigacage.cpp:
3171         (Gigacage::ensureGigacage):
3172         (Gigacage::runway):
3173         (Gigacage::totalSize):
3174         (Gigacage::shouldBeEnabled):
3175         (): Deleted.
3176         (Gigacage::Callback::Callback): Deleted.
3177         (Gigacage::Callback::function): Deleted.
3178         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3179         * bmalloc/Gigacage.h:
3180         (Gigacage::wasEnabled):
3181         (Gigacage::isEnabled):
3182         (Gigacage::runway): Deleted.
3183         (Gigacage::totalSize): Deleted.
3184         * bmalloc/HeapKind.cpp: Added.
3185         (bmalloc::isActiveHeapKind):
3186         (bmalloc::mapToActiveHeapKind):
3187         * bmalloc/HeapKind.h:
3188         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3189         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3190         * bmalloc/Scavenger.cpp:
3191         (bmalloc::Scavenger::scavenge):
3192         * bmalloc/bmalloc.h:
3193         (bmalloc::api::tryLargeMemalignVirtual):
3194         (bmalloc::api::freeLargeVirtual):
3195         (bmalloc::api::isEnabled):
3196
3197 2017-10-09  Commit Queue  <commit-queue@webkit.org>
3198
3199         Unreviewed, rolling out r223015 and r223025.
3200         https://bugs.webkit.org/show_bug.cgi?id=178093
3201
3202         Regressed Kraken on iOS by 20% (Requested by keith_mi_ on
3203         #webkit).
3204
3205         Reverted changesets:
3206
3207         "Enable gigacage on iOS"
3208         https://bugs.webkit.org/show_bug.cgi?id=177586
3209         http://trac.webkit.org/changeset/223015
3210
3211         "Unreviewed, disable Gigacage on ARM64 Linux"
3212         https://bugs.webkit.org/show_bug.cgi?id=177586
3213         http://trac.webkit.org/changeset/223025
3214
3215 2017-10-07  Yusuke Suzuki  <utatane.tea@gmail.com>
3216
3217         Unreviewed, disable Gigacage on ARM64 Linux
3218         https://bugs.webkit.org/show_bug.cgi?id=177586
3219
3220         Gigacage's LLInt change breaks ARM64 Linux.
3221         Currently we do not have maintainers for this.
3222         Let's simply disable it.
3223
3224         * bmalloc/Gigacage.h:
3225
3226 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3227
3228         Enable gigacage on iOS
3229         https://bugs.webkit.org/show_bug.cgi?id=177586
3230
3231         Reviewed by JF Bastien.
3232         
3233         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3234         allocation fails, we free all of the gigacages and turn off gigacage support.
3235
3236         * CMakeLists.txt:
3237         * bmalloc.xcodeproj/project.pbxproj:
3238         * bmalloc/Cache.cpp:
3239         (bmalloc::Cache::scavenge):
3240         * bmalloc/Cache.h:
3241         (bmalloc::Cache::tryAllocate):
3242         (bmalloc::Cache::allocate):
3243         (bmalloc::Cache::deallocate):
3244         (bmalloc::Cache::reallocate):
3245         * bmalloc/Gigacage.cpp:
3246         (Gigacage::ensureGigacage):
3247         (Gigacage::runway):
3248         (Gigacage::totalSize):
3249         (Gigacage::shouldBeEnabled):
3250         (): Deleted.
3251         (Gigacage::Callback::Callback): Deleted.
3252         (Gigacage::Callback::function): Deleted.
3253         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3254         * bmalloc/Gigacage.h:
3255         (Gigacage::wasEnabled):
3256         (Gigacage::isEnabled):
3257         (Gigacage::runway): Deleted.
3258         (Gigacage::totalSize): Deleted.
3259         * bmalloc/HeapKind.cpp: Added.
3260         (bmalloc::isActiveHeapKind):
3261         (bmalloc::mapToActiveHeapKind):
3262         * bmalloc/HeapKind.h:
3263         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3264         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3265         * bmalloc/Scavenger.cpp:
3266         (bmalloc::Scavenger::scavenge):
3267         * bmalloc/bmalloc.h:
3268         (bmalloc::api::tryLargeMemalignVirtual):
3269         (bmalloc::api::freeLargeVirtual):
3270         (bmalloc::api::isEnabled):
3271
3272 2017-10-05  Filip Pizlo  <fpizlo@apple.com>
3273
3274         Use one Scavenger thread for all Heaps
3275         https://bugs.webkit.org/show_bug.cgi?id=174973
3276
3277         Reviewed by JF Bastien.
3278         
3279         This combines the scavengers from all Heap instances into a single scavenger. It also combines
3280         the accounting for deciding when to run. Each Heap still controls what it means to scavenge
3281         itself (it's all in Heap::scavenge) but the policy decisions are all controlled by Scavenger.
3282         Because Scavenger is also the only thing that needs an AsyncTask, this removes AsyncTask and
3283         moves all of AsyncTask's logic into Scavenger.
3284         
3285         This appears to be a 1% progression on JetStream (with high statistical confidence: p = 0.0049).
3286
3287         * bmalloc.xcodeproj/project.pbxproj:
3288         * bmalloc/AsyncTask.h: Removed.
3289         * bmalloc/Heap.cpp:
3290         (bmalloc::Heap::Heap):
3291         (bmalloc::Heap::allocateSmallChunk):
3292         (bmalloc::Heap::allocateSmallPage):
3293         (bmalloc::Heap::deallocateSmallLine):
3294         (bmalloc::Heap::splitAndAllocate):
3295         (bmalloc::Heap::tryAllocateLarge):
3296         (bmalloc::Heap::shrinkLarge):
3297         (bmalloc::Heap::deallocateLarge):
3298         (bmalloc::Heap::concurrentScavenge): Deleted.
3299         (bmalloc::Heap::scheduleScavengerIfUnderMemoryPressure): Deleted.
3300         (bmalloc::Heap::scheduleScavenger): Deleted.
3301         * bmalloc/Heap.h:
3302         * bmalloc/Scavenger.cpp:
3303         (bmalloc::Scavenger::Scavenger):
3304         (bmalloc::Scavenger::run):
3305         (bmalloc::Scavenger::runHoldingLock):
3306         (bmalloc::Scavenger::runSoon):
3307         (bmalloc::Scavenger::runSoonHoldingLock):
3308         (bmalloc::Scavenger::didStartGrowing):
3309         (bmalloc::Scavenger::scheduleIfUnderMemoryPressure):
3310         (bmalloc::Scavenger::scheduleIfUnderMemoryPressureHoldingLock):
3311         (bmalloc::Scavenger::schedule):
3312         (bmalloc::Scavenger::threadEntryPoint):
3313         (bmalloc::Scavenger::threadRunLoop):
3314         (bmalloc::Scavenger::setSelfQOSClass):
3315         * bmalloc/Scavenger.h:
3316         (bmalloc::Scavenger::willRun):
3317         (bmalloc::Scavenger::willRunSoon):
3318
3319 2017-10-04  Filip Pizlo  <fpizlo@apple.com>
3320
3321         bmalloc mutex should be adaptive
3322         https://bugs.webkit.org/show_bug.cgi?id=177839
3323
3324         Reviewed by Michael Saboff.
3325         
3326         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
3327         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
3328         anything other than malloc.
3329
3330         Reland after fixing ancient WordLock bug: the notify_one has to happen with the lock held
3331         to ensure it doesn't run after that thread has died.
3332
3333         * bmalloc/Algorithm.h:
3334         (bmalloc::compareExchangeWeak):
3335         (bmalloc::compareExchangeStrong):
3336         * bmalloc/PerThread.h:
3337         * bmalloc/StaticMutex.cpp:
3338         (bmalloc::StaticMutex::lockSlow):
3339         (bmalloc::StaticMutex::unlockSlow):
3340         (bmalloc::StaticMutex::lockSlowCase): Deleted.
3341         * bmalloc/StaticMutex.h:
3342         (bmalloc::StaticMutex::try_lock):
3343         (bmalloc::StaticMutex::isLocked const):
3344         (bmalloc::StaticMutex::init):
3345         (bmalloc::StaticMutex::tryLock):
3346         (bmalloc::StaticMutex::lock):
3347         (bmalloc::StaticMutex::unlock):
3348         (bmalloc::sleep): Deleted.
3349         (bmalloc::waitUntilFalse): Deleted.
3350
3351 2017-10-05  Matt Lewis  <jlewis3@apple.com>
3352
3353         Unreviewed, rolling out r222893.
3354
3355         This caused multiple API failures.
3356
3357         Reverted changeset:
3358
3359         "bmalloc mutex should be adaptive"
3360         https://bugs.webkit.org/show_bug.cgi?id=177839
3361         http://trac.webkit.org/changeset/222893
3362
3363 2017-10-05  Yusuke Suzuki  <utatane.tea@gmail.com>
3364
3365         [Linux] Port MallocBench
3366         https://bugs.webkit.org/show_bug.cgi?id=177856
3367
3368         Reviewed by Filip Pizlo.
3369
3370         * CMakeLists.txt:
3371
3372 2017-10-04  Filip Pizlo  <fpizlo@apple.com>
3373
3374         bmalloc mutex should be adaptive
3375         https://bugs.webkit.org/show_bug.cgi?id=177839
3376
3377         Reviewed by Michael Saboff.
3378         
3379         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
3380         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
3381         anything other than malloc.
3382
3383         * bmalloc/Algorithm.h:
3384         (bmalloc::compareExchangeWeak):
3385         (bmalloc::compareExchangeStrong):
3386         * bmalloc/PerThread.h:
3387         * bmalloc/StaticMutex.cpp:
3388         (bmalloc::StaticMutex::lockSlow):
3389         (bmalloc::StaticMutex::unlockSlow):
3390         (bmalloc::StaticMutex::lockSlowCase): Deleted.
3391         * bmalloc/StaticMutex.h:
3392         (bmalloc::StaticMutex::try_lock):
3393         (bmalloc::StaticMutex::isLocked const):
3394         (bmalloc::StaticMutex::init):
3395         (bmalloc::StaticMutex::tryLock):
3396         (bmalloc::StaticMutex::lock):
3397         (bmalloc::StaticMutex::unlock):
3398         (bmalloc::sleep): Deleted.
3399         (bmalloc::waitUntilFalse): Deleted.
3400
3401 2017-10-02  Yusuke Suzuki  <utatane.tea@gmail.com>
3402
3403         [Linux] Enable Gigacage in x64 Linux environment
3404         https://bugs.webkit.org/show_bug.cgi?id=177745
3405
3406         Reviewed by Carlos Garcia Campos.
3407
3408         This patch enables Gigacage in x64 Linux environment.
3409         Gigacage enforces a caged pointer to reference to the
3410         specific memory region. This reduces the effectiveness
3411         of some types of attacks setting a pointer to ArrayBuffer
3412         and modifying arbitrary memory region.
3413
3414         * bmalloc/Gigacage.h:
3415
3416 2017-09-29  Commit Queue  <commit-queue@webkit.org>
3417
3418         Unreviewed, rolling out r222625.
3419         https://bugs.webkit.org/show_bug.cgi?id=177664
3420
3421         causes crashes on iOS (Requested by pizlo-mbp on #webkit).
3422
3423         Reverted changeset:
3424
3425         "Enable gigacage on iOS"
3426         https://bugs.webkit.org/show_bug.cgi?id=177586
3427         http://trac.webkit.org/changeset/222625
3428
3429 2017-09-28  Filip Pizlo  <fpizlo@apple.com>
3430
3431         Enable gigacage on iOS
3432         https://bugs.webkit.org/show_bug.cgi?id=177586
3433
3434         Reviewed by Michael Saboff.
3435         
3436         This enables Gigacage on iOS using a much smaller cage size. It's not necessary for it to be so
3437         small, but this is a good conservative starting point to start to exercise the code.
3438
3439         * bmalloc/Gigacage.h:
3440
3441 2017-09-26  Filip Pizlo  <fpizlo@apple.com>
3442
3443         Put g_gigacageBasePtr into its own page and make it read-only
3444         https://bugs.webkit.org/show_bug.cgi?id=174972
3445
3446         Reviewed by Michael Saboff.
3447         
3448         This puts the gigacage base pointers into their own page and makes that page read-only.
3449
3450         * bmalloc/Gigacage.cpp:
3451         (Gigacage::ensureGigacage):
3452         (Gigacage::disablePrimitiveGigacage):
3453         (Gigacage::addPrimitiveDisableCallback):
3454         * bmalloc/Gigacage.h:
3455         (Gigacage::basePtr):
3456         (Gigacage::basePtrs):
3457
3458 2017-09-04  Adrian Perez de Castro  <aperez@igalia.com>
3459
3460         Unreviewed build fix for Clang with libc++
3461
3462         Fixes a build failure when building with Clang, -stdlib=libc++, and gigacage
3463         support enabled, which resulted in "stderr" being undefined.
3464
3465         * bmalloc/Gigacage.cpp: Add missing <ctsdio> include to pull the definition.
3466
3467 2017-09-03  Yusuke Suzuki  <utatane.tea@gmail.com>
3468
3469         Large virtual memory region allocation requires MMAP_NORESERVE in Linux
3470         https://bugs.webkit.org/show_bug.cgi?id=176211
3471
3472         Reviewed by Geoffrey Garen.
3473
3474         In Linux, we cannot allocate very large memory region without MMAP_NORESERVE.
3475         Linux kernel needs to reserve swap area for allocated memory region. If the
3476         swap area is exhausted, kernel fails to allocate the memory region with ENOMEM.
3477
3478         This patch adds MMAP_NORESERVE to mmap flags in Linux. By adding this flag,
3479         mmap does not need to reserve swap area for the reserved memory region.
3480         This allows us to reserve very large memory region that is necessary for Gigacage.
3481
3482         * bmalloc/BPlatform.h:
3483         * bmalloc/VMAllocate.h:
3484         (bmalloc::tryVMAllocate):
3485
3486 2017-08-22  Filip Pizlo  <fpizlo@apple.com>
3487
3488         Strings need to be in some kind of gigacage
3489         https://bugs.webkit.org/show_bug.cgi?id=174924
3490
3491         Reviewed by Oliver Hunt.
3492         
3493         This adds a StringGigacage.
3494
3495         * bmalloc/Gigacage.cpp:
3496         * bmalloc/Gigacage.h:
3497         (Gigacage::name):
3498         (Gigacage::basePtr):
3499         (Gigacage::forEachKind):
3500         * bmalloc/HeapKind.h:
3501         (bmalloc::isGigacage):
3502         (bmalloc::gigacageKind):
3503         (bmalloc::heapKind):
3504
3505 2017-08-30  Matt Lewis  <jlewis3@apple.com>
3506
3507         Unreviewed, rolling out r221384.
3508
3509         This patch caused multiple 32-bit JSC test failures.
3510
3511         Reverted changeset:
3512
3513         "Strings need to be in some kind of gigacage"
3514         https://bugs.webkit.org/show_bug.cgi?id=174924
3515         http://trac.webkit.org/changeset/221384
3516
3517 2017-08-22  Filip Pizlo  <fpizlo@apple.com>
3518
3519         Strings need to be in some kind of gigacage
3520         https://bugs.webkit.org/show_bug.cgi?id=174924
3521
3522         Reviewed by Oliver Hunt.
3523         
3524         This adds a StringGigacage.
3525
3526         * bmalloc/Gigacage.cpp:
3527         * bmalloc/Gigacage.h:
3528         (Gigacage::name):
3529         (Gigacage::basePtr):
3530         (Gigacage::forEachKind):
3531         * bmalloc/HeapKind.h:
3532         (bmalloc::isGigacage):
3533         (bmalloc::gigacageKind):
3534         (bmalloc::heapKind):
3535
3536 2017-08-25  Daniel Bates  <dabates@apple.com>
3537
3538         Demarcate code added due to lack of NSDMI for aggregates
3539         https://bugs.webkit.org/show_bug.cgi?id=175990
3540
3541         Reviewed by Andy Estes.
3542
3543         * bmalloc/BPlatform.h:
3544         * bmalloc/List.h: Be explicit when initializing m_node to improve readability.
3545         (bmalloc::ListNode::ListNode):
3546
3547 2017-08-23  Filip Pizlo  <fpizlo@apple.com>
3548
3549         Reduce Gigacage sizes
3550         https://bugs.webkit.org/show_bug.cgi?id=175920
3551
3552         Reviewed by Mark Lam.
3553
3554         This introduces the ability to have different gigacage sizes for different gigacages, and uses it to reduce the size of both
3555         gigacages, but to different extents: Primitive gets 32GB with a 16GB runway and JSValue gets 16GB.
3556
3557         This is a ~10% membuster progression on my Mac Pro.
3558
3559         * bmalloc/Gigacage.cpp:
3560         (Gigacage::ensureGigacage):
3561         * bmalloc/Gigacage.h:
3562         (Gigacage::size):
3563         (Gigacage::alignment):
3564         (Gigacage::mask):
3565         (Gigacage::runway):
3566         (Gigacage::totalSize):
3567         (Gigacage::caged):
3568         * bmalloc/Heap.cpp:
3569         (bmalloc::Heap::Heap):
3570         (bmalloc::Heap::gigacageSize):
3571         * bmalloc/Heap.h:
3572
3573 2017-08-08  Filip Pizlo  <fpizlo@apple.com>
3574
3575         Baseline JIT should do caging
3576         https://bugs.webkit.org/show_bug.cgi?id=175037
3577
3578         Reviewed by Mark Lam.
3579         
3580         This centralizes the notion of permanently enabling the primitive gigacage, which we only do in jsc
3581         and WebProcess.
3582         
3583         This saves the baseline JIT from emitting some code. Otherwise it would always have to emit enabled
3584         checks on each typed array access.
3585
3586         * bmalloc/Gigacage.cpp:
3587         (Gigacage::primitiveGigacageDisabled):
3588         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
3589         (Gigacage::isDisablingPrimitiveGigacageDisabled):
3590         * bmalloc/Gigacage.h:
3591         (Gigacage::isPrimitiveGigacagePermanentlyEnabled):
3592         (Gigacage::canPrimitiveGigacageBeDisabled):
3593
3594 2017-08-08  Ryan Haddad  <ryanhaddad@apple.com>
3595
3596         Unreviewed, rolling out r220368.
3597
3598         This change caused WK1 tests to exit early with crashes.
3599
3600         Reverted changeset:
3601
3602         "Baseline JIT should do caging"
3603         https://bugs.webkit.org/show_bug.cgi?id=175037
3604         http://trac.webkit.org/changeset/220368
3605
3606 2017-08-07  Filip Pizlo  <fpizlo@apple.com>
3607
3608         Baseline JIT should do caging
3609         https://bugs.webkit.org/show_bug.cgi?id=175037
3610
3611         Reviewed by Mark Lam.
3612         
3613         This centralizes the notion of permanently enabling the primitive gigacage, which we only do in jsc
3614         and WebProcess.
3615         
3616         This saves the baseline JIT from emitting some code. Otherwise it would always have to emit enabled
3617         checks on each typed array access.
3618
3619         * bmalloc/Gigacage.cpp:
3620         (Gigacage::primitiveGigacageDisabled):
3621         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
3622         (Gigacage::isDisablingPrimitiveGigacageDisabled):
3623         * bmalloc/Gigacage.h:
3624         (Gigacage::isPrimitiveGigacagePermanentlyEnabled):
3625         (Gigacage::canPrimitiveGigacageBeDisabled):
3626
3627 2017-08-06  Filip Pizlo  <fpizlo@apple.com>
3628
3629         Primitive auxiliaries and JSValue auxiliaries should have separate gigacages
3630         https://bugs.webkit.org/show_bug.cgi?id=174919
3631
3632         Reviewed by Keith Miller.
3633         
3634         This introduces two kinds of Gigacage, Primitive and JSValue. This translates to two kinds of
3635         HeapKind, PrimitiveGigacage and JSValueGigacage.
3636         
3637         The new support functionality required turning Inline.h into BInline.h, and INLINE into BINLINE, and
3638         NO_INLINE into BNO_INLINE.
3639
3640         * bmalloc.xcodeproj/project.pbxproj:
3641         * bmalloc/Allocator.cpp:
3642         (bmalloc::Allocator::refillAllocatorSlowCase):
3643         (bmalloc::Allocator::refillAllocator):
3644         (bmalloc::Allocator::allocateLarge):
3645         (bmalloc::Allocator::allocateLogSizeClass):
3646         * bmalloc/AsyncTask.h:
3647         * bmalloc/BInline.h: Copied from Source/bmalloc/bmalloc/Inline.h.
3648         * bmalloc/Cache.cpp:
3649         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
3650         (bmalloc::Cache::allocateSlowCaseNullCache):
3651         (bmalloc::Cache::deallocateSlowCaseNullCache):
3652         (bmalloc::Cache::reallocateSlowCaseNullCache):
3653         * bmalloc/Deallocator.cpp:
3654         * bmalloc/Gigacage.cpp:
3655         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks):
3656         (Gigacage::ensureGigacage):
3657         (Gigacage::disablePrimitiveGigacage):
3658         (Gigacage::addPrimitiveDisableCallback):
3659         (Gigacage::removePrimitiveDisableCallback):
3660         (Gigacage::Callbacks::Callbacks): Deleted.
3661         (Gigacage::disableGigacage): Deleted.
3662         (Gigacage::addDisableCallback): Deleted.
3663         (Gigacage::removeDisableCallback): Deleted.
3664         * bmalloc/Gigacage.h:
3665         (Gigacage::name):
3666         (Gigacage::basePtr):
3667         (Gigacage::forEachKind):
3668         (Gigacage::caged):
3669         (Gigacage::isCaged):
3670         * bmalloc/Heap.cpp:
3671         (bmalloc::Heap::Heap):
3672         (bmalloc::Heap::usingGigacage):
3673         (bmalloc::Heap::gigacageBasePtr):
3674         * bmalloc/Heap.h:
3675         * bmalloc/HeapKind.h:
3676         (bmalloc::isGigacage):
3677         (bmalloc::gigacageKind):
3678         (bmalloc::heapKind):
3679         * bmalloc/Inline.h: Removed.
3680         * bmalloc/Map.h:
3681         * bmalloc/PerProcess.h:
3682         (bmalloc::PerProcess<T>::getFastCase):
3683         (bmalloc::PerProcess<T>::get):
3684         (bmalloc::PerProcess<T>::getSlowCase):
3685         * bmalloc/PerThread.h:
3686         (bmalloc::PerThread<T>::getFastCase):
3687         * bmalloc/Vector.h:
3688         (bmalloc::Vector<T>::push):
3689         (bmalloc::Vector<T>::shrinkCapacity):
3690         (bmalloc::Vector<T>::growCapacity):
3691
3692 2017-08-02  Filip Pizlo  <fpizlo@apple.com>
3693
3694         If Gigacage is disabled, bmalloc should service large aligned memory allocation requests through vmAllocate
3695         https://bugs.webkit.org/show_bug.cgi?id=175085
3696
3697         Reviewed by Saam Barati.
3698         
3699         This fixes a problem where if we used gmalloc, WebAssembly memory allocations would still use
3700         bmalloc's large allocator.
3701         
3702         We want to use the page allocator for those "large" allocations when the Gigacage is disabled.
3703
3704         * bmalloc/DebugHeap.cpp:
3705         (bmalloc::DebugHeap::DebugHeap):
3706         (bmalloc::DebugHeap::memalignLarge):
3707         (bmalloc::DebugHeap::freeLarge):
3708         * bmalloc/DebugHeap.h:
3709         * bmalloc/Heap.cpp:
3710         (bmalloc::Heap::tryAllocateLarge):
3711         (bmalloc::Heap::deallocateLarge):
3712
3713 2017-08-02  Filip Pizlo  <fpizlo@apple.com>
3714
3715         We should be OK with the gigacage being disabled on gmalloc
3716         https://bugs.webkit.org/show_bug.cgi?id=175082
3717
3718         Reviewed by Michael Saboff.
3719         
3720         This adds Gigacage::shouldBeEnabled(), which returns false when we're using gmalloc or other things
3721         that enable DebugHeap.
3722
3723         * bmalloc/Environment.cpp:
3724         (bmalloc::Environment::Environment):
3725         * bmalloc/Environment.h:
3726         * bmalloc/Gigacage.cpp:
3727         (Gigacage::ensureGigacage):
3728         (Gigacage::shouldBeEnabled):
3729         * bmalloc/Gigacage.h:
3730         * bmalloc/Heap.cpp:
3731         (bmalloc::Heap::Heap):
3732         * bmalloc/Heap.h:
3733
3734 2017-08-01  Filip Pizlo  <fpizlo@apple.com>
3735
3736         Bmalloc and GC should put auxiliaries (butterflies, typed array backing stores) in a gigacage (separate multi-GB VM region)
3737         https://bugs.webkit.org/show_bug.cgi?id=174727
3738
3739         Reviewed by Mark Lam.
3740         
3741         This adds a mechanism for managing multiple isolated heaps in bmalloc. For now, these isoheaps
3742         (isolated heaps) have a very simple relationship with each other and with the rest of bmalloc:
3743         
3744         - You have to choose how many isoheaps you will have statically. See numHeaps in HeapKind.h.
3745         
3746         - Because numHeaps is static, each isoheap gets fast thread-local allocation. Basically, we have a
3747           Cache for each heap kind.
3748         
3749         - Each isoheap gets its own Heap.
3750         
3751         - Each Heap gets a scavenger thread.
3752         
3753         - Some things, like Zone/VMHeap/Scavenger, are per-process.
3754         
3755         Most of the per-HeapKind functionality is handled by PerHeapKind<>.
3756         
3757         This approach is ideal for supporting special per-HeapKind behaviors. For now we have two heaps:
3758         the Primary heap for normal malloc and the Gigacage. The gigacage is a 64GB-aligned 64GB virtual
3759         region that we now use for variable-length random-access allocations. No Primary allocations will
3760         go into the Gigacage.
3761
3762         * CMakeLists.txt:
3763         * bmalloc.xcodeproj/project.pbxproj:
3764         * bmalloc/AllocationKind.h: Added.
3765         * bmalloc/Allocator.cpp:
3766         (bmalloc::Allocator::Allocator):
3767         (bmalloc::Allocator::tryAllocate):
3768         (bmalloc::Allocator::allocateImpl):
3769         (bmalloc::Allocator::reallocate):
3770         (bmalloc::Allocator::refillAllocatorSlowCase):
3771         (bmalloc::Allocator::allocateLarge):
3772         * bmalloc/Allocator.h:
3773         * bmalloc/BExport.h: Added.
3774         * bmalloc/Cache.cpp:
3775         (bmalloc::Cache::scavenge):
3776         (bmalloc::Cache::Cache):
3777         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
3778         (bmalloc::Cache::allocateSlowCaseNullCache):
3779         (bmalloc::Cache::deallocateSlowCaseNullCache):
3780         (bmalloc::Cache::reallocateSlowCaseNullCache):
3781         (bmalloc::Cache::operator new): Deleted.
3782         (bmalloc::Cache::operator delete): Deleted.
3783         * bmalloc/Cache.h:
3784         (bmalloc::Cache::tryAllocate):
3785         (bmalloc::Cache::allocate):
3786         (bmalloc::Cache::deallocate):
3787         (bmalloc::Cache::reallocate):
3788         * bmalloc/Deallocator.cpp:
3789         (bmalloc::Deallocator::Deallocator):
3790         (bmalloc::Deallocator::scavenge):
3791         (bmalloc::Deallocator::processObjectLog):
3792         (bmalloc::Deallocator::deallocateSlowCase):
3793         * bmalloc/Deallocator.h:
3794         * bmalloc/Gigacage.cpp: Added.
3795         (Gigacage::Callback::Callback):
3796         (Gigacage::Callback::function):
3797         (Gigacage::Callbacks::Callbacks):
3798         (Gigacage::ensureGigacage):
3799         (Gigacage::disableGigacage):
3800         (Gigacage::addDisableCallback):
3801         (Gigacage::removeDisableCallback):
3802         * bmalloc/Gigacage.h: Added.
3803         (Gigacage::caged):
3804         (Gigacage::isCaged):
3805         * bmalloc/Heap.cpp:
3806         (bmalloc::Heap::Heap):
3807         (bmalloc::Heap::usingGigacage):
3808         (bmalloc::Heap::concurrentScavenge):
3809         (bmalloc::Heap::splitAndAllocate):
3810         (bmalloc::Heap::tryAllocateLarge):
3811         (bmalloc::Heap::allocateLarge):
3812         (bmalloc::Heap::shrinkLarge):
3813         (bmalloc::Heap::deallocateLarge):
3814         * bmalloc/Heap.h:
3815         (bmalloc::Heap::mutex):
3816         (bmalloc::Heap::kind const):
3817         (bmalloc::Heap::setScavengerThreadQOSClass): Deleted.
3818         * bmalloc/HeapKind.h: Added.
3819         * bmalloc/ObjectType.cpp:
3820         (bmalloc::objectType):
3821         * bmalloc/ObjectType.h:
3822         * bmalloc/PerHeapKind.h: Added.
3823         (bmalloc::PerHeapKindBase::PerHeapKindBase):
3824         (bmalloc::PerHeapKindBase::size):
3825         (bmalloc::PerHeapKindBase::at):
3826         (bmalloc::PerHeapKindBase::at const):
3827         (bmalloc::PerHeapKindBase::operator[]):
3828         (bmalloc::PerHeapKindBase::operator[] const):
3829         (bmalloc::StaticPerHeapKind::StaticPerHeapKind):
3830         (bmalloc::PerHeapKind::PerHeapKind):
3831         (bmalloc::PerHeapKind::~PerHeapKind):
3832         * bmalloc/PerThread.h:
3833         (bmalloc::PerThread<T>::destructor):
3834         (bmalloc::PerThread<T>::getSlowCase):
3835         (bmalloc::PerThreadStorage<Cache>::get): Deleted.
3836         (bmalloc::PerThreadStorage<Cache>::init): Deleted.
3837         * bmalloc/Scavenger.cpp: Added.
3838         (bmalloc::Scavenger::Scavenger):
3839         (bmalloc::Scavenger::scavenge):
3840         * bmalloc/Scavenger.h: Added.
3841         (bmalloc::Scavenger::setScavengerThreadQOSClass):
3842         (bmalloc::Scavenger::requestedScavengerThreadQOSClass const):
3843         * bmalloc/VMHeap.cpp:
3844         (bmalloc::VMHeap::VMHeap):
3845         (bmalloc::VMHeap::tryAllocateLargeChunk):
3846         * bmalloc/VMHeap.h:
3847         * bmalloc/Zone.cpp:
3848         (bmalloc::Zone::Zone):
3849         * bmalloc/Zone.h:
3850         * bmalloc/bmalloc.h:
3851         (bmalloc::api::tryMalloc):
3852         (bmalloc::api::malloc):
3853         (bmalloc::api::tryMemalign):
3854         (bmalloc::api::memalign):
3855         (bmalloc::api::realloc):
3856         (bmalloc::api::tryLargeMemalignVirtual):
3857         (bmalloc::api::free):
3858         (bmalloc::api::freeLargeVirtual):
3859         (bmalloc::api::scavengeThisThread):
3860         (bmalloc::api::scavenge):
3861         (bmalloc::api::isEnabled):
3862         (bmalloc::api::setScavengerThreadQOSClass):
3863         * bmalloc/mbmalloc.cpp:
3864
3865 2017-08-01  Daewoong Jang  <daewoong.jang@navercorp.com>
3866
3867         Implement __builtin_clzl for MSVC
3868         https://bugs.webkit.org/show_bug.cgi?id=174232
3869
3870         Reviewed by Geoffrey Garen.
3871
3872         * bmalloc/Algorithm.h:
3873         (bmalloc::clzl):
3874         (bmalloc::clzl<1>):
3875         (bmalloc::__builtin_clzl):
3876         * bmalloc/BPlatform.h:
3877
3878 2017-07-31  Mark Lam  <mark.lam@apple.com>
3879
3880         Fixed some comment typos.
3881
3882         Not reviewed.
3883
3884         * bmalloc/PerProcess.h:
3885
3886 2017-07-14  Filip Pizlo  <fpizlo@apple.com>
3887
3888         It should be easy to decide how WebKit yields
3889         https://bugs.webkit.org/show_bug.cgi?id=174298
3890
3891         Reviewed by Saam Barati.
3892         
3893         Use sched_yield() explicitly.
3894
3895         * bmalloc/StaticMutex.cpp:
3896         (bmalloc::StaticMutex::lockSlowCase):
3897
3898 2017-07-20  Chris Dumez  <cdumez@apple.com>
3899
3900         Replace calls to Vector::resize() with calls to more efficient shrink() / grow() when applicable
3901         https://bugs.webkit.org/show_bug.cgi?id=174660
3902
3903         Reviewed by Geoffrey Garen.
3904
3905         Replace calls to Vector::resize() with calls to more efficient shrink() / grow() when applicable.
3906         This essentially replaces a branch to figure out if the new size is less or greater than the
3907         current size by an assertion.
3908
3909         * bmalloc/Map.h:
3910         (bmalloc::Hash>::rehash):
3911
3912 2017-07-18  Andy Estes  <aestes@apple.com>
3913
3914         [Xcode] Enable CLANG_WARN_RANGE_LOOP_ANALYSIS
3915         https://bugs.webkit.org/show_bug.cgi?id=174631
3916
3917         Reviewed by Tim Horton.
3918
3919         * Configurations/Base.xcconfig:
3920
3921 2017-07-18  Andy Estes  <aestes@apple.com>
3922
3923         [Xcode] Enable CLANG_WARN_OBJC_LITERAL_CONVERSION
3924         https://bugs.webkit.org/show_bug.cgi?id=174631
3925
3926         Reviewed by Sam Weinig.
3927
3928         * Configurations/Base.xcconfig:
3929
3930 2017-07-18  Andy Estes  <aestes@apple.com>
3931
3932         [Xcode] Enable CLANG_WARN_NON_LITERAL_NULL_CONVERSION
3933         https://bugs.webkit.org/show_bug.cgi?id=174631
3934
3935         Reviewed by Dan Bernstein.
3936
3937         * Configurations/Base.xcconfig:
3938
3939 2017-07-18  Andy Estes  <aestes@apple.com>
3940
3941         [Xcode] Enable CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING
3942         https://bugs.webkit.org/show_bug.cgi?id=174631
3943
3944         Reviewed by Darin Adler.
3945
3946         * Configurations/Base.xcconfig:
3947
3948 2017-07-12  Adrian Perez de Castro  <aperez@igalia.com>
3949
3950         bmalloc: Failure to build when the compiler specifically targets ARMv8-A / defines __ARM_ARCH_8A__
3951         https://bugs.webkit.org/show_bug.cgi?id=174424
3952
3953         Reviewed by Michael Catanzaro.
3954
3955         * bmalloc/BPlatform.h: Also check for __ARCH_ARM_8A__ to detect ARMv8.
3956
3957 2017-07-05  Daewoong Jang  <daewoong.jang@navercorp.com>
3958
3959         reinterpret_cast does not evaluate to constexpr
3960         https://bugs.webkit.org/show_bug.cgi?id=173622
3961
3962         Reviewed by Yusuke Suzuki.
3963
3964         * bmalloc/Algorithm.h:
3965         (bmalloc::mask):
3966         (bmalloc::roundUpToMultipleOf):
3967
3968 2017-07-03  Andy Estes  <aestes@apple.com>
3969
3970         [Xcode] Add an experimental setting to build with ccache
3971         https://bugs.webkit.org/show_bug.cgi?id=173875
3972
3973         Reviewed by Tim Horton.
3974
3975         * Configurations/DebugRelease.xcconfig: Included ccache.xcconfig.
3976
3977 2017-07-01  Dan Bernstein  <mitz@apple.com>
3978
3979         [iOS] Remove code only needed when building for iOS 9.x
3980         https://bugs.webkit.org/show_bug.cgi?id=174068
3981
3982         Reviewed by Tim Horton.
3983
3984         * bmalloc/BPlatform.h:
3985         * bmalloc/VMAllocate.h:
3986         (bmalloc::vmPageSizePhysical):
3987
3988 2017-07-01  Dan Bernstein  <mitz@apple.com>
3989
3990         [macOS] Remove code only needed when building for OS X Yosemite
3991         https://bugs.webkit.org/show_bug.cgi?id=174067
3992
3993         Reviewed by Tim Horton.
3994
3995         * Configurations/Base.xcconfig:
3996         * Configurations/DebugRelease.xcconfig:
3997
3998 2017-06-30  Ryosuke Niwa  <rniwa@webkit.org>
3999
4000         Ran sort-Xcode-project-file.
4001
4002         * bmalloc.xcodeproj/project.pbxproj:
4003
4004 2017-06-19  Geoffrey Garen  <ggaren@apple.com>
4005
4006         bmalloc: Add a per-thread line cache
4007         https://bugs.webkit.org/show_bug.cgi?id=173552
4008
4009         Reviewed by Darin Adler.
4010
4011         Previously, any thread could allocate out of any page with free lines.
4012         Now, the first thread to free a line in a page owns that page's free
4013         lines until the whole page becomes free.
4014
4015         This patch is a big speedup on multi-threaded benchmarks.
4016         tree_churn --parallel gets 14% faster on a 2-core (4-hyper-core) MacBook
4017         Air and 2.85X faster on 12-core (24-hyper-core) Mac Pro. Other parallel
4018         benchmarks show significant but smaller speedups.
4019
4020         Thread affinity is a great predictor of object lifetime. The per-thread
4021         line cache avoids the pathology of shuffling pages between threads,
4022         turning predictable lifetimes into unpredictable lifetimes, increasing
4023         fragmentation. On tree_churn --parallel, the per-thread line cache
4024         increases free memory found per page scanned by 2.85X.
4025
4026         Free line scanning in fragmented pages is pretty expensive relative to
4027         other allocate / initialize / free operations. According to Instruments,
4028         on tree_churn --parallel, scanning is about 10X more expensive than
4029         freeing. This explains why a 2.85X improvement in scanning efficiency
4030         translates into a 2.85X overall speedup on tree_churn --parallel.
4031
4032         * bmalloc/Allocator.cpp:
4033         (bmalloc::Allocator::refillAllocatorSlowCase): Pass through our line
4034         cache so the Heap can fill it.
4035
4036         * bmalloc/Deallocator.cpp:
4037         (bmalloc::Deallocator::scavenge): Scavenge our line cache.
4038
4039         (bmalloc::Deallocator::processObjectLog): Deleted.
4040
4041         * bmalloc/Deallocator.h:
4042         (bmalloc::Deallocator::lineCache): Added a line cache.
4043
4044         * bmalloc/Heap.cpp:
4045         (bmalloc::Heap::deallocateLineCache): Deallocation function for thread
4046         destruction.
4047
4048         (bmalloc::Heap::allocateSmallPage):
4049         (bmalloc::Heap::deallocateSmallLine):
4050         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
4051         (bmalloc::Heap::allocateSmallBumpRangesByObject): Consult the new per-thread line
4052         cache for allocation and deallocation.
4053
4054         * bmalloc/Heap.h:
4055         (bmalloc::Heap::allocateSmallBumpRanges):
4056         (bmalloc::Heap::derefSmallLine):
4057
4058         * bmalloc/List.h:
4059         (bmalloc::List::remove): Remove has always been a logically static
4060         operation. Declare it static now so that the Heap can remove a page from
4061         a thread's line cache without holding a direct pointer to the cache.
4062
4063         * bmalloc/SmallPage.h:
4064
4065 2017-06-10  Dan Bernstein  <mitz@apple.com>
4066
4067         Reverted r218056 because it made the IDE reindex constantly.
4068
4069         * Configurations/DebugRelease.xcconfig:
4070
4071 2017-06-10  Dan Bernstein  <mitz@apple.com>
4072
4073         [Xcode] With Xcode 9 developer beta, everything rebuilds when switching between command-line and IDE
4074         https://bugs.webkit.org/show_bug.cgi?id=173223
4075
4076         Reviewed by Sam Weinig.
4077
4078         The rebuilds were happening due to a difference in the compiler options that the IDE and
4079         xcodebuild were specifying. Only the IDE was passing the -index-store-path option. To make
4080         xcodebuild pass that option, too, set CLANG_INDEX_STORE_ENABLE to YES if it is unset, and
4081         specify an appropriate path in CLANG_INDEX_STORE_PATH.
4082
4083         * Configurations/DebugRelease.xcconfig:
4084
4085 2017-06-07  Geoffrey Garen  <ggaren@apple.com>
4086
4087         bmalloc: memory APIs don't need to be heap members
4088         https://bugs.webkit.org/show_bug.cgi?id=173076
4089
4090         Reviewed by Sam Weinig.
4091
4092         Asking the OS about memory use is unrelated to the state of bmalloc's
4093         heap, so it's a better separation of concerns if related code is not 
4094         part of the heap.
4095
4096         * bmalloc/AvailableMemory.cpp:
4097         (bmalloc::memoryStatus):
4098         * bmalloc/AvailableMemory.h:
4099         (bmalloc::MemoryStatus::MemoryStatus):
4100         (bmalloc::isUnderMemoryPressure):
4101         (bmalloc::memoryFootprint):
4102         (bmalloc::percentAvailableMemoryInUse):
4103         * bmalloc/Heap.cpp:
4104         (bmalloc::Heap::Heap):
4105         (bmalloc::Heap::updateMemoryInUseParameters): Deleted.
4106         * bmalloc/Heap.h:
4107         (bmalloc::Heap::isUnderMemoryPressure): Deleted.
4108         (bmalloc::Heap::memoryFootprint): Deleted.
4109         (bmalloc::Heap::percentAvailableMemoryInUse): Deleted.
4110
4111 2017-06-06  Yusuke Suzuki  <utatane.tea@gmail.com>
4112
4113         struct does not accept initializer-form if member has initializers in GCC 4.9