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