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