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