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