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