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