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