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