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