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