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