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