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