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