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