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