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