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