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