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