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