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