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