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