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