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