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