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