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