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