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