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