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