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