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