Changeset 180693 in webkit


Ignore:
Timestamp:
Feb 26, 2015 12:05:14 PM (9 years ago)
Author:
ggaren@apple.com
Message:

bmalloc: Refactored SegregatedFreeList and BoundaryTag::init
​https://bugs.webkit.org/show_bug.cgi?id=142049

Reviewed by Anders Carlsson.

Split out a FreeList class from SegregatedFreeList. This will make it
easier to add behaviors on free list insertion and removal -- and it's
probably how I should have designed things at the start.

Moved BoundaryTag::init into LargeObject, since all the related logic
lives in LargeObject now too, and this allows us to remove BoundaryTagInlines.h.

  • bmalloc.xcodeproj/project.pbxproj:
  • bmalloc/BoundaryTagInlines.h: Removed.
  • bmalloc/FreeList.cpp: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.cpp.

(bmalloc::FreeList::takeGreedy):
(bmalloc::FreeList::take):
(bmalloc::SegregatedFreeList::SegregatedFreeList): Deleted.
(bmalloc::SegregatedFreeList::insert): Deleted.
(bmalloc::SegregatedFreeList::takeGreedy): Deleted.
(bmalloc::SegregatedFreeList::take): Deleted.

  • bmalloc/FreeList.h: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.h.

(bmalloc::FreeList::push):

  • bmalloc/LargeObject.h:

(bmalloc::LargeObject::init):

  • bmalloc/SegregatedFreeList.cpp:

(bmalloc::SegregatedFreeList::SegregatedFreeList):
(bmalloc::SegregatedFreeList::insert):
(bmalloc::SegregatedFreeList::takeGreedy):
(bmalloc::SegregatedFreeList::take):

  • bmalloc/SegregatedFreeList.h:
  • bmalloc/Sizes.h:
  • bmalloc/VMHeap.cpp:

(bmalloc::VMHeap::grow):

