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