bmalloc: Renamed LargeChunk => Chunk
[WebKit-https.git] / Source / bmalloc / bmalloc / Chunk.h
similarity index 77%
rename from Source/bmalloc/bmalloc/LargeChunk.h
rename to Source/bmalloc/bmalloc/Chunk.h
index 86df802..fc5c3e1 100644 (file)
@@ -23,8 +23,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef LargeChunk_h
-#define LargeChunk_h
+#ifndef Chunk_h
+#define Chunk_h
 
 #include "BeginTag.h"
 #include "EndTag.h"
 
 namespace bmalloc {
 
-class LargeChunk {
+class Chunk {
 public:
-    static LargeChunk* get(void*);
+    static Chunk* get(void*);
 
     static BeginTag* beginTag(void*);
     static EndTag* endTag(void*, size_t);
 
-    LargeChunk(std::lock_guard<StaticMutex>&);
+    Chunk(std::lock_guard<StaticMutex>&);
 
     size_t offset(void*);
 
@@ -60,11 +60,11 @@ public:
     SmallPage* pages() { return m_pages.begin(); }
 
     char* begin() { return m_memory; }
-    char* end() { return reinterpret_cast<char*>(this) + largeChunkSize; }
+    char* end() { return reinterpret_cast<char*>(this) + chunkSize; }
 
 private:
-    static const size_t boundaryTagCount = largeChunkSize / largeMin;
-    static_assert(boundaryTagCount > 2, "LargeChunk must have space for two sentinel boundary tags");
+    static const size_t boundaryTagCount = chunkSize / largeMin;
+    static_assert(boundaryTagCount > 2, "Chunk must have space for two sentinel boundary tags");
 
     // Our metadata layout includes a left and right edge sentinel.
     // Metadata takes up enough space to leave at least the first two
@@ -80,28 +80,28 @@ private:
     //
     // We use the X's for boundary tags and the O's for edge sentinels.
 
-    std::array<SmallLine, largeChunkSize / smallLineSize> m_lines;
-    std::array<SmallPage, largeChunkSize / vmPageSize> m_pages;
+    std::array<SmallLine, chunkSize / smallLineSize> m_lines;
+    std::array<SmallPage, chunkSize / vmPageSize> m_pages;
     std::array<BoundaryTag, boundaryTagCount> m_boundaryTags;
     char m_memory[] __attribute__((aligned(2 * smallMax + 0)));
 };
 
-static_assert(sizeof(LargeChunk) + largeMax <= largeChunkSize, "largeMax is too big");
+static_assert(sizeof(Chunk) + largeMax <= chunkSize, "largeMax is too big");
 static_assert(
-    sizeof(LargeChunk) % vmPageSize + 2 * smallMax <= vmPageSize,
+    sizeof(Chunk) % vmPageSize + 2 * smallMax <= vmPageSize,
     "the first page of object memory in a small chunk must be able to allocate smallMax");
 
-inline LargeChunk::LargeChunk(std::lock_guard<StaticMutex>& lock)
+inline Chunk::Chunk(std::lock_guard<StaticMutex>& lock)
 {
     Range range(begin(), end() - begin());
     BASSERT(range.size() <= largeObjectMax);
 
-    BeginTag* beginTag = LargeChunk::beginTag(range.begin());
+    BeginTag* beginTag = Chunk::beginTag(range.begin());
     beginTag->setRange(range);
     beginTag->setFree(true);
     beginTag->setVMState(VMState::Virtual);
 
-    EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
+    EndTag* endTag = Chunk::endTag(range.begin(), range.size());
     endTag->init(beginTag);
 
     // Mark the left and right edges of our range as allocated. This naturally
@@ -126,21 +126,21 @@ inline LargeChunk::LargeChunk(std::lock_guard<StaticMutex>& lock)
     }
 }
 
-inline LargeChunk* LargeChunk::get(void* object)
+inline Chunk* Chunk::get(void* object)
 {
-    return static_cast<LargeChunk*>(mask(object, largeChunkMask));
+    return static_cast<Chunk*>(mask(object, chunkMask));
 }
 
-inline BeginTag* LargeChunk::beginTag(void* object)
+inline BeginTag* Chunk::beginTag(void* object)
 {
-    LargeChunk* chunk = get(object);
+    Chunk* chunk = get(object);
     size_t boundaryTagNumber = (static_cast<char*>(object) - reinterpret_cast<char*>(chunk)) / largeMin - 1; // - 1 to offset from the right sentinel.
     return static_cast<BeginTag*>(&chunk->m_boundaryTags[boundaryTagNumber]);
 }
 
-inline EndTag* LargeChunk::endTag(void* object, size_t size)
+inline EndTag* Chunk::endTag(void* object, size_t size)
 {
-    LargeChunk* chunk = get(object);
+    Chunk* chunk = get(object);
     char* end = static_cast<char*>(object) + size;
 
     // We subtract largeMin before computing the end pointer's boundary tag. An
@@ -151,25 +151,25 @@ inline EndTag* LargeChunk::endTag(void* object, size_t size)
     return static_cast<EndTag*>(&chunk->m_boundaryTags[boundaryTagNumber]);
 }
 
-inline size_t LargeChunk::offset(void* object)
+inline size_t Chunk::offset(void* object)
 {
     BASSERT(object >= this);
-    BASSERT(object < reinterpret_cast<char*>(this) + largeChunkSize);
+    BASSERT(object < reinterpret_cast<char*>(this) + chunkSize);
     return static_cast<char*>(object) - reinterpret_cast<char*>(this);
 }
 
-inline void* LargeChunk::object(size_t offset)
+inline void* Chunk::object(size_t offset)
 {
     return reinterpret_cast<char*>(this) + offset;
 }
 
-inline SmallPage* LargeChunk::page(size_t offset)
+inline SmallPage* Chunk::page(size_t offset)
 {
     size_t pageNumber = offset / vmPageSize;
     return &m_pages[pageNumber];
 }
 
-inline SmallLine* LargeChunk::line(size_t offset)
+inline SmallLine* Chunk::line(size_t offset)
 {
     size_t lineNumber = offset / smallLineSize;
     return &m_lines[lineNumber];
@@ -177,7 +177,7 @@ inline SmallLine* LargeChunk::line(size_t offset)
 
 inline char* SmallLine::begin()
 {
-    LargeChunk* chunk = LargeChunk::get(this);
+    Chunk* chunk = Chunk::get(this);
     size_t lineNumber = this - chunk->lines();
     size_t offset = lineNumber * smallLineSize;
     return &reinterpret_cast<char*>(chunk)[offset];
@@ -190,7 +190,7 @@ inline char* SmallLine::end()
 
 inline SmallLine* SmallPage::begin()
 {
-    LargeChunk* chunk = LargeChunk::get(this);
+    Chunk* chunk = Chunk::get(this);
     size_t pageNumber = this - chunk->pages();
     size_t lineNumber = pageNumber * smallLineCount;
     return &chunk->lines()[lineNumber];
@@ -202,16 +202,16 @@ inline SmallLine* SmallPage::end()
 }
 
 inline Object::Object(void* object)
-    : m_chunk(LargeChunk::get(object))
+    : m_chunk(Chunk::get(object))
     , m_offset(m_chunk->offset(object))
 {
 }
 
-inline Object::Object(LargeChunk* chunk, void* object)
+inline Object::Object(Chunk* chunk, void* object)
     : m_chunk(chunk)
     , m_offset(m_chunk->offset(object))
 {
-    BASSERT(chunk == LargeChunk::get(object));
+    BASSERT(chunk == Chunk::get(object));
 }
 
 inline void* Object::begin()
@@ -236,4 +236,4 @@ inline SmallPage* Object::page()
 
 }; // namespace bmalloc
 
-#endif // LargeChunk
+#endif // Chunk