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