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