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