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