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