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