vmmap crash at JavaScriptCore: 0x31cd12f6 (the JavaScript malloc zone enumerator)
[WebKit-https.git] / Source / bmalloc / ChangeLog
1 2015-07-24  Geoffrey Garen  <ggaren@apple.com>
2
3         vmmap crash at JavaScriptCore: 0x31cd12f6 (the JavaScript malloc zone enumerator)
4         https://bugs.webkit.org/show_bug.cgi?id=147274
5
6         Reviewed by Anders Carlsson.
7
8         It's not really clear why vmmap sometimes fails to read the target
9         process, but we can avoid a crash when it does. This is useful because
10         you'll still get all the non-bmalloc data out of the target process,
11         and bmalloc might not even be relevant to your investigation.
12
13         * bmalloc/Zone.cpp:
14         (bmalloc::remoteRead): Check for failure.
15
16 2015-07-24  Geoffrey Garen  <ggaren@apple.com>
17
18         JavaScriptCore bmalloc should not register its malloc zone more than once
19         https://bugs.webkit.org/show_bug.cgi?id=147273
20
21         Reviewed by Andreas Kling.
22
23         This was a goof: The Zone constructor, by virtue of running automatically,
24         was registering a Zone inside the analysis process.
25
26         * bmalloc/Zone.cpp:
27         (bmalloc::remoteRead): Clarify that the pointer is remote.
28
29         (bmalloc::enumerator):
30         (bmalloc::Zone::Zone):
31         * bmalloc/Zone.h: Separate the normal constructor and the remote constructor.
32         The remote constructor skips zone registration since its goal is not
33         to register a zone in the current process or do any allocation but rather
34         to mirror the bytes of the zone from the target process.
35
36 2015-07-23  Geoffrey Garen  <ggaren@apple.com>
37
38         bmalloc: Shrink the super chunk size (again)
39         https://bugs.webkit.org/show_bug.cgi?id=147240
40
41         Reviewed by Andreas Kling.
42
43         Shrinking to 8MB reduced VM exhaustion crashes but did not eliminate them.
44         Let's try 4MB.
45
46         (My previous comment was that the maximum fast object was 2MB. But it
47         was 4MB! Now it's 2MB for realsies.)
48
49         * bmalloc/Sizes.h:
50
51 2015-07-03  Dan Bernstein  <mitz@apple.com>
52
53         [Xcode] Update some build settings as recommended by Xcode 7
54         https://bugs.webkit.org/show_bug.cgi?id=146597
55
56         Reviewed by Sam Weinig.
57
58         * Configurations/Base.xcconfig: Enabled CLANG_WARN_UNREACHABLE_CODE, GCC_NO_COMMON_BLOCKS,
59         and ENABLE_STRICT_OBJC_MSGSEND. Removed GCC_MODEL_TUNING.
60
61         * bmalloc.xcodeproj/project.pbxproj: Updated LastUpgradeCheck.
62
63 2015-07-02  Geoffrey Garen  <ggaren@apple.com>
64
65         bmalloc: Shrink the super chunk size
66         https://bugs.webkit.org/show_bug.cgi?id=146519
67
68         Reviewed by Andreas Kling.
69
70         We have lots of reports of crashing due to failed VM allocation on iOS.
71         (This VM limit on iOS is usually 1GB-2GB, and has been as low as 256MB.)
72
73         Shrink the super chunk size in case fragmentation is the reason for
74         VM allocation failure.
75
76         This has the downside that >= 2MB allocations will now be super slow,
77         but they are also super rare (as in never on most websites), so this
78         is probably an OK tradeoff.
79
80         * bmalloc/Sizes.h:
81
82 2015-07-01  Geoffrey Garen  <ggaren@apple.com>
83
84         bmalloc: realloc of an XLarge range can unmap adjacent VM ranges
85         https://bugs.webkit.org/show_bug.cgi?id=146535
86
87         Reviewed by Anders Carlsson.
88
89         This bug causes a crash when running fast/css/large-list-of-rules-crash.html
90         with the fix applied for https://bugs.webkit.org/show_bug.cgi?id=146519.
91
92         * bmalloc/Allocator.cpp:
93         (bmalloc::Allocator::reallocate): Start at object + newSize since starting
94         at object + oldSize means deleting the adjacent VM range.
95
96 2015-05-26  Geoffrey Garen  <ggaren@apple.com>
97
98         Integer overflow in XLarge allocation (due to unchecked roundUpToMultipleOf)
99         https://bugs.webkit.org/show_bug.cgi?id=145385
100
101         Reviewed by Andreas Kling.
102
103         Added some checking to verify that round-up operations will not overflow
104         a size_t.
105
106         The simplest way to do this was to introduce a notion of xLargeMax, like
107         we have for smallMax, mediumMax, and largeMax. It's a bit surprising at
108         first to think that there is an xLargeMax, since xLarge is what we use
109         to handle the biggest things. But computers have limits, so it makes sense.
110
111         FWIW, TCMalloc used to have an xLargeMax too, which it called kMaxValidPages.
112
113         No test because this bug was found by code inspection and I don't know
114         of a practical way to convince WebKit to make an allocation this large.
115
116         * bmalloc/Allocator.cpp:
117         (bmalloc::Allocator::tryAllocate):
118         (bmalloc::Allocator::allocate):
119         (bmalloc::Allocator::reallocate):
120         (bmalloc::Allocator::allocateSlowCase): Check against xLargeMax to avoid
121         overflow when rounding up.
122
123         * bmalloc/BAssert.h: Added support for explicit crashing.
124
125         * bmalloc/Sizes.h:
126
127 2015-05-26  Dan Bernstein  <mitz@apple.com>
128
129         <rdar://problem/21104551> Update build settings
130
131         Reviewed by Anders Carlsson.
132
133         * Configurations/DebugRelease.xcconfig:
134
135 2015-05-23  Dan Bernstein  <mitz@apple.com>
136
137         Remove unused definitions of WEBKIT_VERSION_MIN_REQUIRED
138         https://bugs.webkit.org/show_bug.cgi?id=145345
139
140         Reviewed by Sam Weinig.
141
142         * Configurations/Base.xcconfig: Also changed to use $(inherited).
143
144 2015-05-07  Geoffrey Garen  <ggaren@apple.com>
145
146         Release assert in com.apple.WebKit.WebContent under JavaScriptCore: JSC::JSONProtoFuncStringify
147         https://bugs.webkit.org/show_bug.cgi?id=144758
148
149         Reviewed by Andreas Kling.
150
151         This was an out-of-memory error when trying to shrink a string builder.
152         bmalloc was missing the optimization that allowed realloc() to shrink
153         without copying. So, let's add it.
154
155         * bmalloc/Allocator.cpp:
156         (bmalloc::Allocator::reallocate): Added Large and XLarge cases for
157         shrinking without copying. This isn't possible for small and medium
158         objects, and probably not very profitable, either.
159
160         * bmalloc/Heap.cpp:
161         (bmalloc::Heap::findXLarge):
162         (bmalloc::Heap::deallocateXLarge):
163         * bmalloc/Heap.h: Refactored this code to return a reference to an
164         XLarge range. This makes the code reusable, and also makes it easier
165         for realloc() to update metadata.
166
167         * bmalloc/LargeObject.h:
168         (bmalloc::LargeObject::split): Allow allocated objects to split because
169         that's what realloc() wants to do, and there's nothing intrinsically
170         wrong with it.
171
172 2015-05-07  Dan Bernstein  <mitz@apple.com>
173
174         <rdar://problem/19317140> [Xcode] Remove usage of AspenFamily.xcconfig in Source/
175         https://bugs.webkit.org/show_bug.cgi?id=144727
176
177         Reviewed by Darin Adler.
178
179         * Configurations/Base.xcconfig: Dont’s include AspenFamily.xcconfig, and define
180         INSTALL_PATH_PREFIX for the iOS 8.x Simulator.
181
182 2015-04-01  Alex Christensen  <achristensen@webkit.org>
183
184         Progress towards CMake on Windows and Mac.
185         https://bugs.webkit.org/show_bug.cgi?id=143293
186
187         Reviewed by Filip Pizlo.
188
189         * bmalloc/BAssert.h:
190         Removed ellipses from macros to appease Visual Studio.
191
192 2015-03-13  Alex Christensen  <achristensen@webkit.org>
193
194         Progress towards CMake on Mac.
195         https://bugs.webkit.org/show_bug.cgi?id=142680
196
197         Reviewed by Gyuyoung Kim.
198
199         * CMakeLists.txt:
200         * PlatformMac.cmake:
201         Added Zone.cpp to Mac CMake builds.
202
203 2015-03-12  Geoffrey Garen  <ggaren@apple.com>
204
205         Assertion failure in bmalloc::LargeObject::validateSelf on Mavericks Debug layout test bot
206         https://bugs.webkit.org/show_bug.cgi?id=142642
207
208         Reviewed by Michael Saboff.
209
210         The typical backtrace to this crash shows the main thread trying to
211         realloc a large string while a DFG compiler thread tries to
212         free a large vector buffer.
213
214         I believe that this is a race condition -- at least in debug builds --
215         since the main thread will try to validate its object's neighbors
216         without holding a lock, even though those neighbors might be in the
217         midst of changing.
218
219         In general, there may be sneaky times when it is valid to look at an
220         object's metadata without holding the heap lock, but it is best not to
221         do so unless we have a really really good reason to.
222
223         * bmalloc/Allocator.cpp:
224         (bmalloc::Allocator::reallocate): Take a lock before reading the metadata
225         for this object, since we generally require any access to shared heap
226         metadata to take a lock.
227
228 2015-03-10  Geoffrey Garen  <ggaren@apple.com>
229
230         bmalloc: tryFastMalloc shouldn't crash
231         https://bugs.webkit.org/show_bug.cgi?id=142443
232
233         Reviewed by Sam Weinig.
234
235         Rolling back in r181307 with a check for whether bmalloc is enabled, to
236         avoid crashes when running with ASan and GuardMalloc.
237
238         * bmalloc/Allocator.cpp:
239         (bmalloc::Allocator::tryAllocate):
240         * bmalloc/Allocator.h:
241         * bmalloc/Cache.cpp:
242         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
243         * bmalloc/Cache.h:
244         (bmalloc::Cache::tryAllocate):
245         * bmalloc/Heap.cpp:
246         (bmalloc::Heap::allocateXLarge):
247         (bmalloc::Heap::tryAllocateXLarge):
248         * bmalloc/Heap.h:
249         * bmalloc/VMAllocate.h:
250         (bmalloc::tryVMAllocate):
251         (bmalloc::vmAllocate):
252         * bmalloc/bmalloc.h:
253         (bmalloc::api::tryMalloc):
254         (bmalloc::api::realloc):
255         (bmalloc::api::free):
256
257 2015-03-09  Commit Queue  <commit-queue@webkit.org>
258
259         Unreviewed, rolling out r181307.
260         https://bugs.webkit.org/show_bug.cgi?id=142525
261
262         Broke ASan tests (Requested by ap on #webkit).
263
264         Reverted changeset:
265
266         "bmalloc: tryFastMalloc shouldn't crash"
267         https://bugs.webkit.org/show_bug.cgi?id=142443
268         http://trac.webkit.org/changeset/181307
269
270 2015-03-09  Geoffrey Garen  <ggaren@apple.com>
271
272         bmalloc: tryFastMalloc shouldn't crash
273         https://bugs.webkit.org/show_bug.cgi?id=142443
274
275         Reviewed by Darin Adler.
276
277         Added support for tryMalloc.
278
279         We assume that non-x-large allocations always succeed, and we crash
280         otherwise, since normal allocation failure will just cause the next
281         non-try allocation or internal metadata allocation to fail, and it's
282         hard and not really useful to keep limping along after that. But
283         extra-large allocations can meaningfully fail, and we can recover.
284
285         * bmalloc/Heap.cpp:
286         (bmalloc::Heap::allocateXLarge):
287         (bmalloc::Heap::tryAllocateXLarge):
288         * bmalloc/Heap.h: Added support for non-crashy x-large allocation.
289
290         * bmalloc/VMAllocate.h:
291         (bmalloc::tryVMAllocate):
292         (bmalloc::vmAllocate): Added support for non-crashy VM allocation.
293
294         * bmalloc/bmalloc.h:
295         (bmalloc::api::tryMalloc):
296         (bmalloc::api::realloc):
297         (bmalloc::api::free): Tried to clarify our behavior with some comments.
298         Unfortunately, calling what we do "malloc" is still not quite right, since
299         malloc returns null on failure and we don't.
300
301 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
302
303         bmalloc: Don't branch when setting the owner of a large object
304         https://bugs.webkit.org/show_bug.cgi?id=142241
305
306         Reviewed by Andreas Kling.
307
308         * bmalloc/BoundaryTag.h:
309         (bmalloc::BoundaryTag::owner):
310         (bmalloc::BoundaryTag::setOwner):
311
312 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
313
314         bmalloc should implement malloc introspection (to stop false-positive leaks when MallocStackLogging is off)
315         https://bugs.webkit.org/show_bug.cgi?id=141802
316
317         Reviewed by Andreas Kling.
318
319         Re-enabled this feature on iOS, now that the iOS crash should be fixed.
320
321         * bmalloc/VMHeap.cpp:
322         (bmalloc::VMHeap::grow):
323         * bmalloc/VMHeap.h:
324
325 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
326
327         bmalloc: Added missing features to the malloc zone introspection API
328         https://bugs.webkit.org/show_bug.cgi?id=142235
329
330         Reviewed by Andreas Kling.
331
332         This should fix the crash we saw on the iOS PLT bot
333         (c.f. http://trac.webkit.org/changeset/180604).
334
335         * bmalloc/Zone.cpp:
336         (bmalloc::good_size):
337         (bmalloc::check):
338         (bmalloc::print):
339         (bmalloc::log):
340         (bmalloc::force_lock):
341         (bmalloc::force_unlock):
342         (bmalloc::statistics):
343         (bmalloc::size):
344         (bmalloc::enumerator): Provide all of these functions since they are called
345         indiscriminately on all zones.
346
347         (bmalloc::Zone::Zone):
348         (bmalloc::Zone::size): Deleted.
349         (bmalloc::Zone::enumerator): Deleted. Moved these functions out of the
350         Zone class since they can stand alone.
351
352         * bmalloc/Zone.h:
353
354 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
355
356         bmalloc should implement malloc introspection (to stop false-positive leaks when MallocStackLogging is off)
357         https://bugs.webkit.org/show_bug.cgi?id=141802
358
359         Reviewed by Andreas Kling.
360
361         Rolling back in but disabled on iOS until I can debug why the iOS PLT crashes.
362
363         * bmalloc/VMHeap.cpp:
364         (bmalloc::VMHeap::grow):
365         * bmalloc/VMHeap.h:
366         * bmalloc/Zone.cpp:
367         (bmalloc::Zone::size):
368         (bmalloc::Zone::Zone):
369         * bmalloc/Zone.h:
370
371 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
372
373         bmalloc: Miscellaneous cleanup
374         https://bugs.webkit.org/show_bug.cgi?id=142231
375
376         Reviewed by Andreas Kling.
377
378         No performance change -- maybe a tiny reduction in memory use.
379
380         * bmalloc/Heap.cpp: Moved the sleep function into StaticMutex, since
381         it's a helper for working with mutexes.
382
383         (bmalloc::Heap::scavenge): Make sure to wait before we start any
384         scavenging, since individual scavenging functions now always scavenge
385         at least one page before waiting themselves.
386
387         (bmalloc::Heap::scavengeSmallPages):
388         (bmalloc::Heap::scavengeMediumPages):
389         (bmalloc::Heap::scavengeLargeObjects): Use the new wait helper to
390         simplify this code. Also, we now require our caller to wait until at
391         least one deallocation is desirable. This simplifies our loop.
392
393         (bmalloc::Heap::allocateSmallPage):
394         (bmalloc::Heap::allocateMediumPage):
395         (bmalloc::Heap::allocateXLarge):
396         (bmalloc::Heap::allocateLarge): Don't freak out any time the heap does
397         an allocation. Only consider the heap to be growing if it actually needs
398         to allocate new VM. This allows us to shrink the heap back down from a
399         high water mark more reliably even if heap activity continues.
400
401         (bmalloc::sleep): Deleted.
402         (bmalloc::Heap::scavengeLargeRanges): Renamed to match our use of
403         "LargeObject".
404
405         * bmalloc/Heap.h:
406
407         * bmalloc/LargeObject.h:
408         (bmalloc::LargeObject::operator bool): Added to simplify a while loop.
409
410         * bmalloc/StaticMutex.h:
411         (bmalloc::sleep):
412         (bmalloc::waitUntilFalse): New helper for waiting until a condition
413         becomes reliably false.
414
415         * bmalloc/Vector.h:
416         (bmalloc::Vector<T>::~Vector): Oops! Don't deallocate the null pointer.
417         We don't actually run any Vector destructors, but an iteration of this
418         patch did, and then crashed. So, let's fix that.
419
420 2015-03-02  Geoffrey Garen  <ggaren@apple.com>
421
422         bmalloc: Eagerly remove allocated objects from the free list
423         https://bugs.webkit.org/show_bug.cgi?id=142194
424
425         Reviewed by Andreas Kling.
426
427         This reduces the pressure to garbage collect the free list.
428
429         Might be a 1% speedup on MallocBench.
430
431         * bmalloc/FreeList.cpp: Put this comment at the top of the file instead
432         of repeating it inside of each function. Tried to clarify the details.
433
434         (bmalloc::FreeList::takeGreedy): Matched the other iteration code in this
435         file for consistency -- even though either direction works fine in this
436         function.
437
438         (bmalloc::FreeList::take): Change to iterate from low to high so that we
439         can maintain an index into the vector that is not disturbed even if we
440         pop from the middle (which invalidates the last index in the vector).
441
442         Decrement i when popping from the middle to make sure that we don't
443         skip the next item after popping.
444
445         (bmalloc::FreeList::removeInvalidAndDuplicateEntries): Ditto.
446
447 2015-02-27  Ryosuke Niwa  <rniwa@webkit.org>
448
449         Fixed a typo in the previous commit.
450
451         * bmalloc/BoundaryTag.h:
452         (bmalloc::BoundaryTag::setOwner):
453
454 2015-02-27  Ryosuke Niwa  <rniwa@webkit.org>
455
456         EFL build fix after r180797.
457
458         * bmalloc/BoundaryTag.h:
459         (bmalloc::BoundaryTag::owner):
460         (bmalloc::BoundaryTag::setOwner):
461
462 2015-02-27  Geoffrey Garen  <ggaren@apple.com>
463
464         bmalloc: Pathological madvise churn on the free(malloc(x)) benchmark
465         https://bugs.webkit.org/show_bug.cgi?id=142058
466
467         Reviewed by Andreas Kling.
468
469         The churn was caused by repeatedly splitting an object with physical
470         pages from an object without, and then merging them back together again.
471         The merge would conservatively forget that we had physical pages, forcing
472         a new call to madvise on the next allocation.
473
474         This patch more strictly segregates objects in the heap from objects in
475         the VM heap, with these changes:
476
477         (1) Objects in the heap are not allowed to merge with objects in the VM
478         heap, and vice versa -- since that would erase our precise knowledge of
479         which physical pages had been allocated.
480
481         (2) The VM heap is exclusively responsible for allocating and deallocating
482         physical pages.
483
484         (3) The heap free list must consider entries for objects that are in the
485         VM heap to be invalid, and vice versa. (This condition can arise
486         because the free list does not eagerly remove items.)
487
488         With these changes, we can know that any valid object in the heap's free
489         list already has physical pages, and does not need to call madvise.
490
491         Note that the VM heap -- as before -- might sometimes contain ranges
492         or pieces of ranges that have physical pages, since we allow splitting
493         of ranges at granularities smaller than the VM page size. These ranges
494         can eventually merge with ranges in the heap during scavenging.
495
496         * bmalloc.xcodeproj/project.pbxproj:
497
498         * bmalloc/BoundaryTag.h:
499         (bmalloc::BoundaryTag::owner):
500         (bmalloc::BoundaryTag::setOwner):
501         (bmalloc::BoundaryTag::initSentinel):
502         (bmalloc::BoundaryTag::hasPhysicalPages): Deleted.
503         (bmalloc::BoundaryTag::setHasPhysicalPages): Deleted. Replaced the concept
504         of "has physical pages" with a bit indicating which heap owns the large
505         object. This is a more precise concept, since the old bit was really a
506         Yes / Maybe bit.
507
508         * bmalloc/Deallocator.cpp:
509
510         * bmalloc/FreeList.cpp: Adopt
511         (bmalloc::FreeList::takeGreedy):
512         (bmalloc::FreeList::take):
513         (bmalloc::FreeList::removeInvalidAndDuplicateEntries):
514         * bmalloc/FreeList.h:
515         (bmalloc::FreeList::push): Added API for considering the owner when
516         deciding if a free list entry is valid.
517
518         * bmalloc/Heap.cpp:
519         (bmalloc::Heap::Heap): Adopt new API.
520
521         (bmalloc::Heap::scavengeLargeRanges): Scavenge all ranges with no minimum,
522         since some ranges might be able to merge with ranges in the VM heap, and
523         they won't be allowed to until we scavenge them.
524
525         (bmalloc::Heap::allocateSmallPage):
526         (bmalloc::Heap::allocateMediumPage):
527         (bmalloc::Heap::allocateLarge): New VM heap API makes this function
528         simpler, since we always get back physical pages now.
529
530         * bmalloc/Heap.h:
531         * bmalloc/LargeObject.h:
532         (bmalloc::LargeObject::end):
533         (bmalloc::LargeObject::owner):
534         (bmalloc::LargeObject::setOwner):
535         (bmalloc::LargeObject::isValidAndFree):
536         (bmalloc::LargeObject::merge): Do not merge objects across heaps since
537         that causes madvise churn.
538         (bmalloc::LargeObject::validateSelf):
539         (bmalloc::LargeObject::init):
540         (bmalloc::LargeObject::hasPhysicalPages): Deleted.
541         (bmalloc::LargeObject::setHasPhysicalPages): Deleted. Propogate the Owner API.
542
543         * bmalloc/Owner.h: Added.
544
545         * bmalloc/SegregatedFreeList.cpp:
546         (bmalloc::SegregatedFreeList::SegregatedFreeList):
547         (bmalloc::SegregatedFreeList::insert):
548         (bmalloc::SegregatedFreeList::takeGreedy):
549         (bmalloc::SegregatedFreeList::take):
550         * bmalloc/SegregatedFreeList.h: Propogate the owner API.
551
552         * bmalloc/VMAllocate.h:
553         (bmalloc::vmDeallocatePhysicalPagesSloppy):
554         (bmalloc::vmAllocatePhysicalPagesSloppy): Clarified these functions and
555         removed an edge case.
556
557         * bmalloc/VMHeap.cpp:
558         (bmalloc::VMHeap::VMHeap):
559         * bmalloc/VMHeap.h:
560         (bmalloc::VMHeap::allocateSmallPage):
561         (bmalloc::VMHeap::allocateMediumPage):
562         (bmalloc::VMHeap::allocateLargeObject):
563         (bmalloc::VMHeap::deallocateLargeObject): Be sure to give each object
564         a new chance to merge, since it might have been prohibited from merging
565         before by virtue of not being in the VM heap.
566
567         (bmalloc::VMHeap::allocateLargeRange): Deleted.
568         (bmalloc::VMHeap::deallocateLargeRange): Deleted.
569
570 2015-02-26  Geoffrey Garen  <ggaren@apple.com>
571
572         bmalloc: Large object free list can grow infinitely
573         https://bugs.webkit.org/show_bug.cgi?id=142055
574
575         Reviewed by Andreas Kling.
576
577         By design, we don't eagerly remove large objects from the free list.
578         This creates two simple pathologies:
579
580             (1) If you free and then allocate the same object repeatedly, it will
581             duplicate itself in the free list repeatedly. Since it is never
582             invalid at the time of allocation, it will never be removed.
583
584             (2) If you split and then merge the same object repeatedly, it will
585             duplicate its split sibling in the free list repeatedly. If its
586             sibling is in a separate free list size class, it will never be
587             consulted at the time of allocation, so it will never be removed.
588
589         So, a simple "while (1) { free(malloc(x)); }" causes infinite memory
590         use in the free list.
591
592         The solution in this patch is a simple helper to remove garbage from the
593         free list if it grows too large. This pathology is not common, so the
594         cost is OK.
595
596         Long-term, perhaps we should rethink the laziness of these free lists.
597
598         * bmalloc/BoundaryTag.h:
599         (bmalloc::BoundaryTag::isMarked):
600         (bmalloc::BoundaryTag::setMarked): New bit, used by free list GC.
601
602         * bmalloc/FreeList.cpp:
603         (bmalloc::FreeList::removeInvalidAndDuplicateEntries): The GC algorithm.
604
605         * bmalloc/FreeList.h:
606         (bmalloc::FreeList::FreeList):
607         (bmalloc::FreeList::push): Invoke the GC if we're getting huge.
608
609         * bmalloc/LargeObject.h:
610         (bmalloc::LargeObject::isMarked):
611         (bmalloc::LargeObject::setMarked):
612         (bmalloc::LargeObject::validateSelf): Expose the new bit.
613
614         * bmalloc/Sizes.h: New constant to control GC frequency.
615
616 2015-02-26  Csaba Osztrogonác  <ossy@webkit.org>
617
618         URTBF after r180693.
619
620         * CMakeLists.txt:
621
622 2015-02-26  Geoffrey Garen  <ggaren@apple.com>
623
624         Try to fix the Mac build.
625
626         Unreviewed.
627
628         * bmalloc.xcodeproj/project.pbxproj: Make FreeList.h available.
629
630 2015-02-26  Geoffrey Garen  <ggaren@apple.com>
631
632         bmalloc: Refactored SegregatedFreeList and BoundaryTag::init
633         https://bugs.webkit.org/show_bug.cgi?id=142049
634
635         Reviewed by Anders Carlsson.
636
637         Split out a FreeList class from SegregatedFreeList. This will make it
638         easier to add behaviors on free list insertion and removal -- and it's
639         probably how I should have designed things at the start.
640
641         Moved BoundaryTag::init into LargeObject, since all the related logic
642         lives in LargeObject now too, and this allows us to remove BoundaryTagInlines.h.
643
644         * bmalloc.xcodeproj/project.pbxproj:
645         * bmalloc/BoundaryTagInlines.h: Removed.
646         * bmalloc/FreeList.cpp: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.cpp.
647         (bmalloc::FreeList::takeGreedy):
648         (bmalloc::FreeList::take):
649         (bmalloc::SegregatedFreeList::SegregatedFreeList): Deleted.
650         (bmalloc::SegregatedFreeList::insert): Deleted.
651         (bmalloc::SegregatedFreeList::takeGreedy): Deleted.
652         (bmalloc::SegregatedFreeList::take): Deleted.
653         * bmalloc/FreeList.h: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.h.
654         (bmalloc::FreeList::push):
655         * bmalloc/LargeObject.h:
656         (bmalloc::LargeObject::init):
657         * bmalloc/SegregatedFreeList.cpp:
658         (bmalloc::SegregatedFreeList::SegregatedFreeList):
659         (bmalloc::SegregatedFreeList::insert):
660         (bmalloc::SegregatedFreeList::takeGreedy):
661         (bmalloc::SegregatedFreeList::take):
662         * bmalloc/SegregatedFreeList.h:
663         * bmalloc/Sizes.h:
664         * bmalloc/VMHeap.cpp:
665         (bmalloc::VMHeap::grow):
666
667 2015-02-26  Geoffrey Garen  <ggaren@apple.com>
668
669         bmalloc: free up a bit in BoundaryTag
670         https://bugs.webkit.org/show_bug.cgi?id=142048
671
672         Reviewed by Brady Eidson.
673
674         We were wasting a bit by accident, and I need one now.
675
676         * bmalloc/Algorithm.h:
677         (bmalloc::rightShift): Deleted. Not needed, now that I've simplified
678         the math.
679
680         * bmalloc/BoundaryTag.h: Since each boundary tag bucket is 1024 bytes
681         long, the maximum offset into a bucket is 1023.
682
683         You need 5 bits to count up to 1024, but only 4 to count up to 1023.
684         
685         Math is hard.
686
687         (bmalloc::BoundaryTag::compactBegin): Switched to division because it
688         is simpler, and easier to match up with our ASSERT. The compiler will
689         turn division by constant power of two into a shift for us.
690
691         (bmalloc::BoundaryTag::setRange): Added an ASSERT for compactBegin
692         because we do encode it, so we should ASSERT that encoding did not
693         lose information.
694
695         * bmalloc/Sizes.h: Shifting is no longer used since we use division
696         instead.
697
698 2015-02-24  Stephanie Lewis  <slewis@apple.com>
699
700         Rolling out http://trac.webkit.org/changeset/180430 as it causes the PLT to crash.
701         <rdar://problem/19948015>
702
703         Unreviewed.
704
705         * bmalloc/VMHeap.cpp:
706         (bmalloc::VMHeap::grow):
707         * bmalloc/VMHeap.h:
708         * bmalloc/Zone.cpp:
709         (bmalloc::Zone::Zone):
710         (bmalloc::Zone::size): Deleted.
711         * bmalloc/Zone.h:
712
713 2015-02-24  Geoffrey Garen  <ggaren@apple.com>
714
715         bmalloc: Added a little more abstraction for large objects
716         https://bugs.webkit.org/show_bug.cgi?id=141978
717
718         Reviewed by Sam Weinig.
719
720         Previously, each client needed to manage the boundary tags of
721         a large object using free functions. This patch introduces a LargeObject
722         class that does things a little more automatically.
723
724         * bmalloc.xcodeproj/project.pbxproj:
725
726         * bmalloc/Allocator.cpp:
727         (bmalloc::Allocator::reallocate): Use the new LargeObject class.
728
729         * bmalloc/BeginTag.h:
730         (bmalloc::BeginTag::isInFreeList): Deleted. Moved this logic into the
731         LargeObject class.
732
733         * bmalloc/BoundaryTag.h:
734         (bmalloc::BoundaryTag::isSentinel):
735         (bmalloc::BoundaryTag::compactBegin):
736         (bmalloc::BoundaryTag::setRange):
737         (bmalloc::BoundaryTag::initSentinel): Added an explicit API for sentinels,
738         which we used to create and test for implicitly.
739
740         * bmalloc/BoundaryTagInlines.h:
741         (bmalloc::BoundaryTag::init):
742         (bmalloc::validate): Deleted.
743         (bmalloc::validatePrev): Deleted.
744         (bmalloc::validateNext): Deleted.
745         (bmalloc::BoundaryTag::mergeLeft): Deleted.
746         (bmalloc::BoundaryTag::mergeRight): Deleted.
747         (bmalloc::BoundaryTag::merge): Deleted.
748         (bmalloc::BoundaryTag::deallocate): Deleted.
749         (bmalloc::BoundaryTag::split): Deleted.
750         (bmalloc::BoundaryTag::allocate): Deleted. Moved this logic into the
751         LargeObject class.
752
753         * bmalloc/EndTag.h:
754         (bmalloc::EndTag::init):
755         (bmalloc::EndTag::operator=): Deleted. Re-reading this code, I found
756         special behavior in the assignment operator to be a surprising API.
757         So, I replaced the assignment operation with an explicit initializing
758         function.
759
760         * bmalloc/Heap.cpp:
761         (bmalloc::Heap::scavengeLargeRanges):
762         (bmalloc::Heap::allocateXLarge):
763         (bmalloc::Heap::findXLarge):
764         (bmalloc::Heap::deallocateXLarge):
765         (bmalloc::Heap::allocateLarge):
766         (bmalloc::Heap::deallocateLarge):
767         * bmalloc/Heap.h: No behavior changes here -- just adopting the
768         LargeObject interface.
769
770         * bmalloc/LargeObject.h: Added.
771         (bmalloc::LargeObject::operator!):
772         (bmalloc::LargeObject::begin):
773         (bmalloc::LargeObject::size):
774         (bmalloc::LargeObject::range):
775         (bmalloc::LargeObject::LargeObject):
776         (bmalloc::LargeObject::setFree):
777         (bmalloc::LargeObject::isFree):
778         (bmalloc::LargeObject::hasPhysicalPages):
779         (bmalloc::LargeObject::setHasPhysicalPages):
780         (bmalloc::LargeObject::isValidAndFree):
781         (bmalloc::LargeObject::merge):
782         (bmalloc::LargeObject::split):
783         (bmalloc::LargeObject::validateSelf):
784         (bmalloc::LargeObject::validate): Moved this code into a class, out of
785         BoundaryTag free functions.
786
787         New to the class are these features:
788
789             (1) Every reference to an object is validated upon creation and use.
790
791             (2) There's an explicit API for "This is a reference to an object
792             that might be stale (the DoNotValidate API)".
793
794             (3) The begin and end tags are kept in sync automatically.
795
796         * bmalloc/SegregatedFreeList.cpp:
797         (bmalloc::SegregatedFreeList::insert):
798         (bmalloc::SegregatedFreeList::takeGreedy):
799         (bmalloc::SegregatedFreeList::take):
800         * bmalloc/SegregatedFreeList.h: Adopt the LargeObject interface.
801
802         * bmalloc/VMHeap.cpp:
803         (bmalloc::VMHeap::grow):
804         * bmalloc/VMHeap.h:
805         (bmalloc::VMHeap::allocateLargeRange):
806         (bmalloc::VMHeap::deallocateLargeRange): Adopt the LargeObject interface.
807
808 2015-02-20  Geoffrey Garen  <ggaren@apple.com>
809
810         bmalloc should implement malloc introspection (to stop false-positive leaks when MallocStackLogging is off)
811         https://bugs.webkit.org/show_bug.cgi?id=141802
812
813         Reviewed by Andreas Kling.
814
815         Rolling back in with a fix for a crash seen while using GuardMalloc.
816
817         * bmalloc/VMHeap.cpp:
818         (bmalloc::VMHeap::grow):
819         * bmalloc/VMHeap.h:
820         * bmalloc/Zone.cpp: Re-land the old patch.
821
822         (bmalloc::Zone::size): Be sure to implement the size() function since
823         it's accessible indirectly via the malloc_zone_from_ptr public API --
824         and GuardMalloc calls it all the time.
825
826         (bmalloc::Zone::Zone):
827         * bmalloc/Zone.h: Re-land the old patch.
828
829 2015-02-19  Commit Queue  <commit-queue@webkit.org>
830
831         Unreviewed, rolling out r180363.
832         https://bugs.webkit.org/show_bug.cgi?id=141814
833
834         Caused >50 crashes when running LayoutTests in GuardMalloc or
835         ASAN modes. (Requested by jernoble on #webkit).
836
837         Reverted changeset:
838
839         "bmalloc should implement malloc introspection (to stop false-
840         positive leaks when MallocStackLogging is off)"
841         https://bugs.webkit.org/show_bug.cgi?id=141802
842         http://trac.webkit.org/changeset/180363
843
844 2015-02-19  Geoffrey Garen  <ggaren@apple.com>
845
846         bmalloc should implement malloc introspection (to stop false-positive leaks when MallocStackLogging is off)
847         https://bugs.webkit.org/show_bug.cgi?id=141802
848
849         Reviewed by Andreas Kling.
850
851         Fixed a last-minute type.
852
853         The macro is OS, not PLATFORM.
854
855         * bmalloc/VMHeap.cpp:
856         (bmalloc::VMHeap::grow):
857         * bmalloc/VMHeap.h:
858         * bmalloc/Zone.h:
859
860 2015-02-19  Geoffrey Garen  <ggaren@apple.com>
861
862         bmalloc should implement malloc introspection (to stop false-positive leaks when MallocStackLogging is off)
863         https://bugs.webkit.org/show_bug.cgi?id=141802
864
865         Reviewed by Andreas Kling.
866
867         This patch does the bare minimum to stop false positive leaks from
868         being reported by the Darwin leaks tool. We register each super chunk
869         as a single object, and then request that the leaks tool scan it.
870
871         * bmalloc.xcodeproj/project.pbxproj: Added an abstraction for the malloc
872         zone introspection API.
873
874         * bmalloc/Algorithm.h: Missing #include.
875
876         * bmalloc/VMHeap.cpp:
877         (bmalloc::VMHeap::grow):
878         * bmalloc/VMHeap.h: Adopt the new abstraction.
879
880         * bmalloc/Zone.cpp: Added.
881         (bmalloc::remoteRead): Helper for reading an object out of another process.
882         (bmalloc::Zone::enumerator):
883         (bmalloc::Zone::Zone): Register a malloc zone so that we will participate
884         in introspection.
885
886         * bmalloc/Zone.h: Added.
887         (bmalloc::Zone::superChunks):
888         (bmalloc::Zone::addSuperChunk): Use a non-dynamically-allocated vector
889         since our dynamic allocations will not be scanned by leaks since they
890         will have the malloc VM tag.
891
892 2015-02-18  Geoffrey Garen  <ggaren@apple.com>
893
894         bmalloc: VMHeap should keep a record of all of its VM ranges (for malloc introspection)
895         https://bugs.webkit.org/show_bug.cgi?id=141759
896
897         Reviewed by Andreas Kling.
898
899         * bmalloc.xcodeproj/project.pbxproj:
900         * bmalloc/SuperChunk.h: Added.
901         (bmalloc::SuperChunk::create):
902         (bmalloc::SuperChunk::SuperChunk):
903         (bmalloc::SuperChunk::smallChunk):
904         (bmalloc::SuperChunk::mediumChunk):
905         (bmalloc::SuperChunk::largeChunk): Factored out super chunk creation
906         into a separate class, for clarity and type safety.
907
908         * bmalloc/VMHeap.cpp:
909         (bmalloc::VMHeap::grow):
910         (bmalloc::VMHeap::allocateSuperChunk): Renamed "allocateSuperChunk" to
911         "grow" because Andreas found "allocateSuperChunk" to be unclear.
912
913         * bmalloc/VMHeap.h: Track all our VM ranges. We will use this information
914         for malloc introspection.
915
916         (bmalloc::VMHeap::allocateSmallPage):
917         (bmalloc::VMHeap::allocateMediumPage):
918         (bmalloc::VMHeap::allocateLargeRange): Updated for renames.
919
920 2015-02-18  Zan Dobersek  <zdobersek@igalia.com>
921
922         Build bmalloc through CMake as a static library. It's then linked either
923         into the WTF library (if built as a shared library) or into the JSC and
924         WebKit2 libraries. There's no need to build it as a standalone shared library.
925
926         Rubber-stamped by Carlos Garcia Campos.
927
928         * CMakeLists.txt:
929
930 2015-02-13  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
931
932         [BMalloc] Add a FIXME comment for memory alignas
933         https://bugs.webkit.org/show_bug.cgi?id=141556
934
935         Reviewed by Csaba Osztrogonác.
936
937         * bmalloc/Chunk.h: Add a FIXME comment.
938         * bmalloc/LargeChunk.h: ditto.
939
940 2015-02-11  Csaba Osztrogonác  <ossy@webkit.org>
941
942         bmalloc buildfix on 32 bit Linux (x86/ARM)
943         https://bugs.webkit.org/show_bug.cgi?id=141472
944
945         Reviewed by Gyuyoung Kim.
946
947         * bmalloc/Algorithm.h:
948         (bmalloc::roundUpToMultipleOf):
949         * bmalloc/FixedVector.h:
950         (bmalloc::FixedVector::clear):
951         * bmalloc/Sizes.h:
952         (bmalloc::Sizes::sizeClass):
953
954 2015-02-11  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
955
956         [EFL][GTK] Use bmalloc instead of tcmalloc
957         https://bugs.webkit.org/show_bug.cgi?id=140162
958
959         Reviewed by Carlos Garcia Campos.
960
961         Support to use bmalloc on EFL and GTK ports.
962
963         * CMakeLists.txt: Added.
964         * bmalloc/Allocator.cpp:
965         (bmalloc::Allocator::allocate):
966             Fix unused return value caused by posix_memalign().
967         * bmalloc/AsyncTask.h:
968         * bmalloc/BoundaryTag.h:
969         (bmalloc::BoundaryTag::clear):
970         * bmalloc/Chunk.h:
971             Change Traits::Page with Traits::PageType in order to fix
972             -fpermitive build error on EFL and GTK port. 
973         * bmalloc/EndTag.h:
974         (bmalloc::EndTag::operator=):
975         * bmalloc/Line.h: ditto.
976         * bmalloc/MediumTraits.h:
977         * bmalloc/Page.h: ditto.
978         * bmalloc/PerThread.h:
979             EFL port doesn't support __has_include definition yet.
980             Define HAVE_PTHREAD_MACHDEP_H according to check if __has_include is supported.
981         * bmalloc/SmallTraits.h: ditto.
982         * bmalloc/VMAllocate.h:
983         (bmalloc::vmDeallocatePhysicalPages):
984         (bmalloc::vmAllocatePhysicalPages):
985         * bmalloc/Vector.h:
986         (bmalloc::Vector<T>::push):
987         (bmalloc::Vector<T>::reallocateBuffer):
988
989 2015-01-31  Sam Weinig  <sam@webkit.org>
990
991         Remove even more Mountain Lion support
992         https://bugs.webkit.org/show_bug.cgi?id=141124
993
994         Reviewed by Alexey Proskuryakov.
995
996         * Configurations/Base.xcconfig:
997         * Configurations/DebugRelease.xcconfig:
998
999 2015-01-30  Geoffrey Garen  <ggaren@apple.com>
1000
1001         GC marking threads should clear malloc caches
1002         https://bugs.webkit.org/show_bug.cgi?id=141097
1003
1004         Reviewed by Andreas Kling.
1005
1006         Split the scavenging API into per-thread vs global, so that you can
1007         request to scavenge your own thread without scavenging the whole heap.
1008
1009         * bmalloc/Cache.cpp:
1010         (bmalloc::Cache::scavenge):
1011         * bmalloc/bmalloc.h:
1012         (bmalloc::api::scavengeThisThread):
1013         (bmalloc::api::scavenge):
1014
1015 2015-01-28  Dana Burkart  <dburkart@apple.com>
1016
1017         Move ASan flag settings from DebugRelease.xcconfig to Base.xcconfig
1018         https://bugs.webkit.org/show_bug.cgi?id=136765
1019
1020         Reviewed by Alexey Proskuryakov.
1021
1022         * Configurations/Base.xcconfig:
1023         * Configurations/DebugRelease.xcconfig:
1024
1025 2015-01-21  Geoffrey Garen  <ggaren@apple.com>
1026
1027         bmalloc: support aligned allocation
1028         https://bugs.webkit.org/show_bug.cgi?id=140732
1029
1030         Reviewed by Andreas Kling.
1031
1032         * bmalloc/Allocator.cpp:
1033         (bmalloc::Allocator::allocate): New function for aligned allocation.
1034
1035         Small and medium requests just allocate and free until they find an
1036         aligned pointer. This is slightly inefficient in the worst case, but
1037         still constant-time with little-to-no space overhead.
1038
1039         Large requests use a new API that requires the client to specify both
1040         its ideal size and alignment, and the worst-case size you would have to
1041         allocate in order to produce some interior pointer of the requested size
1042         and alignment. We put the burden of this calculation on the client
1043         because it simplifies things if we guarantee that allocation won't fail.
1044
1045         XLarge requests are easy: we just forward them to vmAllocate, which
1046         already supported aligned requests.
1047
1048         * bmalloc/BoundaryTag.h:
1049         * bmalloc/BoundaryTagInlines.h:
1050         (bmalloc::BoundaryTag::mergeLeft):
1051         (bmalloc::BoundaryTag::mergeRight):
1052         (bmalloc::BoundaryTag::merge):
1053         (bmalloc::BoundaryTag::deallocate):
1054         (bmalloc::BoundaryTag::split):
1055         (bmalloc::BoundaryTag::allocate): No behavior change here. I just
1056         refactored the interface to remove some reference out parameters in
1057         order to clarify what changes and what doesn't.
1058
1059         * bmalloc/Heap.cpp:
1060         (bmalloc::Heap::allocateXLarge): Added an alignment API.
1061
1062         (bmalloc::Heap::allocateLarge):
1063         * bmalloc/Heap.h: Added an alignment API. I split out allocateLarge into
1064         a few variants, so aligned and unaligned allocation could share some code.
1065
1066         * bmalloc/SegregatedFreeList.cpp:
1067         (bmalloc::SegregatedFreeList::take):
1068         * bmalloc/SegregatedFreeList.h: Changed to use a separate, explicit API
1069         for aligned allocation. It turns out that the aligned path is pretty
1070         different, since it ends up searching for two potential ways to satisfy
1071         an allocation: either large enough and aligned, or large enough to split
1072         into something not aligned and something large enough and aligned.
1073
1074         * bmalloc/VMAllocate.h:
1075         (bmalloc::vmAllocate): Switched alignment to come before size because
1076         that's how the memalign API specifies it.
1077
1078         * bmalloc/VMHeap.h:
1079         (bmalloc::VMHeap::allocateLargeRange): Added an alignment API.
1080
1081 2015-01-20  Geoffrey Garen  <ggaren@apple.com>
1082
1083         bmalloc: a little bit of cleanup
1084         https://bugs.webkit.org/show_bug.cgi?id=140687
1085
1086         Reviewed by Anders Carlsson.
1087
1088         * bmalloc/Algorithm.h:
1089         (bmalloc::isPowerOfTwo): Added a check for 0, since 0 would break a lot
1090         of code.
1091
1092         * bmalloc/BoundaryTag.h:
1093         * bmalloc/BoundaryTagInlines.h:
1094         (bmalloc::BoundaryTag::mergeLeft):
1095         (bmalloc::BoundaryTag::mergeRight):
1096         (bmalloc::BoundaryTag::merge):
1097         (bmalloc::BoundaryTag::deallocate):
1098         (bmalloc::BoundaryTag::split):
1099         (bmalloc::BoundaryTag::allocate):
1100         (bmalloc::BoundaryTag::mergeLargeLeft): Deleted.
1101         (bmalloc::BoundaryTag::mergeLargeRight): Deleted.
1102         (bmalloc::BoundaryTag::mergeLarge): Deleted.
1103         (bmalloc::BoundaryTag::splitLarge): Deleted. Removed the word "Large"
1104         from all these functions, since boundary tags always pertain to large
1105         objects, and putting the word "Large" everywhere wasn't helping to
1106         explain that.
1107
1108         * bmalloc/Heap.cpp:
1109         (bmalloc::Heap::allocateXLarge):
1110         (bmalloc::Heap::findXLarge):
1111         (bmalloc::Heap::deallocateXLarge):
1112         * bmalloc/Heap.h:
1113         * bmalloc/VMHeap.h:
1114         (bmalloc::VMHeap::allocateXLarge): Deleted.
1115         (bmalloc::VMHeap::findXLarge): Deleted.
1116         (bmalloc::VMHeap::deallocateXLarge): Deleted. Moved XLarge allocation
1117         from VMHeap to Heap. Since the purpose of the VMHeap is to cache VM
1118         ranges, and the VMHeap never caches any XLarge ranges, it doesn't
1119         really make sense for the VMHeap to be involved.
1120
1121 2015-01-16  Geoffrey Garen  <ggaren@apple.com>
1122
1123         bmalloc: refactored XLarge allocation for better alignment
1124         https://bugs.webkit.org/show_bug.cgi?id=140582
1125
1126         Reviewed by Andreas Kling.
1127
1128         XLarge objects used to be Large objects with an extra bit of metadata
1129         that said "actually, I'm not large -- I'm extra large".
1130
1131         The metadata header in an XLarge allocation made it impossible for the
1132         XLarge object to honor a very large alignment request.
1133
1134         The solution is to stop using a metadata header for XLarge objects, and
1135         instead to store explicit metadata on the side.
1136
1137         This is a bit less astonishing, which is also nice.
1138
1139         Finding XLarge metadata is now a linear search. That's probably OK, since
1140         it was always so in TCMalloc, and the usual number of XLarge allocations
1141         in a process is 0.
1142
1143         This design makes it possible for the heap to cache XLarge allocations
1144         with and/or without physical pages. I haven't actually done that yet
1145         because the tradeoffs are subtle, so I don't want to do anything without
1146         a motivating test case.
1147
1148         * bmalloc.xcodeproj/project.pbxproj:
1149         * bmalloc/Allocator.cpp:
1150         (bmalloc::Allocator::reallocate): Removed the concept of an XLargeChunk,
1151         since an XLarge allocation is now just a naked buffer without a header.
1152
1153         (bmalloc::Allocator::allocateXLarge): Added an explicit qualifier for
1154         XLarge alignment, since XLargeChunk won't give this to us implicitly
1155         anymore.
1156
1157         * bmalloc/BoundaryTag.h:
1158         (bmalloc::BoundaryTag::setRange):
1159         (bmalloc::BoundaryTag::isXLarge): Deleted.
1160         (bmalloc::BoundaryTag::setXLarge): Deleted.
1161         * bmalloc/BoundaryTagInlines.h:
1162         (bmalloc::validate):
1163         (bmalloc::BoundaryTag::deallocate): Removed the XLarge hacks from Large allocations.
1164
1165         * bmalloc/Deallocator.cpp:
1166         (bmalloc::Deallocator::deallocateXLarge):
1167         (bmalloc::Deallocator::deallocateSlowCase):
1168         * bmalloc/Heap.cpp:
1169         (bmalloc::Heap::findXLarge):
1170         (bmalloc::Heap::allocateXLarge):
1171         (bmalloc::Heap::deallocateXLarge):
1172         * bmalloc/Heap.h: Updated for interface changes.
1173
1174         * bmalloc/ObjectType.cpp:
1175         (bmalloc::objectType):
1176         * bmalloc/ObjectType.h:
1177         (bmalloc::isXLarge): We can now tell if a pointer is XLarge just by
1178         examining its bit pattern -- just like we do for other kinds of
1179         allocations -- which is nice.
1180
1181         * bmalloc/Sizes.h:
1182         * bmalloc/VMHeap.h:
1183         (bmalloc::VMHeap::allocateXLarge):
1184         (bmalloc::VMHeap::findXLarge):
1185         (bmalloc::VMHeap::deallocateXLarge): Keep an explicit vector of metadata
1186         for XLarge allocations.
1187
1188         * bmalloc/XLargeChunk.h: Removed.
1189
1190 2015-01-16  Geoffrey Garen  <ggaren@apple.com>
1191
1192         bmalloc: added some infrastructure for aligned allocation
1193         https://bugs.webkit.org/show_bug.cgi?id=140572
1194
1195         Reviewed by Andreas Kling.
1196
1197         * bmalloc/Algorithm.h:
1198         (bmalloc::isPowerOfTwo):
1199         (bmalloc::roundUpToMultipleOf):
1200         (bmalloc::roundDownToMultipleOf): Refactored some duplicate code to use our
1201         isPowerOfTwo helper function.
1202
1203         * bmalloc/Allocator.cpp:
1204         (bmalloc::Allocator::allocate):
1205         * bmalloc/Allocator.h: Stubbed out an implementation of aligned allocation.
1206         Doesn't do anything yet, but does correctly forward to system malloc
1207         when bmalloc is disabled.
1208
1209         * bmalloc/Cache.cpp:
1210         (bmalloc::Cache::allocateSlowCaseNullCache):
1211         * bmalloc/Cache.h:
1212         (bmalloc::Cache::allocate):
1213         * bmalloc/bmalloc.h:
1214         (bmalloc::api::memalign):
1215         * bmalloc/mbmalloc.cpp: Stubbed out an API for aligned allocation.
1216
1217 2015-01-13  Geoffrey Garen  <ggaren@apple.com>
1218
1219         Consider alignment when allocating from a SegregatedFreeList
1220         https://bugs.webkit.org/show_bug.cgi?id=140408
1221
1222         Reviewed by Sam Weinig.
1223
1224         In preparation for supporting aligned allocation.
1225
1226         No performance change.
1227
1228         Since this is just one extra branch in an already expensive function,
1229         I decided not to duplicate the function just to avoid the branch in
1230         the un-aligned case.
1231
1232         * bmalloc/SegregatedFreeList.cpp:
1233         (bmalloc::SegregatedFreeList::take):
1234         * bmalloc/SegregatedFreeList.h:
1235
1236 2015-01-13  Geoffrey Garen  <ggaren@apple.com>
1237
1238         Renamed minimum to size in SegregatedFreeList
1239         https://bugs.webkit.org/show_bug.cgi?id=140406
1240
1241         Reviewed by Sam Weinig.
1242
1243         In preparation for supporting aligned allocation.
1244
1245         * bmalloc/SegregatedFreeList.cpp:
1246         (bmalloc::SegregatedFreeList::takeGreedy):
1247         (bmalloc::SegregatedFreeList::take): Every size passed to malloc is
1248         really just a minimum. Let's not imply that this value is special.
1249
1250 2015-01-11  Dan Bernstein  <mitz@apple.com>
1251
1252         Geoff is organized, but he is not an organization.
1253
1254         Rubber-stamped by Anders Carlsson.
1255
1256         * bmalloc.xcodeproj/project.pbxproj: Removed the ORGANIZATIONNAME project attribute.
1257
1258 2015-01-07  Geoffrey Garen  <ggaren@apple.com>
1259
1260         Make bmalloc work with ASan
1261         https://bugs.webkit.org/show_bug.cgi?id=140194
1262
1263         Reviewed by Mark Lam.
1264
1265         * bmalloc/BPlatform.h: Added a way to detect Darwin OSes, since we need
1266         an OS-specific API to test for loaded runtime libraries.
1267
1268         * bmalloc/Environment.cpp:
1269         (bmalloc::isASanEnabled):
1270         (bmalloc::Environment::computeIsBmallocEnabled): Disabled bmalloc if
1271         ASan is enabled, since system malloc has the Asan hooks we need.
1272
1273         You could check for the ASan compile-time flag instead, but doing this
1274         check at runtime prepares bmalloc for a world where it is a dynamic
1275         library that might be loaded into projects it did not compile with.
1276
1277 2015-01-05  Geoffrey Garen  <ggaren@apple.com>
1278
1279         Fix up bmalloc's PerThread for use on Linux
1280         https://bugs.webkit.org/show_bug.cgi?id=139804
1281
1282         Reviewed by Anders Carlsson.
1283
1284         The previous implementation was a bit slow.
1285
1286         * bmalloc/PerThread.h:
1287         (bmalloc::PerThreadStorage<Cache>::get):
1288         (bmalloc::PerThreadStorage::get):
1289         (bmalloc::PerThreadStorage::init): Added a catch-all cross-platform Unix
1290         way to do fast per-thread access without taking a lock every time. This
1291         probably works on all the platforms we care about, and it matches other
1292         techniques we use elsewhere in WebKit.
1293
1294         (bmalloc::PerThread<T>::getFastCase): Removed the conditional from
1295         this class because PerThreadStorage now encapsulates everything that
1296         needs to be conditional.
1297
1298         (bmalloc::PerThreadStorage::initSharedKeyIfNeeded): Deleted.
1299
1300 2014-12-26  Dan Bernstein  <mitz@apple.com>
1301
1302         <rdar://problem/19348208> REGRESSION (r177027): iOS builds use the wrong toolchain
1303         https://bugs.webkit.org/show_bug.cgi?id=139950
1304
1305         Reviewed by David Kilzer.
1306
1307         * Configurations/Base.xcconfig: Only define TOOLCHAINS when building for OS X, doing so
1308         in a manner that works with Xcode 5.1.1.
1309
1310 2014-12-15  Geoffrey Garen  <ggaren@apple.com>
1311
1312         Safari crashes when you set Malloc environment variables
1313         https://bugs.webkit.org/show_bug.cgi?id=139656
1314
1315         Reviewed by Michael Saboff.
1316
1317         I forgot to cover the realloc() case. Whoops. (OoPS?)
1318
1319         This time around, I ran the full MallocBench test suite in Malloc=1
1320         mode, and it passed.
1321
1322         * bmalloc/Allocator.cpp:
1323         (bmalloc::Allocator::reallocate):
1324         * bmalloc/Allocator.h: Pushed realloc() logic down into the allocator.
1325         It needs to be down there so that we can do the short-circuiting check
1326         for whether bmalloc is enabled first.
1327
1328         Also added the check.
1329
1330         * bmalloc/Cache.cpp:
1331         (bmalloc::Cache::scavenge):
1332         (bmalloc::Cache::Cache):
1333         (bmalloc::Cache::reallocateSlowCaseNullCache):
1334         * bmalloc/Cache.h:
1335         (bmalloc::Cache::deallocator):
1336         (bmalloc::Cache::reallocate): Ditto.
1337
1338         * bmalloc/bmalloc.h:
1339         (bmalloc::api::free):
1340         (bmalloc::api::realloc): Ditto.
1341
1342         (bmalloc::api::scavenge): Pushed this down into Cache to match the
1343         surrounding functions.
1344
1345 2014-12-11  Geoffrey Garen  <ggaren@apple.com>
1346
1347         bmalloc should support system memory analysis tools (part 2)
1348         https://bugs.webkit.org/show_bug.cgi?id=139565
1349
1350         Reviewed by Mark Lam.
1351
1352         This patch actually queries the environment to see if memory analysis
1353         tools have been enabled.
1354
1355         * bmalloc/Deallocator.cpp:
1356         (bmalloc::Deallocator::scavenge): Don't process the object log if
1357         we've disabled bmalloc because it will be full of invalid nullptrs.
1358
1359         * bmalloc/Environment.cpp:
1360         (bmalloc::isMallocEnvironmentVariableSet): Test for the list of known
1361         Malloc debugging flags. I also added a plain "Malloc" catch-all for
1362         when you want to disable bmalloc without enabling any kind of funny
1363         business.
1364
1365         It would be slightly nicer just to iterate the list of environment
1366         variables and strstr them, but getenv is the more portable option,
1367         and performance here doesn't really matter.
1368
1369         (bmalloc::isLibgmallocEnabled): Test for the libgmalloc insertion
1370         environment variable.
1371
1372         (bmalloc::Environment::computeIsBmallocEnabled):
1373
1374 2014-12-11  Geoffrey Garen  <ggaren@apple.com>
1375
1376         Try to fix the iOS simulator build.
1377
1378         #include the declaration of malloc / free.
1379
1380         * bmalloc/Allocator.cpp:
1381         * bmalloc/Deallocator.cpp:
1382
1383 2014-12-11  Geoffrey Garen  <ggaren@apple.com>
1384
1385         Try to fix the build.
1386
1387         * bmalloc.xcodeproj/project.pbxproj: Marked a header exported.
1388
1389 2014-12-11  Geoffrey Garen  <ggaren@apple.com>
1390
1391         bmalloc should support system memory analysis tools (part 1)
1392         https://bugs.webkit.org/show_bug.cgi?id=139559
1393
1394         Reviewed by Mark Lam.
1395
1396         This patch adds the hooks to disable bmalloc at runtime if certain
1397         environment variables are set, but doesn't actually read from the
1398         environment yet.
1399
1400         No performance change.
1401
1402         * bmalloc.xcodeproj/project.pbxproj: Added the Environment class, which
1403         we'll use to read environment variables and see if memory analysis tools
1404         have been enabled.
1405
1406         * bmalloc/Allocator.cpp:
1407         (bmalloc::Allocator::Allocator):
1408         (bmalloc::Allocator::allocateSlowCase): Added a hook to disable bmalloc
1409         on the allocation path. We cache the setting to make the check fast.
1410
1411         * bmalloc/Allocator.h: Interface changes.
1412
1413         * bmalloc/Cache.cpp:
1414         (bmalloc::Cache::Cache): Pass a heap pointer through to our allocator
1415         and deallocator. This main purpose is to enable them to query the
1416         environment for whether bmalloc is enabled; but this is also a slightly
1417         cleaner way to guarantee to them that the Heap has been pre-initialized.
1418
1419         * bmalloc/Deallocator.cpp:
1420         (bmalloc::Deallocator::Deallocator): If bmalloc is disable, artificially
1421         fill the object log to force us to take the slow path on all deallocations.
1422
1423         (bmalloc::Deallocator::deallocateSlowCase): Do the disabled check.
1424
1425         * bmalloc/Deallocator.h: Interface changes.
1426
1427         * bmalloc/Environment.cpp: Added.
1428         (bmalloc::Environment::Environment):
1429         (bmalloc::Environment::computeIsBmallocEnabled):
1430         * bmalloc/Environment.h: Added.
1431         (bmalloc::Environment::isBmallocEnabled): This is the class that will
1432         encapsulate looking for environment variables that turn on heap
1433         analysis tools.
1434
1435         * bmalloc/Heap.h:
1436         (bmalloc::Heap::environment):
1437
1438         * bmalloc/Mutex.h:
1439         (bmalloc::Mutex::Mutex):
1440         * bmalloc/StaticMutex.h: A little refactoring to clarify these comments,
1441         since I got super confused about them while writing this patch.
1442
1443         * bmalloc/VMHeap.cpp: Fixed an #include.
1444
1445 2014-12-09  David Kilzer  <ddkilzer@apple.com>
1446
1447         Switch from using PLATFORM_NAME to SDK selectors in ANGLE, bmalloc, gtest, JavaScriptCore, WTF
1448         <http://webkit.org/b/139212>
1449
1450         Reviewed by Joseph Pecoraro.
1451
1452         * Configurations/Base.xcconfig:
1453         - Only set GCC_ENABLE_OBJC_GC, GCC_MODEL_TUNING and TOOLCHAINS
1454           on OS X.
1455         * Configurations/DebugRelease.xcconfig:
1456         - Only set MACOSX_DEPLOYMENT_TARGET and SDKROOT on OS X.
1457
1458 2014-11-07  Geoffrey Garen  <ggaren@apple.com>
1459
1460         bmalloc uses 8X more virtual memory than necessary
1461         https://bugs.webkit.org/show_bug.cgi?id=138495
1462
1463         Reviewed by Mark Lam.
1464
1465         iOS has a per-process virtual memory cap around 1GB, so there's some
1466         value to not going totally ham with virtual memory.
1467
1468         We currently use about 8X the necessary amount:
1469             - 2X to align our VM allocation
1470             - 4X to reserve small / medium / (2) large chunk VM ranges per superchunk
1471
1472         We can cut that down:
1473             - Return the unaligned portion of our VM allocation (-2X)
1474             - Use all the chunks in a superchunk, instead of allocating one
1475               chunk per superchunk (-4X)
1476
1477         * bmalloc/Algorithm.h:
1478         (bmalloc::roundUpToMultipleOf): Added a non-constant version of this
1479         function so we can call it with getpagesize() at runtime.
1480
1481         * bmalloc/Chunk.h:
1482         * bmalloc/LargeChunk.h:
1483         (bmalloc::LargeChunk::create): Deleted. Instead of each chunk allocating
1484         its own VM, VMHeap allocates the superchunk and all the chunks in it at a time.
1485
1486         * bmalloc/VMAllocate.h:
1487         (bmalloc::vmValidate):
1488         (bmalloc::vmAllocate): ASSERT that mmap succeeds to make crashes clearer
1489         if it does not succeed. Allocate precisely, and give back the extra.
1490
1491         * bmalloc/VMHeap.cpp:
1492         (bmalloc::VMHeap::allocateSuperChunk):
1493         (bmalloc::VMHeap::allocateSmallChunk): Deleted.
1494         (bmalloc::VMHeap::allocateMediumChunk): Deleted.
1495         (bmalloc::VMHeap::allocateLargeChunk): Deleted. Use all the chunks
1496         in a superchunk, instead of just one.
1497
1498         * bmalloc/VMHeap.h:
1499         (bmalloc::VMHeap::allocateSmallPage):
1500         (bmalloc::VMHeap::allocateMediumPage):
1501         (bmalloc::VMHeap::allocateLargeRange):
1502         * bmalloc/XLargeChunk.h:
1503         (bmalloc::XLargeChunk::create): Updated to match changes above.
1504
1505 2014-11-01  David Kilzer  <ddkilzer@apple.com>
1506
1507         JavaScriptCore is missing debug info for bmalloc because libbmalloc.a is stripped
1508         <https://webkit.org/b/138286>
1509         <rdar://problem/18847087>
1510
1511         Reviewed by Dan Bernstein.
1512
1513         * Configurations/bmalloc.xcconfig: Set STRIP_INSTALLED_PRODUCT
1514         to NO for the target that produces libbmalloc.a so that the
1515         debug symbols will be linked into JavaScriptCore and end up in
1516         its dSYM file.
1517
1518 2014-10-30  Dana Burkart  <dburkart@apple.com>
1519
1520         <rdar://problem/18821260> Prepare for the mysterious future
1521
1522         Reviewed by Lucas Forschler.
1523
1524         * Configurations/Base.xcconfig:
1525         * Configurations/DebugRelease.xcconfig:
1526
1527 2014-09-24  Geoffrey Garen  <ggaren@apple.com>
1528
1529         bmalloc: cleaned up fast path vs slow path
1530         https://bugs.webkit.org/show_bug.cgi?id=137081
1531
1532         Reviewed by Sam Weinig.
1533
1534         Might be a 1% speedup on MallocBench. Also cleans up the code a bit.
1535
1536         * bmalloc/Allocator.cpp:
1537         (bmalloc::Allocator::Allocator): Merged the small and medium range
1538         caches, just like the small and medium allocators. Ranges are abstract
1539         objects that don't really care whether they hold small or medium objects,
1540         so they don't need to be segregated.
1541
1542         (bmalloc::Allocator::scavenge): Ditto.
1543
1544         (bmalloc::Allocator::allocateBumpRangeSlowCase):
1545         (bmalloc::Allocator::allocateBumpRange): Same thing here, except that
1546         we do care a tiny bit, because we need to specify small vs medium when
1547         allocating new ranges from the heap, to ensure that the heap allocates
1548         from the right segment of VM.
1549
1550         (bmalloc::Allocator::allocateLarge):
1551         (bmalloc::Allocator::allocateXLarge): NO_INLINE because this was clouding
1552         up the fast path. Large allocation performance is dominated by allocation
1553         logic and initialization, so inlining it doesn't help.
1554
1555         (bmalloc::Allocator::allocateSlowCase): Slow path got a bit cleaner since
1556         it doesn't need to distinguish small vs medium objects.
1557
1558         (bmalloc::Allocator::allocateSmallBumpRange): Deleted.
1559         (bmalloc::Allocator::allocateMediumBumpRange): Deleted.
1560
1561         * bmalloc/Allocator.h:
1562         * bmalloc/BumpRange.h:
1563
1564         * bmalloc/Cache.cpp:
1565         (bmalloc::Cache::allocateSlowCase): Deleted.
1566         (bmalloc::Cache::deallocateSlowCase): Deleted.
1567         * bmalloc/Cache.h:
1568         (bmalloc::Cache::allocate):
1569         (bmalloc::Cache::deallocate):
1570         (bmalloc::Cache::allocateFastCase): Deleted.
1571         (bmalloc::Cache::deallocateFastCase): Deleted. Removed the Cache slow
1572         paths. The downside to this change is that the fast path branches to two
1573         distinct failure cases instead of one. The upside is that the slow path
1574         doesn't need to re-read the segment register, which is not as cheap as a
1575         normal register, and it doesn't need to do an extra level of function 
1576         call. Seems to be worth it.
1577
1578         * bmalloc/Deallocator.h:
1579         * bmalloc/Heap.cpp:
1580         (bmalloc::Heap::refillSmallBumpRangeCache):
1581         (bmalloc::Heap::refillMediumBumpRangeCache):
1582         * bmalloc/Heap.h: Updated for interface changes.
1583
1584         * bmalloc/Sizes.h: The most ranges a cache will hold is the number of
1585         small lines in a page / 2, since any other free lines will coalesce
1586         with their neighbors.
1587
1588 2014-09-23  Geoffrey Garen  <ggaren@apple.com>
1589
1590         Rolled out r173346.
1591
1592             bmalloc should honor the FastMalloc statistics API
1593             https://bugs.webkit.org/show_bug.cgi?id=136592
1594
1595         This didn't really work. Because we allow ranges with and without
1596         physical pages to merge, and we allow double-committing and
1597         double-decommitting, we can't rely on commit actions to track memory
1598         footprint.
1599
1600         * bmalloc/Heap.cpp:
1601         (bmalloc::Heap::size): Deleted.
1602         (bmalloc::Heap::capacity): Deleted.
1603         * bmalloc/Heap.h:
1604         * bmalloc/VMHeap.cpp:
1605         (bmalloc::VMHeap::VMHeap):
1606         (bmalloc::VMHeap::allocateSmallChunk):
1607         (bmalloc::VMHeap::allocateMediumChunk):
1608         (bmalloc::VMHeap::allocateLargeChunk):
1609         * bmalloc/VMHeap.h:
1610         (bmalloc::VMHeap::allocateSmallPage):
1611         (bmalloc::VMHeap::allocateMediumPage):
1612         (bmalloc::VMHeap::allocateLargeRange):
1613         (bmalloc::VMHeap::deallocateSmallPage):
1614         (bmalloc::VMHeap::deallocateMediumPage):
1615         (bmalloc::VMHeap::deallocateLargeRange):
1616         (bmalloc::VMHeap::size): Deleted.
1617         (bmalloc::VMHeap::capacity): Deleted.
1618         * bmalloc/bmalloc.h:
1619         (bmalloc::api::heapSize): Deleted.
1620         (bmalloc::api::heapCapacity): Deleted.
1621
1622 2014-09-23  Geoffrey Garen  <ggaren@apple.com>
1623
1624         bmalloc: Allocation should be more precise
1625         https://bugs.webkit.org/show_bug.cgi?id=136993
1626
1627         Reviewed by Gavin Barraclough.
1628
1629         13% reduction in heap size on the MallocBench *_memory_warning benchmarks.
1630
1631         This patch teaches the allocator to merge adjacent free lines into a
1632         single allocatable range. This allows us to shrink the size of an
1633         individual line without increasing fragmentation or the rate of allocator
1634         slow paths.
1635
1636         We'll only take more slow paths when available memory is sparse, which
1637         is exactly when it's worth it. When available memory is dense, we'll
1638         take fewer slow paths.
1639
1640         * bmalloc.xcodeproj/project.pbxproj:
1641         * bmalloc/Algorithm.h:
1642         (bmalloc::divideRoundingUp):
1643
1644         * bmalloc/Allocator.cpp:
1645         (bmalloc::Allocator::Allocator): Updated for interface changes.
1646
1647         (bmalloc::Allocator::scavenge): Scavenge by object instead of by line.
1648         Now that we merge lines, it's not convenient to scavenge by line.
1649
1650         (bmalloc::Allocator::allocateSmallBumpRange):
1651         (bmalloc::Allocator::allocateMediumBumpRange): Allocate whole ranges
1652         instead of individual lines.
1653
1654         (bmalloc::Allocator::allocateSlowCase):
1655         (bmalloc::Allocator::allocateSmallLine): Deleted.
1656         (bmalloc::Allocator::allocateMediumLine): Deleted.
1657         (bmalloc::Allocator::allocateMedium): Deleted.
1658         * bmalloc/Allocator.h:
1659         (bmalloc::Allocator::allocateFastCase): Folded medium allocations
1660         into the standard fast path with small allocations. Since a BumpAllocator
1661         just allocates out of an arbitrary range, it doesn't need to distinguish
1662         between small and medium lines.
1663
1664         * bmalloc/BumpAllocator.h:
1665         (bmalloc::BumpAllocator::size):
1666         (bmalloc::BumpAllocator::BumpAllocator):
1667         (bmalloc::BumpAllocator::init):
1668         (bmalloc::BumpAllocator::refill):
1669         (bmalloc::BumpAllocator::line): Deleted. No need to track line information
1670         anymore: the heap just gives us a pointer and a pre-computed number of
1671         objects, and we allocate them.
1672
1673         * bmalloc/Deallocator.cpp:
1674         (bmalloc::Deallocator::processObjectLog): Updated for interface changes.
1675
1676         * bmalloc/Heap.cpp:
1677         (bmalloc::Heap::Heap):
1678         (bmalloc::Heap::initializeLineMetadata): Pre-compute precise metadata
1679         detailing where all objects will lie in memory. After we merge two lines,
1680         we might allocate an object that spans from one line to the next. This
1681         metadata details which bits of memory overlap in that way, and how they
1682         overlap.
1683
1684         (bmalloc::Heap::refillSmallBumpRangeCache):
1685         (bmalloc::Heap::refillMediumBumpRangeCache): Scan a whole page at a time,
1686         and merge adjacent free lines into BumpRanges.
1687
1688         (bmalloc::Heap::allocateSmallPage):
1689         (bmalloc::Heap::allocateMediumPage):
1690         (bmalloc::Heap::deallocateSmallLine):
1691         (bmalloc::Heap::deallocateMediumLine): Track pages rather than lines,
1692         since we scan for free memory a page at a time.
1693
1694         (bmalloc::Heap::allocateSmallLineSlowCase): Deleted.
1695         (bmalloc::Heap::allocateMediumLineSlowCase): Deleted. Folded into the
1696         fast path.
1697
1698         * bmalloc/Heap.h:
1699         (bmalloc::Heap::derefSmallLine):
1700         (bmalloc::Heap::derefMediumLine):
1701         (bmalloc::Heap::deallocateSmallLine): Deleted.
1702         (bmalloc::Heap::allocateSmallLine): Deleted.
1703         (bmalloc::Heap::deallocateMediumLine): Deleted.
1704         (bmalloc::Heap::allocateMediumLine): Deleted. Updated for interface changes.
1705
1706         * bmalloc/Line.h:
1707         (bmalloc::Line<Traits>::ref):
1708         (bmalloc::Line<Traits>::deref):
1709         (bmalloc::Line<Traits>::concurrentRef): Deleted. We don't pass a derefCount
1710         anymore, since we only ever deref by 1 now.
1711
1712         * bmalloc/MediumAllocator.h:
1713         (bmalloc::MediumAllocator::isNull): Deleted.
1714         (bmalloc::MediumAllocator::MediumAllocator): Deleted.
1715         (bmalloc::MediumAllocator::line): Deleted.
1716         (bmalloc::MediumAllocator::allocate): Deleted.
1717         (bmalloc::MediumAllocator::derefCount): Deleted.
1718         (bmalloc::MediumAllocator::refill): Deleted.
1719         (bmalloc::MediumAllocator::clear): Deleted. Deleted some code that's
1720         been dead for a while, since it doesn't build anymore with this patch.
1721
1722         * bmalloc/Page.h:
1723         (bmalloc::Page::sizeClass):
1724         (bmalloc::Page::setSizeClass):
1725         (bmalloc::Page::smallSizeClass): Deleted.
1726         (bmalloc::Page::setSmallSizeClass): Deleted. Renamed setSmallSizeClass
1727         to sizeClass, since we use it for medium sizes too.
1728
1729         * bmalloc/Sizes.h:
1730         (bmalloc::Sizes::sizeClass):
1731         (bmalloc::Sizes::objectSize): Shrank line sizes to save memory.
1732
1733         (bmalloc::Sizes::smallSizeClassFor): Deleted.
1734         (bmalloc::Sizes::mediumSizeClassFor): Deleted.
1735
1736         * bmalloc/bmalloc.h:
1737         (bmalloc::api::realloc): Now that we have precise objects sizes, realloc
1738         can be a bit more precise. It also has to be, since we can't guarantee
1739         that an object ends at the end of a line anymore.
1740
1741 2014-09-19  Daniel Bates  <dabates@apple.com>
1742
1743         Always assume internal SDK when building configuration Production
1744         https://bugs.webkit.org/show_bug.cgi?id=136925
1745         <rdar://problem/18362399>
1746
1747         Reviewed by Dan Bernstein.
1748
1749         * Configurations/Base.xcconfig:
1750
1751 2014-09-16  Geoffrey Garen  <ggaren@apple.com>
1752
1753         bmalloc: moved line caches from the deallocator to the allocator
1754         https://bugs.webkit.org/show_bug.cgi?id=136868
1755
1756         Reviewed by Gavin Barraclough.
1757
1758         I did this mostly as a simplification, to make it easier to change the
1759         allocation strategy.
1760
1761         No throughput change on MallocBench. Saves about 50kB.
1762
1763         Since the deallocator needs to lock the heap when freeing lines anyway,
1764         there isn't much benefit to giving the deallocator a local cache of
1765         deallocated lines.
1766
1767         We still give the allocator a local cache of lines because that does
1768         reduce the frequency at which it needs to lock the heap in order to
1769         acquire more lines.
1770
1771         * bmalloc/Allocator.cpp:
1772         (bmalloc::Allocator::scavenge):
1773         (bmalloc::Allocator::allocateSmallLine):
1774         (bmalloc::Allocator::allocateMediumLine):
1775         (bmalloc::Allocator::allocateMedium):
1776         (bmalloc::Allocator::allocateSlowCase):
1777         * bmalloc/Allocator.h:
1778         * bmalloc/Deallocator.cpp:
1779         (bmalloc::Deallocator::Deallocator):
1780         (bmalloc::Deallocator::scavenge):
1781         (bmalloc::Deallocator::processObjectLog):
1782         (bmalloc::Deallocator::deallocateSmallLine): Deleted.
1783         (bmalloc::Deallocator::allocateSmallLine): Deleted.
1784         (bmalloc::Deallocator::deallocateMediumLine): Deleted.
1785         (bmalloc::Deallocator::allocateMediumLine): Deleted.
1786         * bmalloc/Deallocator.h:
1787
1788         * bmalloc/Sizes.h:
1789         * bmalloc/VMAllocate.h: Took the opportunity to make the line cache size
1790         exactly one page in size. That's about what we were shooting for anyway,
1791         and it may make it easier to switch to per-page allocation in future.
1792
1793 2014-09-15  Geoffrey Garen  <ggaren@apple.com>
1794
1795         bmalloc: allocate small and medium objects using the same bump pointer class
1796         https://bugs.webkit.org/show_bug.cgi?id=136843
1797
1798         Reviewed by Gavin Barraclough.
1799
1800         4% speedup on MallocBench.
1801
1802         Now that medium-sized objects have dedicated per-size allocators, they
1803         don't need to use an arbitrary bump pointer allocator. This means that
1804         every allocator knows how many objects it will allocate from the start,
1805         and we don't need a post-processing step to adjust refcounts based on
1806         real allocation count.
1807
1808         * bmalloc.xcodeproj/project.pbxproj: Renamed SmallAllocator to BumpAllocator
1809         since it's used for small and medium objects now.
1810
1811         * bmalloc/Allocator.cpp:
1812         (bmalloc::Allocator::Allocator): Updated to use new interface.
1813         (bmalloc::Allocator::scavenge): To "retire" an allocator, we just need
1814         to make sure that we finish allocating all the objects in it.
1815
1816         (bmalloc::Allocator::allocateMedium):
1817         (bmalloc::Allocator::allocateSlowCase):
1818         (bmalloc::Allocator::retire): Deleted.
1819         (bmalloc::Allocator::processSmallAllocatorLog): Deleted.
1820         (bmalloc::Allocator::processMediumAllocatorLog): Deleted.
1821         * bmalloc/Allocator.h:
1822         (bmalloc::Allocator::allocateFastCase): Removed abstractions and data
1823         used to post-process an allocator based on how many objects it allocated.
1824
1825         * bmalloc/BumpAllocator.h: Copied from Source/bmalloc/bmalloc/SmallAllocator.h.
1826         (bmalloc::BumpAllocator::BumpAllocator):
1827         (bmalloc::BumpAllocator::init):
1828         (bmalloc::BumpAllocator::line):
1829         (bmalloc::BumpAllocator::validate):
1830         (bmalloc::BumpAllocator::allocate):
1831         (bmalloc::BumpAllocator::refill):
1832         (bmalloc::BumpAllocator::clear): Updated these functions to be agnostic
1833         about the kinds of lines they allocate into. In some cases, the line
1834         type must be provided as a template parameter by the caller.
1835
1836         (bmalloc::SmallAllocator::SmallAllocator): Deleted.
1837         (bmalloc::SmallAllocator::line): Deleted.
1838         (bmalloc::SmallAllocator::allocate): Deleted.
1839         (bmalloc::SmallAllocator::objectCount): Deleted.
1840         (bmalloc::SmallAllocator::derefCount): Deleted.
1841         (bmalloc::SmallAllocator::refill): Deleted.
1842         (bmalloc::SmallAllocator::clear): Deleted.
1843
1844         * bmalloc/ObjectType.h:
1845         (bmalloc::isMedium):
1846
1847         * bmalloc/SmallAllocator.h:
1848         (bmalloc::SmallAllocator::isNull): Deleted.
1849         (bmalloc::SmallAllocator::canAllocate): Deleted.
1850         (bmalloc::SmallAllocator::SmallAllocator): Deleted.
1851         (bmalloc::SmallAllocator::line): Deleted.
1852         (bmalloc::SmallAllocator::allocate): Deleted.
1853         (bmalloc::SmallAllocator::objectCount): Deleted.
1854         (bmalloc::SmallAllocator::derefCount): Deleted.
1855         (bmalloc::SmallAllocator::refill): Deleted.
1856         (bmalloc::SmallAllocator::clear): Deleted.
1857
1858 2014-09-12  Geoffrey Garen  <ggaren@apple.com>
1859
1860         Fixed a goof in bmalloc Vector sizing
1861         https://bugs.webkit.org/show_bug.cgi?id=136795
1862
1863         Reviewed by Gavin Barraclough and Sam Weinig.
1864
1865         We want our minimum vector to be page-sized since the OS will give us
1866         a page no matter what -- but we want that many bytes, and not enough
1867         bytes to store that many elements.
1868
1869         * bmalloc/Vector.h: Math is hard.
1870
1871 2014-09-11  Geoffrey Garen  <ggaren@apple.com>
1872
1873         bmalloc should segregate medium-sized objects by line like it does for small-sized objects
1874         https://bugs.webkit.org/show_bug.cgi?id=136693
1875
1876         Reviewed by Gavin Barraclough.
1877
1878         4% reduction in heap size on the MallocBench *_memory_warning benchmarks.
1879
1880         No throughput change.
1881
1882         We keep an array of medium allocators, just like our array of small
1883         allocators.
1884
1885         In future, we can simplify the allocation fast path by merging the small
1886         and medium allocator arrays. For now, this is the simplest change that
1887         gets the win.
1888
1889         * bmalloc/Allocator.cpp:
1890         (bmalloc::Allocator::Allocator):
1891         (bmalloc::Allocator::scavenge):
1892         (bmalloc::Allocator::allocateMedium):
1893         * bmalloc/Allocator.h:
1894         * bmalloc/Sizes.h:
1895         (bmalloc::Sizes::mediumSizeClassFor):
1896
1897 2014-09-11  Geoffrey Garen  <ggaren@apple.com>
1898
1899         Reviewed by Sam Weinig.
1900
1901         Renamed log => retire for clarity.
1902
1903         * bmalloc/Allocator.cpp:
1904         (bmalloc::Allocator::scavenge):
1905         (bmalloc::Allocator::retire):
1906         (bmalloc::Allocator::allocateMedium):
1907         (bmalloc::Allocator::allocateSlowCase):
1908         (bmalloc::Allocator::log): Deleted.
1909         * bmalloc/Allocator.h:
1910
1911 2014-09-11  Geoffrey Garen  <ggaren@apple.com>
1912
1913         bmalloc: eager scavenge leaves behind a bogus allocator
1914         https://bugs.webkit.org/show_bug.cgi?id=136743
1915
1916         Reviewed by Sam Weinig.
1917
1918         Be sure to clear the allocator after logging it in the eager scavenge
1919         case, so that we don't later try to allocate out of the lines that we
1920         have thrown away.
1921
1922         We didn't need to do this previously because scavenge would only happen
1923         at thread exit time, after which no further allocation from the per-thread
1924         cache would take place.
1925
1926         * bmalloc/Allocator.cpp:
1927         (bmalloc::Allocator::scavenge):
1928         * bmalloc/MediumAllocator.h:
1929         (bmalloc::MediumAllocator::clear):
1930         * bmalloc/SmallAllocator.h:
1931         (bmalloc::SmallAllocator::clear):
1932
1933 2014-09-05  Geoffrey Garen  <ggaren@apple.com>
1934
1935         bmalloc should honor the FastMalloc statistics API
1936         https://bugs.webkit.org/show_bug.cgi?id=136592
1937
1938         Reviewed by Gavin Barraclough.
1939
1940         We do this by tracking "size" and "capacity" in the VM heap.
1941
1942         The VM heap's "capacity" is all the VM we ever allocated.
1943
1944         The VM heap's "size" the subset of VM currently held onto by the
1945         VM heap (and therefore not in use by the regular heap).
1946
1947         Somewhat ironically, reducing the process's memory footprint, increases
1948         the size of the VM heap, since the VM heap holds the pages that are
1949         purely virtual and not physical.
1950
1951         * bmalloc/Heap.cpp:
1952         (bmalloc::Heap::size):
1953         (bmalloc::Heap::capacity):
1954         * bmalloc/Heap.h:
1955         * bmalloc/VMHeap.cpp:
1956         (bmalloc::VMHeap::VMHeap):
1957         (bmalloc::VMHeap::allocateSmallChunk):
1958         (bmalloc::VMHeap::allocateMediumChunk):
1959         (bmalloc::VMHeap::allocateLargeChunk):
1960         * bmalloc/VMHeap.h:
1961         (bmalloc::VMHeap::size):
1962         (bmalloc::VMHeap::capacity):
1963         (bmalloc::VMHeap::allocateSmallPage):
1964         (bmalloc::VMHeap::allocateMediumPage):
1965         (bmalloc::VMHeap::allocateLargeRange):
1966         (bmalloc::VMHeap::deallocateSmallPage):
1967         (bmalloc::VMHeap::deallocateMediumPage):
1968         (bmalloc::VMHeap::deallocateLargeRange):
1969         * bmalloc/bmalloc.h:
1970         (bmalloc::api::heapSize):
1971         (bmalloc::api::heapCapacity):
1972
1973 2014-09-02  Geoffrey Garen  <ggaren@apple.com>
1974
1975         bmalloc crashes on the EWS bots (due to bad large object allocation)
1976         https://bugs.webkit.org/show_bug.cgi?id=136469
1977
1978         Reviewed by Andreas Kling.
1979
1980         It's possible to convince bmalloc to perform a bad large object allocation,
1981         through these steps:
1982
1983         (1) Insert object A into freelist F0.
1984
1985         (2) Split, merge and split again A's neighbors such that object B is
1986         inserted into freelist F0, with boundary tag and size equal to object A,
1987         but pointer not completely equal to object A. Put object B at the head of F0.
1988
1989         (3) Allocate some other object from F0, swapping its position in the
1990         freelist with object B, such that object A is now ahead of object B.
1991
1992         --> Now, the next allocation for size A/B will allocate object A, which
1993         has a slightly wrong idea about where the object actually begins.
1994         Immediately, you'll corrupt a little memory, and over time, you'll also
1995         corrupt boundary tag metadata.
1996
1997         The solution is to store the begin pointer in the boundary tag. Luckily,
1998         this doesn't make the tag any bigger, and it's not a noticeable slowdown
1999         on MallocBench.
2000
2001         * bmalloc/Algorithm.h:
2002         (bmalloc::rightShift):
2003         * bmalloc/BeginTag.h:
2004         (bmalloc::BeginTag::isInFreeList): This is the bug fix. Make sure to
2005         validate the start pointer when popping off the free list. Through a
2006         very uncommon set of steps, it is possible to have an item in the free
2007         list that is valid by all accounts except for its start pointer.
2008
2009         * bmalloc/BoundaryTag.h:
2010         (bmalloc::BoundaryTag::compactBegin):
2011         (bmalloc::BoundaryTag::setRange):
2012         (bmalloc::BoundaryTag::setSize): Deleted. Record a compact version of the
2013         start pointer. We don't need the whole pointer -- just the offset, in
2014         largeAlignment increments, into the relevant boundary tag bucket.
2015
2016         * bmalloc/BoundaryTagInlines.h:
2017         (bmalloc::validateNext):
2018         (bmalloc::BoundaryTag::init):
2019         (bmalloc::BoundaryTag::mergeLarge):
2020         (bmalloc::BoundaryTag::splitLarge):
2021         * bmalloc/SegregatedFreeList.cpp:
2022         (bmalloc::SegregatedFreeList::insert):
2023         (bmalloc::SegregatedFreeList::takeGreedy):
2024         (bmalloc::SegregatedFreeList::take): Provide the whole range instead of
2025         the size when establishing a boundary tag, as required by the new
2026         interface.
2027
2028         * bmalloc/Sizes.h:
2029
2030 2014-08-14  Geoffrey Garen  <ggaren@apple.com>
2031
2032         Fixed a bmalloc crash seen on the EWS bot
2033         https://bugs.webkit.org/show_bug.cgi?id=135955
2034
2035         Reviewed by Andreas Kling.
2036
2037         * bmalloc/Syscall.h: Some CG APIs vm_copy their input buffers. If the
2038         input buffer is a malloc region, that region will get marked Copy-On-Write
2039         by the kernel. Calls to madvise() for COW regions fail and return EINVAL
2040         on older OS X's. In 10.10, they still fail, but they do not return
2041         EINVAL.
2042
2043         So, we can only ASSERT that our syscalls succeed starting with 10.10.
2044
2045 2014-08-14  Geoffrey Garen  <ggaren@apple.com>
2046
2047         Fixed the bmalloc build
2048         https://bugs.webkit.org/show_bug.cgi?id=135953
2049
2050         Reviewed by Andreas Kling.
2051
2052         * bmalloc.xcodeproj/project.pbxproj: Marked a few headers as private.
2053         These headers are used, so they must be available outside the project.
2054
2055 2014-08-13  Daniel Bates  <dabates@apple.com>
2056
2057         Attempt to fix the build following <http://trac.webkit.org/changeset/172576>
2058         (https://bugs.webkit.org/show_bug.cgi?id=135895)
2059
2060         Substitute PerThreadStorage<T>::initSharedKeyIfNeeded() for initSharedKeyIfNeeded() in
2061         implementation of PerThread<T>::getFastCase().
2062
2063         * bmalloc/PerThread.h:
2064         (bmalloc::PerThread<T>::getFastCase):
2065
2066 2014-08-13  Daniel Bates  <dabates@apple.com>
2067
2068         Make bmalloc::PerThread work without C++ thread local storage
2069         https://bugs.webkit.org/show_bug.cgi?id=135895
2070
2071         Reviewed by Geoffrey Garen.
2072
2073         Implement support for building bmalloc without C++ thread local storage.
2074
2075         * bmalloc/BPlatform.h: Remove macro define BPLATFORM_IOS_SIMULATOR. Added macro function
2076         BCOMPILER_SUPPORTS() and macro define BCOMPILER_SUPPORTS_CXX_THREAD_LOCAL that can be used
2077         to determine whether the compiler supports C++ thread local storage.
2078         * bmalloc/PerThread.h:
2079         (bmalloc::PerThreadStorage::get): Modified to call pthread_getspecific() when building
2080         without C++ thread local storage.
2081         (bmalloc::PerThreadStorage::initSharedKeyIfNeeded): Added.
2082         (bmalloc::PerThreadStorage::init): Moved logic to initialize shared Pthread key from here to
2083         PerThreadStorage::initSharedKeyIfNeeded().
2084         (bmalloc::PerThread<T>::getFastCase): Modified to call PerThreadStorage::initSharedKeyIfNeeded()
2085         before querying PerThreadStorage::get() when building without C++ thread local storage so as to
2086         ensure that the shared key has been initialized.
2087         (_pthread_setspecific_direct): Deleted.
2088         (_pthread_getspecific_direct): Deleted.
2089
2090 2014-08-13  Daniel Bates  <dabates@apple.com>
2091
2092         [iOS] Make JavaScriptCore and bmalloc build with the public SDK
2093         https://bugs.webkit.org/show_bug.cgi?id=135848
2094
2095         Reviewed by Geoffrey Garen.
2096
2097         * bmalloc/BPlatform.h: Added macro BPLATFORM_IOS_SIMULATOR, which evaluates to true
2098         when building for the iOS Simulator.
2099         * bmalloc/PerThread.h: Use pthread_machdep.h code path when building for iOS Simulator
2100         using the public SDK.
2101         (_pthread_setspecific_direct): Added; only defined when building for the iOS Simulator
2102         using the public SDK.
2103         (_pthread_getspecific_direct): Added; only defined when building for the iOS Simulator
2104         using the public SDK.
2105
2106 2014-08-12  Daniel Bates  <dabates@apple.com>
2107
2108         BPLATFORM(IOS) always evaluates to false
2109         https://bugs.webkit.org/show_bug.cgi?id=135843
2110
2111         Reviewed by Geoffrey Garen.
2112
2113         Fix typo in definition of BPLATFORM() and include system header TargetConditionals.h
2114         (when building on an Apple platform) so that BPLATFORM(X) evaluates to true when
2115         building for platform X. In particular, so that BPLATFORM(IOS) evaluates to true when
2116         building for iOS.
2117
2118         As a side effect of this change, the change made in <http://trac.webkit.org/changeset/167289>
2119         will be honored and iOS will assume a VM page size of 16kB (again) instead of 4kB.
2120
2121         * bmalloc/BPlatform.h:
2122
2123 2014-08-11  Andy Estes  <aestes@apple.com>
2124
2125         [iOS] Get rid of iOS.xcconfig
2126         https://bugs.webkit.org/show_bug.cgi?id=135809
2127
2128         Reviewed by Joseph Pecoraro.
2129
2130         All iOS.xcconfig did was include AspenFamily.xcconfig, so there's no need for the indirection.
2131
2132         * Configurations/Base.xcconfig:
2133         * Configurations/iOS.xcconfig: Removed.
2134         * bmalloc.xcodeproj/project.pbxproj:
2135
2136 2014-05-01  Dan Bernstein  <mitz@apple.com>
2137
2138         Fixed production builds for the iOS Simulator.
2139         <rdar://problem/16792221>
2140
2141         * Configurations/bmalloc.xcconfig: Include INSTALL_PATH_PREFIX in
2142         PRIVATE_HEADERS_FOLDER_PATH when installing.
2143
2144 2014-04-20  Geoffrey Garen  <ggaren@apple.com>
2145
2146         bmalloc: Segregate pages by objects size
2147         https://bugs.webkit.org/show_bug.cgi?id=131909
2148
2149         Reviewed by Andreas Kling.
2150
2151         2% reduction in memory-at-end on the Membuster memory_warning benchmarks.
2152
2153         * bmalloc/Allocator.cpp:
2154         (bmalloc::Allocator::allocateSlowCase):
2155         * bmalloc/Allocator.h:
2156         (bmalloc::Allocator::allocateFastCase):
2157         (bmalloc::Allocator::smallAllocatorFor): Use the new shared helper
2158         function for size class calculation.
2159
2160         * bmalloc/Deallocator.cpp:
2161         (bmalloc::Deallocator::Deallocator):
2162         (bmalloc::Deallocator::scavenge):
2163         (bmalloc::Deallocator::deallocateSmallLine):
2164         (bmalloc::Deallocator::allocateSmallLine):
2165         * bmalloc/Deallocator.h: Keep a cache for every size class, since the
2166         cache can't be shared anymore.
2167
2168         * bmalloc/Heap.cpp:
2169         (bmalloc::Heap::allocateSmallLineSlowCase):
2170         * bmalloc/Heap.h:
2171         (bmalloc::Heap::deallocateSmallLine): Ditto.
2172
2173         (bmalloc::Heap::allocateSmallLine): Check size class in addition to
2174         page refcount when allocating a line because we might have deallocated
2175         the page and the recycled it for another size class.
2176
2177         (bmalloc::Heap::deallocateMediumLine):
2178         (bmalloc::Heap::allocateMediumLine):
2179         * bmalloc/Line.h:
2180         (bmalloc::Line::refCount):
2181         * bmalloc/Page.h:
2182         (bmalloc::Page::refCount):
2183         (bmalloc::Page::smallSizeClass):
2184         (bmalloc::Page::setSmallSizeClass):
2185         (bmalloc::Page<Traits>::refCount): Deleted.
2186         * bmalloc/Sizes.h:
2187         (bmalloc::Sizes::smallSizeClassFor): New shared API for computing
2188         an index into an array from a size.
2189
2190 2014-04-19  Geoffrey Garen  <ggaren@apple.com>
2191
2192         bmalloc: Improved alignment in LargeChunk
2193         https://bugs.webkit.org/show_bug.cgi?id=131895
2194
2195         Reviewed by Andreas Kling.
2196
2197         * bmalloc/Chunk.h:
2198         * bmalloc/LargeChunk.h: Align to vmPageSize just like Chunk does.
2199         Technically, the previous alignment was harmless, but I would prefer,
2200         dear reader, not to have to explain the interlocking set of
2201         circumstances that made it so.
2202
2203 2014-04-19  Geoffrey Garen  <ggaren@apple.com>
2204
2205         Rolled out r167502 because it caused a crash on the facebook benchmark.
2206
2207         Unreviewed.
2208
2209             bmalloc: Added an XSmall line size
2210             https://bugs.webkit.org/show_bug.cgi?id=131851
2211
2212             Reviewed by Sam Weinig.
2213
2214 2014-04-19  Geoffrey Garen  <ggaren@apple.com>
2215
2216         bmalloc: Mutex should be harder to use wrong
2217         https://bugs.webkit.org/show_bug.cgi?id=131879
2218
2219         Reviewed by Andreas Kling.
2220
2221         Mutex now has a proper constructor, so you can't deadlock by forgetting
2222         to initialize it.
2223
2224         * bmalloc.xcodeproj/project.pbxproj:
2225         * bmalloc/Allocator.cpp:
2226         (bmalloc::Allocator::processXSmallAllocatorLog):
2227         (bmalloc::Allocator::processSmallAllocatorLog):
2228         (bmalloc::Allocator::processMediumAllocatorLog):
2229         (bmalloc::Allocator::allocateLarge):
2230         (bmalloc::Allocator::allocateXLarge): Global replace Mutex => StaticMutex,
2231         since the Heap mutex is a static.
2232
2233         * bmalloc/AsyncTask.h:
2234         (bmalloc::Function>::AsyncTask): Use Mutex, since we're not static. No
2235         need for explicit initialization anymore.
2236
2237         * bmalloc/Deallocator.cpp:
2238         (bmalloc::Deallocator::scavenge):
2239         (bmalloc::Deallocator::deallocateLarge):
2240         (bmalloc::Deallocator::deallocateXLarge):
2241         (bmalloc::Deallocator::processObjectLog):
2242         (bmalloc::Deallocator::deallocateSmallLine):
2243         (bmalloc::Deallocator::deallocateXSmallLine):
2244         (bmalloc::Deallocator::allocateSmallLine):
2245         (bmalloc::Deallocator::allocateXSmallLine):
2246         (bmalloc::Deallocator::deallocateMediumLine):
2247         (bmalloc::Deallocator::allocateMediumLine):
2248         * bmalloc/Deallocator.h:
2249         * bmalloc/Heap.cpp:
2250         (bmalloc::sleep):
2251         (bmalloc::Heap::Heap):
2252         (bmalloc::Heap::concurrentScavenge):
2253         (bmalloc::Heap::scavenge):
2254         (bmalloc::Heap::scavengeSmallPages):
2255         (bmalloc::Heap::scavengeXSmallPages):
2256         (bmalloc::Heap::scavengeMediumPages):
2257         (bmalloc::Heap::scavengeLargeRanges):
2258         (bmalloc::Heap::allocateXSmallLineSlowCase):
2259         (bmalloc::Heap::allocateSmallLineSlowCase):
2260         (bmalloc::Heap::allocateMediumLineSlowCase):
2261         (bmalloc::Heap::allocateXLarge):
2262         (bmalloc::Heap::deallocateXLarge):
2263         (bmalloc::Heap::allocateLarge):
2264         (bmalloc::Heap::deallocateLarge):
2265         * bmalloc/Heap.h:
2266         (bmalloc::Heap::deallocateXSmallLine):
2267         (bmalloc::Heap::allocateXSmallLine):
2268         (bmalloc::Heap::deallocateSmallLine):
2269         (bmalloc::Heap::allocateSmallLine):
2270         (bmalloc::Heap::deallocateMediumLine):
2271         (bmalloc::Heap::allocateMediumLine):
2272         * bmalloc/Line.h:
2273         (bmalloc::Line<Traits>::deref):
2274         * bmalloc/Mutex.cpp: Removed.
2275         * bmalloc/Mutex.h:
2276         (bmalloc::Mutex::Mutex):
2277         (bmalloc::Mutex::init): Deleted.
2278         (bmalloc::Mutex::try_lock): Deleted.
2279         (bmalloc::Mutex::lock): Deleted.
2280         (bmalloc::Mutex::unlock): Deleted.
2281         * bmalloc/Page.h:
2282         (bmalloc::Page<Traits>::ref):
2283         (bmalloc::Page<Traits>::deref):
2284         (bmalloc::Page<Traits>::refCount):
2285         * bmalloc/PerProcess.h:
2286         (bmalloc::PerProcess::mutex):
2287         (bmalloc::PerProcess<T>::getSlowCase):
2288         * bmalloc/StaticMutex.cpp: Added.
2289         (bmalloc::StaticMutex::lockSlowCase):
2290         * bmalloc/StaticMutex.h: Added.
2291         (bmalloc::StaticMutex::init):
2292         (bmalloc::StaticMutex::try_lock):
2293         (bmalloc::StaticMutex::lock):
2294         (bmalloc::StaticMutex::unlock):
2295         * bmalloc/VMHeap.h:
2296         (bmalloc::VMHeap::deallocateXSmallPage):
2297         (bmalloc::VMHeap::deallocateSmallPage):
2298         (bmalloc::VMHeap::deallocateMediumPage):
2299         (bmalloc::VMHeap::deallocateLargeRange):
2300         * bmalloc/bmalloc.h:
2301         (bmalloc::api::scavenge): Global replace Mutex => StaticMutex,
2302         since the Heap mutex is a static.
2303
2304 2014-04-18  Geoffrey Garen  <ggaren@apple.com>
2305
2306         bmalloc: AsyncTask should use Mutex instead of std::mutex
2307         https://bugs.webkit.org/show_bug.cgi?id=131865
2308
2309         Reviewed by Gavin Barraclough.
2310
2311         std::mutex is so slow that it makes parallelizing simple tasks through
2312         AsyncTask a net regression. Mutex fixes this.
2313
2314         * bmalloc/AsyncTask.h:
2315         (bmalloc::Function>::AsyncTask):
2316         (bmalloc::Function>::join):
2317         (bmalloc::Function>::runSlowCase):
2318         (bmalloc::Function>::entryPoint):
2319         * bmalloc/Mutex.h:
2320         (bmalloc::Mutex::init):
2321
2322 2014-04-18  Geoffrey Garen  <ggaren@apple.com>
2323
2324         bmalloc: Added an XSmall line size
2325         https://bugs.webkit.org/show_bug.cgi?id=131851
2326
2327         Reviewed by Sam Weinig.
2328
2329         Reduces malloc footprint on Membuster recordings by 10%.
2330
2331         This is a throughput regression, but we're still way ahead of TCMalloc.
2332         I have some ideas for how to recover the regression -- but I wanted to
2333         get this win in first.
2334
2335         Full set of benchmark results:
2336
2337                 bmalloc> ~/webkit/PerformanceTests/MallocBench/run-malloc-benchmarks --measure-heap nopatch:~/scratch/Build-nopatch/Release/ patch:~/webkit/WebKitBuild/Release/
2338                                                                                                 
2339                                                                nopatch                      patch                                Δ
2340                 Peak Memory:
2341                     reddit_memory_warning                      7,896kB                    7,532kB                  ^ 1.05x smaller
2342                     flickr_memory_warning                     12,968kB                   12,324kB                  ^ 1.05x smaller
2343                     theverge_memory_warning                   16,672kB                   15,200kB                   ^ 1.1x smaller
2344
2345                     <geometric mean>                          11,952kB                   11,216kB                  ^ 1.07x smaller
2346                     <arithmetic mean>                         12,512kB                   11,685kB                  ^ 1.07x smaller
2347                     <harmonic mean>                           11,375kB                   10,726kB                  ^ 1.06x smaller
2348
2349                 Memory at End:
2350                     reddit_memory_warning                      7,320kB                    6,856kB                  ^ 1.07x smaller
2351                     flickr_memory_warning                     10,848kB                    9,692kB                  ^ 1.12x smaller
2352                     theverge_memory_warning                   16,380kB                   14,872kB                   ^ 1.1x smaller
2353
2354                     <geometric mean>                          10,916kB                    9,961kB                   ^ 1.1x smaller
2355                     <arithmetic mean>                         11,516kB                   10,473kB                   ^ 1.1x smaller
2356                     <harmonic mean>                           10,350kB                    9,485kB                  ^ 1.09x smaller
2357
2358                 MallocBench> ~/webkit/PerformanceTests/MallocBench/run-malloc-benchmarks nopatch:~/scratch/Build-nopatch/Release/ patch:~/webkit/WebKitBuild/Release/
2359                                                                                                 
2360                                                    nopatch                patch                         Δ
2361                 Execution Time:
2362                     churn                            127ms                151ms            ! 1.19x slower
2363                     list_allocate                    130ms                164ms            ! 1.26x slower
2364                     tree_allocate                    109ms                127ms            ! 1.17x slower
2365                     tree_churn                       115ms                120ms            ! 1.04x slower
2366                     facebook                         240ms                259ms            ! 1.08x slower
2367                     fragment                          91ms                131ms            ! 1.44x slower
2368                     fragment_iterate                 105ms                106ms            ! 1.01x slower
2369                     message_one                      260ms                259ms             ^ 1.0x faster
2370                     message_many                     149ms                154ms            ! 1.03x slower
2371                     medium                           194ms                248ms            ! 1.28x slower
2372                     big                              157ms                160ms            ! 1.02x slower
2373
2374                     <geometric mean>                 144ms                163ms            ! 1.13x slower
2375                     <arithmetic mean>                152ms                171ms            ! 1.12x slower
2376                     <harmonic mean>                  137ms                156ms            ! 1.14x slower
2377
2378                 MallocBench> ~/webkit/PerformanceTests/MallocBench/run-malloc-benchmarks nopatch:~/scratch/Build-nopatch/Release/ patch:~/webkit/WebKitBuild/Release/
2379                                                                                                 
2380                                                                        nopatch                          patch                                     Δ
2381                 Execution Time:
2382                     churn                                                126ms                          148ms                        ! 1.17x slower
2383                     churn --parallel                                      62ms                           76ms                        ! 1.23x slower
2384                     list_allocate                                        130ms                          164ms                        ! 1.26x slower
2385                     list_allocate --parallel                             120ms                          175ms                        ! 1.46x slower
2386                     tree_allocate                                        111ms                          127ms                        ! 1.14x slower
2387                     tree_allocate --parallel                              95ms                          135ms                        ! 1.42x slower
2388                     tree_churn                                           115ms                          124ms                        ! 1.08x slower
2389                     tree_churn --parallel                                107ms                          126ms                        ! 1.18x slower
2390                     facebook                                             240ms                          276ms                        ! 1.15x slower
2391                     facebook --parallel                                  802ms                        1,088ms                        ! 1.36x slower
2392                     fragment                                              92ms                          130ms                        ! 1.41x slower
2393                     fragment --parallel                                   66ms                          124ms                        ! 1.88x slower
2394                     fragment_iterate                                     109ms                          127ms                        ! 1.17x slower
2395                     fragment_iterate --parallel                           55ms                           64ms                        ! 1.16x slower
2396                     message_one                                          260ms                          260ms                                      
2397                     message_many                                         170ms                          238ms                         ! 1.4x slower
2398                     medium                                               185ms                          250ms                        ! 1.35x slower
2399                     medium --parallel                                    210ms                          334ms                        ! 1.59x slower
2400                     big                                                  150ms                          169ms                        ! 1.13x slower
2401                     big --parallel                                       138ms                          144ms                        ! 1.04x slower
2402
2403                     <geometric mean>                                     135ms                          170ms                        ! 1.26x slower
2404                     <arithmetic mean>                                    167ms                          214ms                        ! 1.28x slower
2405                     <harmonic mean>                                      117ms                          148ms                        ! 1.26x slower
2406
2407                 MallocBench> ~/webkit/PerformanceTests/MallocBench/run-malloc-benchmarks TC:~/scratch/Build-TCMalloc/Release/ patch:~/webkit/WebKitBuild/Release/
2408
2409                                                                     TC                      patch                                Δ
2410                 Peak Memory:
2411                     reddit_memory_warning                     13,836kB                   13,436kB                  ^ 1.03x smaller
2412                     flickr_memory_warning                     24,868kB                   25,188kB                   ! 1.01x bigger
2413                     theverge_memory_warning                   24,504kB                   26,636kB                   ! 1.09x bigger
2414
2415                     <geometric mean>                          20,353kB                   20,812kB                   ! 1.02x bigger
2416                     <arithmetic mean>                         21,069kB                   21,753kB                   ! 1.03x bigger
2417                     <harmonic mean>                           19,570kB                   19,780kB                   ! 1.01x bigger
2418
2419                 Memory at End:
2420                     reddit_memory_warning                      8,656kB                   10,016kB                   ! 1.16x bigger
2421                     flickr_memory_warning                     11,844kB                   13,784kB                   ! 1.16x bigger
2422                     theverge_memory_warning                   18,516kB                   22,748kB                   ! 1.23x bigger
2423
2424                     <geometric mean>                          12,382kB                   14,644kB                   ! 1.18x bigger
2425                     <arithmetic mean>                         13,005kB                   15,516kB                   ! 1.19x bigger
2426                     <harmonic mean>                           11,813kB                   13,867kB                   ! 1.17x bigger
2427
2428                 MallocBench> ~/webkit/PerformanceTests/MallocBench/run-malloc-benchmarks TC:~/scratch/Build-TCMalloc/Release/ patch:~/webkit/WebKitBuild/Release/
2429                                                                                                 
2430                                                         TC                patch                         Δ
2431                 Execution Time:
2432                     churn                            416ms                148ms            ^ 2.81x faster
2433                     list_allocate                    463ms                164ms            ^ 2.82x faster
2434                     tree_allocate                    292ms                127ms             ^ 2.3x faster
2435                     tree_churn                       157ms                120ms            ^ 1.31x faster
2436                     facebook                         327ms                276ms            ^ 1.18x faster
2437                     fragment                         335ms                129ms             ^ 2.6x faster
2438                     fragment_iterate                 344ms                108ms            ^ 3.19x faster
2439                     message_one                      386ms                258ms             ^ 1.5x faster
2440                     message_many                     410ms                154ms            ^ 2.66x faster
2441                     medium                           391ms                245ms             ^ 1.6x faster
2442                     big                              261ms                167ms            ^ 1.56x faster
2443
2444                     <geometric mean>                 332ms                164ms            ^ 2.02x faster
2445                     <arithmetic mean>                344ms                172ms            ^ 1.99x faster
2446                     <harmonic mean>                  317ms                157ms            ^ 2.02x faster
2447
2448         * bmalloc.xcodeproj/project.pbxproj:
2449         * bmalloc/Allocator.cpp:
2450         (bmalloc::Allocator::Allocator): Don't assume that each allocator's
2451         index corresponds with its size. Instead, use the size selection function
2452         explicitly. Now that we have XSmall, some small allocator entries are
2453         unused.
2454
2455         (bmalloc::Allocator::scavenge):
2456         (bmalloc::Allocator::log):
2457         (bmalloc::Allocator::processXSmallAllocatorLog):
2458         (bmalloc::Allocator::allocateSlowCase):
2459         * bmalloc/Allocator.h:
2460         (bmalloc::Allocator::xSmallAllocatorFor):
2461         (bmalloc::Allocator::allocateFastCase):
2462         * bmalloc/Chunk.h:
2463         * bmalloc/Deallocator.cpp:
2464         (bmalloc::Deallocator::scavenge):
2465         (bmalloc::Deallocator::processObjectLog):
2466         (bmalloc::Deallocator::deallocateSlowCase):
2467         (bmalloc::Deallocator::deallocateXSmallLine):
2468         (bmalloc::Deallocator::allocateXSmallLine):
2469         * bmalloc/Deallocator.h:
2470         (bmalloc::Deallocator::deallocateFastCase):
2471         * bmalloc/Heap.cpp:
2472         (bmalloc::Heap::scavenge):
2473         (bmalloc::Heap::scavengeXSmallPages):
2474         (bmalloc::Heap::allocateXSmallLineSlowCase):
2475         * bmalloc/Heap.h:
2476         (bmalloc::Heap::deallocateXSmallLine):
2477         (bmalloc::Heap::allocateXSmallLine):
2478         * bmalloc/LargeChunk.h:
2479         (bmalloc::LargeChunk::get):
2480         (bmalloc::LargeChunk::endTag):
2481         * bmalloc/Line.h:
2482         * bmalloc/MediumAllocator.h:
2483         (bmalloc::MediumAllocator::allocate):
2484         (bmalloc::MediumAllocator::refill):
2485         * bmalloc/ObjectType.cpp:
2486         (bmalloc::objectType):
2487         * bmalloc/ObjectType.h:
2488         (bmalloc::isXSmall):
2489         (bmalloc::isSmall):
2490         (bmalloc::isMedium):
2491         (bmalloc::isLarge):
2492         (bmalloc::isSmallOrMedium): Deleted.
2493         * bmalloc/SegregatedFreeList.h: I boiler-plate copied existing code for
2494         handling small objects. There's probably a reasonable way to share this
2495         code in the future -- I'll look into that once it's stopped changing.
2496
2497         * bmalloc/Sizes.h: Tweaked size classes to make Membuster happy. This
2498         is the main reason things got slower.
2499
2500         * bmalloc/SmallAllocator.h:
2501         (bmalloc::SmallAllocator::allocate):
2502         * bmalloc/SmallTraits.h:
2503         * bmalloc/VMHeap.cpp:
2504         (bmalloc::VMHeap::allocateXSmallChunk):
2505         * bmalloc/VMHeap.h:
2506         (bmalloc::VMHeap::allocateXSmallPage):
2507         (bmalloc::VMHeap::deallocateXSmallPage):
2508         * bmalloc/XSmallAllocator.h: Added.
2509         (bmalloc::XSmallAllocator::isNull):
2510         (bmalloc::XSmallAllocator::canAllocate):
2511         (bmalloc::XSmallAllocator::XSmallAllocator):
2512         (bmalloc::XSmallAllocator::line):
2513         (bmalloc::XSmallAllocator::allocate):
2514         (bmalloc::XSmallAllocator::objectCount):
2515         (bmalloc::XSmallAllocator::derefCount):
2516         (bmalloc::XSmallAllocator::refill):
2517         * bmalloc/XSmallChunk.h: Added.
2518         * bmalloc/XSmallLine.h: Added.
2519         * bmalloc/XSmallPage.h: Added.
2520         * bmalloc/XSmallTraits.h: Added.
2521         * bmalloc/bmalloc.h:
2522         (bmalloc::api::realloc): Boiler-plate copy, as above.
2523
2524 2014-04-14  Geoffrey Garen  <ggaren@apple.com>
2525
2526         MallocBench should scavenge explicitly instead of waiting
2527         https://bugs.webkit.org/show_bug.cgi?id=131661
2528
2529         Reviewed by Andreas Kling.
2530
2531         Added explicit scavenge support to bmalloc. This isn't a memory win,
2532         since bmalloc's per-thread cache is so small. But it makes testing
2533         simpler.
2534
2535         * bmalloc/Allocator.cpp:
2536         (bmalloc::Allocator::~Allocator):
2537         (bmalloc::Allocator::scavenge):
2538         * bmalloc/Allocator.h:
2539         * bmalloc/Cache.cpp:
2540         (bmalloc::Cache::operator new):
2541         (bmalloc::Cache::operator delete):
2542         (bmalloc::Cache::Cache):
2543         (bmalloc::Cache::scavenge):
2544         * bmalloc/Cache.h:
2545         * bmalloc/Deallocator.cpp:
2546         (bmalloc::Deallocator::~Deallocator):
2547         (bmalloc::Deallocator::scavenge):
2548         * bmalloc/Deallocator.h: Factored existing scavenging code into helper
2549         functions, for reuse.
2550
2551         * bmalloc/Heap.cpp:
2552         (bmalloc::sleep):
2553         (bmalloc::Heap::concurrentScavenge):
2554         (bmalloc::Heap::scavenge):
2555         (bmalloc::Heap::scavengeSmallPages):
2556         (bmalloc::Heap::scavengeMediumPages):
2557         (bmalloc::Heap::scavengeLargeRanges):
2558         * bmalloc/Heap.h: Made scavenge sleep duration a parameter. Forced
2559         scavenging -- in response to a benchmark or a low memory warning --
2560         wants to complete as soon as possible, so its sleep duration is 0.
2561
2562         * bmalloc/bmalloc.h:
2563         (bmalloc::api::scavenge):
2564         * bmalloc/mbmalloc.cpp: Exported the scavenge API for MallocBench's use.
2565
2566 2014-04-14  Geoffrey Garen  <ggaren@apple.com>
2567
2568         Use 4kB pages on Mac
2569         https://bugs.webkit.org/show_bug.cgi?id=131658
2570
2571         Reviewed by Sam Weinig.
2572
2573         This reduces memory use a lot on Membuster:
2574
2575                                                                   base                      patch                                Δ
2576                 Execution Time:
2577                     reddit_memory_warning                         18ms                       17ms                   ^ 1.06x faster
2578                     flickr_memory_warning                         34ms                       36ms                   ! 1.06x slower
2579                     theverge_memory_warning                       39ms                       41ms                   ! 1.05x slower
2580
2581                     <geometric mean>                              29ms                       29ms                   ! 1.02x slower
2582                     <arithmetic mean>                             30ms                       31ms                   ! 1.03x slower
2583                     <harmonic mean>                               27ms                       27ms                    ^ 1.0x faster
2584
2585                 Peak Memory:
2586                     reddit_memory_warning                     16,412kB                   16,436kB                    ! 1.0x bigger
2587                     flickr_memory_warning                     30,120kB                   30,184kB                    ! 1.0x bigger
2588                     theverge_memory_warning                   33,408kB                   33,420kB                    ! 1.0x bigger
2589
2590                     <geometric mean>                          25,466kB                   25,499kB                    ! 1.0x bigger
2591                     <arithmetic mean>                         26,647kB                   26,680kB                    ! 1.0x bigger
2592                     <harmonic mean>                           24,181kB                   24,214kB                    ! 1.0x bigger
2593
2594                 Memory at End:
2595                     reddit_memory_warning                      2,404kB                    1,920kB                  ^ 1.25x smaller
2596                     flickr_memory_warning                      3,764kB                    3,072kB                  ^ 1.23x smaller
2597                     theverge_memory_warning                    3,648kB                    3,132kB                  ^ 1.16x smaller
2598
2599                     <geometric mean>                           3,208kB                    2,644kB                  ^ 1.21x smaller
2600                     <arithmetic mean>                          3,272kB                    2,708kB                  ^ 1.21x smaller
2601                     <harmonic mean>                            3,139kB                    2,574kB                  ^ 1.22x smaller
2602
2603
2604         * bmalloc.xcodeproj/project.pbxproj:
2605         * bmalloc/BPlatform.h: Added.
2606         * bmalloc/VMAllocate.h: Only use 16kB pages on iOS because the page size
2607         is 4kB on Mac.
2608
2609 2014-04-14  Alexey Proskuryakov  <ap@apple.com>
2610
2611         Fixed svn:ignore on bmalloc.xcodeproj, it had erroneous leading spaces.
2612
2613         * bmalloc.xcodeproj: Modified property svn:ignore.
2614
2615 2014-04-13  Geoffrey Garen  <ggaren@apple.com>
2616
2617         Fixed some mbmalloc exports
2618         https://bugs.webkit.org/show_bug.cgi?id=131599
2619
2620         Reviewed by Ryosuke Niwa.
2621
2622         * bmalloc.xcodeproj/project.pbxproj: Made some headers a private part
2623         of the project, so we can call them from API.
2624
2625         * bmalloc/mbmalloc.cpp: Marked the mbmalloc functions with default
2626         visibility, so they show up as exported in the .dylib.
2627
2628 2014-04-09  Geoffrey Garen  <ggaren@apple.com>
2629
2630         Put bmalloc headers in the right place
2631         https://bugs.webkit.org/show_bug.cgi?id=131464
2632
2633         Reviewed by Mark Rowe.
2634
2635         * Configurations/bmalloc.xcconfig: Set PRIVATE_HEADERS_FOLDER_PATH to
2636         specify that we don't just want to dump all of our generically-named
2637         headers into /usr/local/include.
2638
2639 2014-04-08  Geoffrey Garen  <ggaren@apple.com>
2640
2641         Made bmalloc more #include friendly
2642         https://bugs.webkit.org/show_bug.cgi?id=131386
2643
2644         Reviewed by Andreas Kling.
2645
2646         Marked a bunch of headers private so they can be used from client code
2647         that #includes bmalloc.h.
2648
2649         Renamed ASSERT macros to BASSERT. This matches their header, which already
2650         had to be renamed, and fixes conflicts with WTF's ASSERT macros.
2651
2652         * bmalloc.xcodeproj/project.pbxproj:
2653         * bmalloc/Allocator.cpp:
2654         (bmalloc::Allocator::allocateSlowCase):
2655         * bmalloc/AsyncTask.h:
2656         (bmalloc::Function>::runSlowCase):
2657         * bmalloc/BAssert.h:
2658         * bmalloc/BoundaryTag.h:
2659         (bmalloc::BoundaryTag::setSize):
2660         * bmalloc/BoundaryTagInlines.h:
2661         (bmalloc::validate):
2662         (bmalloc::BoundaryTag::init):
2663         (bmalloc::BoundaryTag::deallocate):
2664         (bmalloc::BoundaryTag::splitLarge):
2665         (bmalloc::BoundaryTag::allocate):
2666         * bmalloc/Chunk.h:
2667         * bmalloc/Deallocator.cpp:
2668         (bmalloc::Deallocator::processObjectLog):
2669         (bmalloc::Deallocator::deallocateSlowCase):
2670         * bmalloc/Deallocator.h:
2671         (bmalloc::Deallocator::deallocateFastCase):
2672         * bmalloc/FixedVector.h:
2673         (bmalloc::Capacity>::operator):
2674         (bmalloc::Capacity>::push):
2675         (bmalloc::Capacity>::pop):
2676         (bmalloc::Capacity>::shrink):
2677         * bmalloc/Heap.cpp:
2678         (bmalloc::Heap::allocateLarge):
2679         * bmalloc/LargeChunk.h:
2680         (bmalloc::LargeChunk::get):
2681         (bmalloc::LargeChunk::endTag):
2682         * bmalloc/Line.h:
2683         (bmalloc::Line<Traits>::concurrentRef):
2684         (bmalloc::Line<Traits>::deref):
2685         * bmalloc/MediumAllocator.h:
2686         (bmalloc::MediumAllocator::allocate):
2687         * bmalloc/ObjectType.h:
2688         (bmalloc::isSmall):
2689         * bmalloc/Page.h:
2690         (bmalloc::Page<Traits>::ref):
2691         (bmalloc::Page<Traits>::deref):
2692         * bmalloc/PerThread.h:
2693         (bmalloc::PerThread<T>::getSlowCase):
2694         * bmalloc/SegregatedFreeList.cpp:
2695         (bmalloc::SegregatedFreeList::SegregatedFreeList):
2696         (bmalloc::SegregatedFreeList::insert):
2697         * bmalloc/SmallAllocator.h:
2698         (bmalloc::SmallAllocator::allocate):
2699         (bmalloc::SmallAllocator::refill):
2700         * bmalloc/Syscall.h:
2701         * bmalloc/VMAllocate.h:
2702         (bmalloc::vmValidate):
2703         (bmalloc::vmAllocate):
2704         (bmalloc::vmDeallocatePhysicalPagesSloppy):
2705         * bmalloc/Vector.h:
2706         (bmalloc::Vector<T>::operator):
2707         (bmalloc::Vector<T>::pop):
2708         (bmalloc::Vector<T>::shrink):
2709         * bmalloc/XLargeChunk.h:
2710         (bmalloc::XLargeChunk::range):
2711         (bmalloc::XLargeChunk::size):
2712
2713 2014-04-08  Geoffrey Garen  <ggaren@apple.com>
2714
2715         Removed an unused file.
2716
2717         Unreviewed.
2718
2719         * bmalloc/AsyncTask.cpp: Removed.
2720
2721 2014-04-07  Geoffrey Garen  <ggaren@apple.com>
2722
2723         Build bmalloc on Mac
2724         https://bugs.webkit.org/show_bug.cgi?id=131333
2725
2726         Reviewed by Mark Rowe.
2727
2728         * Makefile: Added. For make clients.
2729
2730         These files are required for building any project in WebKit. I copied
2731         them from WTF:
2732         * Configurations: Added.
2733         * Configurations/Base.xcconfig: Added.
2734         * Configurations/DebugRelease.xcconfig: Added.
2735         * Configurations/bmalloc.xcconfig: Added.
2736         * Configurations/iOS.xcconfig: Added.
2737         * Configurations/mbmalloc.xcconfig: Added.
2738
2739         * bmalloc.xcodeproj/project.pbxproj: I removed per-project-file stuff
2740         from here because everything is in .xcconfig files now.
2741
2742         I had to fix a bunch of minor warnings, since they're enabled in our
2743         .xcconfig files:
2744
2745         * bmalloc/AsyncTask.h:
2746         (bmalloc::Function>::AsyncTask):
2747         * bmalloc/BAssert.h:
2748         * bmalloc/BoundaryTagInlines.h:
2749         (bmalloc::validate):
2750         * bmalloc/Heap.cpp:
2751         (bmalloc::Heap::Heap):
2752         (bmalloc::Heap::allocateLarge):
2753         (bmalloc::Heap::deallocateLarge):
2754         * bmalloc/Mutex.h:
2755         (bmalloc::Mutex::Mutex): Deleted.
2756         * bmalloc/VMAllocate.h:
2757         (bmalloc::vmValidate):
2758         * bmalloc/mbmalloc.cpp:
2759
2760 2014-04-07  Geoffrey Garen  <ggaren@apple.com>
2761
2762         bmalloc: Fixed a leak in the per-thread cache
2763         https://bugs.webkit.org/show_bug.cgi?id=131330
2764
2765         Reviewed by Andreas Kling.
2766
2767         Remember to deallocate our line caches upon thread exit.
2768
2769         * bmalloc/Deallocator.cpp:
2770         (bmalloc::Deallocator::~Deallocator):
2771
2772 2014-04-07  Geoffrey Garen  <ggaren@apple.com>
2773
2774         bmalloc: rolled out the tryLock experiment
2775         https://bugs.webkit.org/show_bug.cgi?id=131328
2776
2777         Reviewed by Andreas Kling.
2778
2779         It wasn't a speedup.
2780
2781         * bmalloc.xcodeproj/project.pbxproj:
2782         * bmalloc/Allocator.cpp:
2783         (bmalloc::Allocator::processSmallAllocatorLog):
2784         (bmalloc::Allocator::processMediumAllocatorLog):
2785         * bmalloc/Deallocator.cpp:
2786         (bmalloc::Deallocator::processObjectLog):
2787         (bmalloc::Deallocator::deallocateSlowCase):
2788         (bmalloc::Deallocator::deallocateSmallLine):
2789         (bmalloc::Deallocator::deallocateMediumLine):
2790         * bmalloc/Deallocator.h:
2791         (bmalloc::Deallocator::deallocateFastCase):
2792         * bmalloc/Heap.h:
2793         (bmalloc::Heap::deallocateSmallLine):
2794         (bmalloc::Heap::deallocateMediumLine):
2795         * bmalloc/Line.h:
2796         (bmalloc::Line<Traits>::deref):
2797         * bmalloc/Page.h:
2798         (bmalloc::Page<Traits>::deref):
2799
2800 2014-04-07  Geoffrey Garen  <ggaren@apple.com>
2801
2802         bmalloc
2803         https://bugs.webkit.org/show_bug.cgi?id=131170
2804
2805         Reviewed by Andreas Kling.
2806
2807         Initial commit.
2808
2809         * bmalloc: Added.
2810         * bmalloc.xcodeproj: Added.
2811         * bmalloc.xcodeproj/project.pbxproj: Added.
2812         * bmalloc/Algorithm.h: Added.
2813         (bmalloc::max):
2814         (bmalloc::min):
2815         (bmalloc::mask):
2816         (bmalloc::test):
2817         (bmalloc::roundUpToMultipleOf):
2818         (bmalloc::roundDownToMultipleOf):
2819         (bmalloc::sizeOf):
2820         (bmalloc::bitCount):
2821         (bmalloc::isPowerOfTwo):
2822         * bmalloc/Allocator.cpp: Added.
2823         (bmalloc::Allocator::Allocator):
2824         (bmalloc::Allocator::~Allocator):
2825         (bmalloc::Allocator::log):
2826         (bmalloc::Allocator::processSmallAllocatorLog):
2827         (bmalloc::Allocator::processMediumAllocatorLog):
2828         (bmalloc::Allocator::allocateLarge):
2829         (bmalloc::Allocator::allocateXLarge):
2830         (bmalloc::Allocator::allocateMedium):
2831         (bmalloc::Allocator::allocateSlowCase):
2832         * bmalloc/Allocator.h: Added.
2833         (bmalloc::Allocator::smallAllocatorFor):
2834         (bmalloc::Allocator::allocateFastCase):
2835         (bmalloc::Allocator::allocate):
2836         * bmalloc/AsyncTask.cpp: Added.
2837         (bmalloc::AsyncTask<Function>::runSlowCase):
2838         (bmalloc::AsyncTask<Function>::pthreadEntryPoint):
2839         (bmalloc::AsyncTask<Function>::entryPoint):
2840         * bmalloc/AsyncTask.h: Added.
2841         (bmalloc::Function>::AsyncTask):
2842         (bmalloc::Function>::join):
2843         (bmalloc::Function>::run):
2844         (bmalloc::Function>::runSlowCase):
2845         (bmalloc::Function>::pthreadEntryPoint):
2846         (bmalloc::Function>::entryPoint):
2847         * bmalloc/BAssert.h: Added.
2848         * bmalloc/BeginTag.h: Added.
2849         (bmalloc::BeginTag::isInFreeList):
2850         * bmalloc/BoundaryTag.h: Added.
2851         (bmalloc::BoundaryTag::isXLarge):
2852         (bmalloc::BoundaryTag::setXLarge):
2853         (bmalloc::BoundaryTag::isFree):
2854         (bmalloc::BoundaryTag::setFree):
2855         (bmalloc::BoundaryTag::isEnd):
2856         (bmalloc::BoundaryTag::setEnd):
2857         (bmalloc::BoundaryTag::hasPhysicalPages):
2858         (bmalloc::BoundaryTag::setHasPhysicalPages):
2859         (bmalloc::BoundaryTag::isNull):
2860         (bmalloc::BoundaryTag::clear):
2861         (bmalloc::BoundaryTag::size):
2862         (bmalloc::BoundaryTag::setSize):
2863         (bmalloc::BoundaryTag::prev):
2864         (bmalloc::BoundaryTag::next):
2865         * bmalloc/BoundaryTagInlines.h: Added.
2866         (bmalloc::validate):
2867         (bmalloc::validatePrev):
2868         (bmalloc::validateNext):
2869         (bmalloc::BoundaryTag::init):
2870         (bmalloc::BoundaryTag::mergeLargeLeft):
2871         (bmalloc::BoundaryTag::mergeLargeRight):
2872         (bmalloc::BoundaryTag::mergeLarge):
2873         (bmalloc::BoundaryTag::deallocate):
2874         (bmalloc::BoundaryTag::splitLarge):
2875         (bmalloc::BoundaryTag::allocate):
2876         * bmalloc/Cache.cpp: Added.
2877         (bmalloc::Cache::operator new):
2878         (bmalloc::Cache::operator delete):
2879         (bmalloc::Cache::Cache):
2880         (bmalloc::Cache::allocateSlowCase):
2881         (bmalloc::Cache::allocateSlowCaseNullCache):
2882         (bmalloc::Cache::deallocateSlowCase):
2883         (bmalloc::Cache::deallocateSlowCaseNullCache):
2884         * bmalloc/Cache.h: Added.
2885         (bmalloc::Cache::allocator):
2886         (bmalloc::Cache::deallocator):
2887         (bmalloc::Cache::allocateFastCase):
2888         (bmalloc::Cache::deallocateFastCase):
2889         (bmalloc::Cache::allocate):
2890         (bmalloc::Cache::deallocate):
2891         * bmalloc/Chunk.h: Added.
2892         (bmalloc::Chunk::begin):
2893         (bmalloc::Chunk::end):
2894         (bmalloc::Chunk::lines):
2895         (bmalloc::Chunk::pages):
2896         * bmalloc/Deallocator.cpp: Added.
2897         (bmalloc::Deallocator::Deallocator):
2898         (bmalloc::Deallocator::~Deallocator):
2899         (bmalloc::Deallocator::deallocateLarge):
2900         (bmalloc::Deallocator::deallocateXLarge):
2901         (bmalloc::Deallocator::processObjectLog):
2902         (bmalloc::Deallocator::deallocateSlowCase):
2903         (bmalloc::Deallocator::deallocateSmallLine):
2904         (bmalloc::Deallocator::allocateSmallLine):
2905         (bmalloc::Deallocator::deallocateMediumLine):
2906         (bmalloc::Deallocator::allocateMediumLine):
2907         * bmalloc/Deallocator.h: Added.
2908         (bmalloc::Deallocator::deallocateFastCase):
2909         (bmalloc::Deallocator::deallocate):
2910         * bmalloc/EndTag.h: Added.
2911         (bmalloc::EndTag::operator=):
2912         * bmalloc/FixedVector.h: Added.
2913         (bmalloc::FixedVector::begin):
2914         (bmalloc::FixedVector::end):
2915         (bmalloc::FixedVector::size):
2916         (bmalloc::FixedVector::capacity):
2917         (bmalloc::FixedVector::clear):
2918         (bmalloc::FixedVector::isEmpty):
2919         (bmalloc::Capacity>::FixedVector):
2920         (bmalloc::Capacity>::operator):
2921         (bmalloc::Capacity>::push):
2922         (bmalloc::Capacity>::pop):
2923         (bmalloc::Capacity>::shrink):
2924         * bmalloc/Heap.cpp: Added.
2925         (bmalloc::sleep):
2926         (bmalloc::Heap::Heap):
2927         (bmalloc::Heap::concurrentScavenge):
2928         (bmalloc::Heap::scavengeSmallPages):
2929         (bmalloc::Heap::scavengeMediumPages):
2930         (bmalloc::Heap::scavengeLargeRanges):
2931         (bmalloc::Heap::allocateSmallLineSlowCase):
2932         (bmalloc::Heap::allocateMediumLineSlowCase):
2933         (bmalloc::Heap::allocateXLarge):
2934         (bmalloc::Heap::deallocateXLarge):
2935         (bmalloc::Heap::allocateLarge):
2936         (bmalloc::Heap::deallocateLarge):
2937         * bmalloc/Heap.h: Added.
2938         (bmalloc::Heap::deallocateSmallLine):
2939         (bmalloc::Heap::allocateSmallLine):
2940         (bmalloc::Heap::deallocateMediumLine):
2941         (bmalloc::Heap::allocateMediumLine):
2942         * bmalloc/Inline.h: Added.
2943         * bmalloc/LargeChunk.h: Added.
2944         (bmalloc::LargeChunk::begin):
2945         (bmalloc::LargeChunk::end):
2946         (bmalloc::LargeChunk::create):
2947         (bmalloc::LargeChunk::get):
2948         (bmalloc::LargeChunk::beginTag):
2949         (bmalloc::LargeChunk::endTag):
2950         * bmalloc/Line.h: Added.
2951         (bmalloc::Line<Traits>::begin):
2952         (bmalloc::Line<Traits>::end):
2953         (bmalloc::Line<Traits>::concurrentRef):
2954         (bmalloc::Line<Traits>::deref):
2955         * bmalloc/MediumAllocator.h: Added.
2956         (bmalloc::MediumAllocator::isNull):
2957         (bmalloc::MediumAllocator::MediumAllocator):
2958         (bmalloc::MediumAllocator::line):
2959         (bmalloc::MediumAllocator::allocate):
2960         (bmalloc::MediumAllocator::derefCount):
2961         (bmalloc::MediumAllocator::refill):
2962         * bmalloc/MediumChunk.h: Added.
2963         * bmalloc/MediumLine.h: Added.
2964         * bmalloc/MediumPage.h: Added.
2965         * bmalloc/MediumTraits.h: Added.
2966         * bmalloc/Mutex.cpp: Added.
2967         (bmalloc::Mutex::lockSlowCase):
2968         * bmalloc/Mutex.h: Added.
2969         (bmalloc::Mutex::Mutex):
2970         (bmalloc::Mutex::try_lock):
2971         (bmalloc::Mutex::lock):
2972         (bmalloc::Mutex::unlock):
2973         * bmalloc/ObjectType.cpp: Added.
2974         (bmalloc::objectType):
2975         * bmalloc/ObjectType.h: Added.
2976         (bmalloc::isSmallOrMedium):
2977         (bmalloc::isSmall):
2978         * bmalloc/Page.h: Added.
2979         (bmalloc::Page<Traits>::ref):
2980         (bmalloc::Page<Traits>::deref):
2981         (bmalloc::Page<Traits>::refCount):
2982         * bmalloc/PerProcess.h: Added.
2983         (bmalloc::PerProcess::mutex):
2984         (bmalloc::PerProcess<T>::getFastCase):
2985         (bmalloc::PerProcess<T>::get):
2986         (bmalloc::PerProcess<T>::getSlowCase):
2987         * bmalloc/PerThread.h: Added.
2988         (bmalloc::PerThreadStorage<Cache>::get):
2989         (bmalloc::PerThreadStorage<Cache>::init):
2990         (bmalloc::PerThreadStorage::get):
2991         (bmalloc::PerThreadStorage::init):
2992         (bmalloc::PerThread<T>::getFastCase):
2993         (bmalloc::PerThread<T>::get):
2994         (bmalloc::PerThread<T>::destructor):
2995         (bmalloc::PerThread<T>::getSlowCase):
2996         * bmalloc/Range.h: Added.
2997         (bmalloc::Range::Range):
2998         (bmalloc::Range::begin):
2999         (bmalloc::Range::end):
3000         (bmalloc::Range::size):
3001         (bmalloc::Range::operator!):
3002         (bmalloc::Range::operator<):
3003         * bmalloc/SegregatedFreeList.cpp: Added.
3004         (bmalloc::SegregatedFreeList::SegregatedFreeList):
3005         (bmalloc::SegregatedFreeList::insert):
3006         (bmalloc::SegregatedFreeList::takeGreedy):
3007         (bmalloc::SegregatedFreeList::take):
3008         * bmalloc/SegregatedFreeList.h: Added.
3009         * bmalloc/Sizes.h: Added.
3010         * bmalloc/SmallAllocator.h: Added.
3011         (bmalloc::SmallAllocator::isNull):
3012         (bmalloc::SmallAllocator::canAllocate):
3013         (bmalloc::SmallAllocator::SmallAllocator):
3014         (bmalloc::SmallAllocator::line):
3015         (bmalloc::SmallAllocator::allocate):
3016         (bmalloc::SmallAllocator::objectCount):
3017         (bmalloc::SmallAllocator::derefCount):
3018         (bmalloc::SmallAllocator::refill):
3019         * bmalloc/SmallChunk.h: Added.
3020         * bmalloc/SmallLine.h: Added.
3021         * bmalloc/SmallPage.h: Added.
3022         * bmalloc/SmallTraits.h: Added.
3023         * bmalloc/Syscall.h: Added.
3024         * bmalloc/VMAllocate.h: Added.
3025         (bmalloc::vmSize):
3026         (bmalloc::vmValidate):
3027         (bmalloc::vmAllocate):
3028         (bmalloc::vmDeallocate):
3029         (bmalloc::vmDeallocatePhysicalPages):
3030         (bmalloc::vmAllocatePhysicalPages):
3031         (bmalloc::vmDeallocatePhysicalPagesSloppy):
3032         (bmalloc::vmAllocatePhysicalPagesSloppy):
3033         * bmalloc/VMHeap.cpp: Added.
3034         (bmalloc::VMHeap::VMHeap):
3035         (bmalloc::VMHeap::allocateSmallChunk):
3036         (bmalloc::VMHeap::allocateMediumChunk):
3037         (bmalloc::VMHeap::allocateLargeChunk):
3038         * bmalloc/VMHeap.h: Added.
3039         (bmalloc::VMHeap::allocateSmallPage):
3040         (bmalloc::VMHeap::allocateMediumPage):
3041         (bmalloc::VMHeap::allocateLargeRange):
3042         (bmalloc::VMHeap::deallocateSmallPage):
3043         (bmalloc::VMHeap::deallocateMediumPage):
3044         (bmalloc::VMHeap::deallocateLargeRange):
3045         * bmalloc/Vector.h: Added.
3046         (bmalloc::Vector::begin):
3047         (bmalloc::Vector::end):
3048         (bmalloc::Vector::size):
3049         (bmalloc::Vector::capacity):
3050         (bmalloc::Vector::last):
3051         (bmalloc::Vector::pop):
3052         (bmalloc::Vector<T>::Vector):
3053         (bmalloc::Vector<T>::~Vector):
3054         (bmalloc::Vector<T>::operator):
3055         (bmalloc::Vector<T>::push):
3056         (bmalloc::Vector<T>::pop):
3057         (bmalloc::Vector<T>::shrink):
3058         (bmalloc::Vector<T>::reallocateBuffer):
3059         (bmalloc::Vector<T>::shrinkCapacity):
3060         (bmalloc::Vector<T>::growCapacity):
3061         * bmalloc/XLargeChunk.h: Added.
3062         (bmalloc::XLargeChunk::get):
3063         (bmalloc::XLargeChunk::begin):
3064         (bmalloc::XLargeChunk::XLargeChunk):
3065         (bmalloc::XLargeChunk::create):
3066         (bmalloc::XLargeChunk::destroy):
3067         (bmalloc::XLargeChunk::range):
3068         (bmalloc::XLargeChunk::size):
3069         * bmalloc/bmalloc.h: Added.
3070         (bmalloc::api::malloc):
3071         (bmalloc::api::free):
3072         (bmalloc::api::realloc):
3073         * bmalloc/mbmalloc.cpp: Added.
3074