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