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