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