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