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