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