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