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