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