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