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