<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[164728] trunk/Source/WTF</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/164728">164728</a></dd>
<dt>Author</dt> <dd>barraclough@apple.com</dd>
<dt>Date</dt> <dd>2014-02-26 11:17:19 -0800 (Wed, 26 Feb 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>FastMalloc should use vm_page_shift intead of PAGE_SHIFT.
https://bugs.webkit.org/show_bug.cgi?id=129370
Reviewed by Geoff Garen.
Previously we used PAGE_SHIFT to initialize kPageShift.
Since this was a constant, it could be used to calculate other
contants used in the code. Some of these values are used in the
definition of certain data structures (specifiying the length of
some array members).
Make kPageShift & dependent properties variables setup during
initialization. Add upper bound values (K_PAGE_SHIFT_MAX,
K_NUM_CLASSES_MAX) for use in cases where we need a constant.
* wtf/FastMalloc.cpp:
(WTF::InitSizeClasses):
- initialize kPageShift, kNumClasses, kPageSize, kMaxValidPages.
(WTF::pages):
- added ASSERT.
(WTF::AllocationSize):
- added ASSERT.
(WTF::TCMalloc_PageHeap::FreeBytes):
- added ASSERT.
(WTF::TCMalloc_PageHeap::init):
- COMPILE_ASSERT -> ASSERT
(WTF::TCMalloc_PageHeap::scavenge):
- added ASSERT.
(WTF::TCMalloc_PageHeap::Carve):
- added ASSERT.
(WTF::mergeDecommittedStates):
- added ASSERT.
(WTF::TCMalloc_PageHeap::IncrementalScavenge):
- added ASSERT.
(WTF::TCMalloc_PageHeap::ReturnedBytes):
- added ASSERT.
(WTF::PagesToMB):
- added ASSERT.
(WTF::TCMalloc_PageHeap::GrowHeap):
- added ASSERT.
(WTF::TCMalloc_PageHeap::ReleaseFreeList):
- kNumClasses -> K_NUM_CLASSES_MAX
(WTF::TCMalloc_ThreadCache::enumerateFreeObjects):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::Init):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::ReleaseToSpans):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::EvictRandomSizeClass):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::MakeCacheSpace):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::InsertRange):
- added ASSERT.
(WTF::TCMalloc_Central_FreeList::Populate):
- added ASSERT.
(WTF::TCMalloc_ThreadCache::Init):
- added ASSERT.
(WTF::TCMalloc_ThreadCache::Cleanup):
- added ASSERT.
(WTF::TCMalloc_ThreadCache::Scavenge):
- added ASSERT.
(WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary):
- added ASSERT.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWTFChangeLog">trunk/Source/WTF/ChangeLog</a></li>
<li><a href="#trunkSourceWTFwtfFastMalloccpp">trunk/Source/WTF/wtf/FastMalloc.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWTFChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/ChangeLog (164727 => 164728)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/ChangeLog 2014-02-26 19:16:21 UTC (rev 164727)
+++ trunk/Source/WTF/ChangeLog 2014-02-26 19:17:19 UTC (rev 164728)
</span><span class="lines">@@ -1,3 +1,70 @@
</span><ins>+2014-02-25 Gavin Barraclough <barraclough@apple.com>
+
+ FastMalloc should use vm_page_shift intead of PAGE_SHIFT.
+ https://bugs.webkit.org/show_bug.cgi?id=129370
+
+ Reviewed by Geoff Garen.
+
+ Previously we used PAGE_SHIFT to initialize kPageShift.
+ Since this was a constant, it could be used to calculate other
+ contants used in the code. Some of these values are used in the
+ definition of certain data structures (specifiying the length of
+ some array members).
+
+ Make kPageShift & dependent properties variables setup during
+ initialization. Add upper bound values (K_PAGE_SHIFT_MAX,
+ K_NUM_CLASSES_MAX) for use in cases where we need a constant.
+
+ * wtf/FastMalloc.cpp:
+ (WTF::InitSizeClasses):
+ - initialize kPageShift, kNumClasses, kPageSize, kMaxValidPages.
+ (WTF::pages):
+ - added ASSERT.
+ (WTF::AllocationSize):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::FreeBytes):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::init):
+ - COMPILE_ASSERT -> ASSERT
+ (WTF::TCMalloc_PageHeap::scavenge):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::Carve):
+ - added ASSERT.
+ (WTF::mergeDecommittedStates):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::IncrementalScavenge):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::ReturnedBytes):
+ - added ASSERT.
+ (WTF::PagesToMB):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::GrowHeap):
+ - added ASSERT.
+ (WTF::TCMalloc_PageHeap::ReleaseFreeList):
+ - kNumClasses -> K_NUM_CLASSES_MAX
+ (WTF::TCMalloc_ThreadCache::enumerateFreeObjects):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::Init):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::ReleaseToSpans):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::EvictRandomSizeClass):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::MakeCacheSpace):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::InsertRange):
+ - added ASSERT.
+ (WTF::TCMalloc_Central_FreeList::Populate):
+ - added ASSERT.
+ (WTF::TCMalloc_ThreadCache::Init):
+ - added ASSERT.
+ (WTF::TCMalloc_ThreadCache::Cleanup):
+ - added ASSERT.
+ (WTF::TCMalloc_ThreadCache::Scavenge):
+ - added ASSERT.
+ (WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary):
+ - added ASSERT.
+
</ins><span class="cx"> 2014-02-24 Alex Christensen <achristensen@webkit.org>
</span><span class="cx">
</span><span class="cx"> Disabled WebGL on WinCairo.
</span></span></pre></div>
<a id="trunkSourceWTFwtfFastMalloccpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/wtf/FastMalloc.cpp (164727 => 164728)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/wtf/FastMalloc.cpp 2014-02-26 19:16:21 UTC (rev 164727)
+++ trunk/Source/WTF/wtf/FastMalloc.cpp 2014-02-26 19:17:19 UTC (rev 164728)
</span><span class="lines">@@ -91,6 +91,7 @@
</span><span class="cx"> #include <wtf/StdLibExtras.h>
</span><span class="cx">
</span><span class="cx"> #if OS(DARWIN)
</span><ins>+#include <mach/mach_init.h>
</ins><span class="cx"> #include <malloc/malloc.h>
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -629,28 +630,21 @@
</span><span class="cx"> // Configuration
</span><span class="cx"> //-------------------------------------------------------------------
</span><span class="cx">
</span><ins>+// Type that can hold the length of a run of pages
+typedef uintptr_t Length;
+
</ins><span class="cx"> // Not all possible combinations of the following parameters make
</span><span class="cx"> // sense. In particular, if kMaxSize increases, you may have to
</span><span class="cx"> // increase kNumClasses as well.
</span><del>-#if OS(DARWIN)
-# define K_PAGE_SHIFT PAGE_SHIFT
-# if (K_PAGE_SHIFT == 12)
-# define K_NUM_CLASSES 68
-# elif (K_PAGE_SHIFT == 14)
-# define K_NUM_CLASSES 77
-# else
-# error "Unsupported PAGE_SHIFT amount"
-# endif
-#else
-# define K_PAGE_SHIFT 12
-# define K_NUM_CLASSES 68
-#endif
-static const size_t kPageShift = K_PAGE_SHIFT;
-static const size_t kPageSize = 1 << kPageShift;
</del><ins>+#define K_PAGE_SHIFT_MAX 14
+#define K_NUM_CLASSES_MAX 77
+static size_t kPageShift = 0;
+static size_t kNumClasses = 0;
+static size_t kPageSize = 0;
+static Length kMaxValidPages = 0;
</ins><span class="cx"> static const size_t kMaxSize = 32u * 1024;
</span><span class="cx"> static const size_t kAlignShift = 3;
</span><span class="cx"> static const size_t kAlignment = 1 << kAlignShift;
</span><del>-static const size_t kNumClasses = K_NUM_CLASSES;
</del><span class="cx">
</span><span class="cx"> // Allocates a big block of memory for the pagemap once we reach more than
</span><span class="cx"> // 128MB
</span><span class="lines">@@ -662,14 +656,14 @@
</span><span class="cx"> // should keep this value big because various incarnations of Linux
</span><span class="cx"> // have small limits on the number of mmap() regions per
</span><span class="cx"> // address-space.
</span><del>-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</del><ins>+static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</ins><span class="cx">
</span><span class="cx"> // Number of objects to move between a per-thread list and a central
</span><span class="cx"> // list in one shot. We want this to be not too small so we can
</span><span class="cx"> // amortize the lock overhead for accessing the central list. Making
</span><span class="cx"> // it too big may temporarily cause unnecessary memory wastage in the
</span><span class="cx"> // per-thread free list until the scavenger cleans up the list.
</span><del>-static int num_objects_to_move[kNumClasses];
</del><ins>+static int num_objects_to_move[K_NUM_CLASSES_MAX];
</ins><span class="cx">
</span><span class="cx"> // Maximum length we allow a per-thread free-list to have before we
</span><span class="cx"> // move objects from it into the corresponding central free-list. We
</span><span class="lines">@@ -765,10 +759,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Mapping from size class to max size storable in that class
</span><del>-static size_t class_to_size[kNumClasses];
</del><ins>+static size_t class_to_size[K_NUM_CLASSES_MAX];
</ins><span class="cx">
</span><span class="cx"> // Mapping from size class to number of pages to allocate at a time
</span><del>-static size_t class_to_pages[kNumClasses];
</del><ins>+static size_t class_to_pages[K_NUM_CLASSES_MAX];
</ins><span class="cx">
</span><span class="cx"> // Hardened singly linked list. We make this a class to allow compiler to
</span><span class="cx"> // statically prevent mismatching hardened and non-hardened list
</span><span class="lines">@@ -813,7 +807,8 @@
</span><span class="cx"> // number of TCEntries across size classes is fixed. Currently each size
</span><span class="cx"> // class is initially given one TCEntry which also means that the maximum any
</span><span class="cx"> // one class can have is kNumClasses.
</span><del>-static const int kNumTransferEntries = kNumClasses;
</del><ins>+#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
+#define kNumTransferEntries static_cast<int>(kNumClasses)
</ins><span class="cx">
</span><span class="cx"> // Note: the following only works for "n"s that fit in 32-bits, but
</span><span class="cx"> // that is fine since we only use it for small sizes.
</span><span class="lines">@@ -917,6 +912,25 @@
</span><span class="cx">
</span><span class="cx"> // Initialize the mapping arrays
</span><span class="cx"> static void InitSizeClasses() {
</span><ins>+#if OS(DARWIN)
+ kPageShift = vm_page_shift;
+ switch (kPageShift) {
+ case 12:
+ kNumClasses = 68;
+ break;
+ case 14:
+ kNumClasses = 77;
+ break;
+ default:
+ CRASH();
+ };
+#else
+ kPageShift = 12;
+ kNumClasses = 68;
+#endif
+ kPageSize = 1 << kPageShift;
+ kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
+
</ins><span class="cx"> // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span class="cx"> if (ClassIndex(0) < 0) {
</span><span class="cx"> MESSAGE("Invalid class index %d for size 0\n", ClassIndex(0));
</span><span class="lines">@@ -1144,14 +1158,10 @@
</span><span class="cx"> // Type that can hold a page number
</span><span class="cx"> typedef uintptr_t PageID;
</span><span class="cx">
</span><del>-// Type that can hold the length of a run of pages
-typedef uintptr_t Length;
-
-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
-
</del><span class="cx"> // Convert byte size into pages. This won't overflow, but may return
</span><span class="cx"> // an unreasonably large value if bytes is huge enough.
</span><span class="cx"> static inline Length pages(size_t bytes) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> return (bytes >> kPageShift) +
</span><span class="cx"> ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span class="cx"> }
</span><span class="lines">@@ -1159,6 +1169,7 @@
</span><span class="cx"> // Convert a user size into the number of bytes that will actually be
</span><span class="cx"> // allocated
</span><span class="cx"> static size_t AllocationSize(size_t bytes) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> if (bytes > kMaxSize) {
</span><span class="cx"> // Large object: we allocate an integral number of pages
</span><span class="cx"> ASSERT(bytes <= (kMaxValidPages << kPageShift));
</span><span class="lines">@@ -1431,7 +1442,7 @@
</span><span class="cx"> // Here we reserve space for TCEntry cache slots. Since one size class can
</span><span class="cx"> // end up getting all the TCEntries quota in the system we just preallocate
</span><span class="cx"> // sufficient number of entries here.
</span><del>- TCEntry tc_slots_[kNumTransferEntries];
</del><ins>+ TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</ins><span class="cx">
</span><span class="cx"> // Number of currently used cached entries in tc_slots_. This variable is
</span><span class="cx"> // updated under a lock but can be read without one.
</span><span class="lines">@@ -1653,7 +1664,7 @@
</span><span class="cx"> // Selector class -- general selector uses 3-level map
</span><span class="cx"> template <int BITS> class MapSelector {
</span><span class="cx"> public:
</span><del>- typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</del><ins>+ typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MAX> Type;
</ins><span class="cx"> typedef PackedCache<BITS, uint64_t> CacheType;
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -1671,7 +1682,7 @@
</span><span class="cx"> // A three-level map for 64-bit machines
</span><span class="cx"> template <> class MapSelector<64> {
</span><span class="cx"> public:
</span><del>- typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</del><ins>+ typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MAX - kBitsUnusedOn64Bit> Type;
</ins><span class="cx"> typedef PackedCache<64, uint64_t> CacheType;
</span><span class="cx"> };
</span><span class="cx"> #endif
</span><span class="lines">@@ -1679,8 +1690,8 @@
</span><span class="cx"> // A two-level map for 32-bit machines
</span><span class="cx"> template <> class MapSelector<32> {
</span><span class="cx"> public:
</span><del>- typedef TCMalloc_PageMap2<32 - kPageShift> Type;
- typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</del><ins>+ typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MAX> Type;
+ typedef PackedCache<32 - K_PAGE_SHIFT_MAX, uint16_t> CacheType;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> // -------------------------------------------------------------------------
</span><span class="lines">@@ -1777,6 +1788,7 @@
</span><span class="cx">
</span><span class="cx"> // Return number of free bytes in heap
</span><span class="cx"> uint64_t FreeBytes() const {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1912,6 +1924,8 @@
</span><span class="cx">
</span><span class="cx"> void TCMalloc_PageHeap::init()
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
+
</ins><span class="cx"> pagemap_.init(MetaDataAlloc);
</span><span class="cx"> pagemap_cache_ = PageMapCache(0);
</span><span class="cx"> free_pages_ = 0;
</span><span class="lines">@@ -1926,7 +1940,7 @@
</span><span class="cx"> scavenge_counter_ = 0;
</span><span class="cx"> // Start scavenging at kMaxPages list
</span><span class="cx"> scavenge_index_ = kMaxPages-1;
</span><del>- COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</del><ins>+ ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</ins><span class="cx"> DLL_Init(&large_.normal, entropy_);
</span><span class="cx"> DLL_Init(&large_.returned, entropy_);
</span><span class="cx"> for (size_t i = 0; i < kMaxPages; i++) {
</span><span class="lines">@@ -2067,6 +2081,7 @@
</span><span class="cx">
</span><span class="cx"> void TCMalloc_PageHeap::scavenge()
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span class="cx"> size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span class="cx">
</span><span class="lines">@@ -2228,6 +2243,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> ASSERT(n > 0);
</span><span class="cx"> DLL_Remove(span, entropy_);
</span><span class="cx"> span->free = 0;
</span><span class="lines">@@ -2264,6 +2280,7 @@
</span><span class="cx">
</span><span class="cx"> static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> if (destination->decommitted && !other->decommitted) {
</span><span class="cx"> TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span class="cx"> static_cast<size_t>(other->length << kPageShift));
</span><span class="lines">@@ -2367,6 +2384,7 @@
</span><span class="cx">
</span><span class="cx"> #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span class="cx"> void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // Fast path; not yet time to release memory
</span><span class="cx"> scavenge_counter_ -= n;
</span><span class="cx"> if (scavenge_counter_ >= 0) return; // Not yet time to scavenge
</span><span class="lines">@@ -2428,6 +2446,7 @@
</span><span class="cx">
</span><span class="cx"> #ifdef WTF_CHANGES
</span><span class="cx"> size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> size_t result = 0;
</span><span class="cx"> for (unsigned s = 0; s < kMaxPages; s++) {
</span><span class="cx"> const int r_length = DLL_Length(&free_[s].returned, entropy_);
</span><span class="lines">@@ -2443,6 +2462,7 @@
</span><span class="cx">
</span><span class="cx"> #ifndef WTF_CHANGES
</span><span class="cx"> static double PagesToMB(uint64_t pages) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> return (pages << kPageShift) / 1048576.0;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2509,6 +2529,7 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span class="cx"> if (n > kMaxValidPages) return false;
</span><span class="cx"> Length ask = (n>kMinSystemAlloc) ? n : static_cast<Length>(kMinSystemAlloc);
</span><span class="lines">@@ -2605,6 +2626,7 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // Walk backwards through list so that when we push these
</span><span class="cx"> // spans on the "returned" list, we preserve the order.
</span><span class="cx"> #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span class="lines">@@ -2738,7 +2760,7 @@
</span><span class="cx"> size_t size_; // Combined size of data
</span><span class="cx"> ThreadIdentifier tid_; // Which thread owns it
</span><span class="cx"> bool in_setspecific_; // Called pthread_setspecific?
</span><del>- FreeList list_[kNumClasses]; // Array indexed by size-class
</del><ins>+ FreeList list_[K_NUM_CLASSES_MAX]; // Array indexed by size-class
</ins><span class="cx">
</span><span class="cx"> // We sample allocations, biased by the size of the allocation
</span><span class="cx"> uint32_t rnd_; // Cheap random number generator
</span><span class="lines">@@ -2794,6 +2816,7 @@
</span><span class="cx"> template <class Finder, class Reader>
</span><span class="cx"> void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span class="cx"> list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span class="cx"> }
</span><span class="lines">@@ -2806,7 +2829,7 @@
</span><span class="cx">
</span><span class="cx"> // Central cache -- a collection of free-lists, one per size-class.
</span><span class="cx"> // We have a separate lock per free-list to reduce contention.
</span><del>-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</del><ins>+static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</ins><span class="cx">
</span><span class="cx"> // Page-level allocator
</span><span class="cx"> static AllocAlignmentInteger pageheap_memory[(sizeof(TCMalloc_PageHeap) + sizeof(AllocAlignmentInteger) - 1) / sizeof(AllocAlignmentInteger)];
</span><span class="lines">@@ -2962,6 +2985,7 @@
</span><span class="cx"> //-------------------------------------------------------------------
</span><span class="cx">
</span><span class="cx"> void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> lock_.Init();
</span><span class="cx"> size_class_ = cl;
</span><span class="cx"> entropy_ = entropy;
</span><span class="lines">@@ -2986,6 +3010,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span class="cx"> Span* span = pageheap->GetDescriptor(p);
</span><span class="cx"> ASSERT(span != NULL);
</span><span class="lines">@@ -3032,6 +3057,7 @@
</span><span class="cx">
</span><span class="cx"> ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span class="cx"> size_t locked_size_class, bool force) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> static int race_counter = 0;
</span><span class="cx"> int t = race_counter++; // Updated without a lock, but who cares.
</span><span class="cx"> if (t >= static_cast<int>(kNumClasses)) {
</span><span class="lines">@@ -3047,6 +3073,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // Is there room in the cache?
</span><span class="cx"> if (used_slots_ < cache_size_) return true;
</span><span class="cx"> // Check if we can expand this cache?
</span><span class="lines">@@ -3101,6 +3128,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> SpinLockHolder h(&lock_);
</span><span class="cx"> if (N == num_objects_to_move[size_class_] &&
</span><span class="cx"> MakeCacheSpace()) {
</span><span class="lines">@@ -3183,6 +3211,7 @@
</span><span class="cx">
</span><span class="cx"> // Fetch memory from the system and add to the central cache freelist.
</span><span class="cx"> ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // Release central list lock while operating on pageheap
</span><span class="cx"> lock_.Unlock();
</span><span class="cx"> const size_t npages = class_to_pages[size_class_];
</span><span class="lines">@@ -3269,6 +3298,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> size_ = 0;
</span><span class="cx"> next_ = NULL;
</span><span class="cx"> prev_ = NULL;
</span><span class="lines">@@ -3291,6 +3321,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void TCMalloc_ThreadCache::Cleanup() {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // Put unused memory back into central cache
</span><span class="cx"> for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span class="cx"> if (list_[cl].length() > 0) {
</span><span class="lines">@@ -3365,6 +3396,7 @@
</span><span class="cx">
</span><span class="cx"> // Release idle memory to the central cache
</span><span class="cx"> inline void TCMalloc_ThreadCache::Scavenge() {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> // If the low-water mark for the free list is L, it means we would
</span><span class="cx"> // not have had to allocate anything from the central cache even if
</span><span class="cx"> // we had reduced the free list size by L. We aim to get closer to
</span><span class="lines">@@ -3657,6 +3689,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void TCMalloc_ThreadCache::Print() const {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span class="cx"> MESSAGE(" %5" PRIuS " : %4d len; %4d lo\n",
</span><span class="cx"> ByteSizeForClass(cl),
</span><span class="lines">@@ -3678,6 +3711,7 @@
</span><span class="cx"> #ifndef WTF_CHANGES
</span><span class="cx"> // Get stats into "r". Also get per-size-class counts if class_count != NULL
</span><span class="cx"> static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> r->central_bytes = 0;
</span><span class="cx"> r->transfer_bytes = 0;
</span><span class="cx"> for (int cl = 0; cl < kNumClasses; ++cl) {
</span><span class="lines">@@ -3715,6 +3749,7 @@
</span><span class="cx"> #ifndef WTF_CHANGES
</span><span class="cx"> // WRITE stats to "out"
</span><span class="cx"> static void DumpStats(TCMalloc_Printer* out, int level) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> TCMallocStats stats;
</span><span class="cx"> uint64_t class_count[kNumClasses];
</span><span class="cx"> ExtractStats(&stats, (level >= 2 ? class_count : NULL));
</span><span class="lines">@@ -4003,6 +4038,7 @@
</span><span class="cx">
</span><span class="cx"> #if !ASSERT_DISABLED
</span><span class="cx"> static inline bool CheckCachedSizeClass(void *ptr) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span class="cx"> size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span class="cx"> return cached_value == 0 ||
</span><span class="lines">@@ -4017,6 +4053,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static inline void* SpanToMallocResult(Span *span) {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> ASSERT_SPAN_COMMITTED(span);
</span><span class="cx"> pageheap->CacheSizeClass(span->start, 0);
</span><span class="cx"> void* result = reinterpret_cast<void*>(span->start << kPageShift);
</span><span class="lines">@@ -4070,6 +4107,7 @@
</span><span class="cx"> static ALWAYS_INLINE void do_free(void* ptr) {
</span><span class="cx"> if (ptr == NULL) return;
</span><span class="cx"> ASSERT(pageheap != NULL); // Should not call free() before malloc()
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span class="cx"> Span* span = pageheap->GetDescriptor(p);
</span><span class="cx"> RELEASE_ASSERT(span->isValid());
</span><span class="lines">@@ -4121,6 +4159,7 @@
</span><span class="cx"> ASSERT((align & (align - 1)) == 0);
</span><span class="cx"> ASSERT(align > 0);
</span><span class="cx"> if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx">
</span><span class="cx"> // Allocate at least one byte to avoid boundary conditions below
</span><span class="cx"> if (size == 0) size = 1;
</span><span class="lines">@@ -4441,6 +4480,9 @@
</span><span class="cx"> new_size += Internal::ValidationBufferSize;
</span><span class="cx"> #endif
</span><span class="cx">
</span><ins>+ ASSERT(pageheap != NULL); // Should not call realloc() before malloc()
+ ASSERT(kPageShift && kNumClasses && kPageSize);
+
</ins><span class="cx"> // Get the size of the old entry
</span><span class="cx"> const PageID p = reinterpret_cast<uintptr_t>(old_ptr) >> kPageShift;
</span><span class="cx"> size_t cl = pageheap->GetSizeClassIfCached(p);
</span><span class="lines">@@ -4659,6 +4701,7 @@
</span><span class="cx">
</span><span class="cx"> FastMallocStatistics fastMallocStatistics()
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> FastMallocStatistics statistics;
</span><span class="cx">
</span><span class="cx"> SpinLockHolder lockHolder(&pageheap_lock);
</span><span class="lines">@@ -4680,6 +4723,9 @@
</span><span class="cx">
</span><span class="cx"> size_t fastMallocSize(const void* ptr)
</span><span class="cx"> {
</span><ins>+ if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
+ ASSERT(kPageShift && kNumClasses && kPageSize);
+
</ins><span class="cx"> #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span class="cx"> return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span class="cx"> #else
</span><span class="lines">@@ -4791,6 +4837,7 @@
</span><span class="cx">
</span><span class="cx"> int visit(void* ptr) const
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> if (!ptr)
</span><span class="cx"> return 1;
</span><span class="cx">
</span><span class="lines">@@ -4838,6 +4885,8 @@
</span><span class="cx">
</span><span class="cx"> void recordPendingRegions()
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
+
</ins><span class="cx"> bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span class="cx"> bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span class="cx">
</span><span class="lines">@@ -4886,6 +4935,7 @@
</span><span class="cx">
</span><span class="cx"> int visit(void* ptr)
</span><span class="cx"> {
</span><ins>+ ASSERT(kPageShift && kNumClasses && kPageSize);
</ins><span class="cx"> if (!ptr)
</span><span class="cx"> return 1;
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>