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