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