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