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