Location:
trunk/Source/bmalloc
Files:
1 deleted
7 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/bmalloc/ChangeLog

    r180688 r180693  
     12015-02-26  Geoffrey Garen  <ggaren@apple.com>
     2
     3        bmalloc: Refactored SegregatedFreeList and BoundaryTag::init
     4        https://bugs.webkit.org/show_bug.cgi?id=142049
     5
     6        Reviewed by Anders Carlsson.
     7
     8        Split out a FreeList class from SegregatedFreeList. This will make it
     9        easier to add behaviors on free list insertion and removal -- and it's
     10        probably how I should have designed things at the start.
     11
     12        Moved BoundaryTag::init into LargeObject, since all the related logic
     13        lives in LargeObject now too, and this allows us to remove BoundaryTagInlines.h.
     14
     15        * bmalloc.xcodeproj/project.pbxproj:
     16        * bmalloc/BoundaryTagInlines.h: Removed.
     17        * bmalloc/FreeList.cpp: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.cpp.
     18        (bmalloc::FreeList::takeGreedy):
     19        (bmalloc::FreeList::take):
     20        (bmalloc::SegregatedFreeList::SegregatedFreeList): Deleted.
     21        (bmalloc::SegregatedFreeList::insert): Deleted.
     22        (bmalloc::SegregatedFreeList::takeGreedy): Deleted.
     23        (bmalloc::SegregatedFreeList::take): Deleted.
     24        * bmalloc/FreeList.h: Copied from Source/bmalloc/bmalloc/SegregatedFreeList.h.
     25        (bmalloc::FreeList::push):
     26        * bmalloc/LargeObject.h:
     27        (bmalloc::LargeObject::init):
     28        * bmalloc/SegregatedFreeList.cpp:
     29        (bmalloc::SegregatedFreeList::SegregatedFreeList):
     30        (bmalloc::SegregatedFreeList::insert):
     31        (bmalloc::SegregatedFreeList::takeGreedy):
     32        (bmalloc::SegregatedFreeList::take):
     33        * bmalloc/SegregatedFreeList.h:
     34        * bmalloc/Sizes.h:
     35        * bmalloc/VMHeap.cpp:
     36        (bmalloc::VMHeap::grow):
     37
    1382015-02-26  Geoffrey Garen  <ggaren@apple.com>
    239

  • trunk/Source/bmalloc/bmalloc.xcodeproj/project.pbxproj

    r180576 r180693  
    1010                1400274918F89C1300115C97 /* Heap.h in Headers */ = {isa = PBXBuildFile; fileRef = 14DA320C18875B09007269E0 /* Heap.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1111                1400274A18F89C2300115C97 /* VMHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 144F7BFC18BFC517003537F3 /* VMHeap.h */; settings = {ATTRIBUTES = (Private, ); }; };
    12                 1400274B18F89C3D00115C97 /* BoundaryTagInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = 14105E7B18DBD7AF003A106E /* BoundaryTagInlines.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1312                1400274C18F89C3D00115C97 /* SegregatedFreeList.h in Headers */ = {isa = PBXBuildFile; fileRef = 146BEE1E18C841C50002D5A2 /* SegregatedFreeList.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1413                140FA00319CE429C00FFD3C8 /* BumpRange.h in Headers */ = {isa = PBXBuildFile; fileRef = 140FA00219CE429C00FFD3C8 /* BumpRange.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1615                143CB81C19022BC900B16A45 /* StaticMutex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 143CB81A19022BC900B16A45 /* StaticMutex.cpp */; };
    1716                143CB81D19022BC900B16A45 /* StaticMutex.h in Headers */ = {isa = PBXBuildFile; fileRef = 143CB81B19022BC900B16A45 /* StaticMutex.h */; settings = {ATTRIBUTES = (Private, ); }; };
     17                143EF9AF1A9FABF6004F5C77 /* FreeList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 143EF9AD1A9FABF6004F5C77 /* FreeList.cpp */; };
     18                143EF9B01A9FABF6004F5C77 /* FreeList.h in Headers */ = {isa = PBXBuildFile; fileRef = 143EF9AE1A9FABF6004F5C77 /* FreeList.h */; };
    1819                1440AFC91A95142400837FAA /* SuperChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 1440AFC81A95142400837FAA /* SuperChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1920                1440AFCB1A95261100837FAA /* Zone.h in Headers */ = {isa = PBXBuildFile; fileRef = 1440AFCA1A95261100837FAA /* Zone.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    8182                140FA00219CE429C00FFD3C8 /* BumpRange.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BumpRange.h; path = bmalloc/BumpRange.h; sourceTree = "<group>"; };
    8283                140FA00419CE4B6800FFD3C8 /* LineMetadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LineMetadata.h; path = bmalloc/LineMetadata.h; sourceTree = "<group>"; };
    83                 14105E7B18DBD7AF003A106E /* BoundaryTagInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BoundaryTagInlines.h; path = bmalloc/BoundaryTagInlines.h; sourceTree = "<group>"; };
    8484                14105E8318E14374003A106E /* ObjectType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ObjectType.cpp; path = bmalloc/ObjectType.cpp; sourceTree = "<group>"; };
    8585                1413E460189DCE1E00546D68 /* Inline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Inline.h; path = bmalloc/Inline.h; sourceTree = "<group>"; };
    … …  
    9595                143E29E918CAE8BE00FE8A0F /* MediumPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MediumPage.h; path = bmalloc/MediumPage.h; sourceTree = "<group>"; };
    9696                143E29ED18CAE90500FE8A0F /* SmallPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SmallPage.h; path = bmalloc/SmallPage.h; sourceTree = "<group>"; };
     97                143EF9AD1A9FABF6004F5C77 /* FreeList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FreeList.cpp; path = bmalloc/FreeList.cpp; sourceTree = "<group>"; };
     98                143EF9AE1A9FABF6004F5C77 /* FreeList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FreeList.h; path = bmalloc/FreeList.h; sourceTree = "<group>"; };
    9799                1440AFC81A95142400837FAA /* SuperChunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SuperChunk.h; path = bmalloc/SuperChunk.h; sourceTree = "<group>"; };
    98100                1440AFCA1A95261100837FAA /* Zone.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Zone.h; path = bmalloc/Zone.h; sourceTree = "<group>"; };
    … …  
    218220                                1417F64518B54A700076FA3F /* BeginTag.h */,
    219221                                1485655E18A43AF900ED6942 /* BoundaryTag.h */,
    220                                 14105E7B18DBD7AF003A106E /* BoundaryTagInlines.h */,
    221222                                1417F64618B54A700076FA3F /* EndTag.h */,
     223                                143EF9AD1A9FABF6004F5C77 /* FreeList.cpp */,
     224                                143EF9AE1A9FABF6004F5C77 /* FreeList.h */,
    222225                                147AAA8818CD17CE002201E4 /* LargeChunk.h */,
    223226                                14C6216E1A9A9A6200E72293 /* LargeObject.h */,
    … …  
    335338                                14DD78D018F48D7500950702 /* VMAllocate.h in Headers */,
    336339                                1440AFC91A95142400837FAA /* SuperChunk.h in Headers */,
     340                                143EF9B01A9FABF6004F5C77 /* FreeList.h in Headers */,
    337341                                14DD78CE18F48D7500950702 /* Syscall.h in Headers */,
    338342                                14DD78C618F48D7500950702 /* AsyncTask.h in Headers */,
    … …  
    347351                                14DD78C518F48D7500950702 /* Algorithm.h in Headers */,
    348352                                14DD78BD18F48D6B00950702 /* SmallPage.h in Headers */,
    349                                 1400274B18F89C3D00115C97 /* BoundaryTagInlines.h in Headers */,
    350353                                14DD788E18F48CCD00950702 /* BoundaryTag.h in Headers */,
    351354                                14DD78C818F48D7500950702 /* FixedVector.h in Headers */,
    … …  
    440443                                14F271C318EA3978008C152F /* Allocator.cpp in Sources */,
    441444                                14895D911A3A319C0006235D /* Environment.cpp in Sources */,
     445                                143EF9AF1A9FABF6004F5C77 /* FreeList.cpp in Sources */,
    442446                                14F271C718EA3990008C152F /* Heap.cpp in Sources */,
    443447                                14F271C918EA3990008C152F /* VMHeap.cpp in Sources */,

  • trunk/Source/bmalloc/bmalloc/FreeList.cpp

    r180686 r180693  
    2626#include "BeginTag.h"
    2727#include "LargeChunk.h"
    28 #include "SegregatedFreeList.h"
     28#include "FreeList.h"
    2929#include "Vector.h"
    3030
    3131namespace bmalloc {
    3232
    33 SegregatedFreeList::SegregatedFreeList()
     33LargeObject FreeList::takeGreedy(size_t size)
    3434{
    35     BASSERT(static_cast<size_t>(&select(largeMax) - m_lists.begin()) == m_lists.size() - 1);
    36 }
    37 
    38 void SegregatedFreeList::insert(const LargeObject& largeObject)
    39 {
    40     BASSERT(largeObject.isFree());
    41     auto& list = select(largeObject.size());
    42     list.push(largeObject.range());
    43 }
    44 
    45 LargeObject SegregatedFreeList::takeGreedy(size_t size)
    46 {
    47     for (size_t i = m_lists.size(); i-- > 0; ) {
    48         LargeObject largeObject = takeGreedy(m_lists[i], size);
    49         if (!largeObject)
    50             continue;
    51 
    52         return largeObject;
    53     }
    54     return LargeObject();
    55 }
    56 
    57 LargeObject SegregatedFreeList::takeGreedy(List& list, size_t size)
    58 {
    59     for (size_t i = list.size(); i-- > 0; ) {
     35    for (size_t i = m_vector.size(); i-- > 0; ) {
    6036        // We don't eagerly remove items when we merge and/or split ranges,
    6137        // so we need to validate each free list entry before using it.
    62         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    63         if (!largeObject.isValidAndFree(list[i].size())) {
    64             list.pop(i);
     38        LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin());
     39        if (!largeObject.isValidAndFree(m_vector[i].size())) {
     40            m_vector.pop(i);
    6541            continue;
    6642        }
    … …  
    6945            continue;
    7046
    71         list.pop(i);
     47        m_vector.pop(i);
    7248        return largeObject;
    7349    }
    … …  
    7652}
    7753
    78 LargeObject SegregatedFreeList::take(size_t size)
    79 {
    80     for (auto* list = &select(size); list != m_lists.end(); ++list) {
    81         LargeObject largeObject = take(*list, size);
    82         if (!largeObject)
    83             continue;
    84 
    85         return largeObject;
    86     }
    87     return LargeObject();
    88 }
    89 
    90 LargeObject SegregatedFreeList::take(size_t alignment, size_t size, size_t unalignedSize)
    91 {
    92     for (auto* list = &select(size); list != m_lists.end(); ++list) {
    93         LargeObject largeObject = take(*list, alignment, size, unalignedSize);
    94         if (!largeObject)
    95             continue;
    96 
    97         return largeObject;
    98     }
    99     return LargeObject();
    100 }
    101 
    102 INLINE auto SegregatedFreeList::select(size_t size) -> List&
    103 {
    104     size_t alignCount = (size - largeMin) / largeAlignment;
    105     size_t result = 0;
    106     while (alignCount) {
    107         ++result;
    108         alignCount >>= 1;
    109     }
    110     return m_lists[result];
    111 }
    112 
    113 INLINE LargeObject SegregatedFreeList::take(List& list, size_t size)
     54LargeObject FreeList::take(size_t size)
    11455{
    11556    LargeObject first;
    116     size_t end = list.size() > segregatedFreeListSearchDepth ? list.size() - segregatedFreeListSearchDepth : 0;
    117     for (size_t i = list.size(); i-- > end; ) {
     57    size_t end = m_vector.size() > freeListSearchDepth ? m_vector.size() - freeListSearchDepth : 0;
     58    for (size_t i = m_vector.size(); i-- > end; ) {
    11859        // We don't eagerly remove items when we merge and/or split ranges, so
    11960        // we need to validate each free list entry before using it.
    120         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    121         if (!largeObject.isValidAndFree(list[i].size())) {
    122             list.pop(i);
     61        LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin());
     62        if (!largeObject.isValidAndFree(m_vector[i].size())) {
     63            m_vector.pop(i);
    12364            continue;
    12465        }
    … …  
    13677}
    13778
    138 INLINE LargeObject SegregatedFreeList::take(List& list, size_t alignment, size_t size, size_t unalignedSize)
     79LargeObject FreeList::take(size_t alignment, size_t size, size_t unalignedSize)
    13980{
    14081    BASSERT(isPowerOfTwo(alignment));
    … …  
    14283
    14384    LargeObject first;
    144     size_t end = list.size() > segregatedFreeListSearchDepth ? list.size() - segregatedFreeListSearchDepth : 0;
    145     for (size_t i = list.size(); i-- > end; ) {
     85    size_t end = m_vector.size() > freeListSearchDepth ? m_vector.size() - freeListSearchDepth : 0;
     86    for (size_t i = m_vector.size(); i-- > end; ) {
    14687        // We don't eagerly remove items when we merge and/or split ranges, so
    14788        // we need to validate each free list entry before using it.
    148         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    149         if (!largeObject.isValidAndFree(list[i].size())) {
    150             list.pop(i);
     89        LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin());
     90        if (!largeObject.isValidAndFree(m_vector[i].size())) {
     91            m_vector.pop(i);
    15192            continue;
    15293        }

  • trunk/Source/bmalloc/bmalloc/FreeList.h

    r180686 r180693  
    2424 */
    2525
    26 #ifndef SegregatedFreeList_h
    27 #define SegregatedFreeList_h
     26#ifndef FreeList_h
     27#define FreeList_h
    2828
    2929#include "LargeObject.h"
    3030#include "Vector.h"
    31 #include <array>
    3231
    3332namespace bmalloc {
    3433
    35 class SegregatedFreeList {
     34// Helper object for SegregatedFreeList.
     35
     36class FreeList {
    3637public:
    37     SegregatedFreeList();
     38    void push(const LargeObject&);
    3839
    39     void insert(const LargeObject&);
    40 
    41     // Returns a reasonable fit for the provided size, or LargeObject() if no fit
    42     // is found. May return LargeObject() spuriously if searching takes too long.
    43     // Incrementally removes stale items from the free list while searching.
    44     // Does not eagerly remove the returned object from the free list.
    4540    LargeObject take(size_t);
    46 
    47     // Returns a reasonable fit for the provided alignment and size, or
    48     // a reasonable fit for the provided unaligned size, or LargeObject() if no
    49     // fit is found. May return LargeObject() spuriously if searching takes too
    50     // long. Incrementally removes stale items from the free list while
    51     // searching. Does not eagerly remove the returned object from the free list.
    5241    LargeObject take(size_t alignment, size_t, size_t unalignedSize);
    53 
    54     // Returns an unreasonable fit for the provided size, or LargeObject() if no
    55     // fit is found. Never returns LargeObject() spuriously. Incrementally
    56     // removes stale items from the free list while searching. Eagerly removes
    57     // the returned object from the free list.
    5842    LargeObject takeGreedy(size_t);
    5943   
    6044private:
    61     typedef Vector<Range> List;
     45    Vector<Range> m_vector;
     46};
    6247
    63     List& select(size_t);
    64     LargeObject take(List&, size_t);
    65     LargeObject take(List&, size_t alignment, size_t, size_t unalignedSize);
    66     LargeObject takeGreedy(List&, size_t);
    67 
    68     std::array<List, 19> m_lists;
    69 };
     48inline void FreeList::push(const LargeObject& largeObject)
     49{
     50    BASSERT(largeObject.isFree());
     51    m_vector.push(largeObject.range());
     52}
    7053
    7154} // namespace bmalloc
    7255
    73 #endif // SegregatedFreeList_h
     56#endif // FreeList_h

  • trunk/Source/bmalloc/bmalloc/LargeObject.h

    r180576 r180693  
    3030#include "EndTag.h"
    3131#include "LargeChunk.h"
     32#include "Range.h"
    3233
    3334namespace bmalloc {
    … …  
    3536class LargeObject {
    3637public:
     38    static Range init(LargeChunk*);
     39
    3740    LargeObject();
    3841    LargeObject(void*);
    … …  
    238241}
    239242
     243inline Range LargeObject::init(LargeChunk* chunk)
     244{
     245    Range range(chunk->begin(), chunk->end() - chunk->begin());
     246
     247    BeginTag* beginTag = LargeChunk::beginTag(range.begin());
     248    beginTag->setRange(range);
     249    beginTag->setFree(true);
     250    beginTag->setHasPhysicalPages(false);
     251
     252    EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
     253    endTag->init(beginTag);
     254
     255    // Mark the left and right edges of our chunk as allocated. This naturally
     256    // prevents merging logic from overflowing beyond our chunk, without requiring
     257    // special-case checks.
     258   
     259    EndTag* leftSentinel = beginTag->prev();
     260    BASSERT(leftSentinel >= static_cast<void*>(chunk));
     261    leftSentinel->initSentinel();
     262
     263    BeginTag* rightSentinel = endTag->next();
     264    BASSERT(rightSentinel < static_cast<void*>(range.begin()));
     265    rightSentinel->initSentinel();
     266   
     267    return range;
     268}
     269
    240270} // namespace bmalloc
    241271

  • trunk/Source/bmalloc/bmalloc/SegregatedFreeList.cpp

    r180576 r180693  
    2424 */
    2525
    26 #include "BeginTag.h"
    27 #include "LargeChunk.h"
    2826#include "SegregatedFreeList.h"
    29 #include "Vector.h"
    3027
    3128namespace bmalloc {
    … …  
    3330SegregatedFreeList::SegregatedFreeList()
    3431{
    35     BASSERT(static_cast<size_t>(&select(largeMax) - m_lists.begin()) == m_lists.size() - 1);
     32    BASSERT(static_cast<size_t>(&select(largeMax) - m_freeLists.begin()) == m_freeLists.size() - 1);
    3633}
    3734
    3835void SegregatedFreeList::insert(const LargeObject& largeObject)
    3936{
    40     BASSERT(largeObject.isFree());
    4137    auto& list = select(largeObject.size());
    42     list.push(largeObject.range());
     38    list.push(largeObject);
    4339}
    4440
    4541LargeObject SegregatedFreeList::takeGreedy(size_t size)
    4642{
    47     for (size_t i = m_lists.size(); i-- > 0; ) {
    48         LargeObject largeObject = takeGreedy(m_lists[i], size);
     43    for (size_t i = m_freeLists.size(); i-- > 0; ) {
     44        LargeObject largeObject = m_freeLists[i].takeGreedy(size);
    4945        if (!largeObject)
    5046            continue;
    … …  
    5551}
    5652
    57 LargeObject SegregatedFreeList::takeGreedy(List& list, size_t size)
    58 {
    59     for (size_t i = list.size(); i-- > 0; ) {
    60         // We don't eagerly remove items when we merge and/or split ranges,
    61         // so we need to validate each free list entry before using it.
    62         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    63         if (!largeObject.isValidAndFree(list[i].size())) {
    64             list.pop(i);
    65             continue;
    66         }
    67 
    68         if (largeObject.size() < size)
    69             continue;
    70 
    71         list.pop(i);
    72         return largeObject;
    73     }
    74 
    75     return LargeObject();
    76 }
    77 
    7853LargeObject SegregatedFreeList::take(size_t size)
    7954{
    80     for (auto* list = &select(size); list != m_lists.end(); ++list) {
    81         LargeObject largeObject = take(*list, size);
     55    for (auto* list = &select(size); list != m_freeLists.end(); ++list) {
     56        LargeObject largeObject = list->take(size);
    8257        if (!largeObject)
    8358            continue;
    … …  
    9065LargeObject SegregatedFreeList::take(size_t alignment, size_t size, size_t unalignedSize)
    9166{
    92     for (auto* list = &select(size); list != m_lists.end(); ++list) {
    93         LargeObject largeObject = take(*list, alignment, size, unalignedSize);
     67    for (auto* list = &select(size); list != m_freeLists.end(); ++list) {
     68        LargeObject largeObject = list->take(alignment, size, unalignedSize);
    9469        if (!largeObject)
    9570            continue;
    … …  
    10075}
    10176
    102 INLINE auto SegregatedFreeList::select(size_t size) -> List&
     77INLINE auto SegregatedFreeList::select(size_t size) -> FreeList&
    10378{
    10479    size_t alignCount = (size - largeMin) / largeAlignment;
    … …  
    10883        alignCount >>= 1;
    10984    }
    110     return m_lists[result];
    111 }
    112 
    113 INLINE LargeObject SegregatedFreeList::take(List& list, size_t size)
    114 {
    115     LargeObject first;
    116     size_t end = list.size() > segregatedFreeListSearchDepth ? list.size() - segregatedFreeListSearchDepth : 0;
    117     for (size_t i = list.size(); i-- > end; ) {
    118         // We don't eagerly remove items when we merge and/or split ranges, so
    119         // we need to validate each free list entry before using it.
    120         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    121         if (!largeObject.isValidAndFree(list[i].size())) {
    122             list.pop(i);
    123             continue;
    124         }
    125 
    126         if (largeObject.size() < size)
    127             continue;
    128 
    129         if (!!first && first.begin() < largeObject.begin())
    130             continue;
    131 
    132         first = largeObject;
    133     }
    134    
    135     return first;
    136 }
    137 
    138 INLINE LargeObject SegregatedFreeList::take(List& list, size_t alignment, size_t size, size_t unalignedSize)
    139 {
    140     BASSERT(isPowerOfTwo(alignment));
    141     size_t alignmentMask = alignment - 1;
    142 
    143     LargeObject first;
    144     size_t end = list.size() > segregatedFreeListSearchDepth ? list.size() - segregatedFreeListSearchDepth : 0;
    145     for (size_t i = list.size(); i-- > end; ) {
    146         // We don't eagerly remove items when we merge and/or split ranges, so
    147         // we need to validate each free list entry before using it.
    148         LargeObject largeObject(LargeObject::DoNotValidate, list[i].begin());
    149         if (!largeObject.isValidAndFree(list[i].size())) {
    150             list.pop(i);
    151             continue;
    152         }
    153 
    154         if (largeObject.size() < size)
    155             continue;
    156 
    157         if (test(largeObject.begin(), alignmentMask) && largeObject.size() < unalignedSize)
    158             continue;
    159 
    160         if (!!first && first.begin() < largeObject.begin())
    161             continue;
    162 
    163         first = largeObject;
    164     }
    165    
    166     return first;
     85    return m_freeLists[result];
    16786}
    16887

  • trunk/Source/bmalloc/bmalloc/SegregatedFreeList.h

    r180576 r180693  
    2727#define SegregatedFreeList_h
    2828
    29 #include "LargeObject.h"
    30 #include "Vector.h"
     29#include "FreeList.h"
    3130#include <array>
    3231
    … …  
    5958   
    6059private:
    61     typedef Vector<Range> List;
     60    FreeList& select(size_t);
    6261
    63     List& select(size_t);
    64     LargeObject take(List&, size_t);
    65     LargeObject take(List&, size_t alignment, size_t, size_t unalignedSize);
    66     LargeObject takeGreedy(List&, size_t);
    67 
    68     std::array<List, 19> m_lists;
     62    std::array<FreeList, 19> m_freeLists;
    6963};
    7064

  • trunk/Source/bmalloc/bmalloc/Sizes.h

    r180688 r180693  
    8282    static const size_t xLargeAlignment = vmPageSize;
    8383
    84     static const size_t segregatedFreeListSearchDepth = 16;
     84    static const size_t freeListSearchDepth = 16;
    8585
    8686    static const uintptr_t typeMask = (superChunkSize - 1) & ~((superChunkSize / 4) - 1); // 4 taggable chunks

  • trunk/Source/bmalloc/bmalloc/VMHeap.cpp

    r180604 r180693  
    2424 */
    2525
    26 #include "BoundaryTagInlines.h"
    27 #include "LargeChunk.h"
     26#include "LargeObject.h"
    2827#include "Line.h"
    2928#include "PerProcess.h"
    … …  
    5453
    5554    LargeChunk* largeChunk = superChunk->largeChunk();
    56     m_largeObjects.insert(LargeObject(BoundaryTag::init(largeChunk).begin()));
     55    m_largeObjects.insert(LargeObject(LargeObject::init(largeChunk).begin()));
    5756}
    5857
Note: See TracChangeset for help on using the changeset viewer.