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