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