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