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