Diff
Modified: trunk/Source/bmalloc/ChangeLog (198197 => 198198)
--- trunk/Source/bmalloc/ChangeLog 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/ChangeLog 2016-03-15 05:39:35 UTC (rev 198198)
@@ -1,3 +1,15 @@
+2016-03-14 Geoffrey Garen <[email protected]>
+
+ Unreviewed, rolling out r197955.
+
+ I decided to go in another direction
+
+ Reverted changeset:
+
+ "bmalloc: Rename SmallPage to SmallRun"
+ https://bugs.webkit.org/show_bug.cgi?id=155320
+ http://trac.webkit.org/changeset/197955
+
2016-03-10 Geoffrey Garen <[email protected]>
bmalloc: Rename SmallPage to SmallRun
Modified: trunk/Source/bmalloc/bmalloc/Allocator.cpp (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/Allocator.cpp 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/Allocator.cpp 2016-03-15 05:39:35 UTC (rev 198198)
@@ -114,8 +114,8 @@
size_t oldSize = 0;
switch (objectType(object)) {
case Small: {
- SmallRun* run = SmallRun::get(SmallLine::get(object));
- oldSize = objectSize(run->sizeClass());
+ SmallPage* page = SmallPage::get(SmallLine::get(object));
+ oldSize = objectSize(page->sizeClass());
break;
}
case Large: {
Modified: trunk/Source/bmalloc/bmalloc/Heap.cpp (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/Heap.cpp 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/Heap.cpp 2016-03-15 05:39:35 UTC (rev 198198)
@@ -30,7 +30,7 @@
#include "PerProcess.h"
#include "SmallChunk.h"
#include "SmallLine.h"
-#include "SmallRun.h"
+#include "SmallPage.h"
#include <thread>
namespace bmalloc {
@@ -40,16 +40,16 @@
, m_isAllocatingPages(false)
, m_scavenger(*this, &Heap::concurrentScavenge)
{
- initializeSmallRunMetadata();
+ initializeLineMetadata();
}
-void Heap::initializeSmallRunMetadata()
+void Heap::initializeLineMetadata()
{
- // We assume that m_smallRunMetadata is zero-filled.
+ // We assume that m_smallLineMetadata is zero-filled.
for (size_t size = alignment; size <= smallMax; size += alignment) {
size_t sizeClass = bmalloc::sizeClass(size);
- auto& metadata = m_smallRunMetadata[sizeClass];
+ auto& metadata = m_smallLineMetadata[sizeClass];
size_t object = 0;
size_t line = 0;
@@ -84,17 +84,17 @@
{
waitUntilFalse(lock, sleepDuration, m_isAllocatingPages);
- scavengeSmallRuns(lock, sleepDuration);
+ scavengeSmallPages(lock, sleepDuration);
scavengeLargeObjects(lock, sleepDuration);
scavengeXLargeObjects(lock, sleepDuration);
sleep(lock, sleepDuration);
}
-void Heap::scavengeSmallRuns(std::unique_lock<StaticMutex>& lock, std::chrono::milliseconds sleepDuration)
+void Heap::scavengeSmallPages(std::unique_lock<StaticMutex>& lock, std::chrono::milliseconds sleepDuration)
{
- while (!m_smallRuns.isEmpty()) {
- m_vmHeap.deallocateSmallRun(lock, m_smallRuns.pop());
+ while (!m_smallPages.isEmpty()) {
+ m_vmHeap.deallocateSmallPage(lock, m_smallPages.pop());
waitUntilFalse(lock, sleepDuration, m_isAllocatingPages);
}
}
@@ -126,22 +126,22 @@
void Heap::allocateSmallBumpRanges(std::lock_guard<StaticMutex>& lock, size_t sizeClass, BumpAllocator& allocator, BumpRangeCache& rangeCache)
{
BASSERT(!rangeCache.size());
- SmallRun* run = allocateSmallRun(lock, sizeClass);
- SmallLine* lines = run->begin();
- BASSERT(run->hasFreeLines(lock));
+ SmallPage* page = allocateSmallPage(lock, sizeClass);
+ SmallLine* lines = page->begin();
+ BASSERT(page->hasFreeLines(lock));
// Find a free line.
for (size_t lineNumber = 0; lineNumber < smallLineCount; ++lineNumber) {
if (lines[lineNumber].refCount(lock))
continue;
- LineMetadata& lineMetadata = m_smallRunMetadata[sizeClass][lineNumber];
+ LineMetadata& lineMetadata = m_smallLineMetadata[sizeClass][lineNumber];
if (!lineMetadata.objectCount)
continue;
- // In a fragmented run, some free ranges might not fit in the cache.
+ // In a fragmented page, some free ranges might not fit in the cache.
if (rangeCache.size() == rangeCache.capacity()) {
- m_smallRunsWithFreeLines[sizeClass].push(run);
+ m_smallPagesWithFreeLines[sizeClass].push(page);
BASSERT(allocator.canAllocate());
return;
}
@@ -149,20 +149,20 @@
char* begin = lines[lineNumber].begin() + lineMetadata.startOffset;
unsigned short objectCount = lineMetadata.objectCount;
lines[lineNumber].ref(lock, lineMetadata.objectCount);
- run->ref(lock);
+ page->ref(lock);
// Merge with subsequent free lines.
while (++lineNumber < smallLineCount) {
if (lines[lineNumber].refCount(lock))
break;
- LineMetadata& lineMetadata = m_smallRunMetadata[sizeClass][lineNumber];
+ LineMetadata& lineMetadata = m_smallLineMetadata[sizeClass][lineNumber];
if (!lineMetadata.objectCount)
continue;
objectCount += lineMetadata.objectCount;
lines[lineNumber].ref(lock, lineMetadata.objectCount);
- run->ref(lock);
+ page->ref(lock);
}
if (!allocator.canAllocate())
@@ -172,45 +172,46 @@
}
BASSERT(allocator.canAllocate());
- run->setHasFreeLines(lock, false);
+ page->setHasFreeLines(lock, false);
}
-SmallRun* Heap::allocateSmallRun(std::lock_guard<StaticMutex>& lock, size_t sizeClass)
+SmallPage* Heap::allocateSmallPage(std::lock_guard<StaticMutex>& lock, size_t sizeClass)
{
- if (!m_smallRunsWithFreeLines[sizeClass].isEmpty())
- return m_smallRunsWithFreeLines[sizeClass].pop();
+ if (!m_smallPagesWithFreeLines[sizeClass].isEmpty())
+ return m_smallPagesWithFreeLines[sizeClass].pop();
- SmallRun* run = [this, &lock]() {
- if (!m_smallRuns.isEmpty())
- return m_smallRuns.pop();
+ SmallPage* page = [this, &lock]() {
+ if (!m_smallPages.isEmpty())
+ return m_smallPages.pop();
m_isAllocatingPages = true;
- return m_vmHeap.allocateSmallRun(lock);
+ SmallPage* page = m_vmHeap.allocateSmallPage(lock);
+ return page;
}();
- run->setSizeClass(sizeClass);
- return run;
+ page->setSizeClass(sizeClass);
+ return page;
}
void Heap::deallocateSmallLine(std::lock_guard<StaticMutex>& lock, SmallLine* line)
{
BASSERT(!line->refCount(lock));
- SmallRun* run = SmallRun::get(line);
- run->deref(lock);
+ SmallPage* page = SmallPage::get(line);
+ page->deref(lock);
- if (!run->hasFreeLines(lock)) {
- run->setHasFreeLines(lock, true);
- m_smallRunsWithFreeLines[run->sizeClass()].push(run);
+ if (!page->hasFreeLines(lock)) {
+ page->setHasFreeLines(lock, true);
+ m_smallPagesWithFreeLines[page->sizeClass()].push(page);
- BASSERT(run->refCount(lock));
+ BASSERT(page->refCount(lock));
return;
}
- if (run->refCount(lock))
+ if (page->refCount(lock))
return;
- m_smallRunsWithFreeLines[run->sizeClass()].remove(run);
- m_smallRuns.push(run);
+ m_smallPagesWithFreeLines[page->sizeClass()].remove(page);
+ m_smallPages.push(page);
m_scavenger.run();
}
Modified: trunk/Source/bmalloc/bmalloc/Heap.h (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/Heap.h 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/Heap.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -34,7 +34,7 @@
#include "SegregatedFreeList.h"
#include "SmallChunk.h"
#include "SmallLine.h"
-#include "SmallRun.h"
+#include "SmallPage.h"
#include "VMHeap.h"
#include "Vector.h"
#include "XLargeMap.h"
@@ -72,9 +72,9 @@
private:
~Heap() = delete;
- void initializeSmallRunMetadata();
+ void initializeLineMetadata();
- SmallRun* allocateSmallRun(std::lock_guard<StaticMutex>&, size_t sizeClass);
+ SmallPage* allocateSmallPage(std::lock_guard<StaticMutex>&, size_t sizeClass);
void deallocateSmallLine(std::lock_guard<StaticMutex>&, SmallLine*);
void deallocateLarge(std::lock_guard<StaticMutex>&, const LargeObject&);
@@ -88,15 +88,15 @@
XLargeRange splitAndAllocate(XLargeRange&, size_t alignment, size_t);
void concurrentScavenge();
- void scavengeSmallRuns(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
+ void scavengeSmallPages(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
void scavengeLargeObjects(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
void scavengeXLargeObjects(std::unique_lock<StaticMutex>&, std::chrono::milliseconds);
- std::array<RunMetadata, smallMax / alignment> m_smallRunMetadata;
+ std::array<std::array<LineMetadata, smallLineCount>, smallMax / alignment> m_smallLineMetadata;
- std::array<List<SmallRun>, smallMax / alignment> m_smallRunsWithFreeLines;
+ std::array<List<SmallPage>, smallMax / alignment> m_smallPagesWithFreeLines;
- List<SmallRun> m_smallRuns;
+ List<SmallPage> m_smallPages;
SegregatedFreeList m_largeObjects;
Modified: trunk/Source/bmalloc/bmalloc/LineMetadata.h (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/LineMetadata.h 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/LineMetadata.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -33,8 +33,6 @@
unsigned short objectCount;
};
-typedef std::array<LineMetadata, smallLineCount> RunMetadata;
-
} // namespace bmalloc
#endif // LineMetadata_h
Modified: trunk/Source/bmalloc/bmalloc/SmallChunk.h (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/SmallChunk.h 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/SmallChunk.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -28,7 +28,7 @@
#include "Sizes.h"
#include "SmallLine.h"
-#include "SmallRun.h"
+#include "SmallPage.h"
#include "VMAllocate.h"
namespace bmalloc {
@@ -39,15 +39,15 @@
static SmallChunk* get(void*);
- SmallRun* begin() { return SmallRun::get(SmallLine::get(m_memory)); }
- SmallRun* end() { return m_runs.end(); }
+ SmallPage* begin() { return SmallPage::get(SmallLine::get(m_memory)); }
+ SmallPage* end() { return m_pages.end(); }
SmallLine* lines() { return m_lines.begin(); }
- SmallRun* runs() { return m_runs.begin(); }
+ SmallPage* pages() { return m_pages.begin(); }
private:
std::array<SmallLine, smallChunkSize / smallLineSize> m_lines;
- std::array<SmallRun, smallChunkSize / vmPageSize> m_runs;
+ std::array<SmallPage, smallChunkSize / vmPageSize> m_pages;
char m_memory[] __attribute__((aligned(2 * smallMax + 0)));
};
@@ -63,11 +63,11 @@
for (SmallLine* line = m_lines.begin(); line < SmallLine::get(m_memory); ++line) {
line->ref(lock, 1);
- SmallRun* page = SmallRun::get(line);
+ SmallPage* page = SmallPage::get(line);
page->ref(lock);
}
- for (SmallRun* page = begin(); page != end(); ++page)
+ for (SmallPage* page = begin(); page != end(); ++page)
page->setHasFreeLines(lock, true);
}
@@ -98,23 +98,23 @@
return begin() + smallLineSize;
}
-inline SmallRun* SmallRun::get(SmallLine* line)
+inline SmallPage* SmallPage::get(SmallLine* line)
{
SmallChunk* chunk = SmallChunk::get(line);
size_t lineNumber = line - chunk->lines();
- size_t runNumber = lineNumber * smallLineSize / vmPageSize;
- return &chunk->runs()[runNumber];
+ size_t pageNumber = lineNumber * smallLineSize / vmPageSize;
+ return &chunk->pages()[pageNumber];
}
-inline SmallLine* SmallRun::begin()
+inline SmallLine* SmallPage::begin()
{
SmallChunk* chunk = SmallChunk::get(this);
- size_t runNumber = this - chunk->runs();
- size_t lineNumber = runNumber * smallLineCount;
+ size_t pageNumber = this - chunk->pages();
+ size_t lineNumber = pageNumber * smallLineCount;
return &chunk->lines()[lineNumber];
}
-inline SmallLine* SmallRun::end()
+inline SmallLine* SmallPage::end()
{
return begin() + smallLineCount;
}
Copied: trunk/Source/bmalloc/bmalloc/SmallPage.h (from rev 197954, trunk/Source/bmalloc/bmalloc/SmallPage.h) (0 => 198198)
--- trunk/Source/bmalloc/bmalloc/SmallPage.h (rev 0)
+++ trunk/Source/bmalloc/bmalloc/SmallPage.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2014-2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SmallPage_h
+#define SmallPage_h
+
+#include "BAssert.h"
+#include "List.h"
+#include "Mutex.h"
+#include "VMAllocate.h"
+#include <mutex>
+
+namespace bmalloc {
+
+class SmallPage : public ListNode<SmallPage> {
+public:
+ static const unsigned char maxRefCount = std::numeric_limits<unsigned char>::max();
+ static_assert(smallLineCount < maxRefCount, "maximum line count must fit in SmallPage");
+
+ static SmallPage* get(SmallLine*);
+
+ SmallPage()
+ : m_hasFreeLines(true)
+ {
+ }
+
+ void ref(std::lock_guard<StaticMutex>&);
+ bool deref(std::lock_guard<StaticMutex>&);
+ unsigned refCount(std::lock_guard<StaticMutex>&) { return m_refCount; }
+
+ size_t sizeClass() { return m_sizeClass; }
+ void setSizeClass(size_t sizeClass) { m_sizeClass = sizeClass; }
+
+ bool hasFreeLines(std::lock_guard<StaticMutex>&) const { return m_hasFreeLines; }
+ void setHasFreeLines(std::lock_guard<StaticMutex>&, bool hasFreeLines) { m_hasFreeLines = hasFreeLines; }
+
+ SmallLine* begin();
+ SmallLine* end();
+
+private:
+ unsigned char m_hasFreeLines: 1;
+ unsigned char m_refCount: 7;
+ unsigned char m_sizeClass;
+};
+
+inline void SmallPage::ref(std::lock_guard<StaticMutex>&)
+{
+ BASSERT(m_refCount < maxRefCount);
+ ++m_refCount;
+}
+
+inline bool SmallPage::deref(std::lock_guard<StaticMutex>&)
+{
+ BASSERT(m_refCount);
+ --m_refCount;
+ return !m_refCount;
+}
+
+} // namespace bmalloc
+
+#endif // SmallPage_h
Deleted: trunk/Source/bmalloc/bmalloc/SmallRun.h (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/SmallRun.h 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/SmallRun.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2014-2016 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SmallRun_h
-#define SmallRun_h
-
-#include "BAssert.h"
-#include "List.h"
-#include "Mutex.h"
-#include "VMAllocate.h"
-#include <mutex>
-
-namespace bmalloc {
-
-class SmallRun : public ListNode<SmallRun> {
-public:
- static const unsigned char maxRefCount = std::numeric_limits<unsigned char>::max();
- static_assert(smallLineCount < maxRefCount, "maximum line count must fit in SmallRun");
-
- static SmallRun* get(SmallLine*);
-
- SmallRun()
- : m_hasFreeLines(true)
- {
- }
-
- void ref(std::lock_guard<StaticMutex>&);
- bool deref(std::lock_guard<StaticMutex>&);
- unsigned refCount(std::lock_guard<StaticMutex>&) { return m_refCount; }
-
- size_t sizeClass() { return m_sizeClass; }
- void setSizeClass(size_t sizeClass) { m_sizeClass = sizeClass; }
-
- bool hasFreeLines(std::lock_guard<StaticMutex>&) const { return m_hasFreeLines; }
- void setHasFreeLines(std::lock_guard<StaticMutex>&, bool hasFreeLines) { m_hasFreeLines = hasFreeLines; }
-
- SmallLine* begin();
- SmallLine* end();
-
-private:
- unsigned char m_hasFreeLines: 1;
- unsigned char m_refCount: 7;
- unsigned char m_sizeClass;
-};
-
-inline void SmallRun::ref(std::lock_guard<StaticMutex>&)
-{
- BASSERT(m_refCount < maxRefCount);
- ++m_refCount;
-}
-
-inline bool SmallRun::deref(std::lock_guard<StaticMutex>&)
-{
- BASSERT(m_refCount);
- --m_refCount;
- return !m_refCount;
-}
-
-} // namespace bmalloc
-
-#endif // SmallRun_h
Modified: trunk/Source/bmalloc/bmalloc/VMHeap.cpp (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/VMHeap.cpp 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/VMHeap.cpp 2016-03-15 05:39:35 UTC (rev 198198)
@@ -44,7 +44,7 @@
// We initialize chunks lazily to avoid dirtying their metadata pages.
SmallChunk* smallChunk = new (m_smallChunks.pop()->smallChunk()) SmallChunk(lock);
for (auto* it = smallChunk->begin(); it < smallChunk->end(); ++it)
- m_smallRuns.push(it);
+ m_smallPages.push(it);
}
LargeObject VMHeap::allocateLargeChunk(std::lock_guard<StaticMutex>& lock)
Modified: trunk/Source/bmalloc/bmalloc/VMHeap.h (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc/VMHeap.h 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc/VMHeap.h 2016-03-15 05:39:35 UTC (rev 198198)
@@ -50,11 +50,11 @@
public:
VMHeap();
- SmallRun* allocateSmallRun(std::lock_guard<StaticMutex>&);
+ SmallPage* allocateSmallPage(std::lock_guard<StaticMutex>&);
LargeObject allocateLargeObject(std::lock_guard<StaticMutex>&, size_t);
LargeObject allocateLargeObject(std::lock_guard<StaticMutex>&, size_t, size_t, size_t);
- void deallocateSmallRun(std::unique_lock<StaticMutex>&, SmallRun*);
+ void deallocateSmallPage(std::unique_lock<StaticMutex>&, SmallPage*);
void deallocateLargeObject(std::unique_lock<StaticMutex>&, LargeObject);
private:
@@ -62,7 +62,7 @@
LargeObject allocateLargeChunk(std::lock_guard<StaticMutex>&);
void allocateSuperChunk(std::lock_guard<StaticMutex>&);
- List<SmallRun> m_smallRuns;
+ List<SmallPage> m_smallPages;
SegregatedFreeList m_largeObjects;
Vector<SuperChunk*> m_smallChunks;
@@ -73,14 +73,14 @@
#endif
};
-inline SmallRun* VMHeap::allocateSmallRun(std::lock_guard<StaticMutex>& lock)
+inline SmallPage* VMHeap::allocateSmallPage(std::lock_guard<StaticMutex>& lock)
{
- if (m_smallRuns.isEmpty())
+ if (m_smallPages.isEmpty())
allocateSmallChunk(lock);
- SmallRun* run = m_smallRuns.pop();
- vmAllocatePhysicalPages(run->begin()->begin(), vmPageSize);
- return run;
+ SmallPage* page = m_smallPages.pop();
+ vmAllocatePhysicalPages(page->begin()->begin(), vmPageSize);
+ return page;
}
inline LargeObject VMHeap::allocateLargeObject(std::lock_guard<StaticMutex>& lock, size_t size)
@@ -101,13 +101,13 @@
return allocateLargeChunk(lock);
}
-inline void VMHeap::deallocateSmallRun(std::unique_lock<StaticMutex>& lock, SmallRun* run)
+inline void VMHeap::deallocateSmallPage(std::unique_lock<StaticMutex>& lock, SmallPage* page)
{
lock.unlock();
- vmDeallocatePhysicalPages(run->begin()->begin(), vmPageSize);
+ vmDeallocatePhysicalPages(page->begin()->begin(), vmPageSize);
lock.lock();
- m_smallRuns.push(run);
+ m_smallPages.push(page);
}
inline void VMHeap::deallocateLargeObject(std::unique_lock<StaticMutex>& lock, LargeObject largeObject)
Modified: trunk/Source/bmalloc/bmalloc.xcodeproj/project.pbxproj (198197 => 198198)
--- trunk/Source/bmalloc/bmalloc.xcodeproj/project.pbxproj 2016-03-15 05:32:45 UTC (rev 198197)
+++ trunk/Source/bmalloc/bmalloc.xcodeproj/project.pbxproj 2016-03-15 05:39:35 UTC (rev 198198)
@@ -43,7 +43,7 @@
14DD789C18F48D4A00950702 /* BumpAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E462189DE1CD00546D68 /* BumpAllocator.h */; settings = {ATTRIBUTES = (Private, ); }; };
14DD78BB18F48D6B00950702 /* SmallChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA8C18CD36A7002201E4 /* SmallChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
14DD78BC18F48D6B00950702 /* SmallLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 1452478618BC757C00F80098 /* SmallLine.h */; settings = {ATTRIBUTES = (Private, ); }; };
- 14DD78BD18F48D6B00950702 /* SmallRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 143E29ED18CAE90500FE8A0F /* SmallRun.h */; settings = {ATTRIBUTES = (Private, ); }; };
+ 14DD78BD18F48D6B00950702 /* SmallPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 143E29ED18CAE90500FE8A0F /* SmallPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
14DD78C518F48D7500950702 /* Algorithm.h in Headers */ = {isa = PBXBuildFile; fileRef = 1421A87718EE462A00B4DD68 /* Algorithm.h */; settings = {ATTRIBUTES = (Private, ); }; };
14DD78C618F48D7500950702 /* AsyncTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 1417F65218BA88A00076FA3F /* AsyncTask.h */; settings = {ATTRIBUTES = (Private, ); }; };
14DD78C718F48D7500950702 /* BAssert.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E468189EEDE400546D68 /* BAssert.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -91,7 +91,7 @@
1421A87718EE462A00B4DD68 /* Algorithm.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Algorithm.h; path = bmalloc/Algorithm.h; sourceTree = "<group>"; };
143CB81A19022BC900B16A45 /* StaticMutex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticMutex.cpp; path = bmalloc/StaticMutex.cpp; sourceTree = "<group>"; };
143CB81B19022BC900B16A45 /* StaticMutex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StaticMutex.h; path = bmalloc/StaticMutex.h; sourceTree = "<group>"; };
- 143E29ED18CAE90500FE8A0F /* SmallRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SmallRun.h; path = bmalloc/SmallRun.h; sourceTree = "<group>"; };
+ 143E29ED18CAE90500FE8A0F /* SmallPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SmallPage.h; path = bmalloc/SmallPage.h; sourceTree = "<group>"; };
143EF9AD1A9FABF6004F5C77 /* FreeList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FreeList.cpp; path = bmalloc/FreeList.cpp; sourceTree = "<group>"; };
143EF9AE1A9FABF6004F5C77 /* FreeList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FreeList.h; path = bmalloc/FreeList.h; sourceTree = "<group>"; };
1440AFC81A95142400837FAA /* SuperChunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SuperChunk.h; path = bmalloc/SuperChunk.h; sourceTree = "<group>"; };
@@ -208,7 +208,7 @@
children = (
147AAA8C18CD36A7002201E4 /* SmallChunk.h */,
1452478618BC757C00F80098 /* SmallLine.h */,
- 143E29ED18CAE90500FE8A0F /* SmallRun.h */,
+ 143E29ED18CAE90500FE8A0F /* SmallPage.h */,
);
name = "heap: small";
sourceTree = "<group>";
@@ -346,7 +346,7 @@
1400274918F89C1300115C97 /* Heap.h in Headers */,
140FA00319CE429C00FFD3C8 /* BumpRange.h in Headers */,
14DD78C518F48D7500950702 /* Algorithm.h in Headers */,
- 14DD78BD18F48D6B00950702 /* SmallRun.h in Headers */,
+ 14DD78BD18F48D6B00950702 /* SmallPage.h in Headers */,
14DD788E18F48CCD00950702 /* BoundaryTag.h in Headers */,
146041E71C7FF2EF00E9F94E /* SortedVector.h in Headers */,
14DD78C818F48D7500950702 /* FixedVector.h in Headers */,
