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