Changeset 240171 in webkit


Ignore:
Timestamp:
Jan 18, 2019 1:32:32 PM (5 years ago)
Author:
Matt Lewis
Message:

Unreviewed, rolling out r240160.

This broke multiple internal builds.

Reverted changeset:

"Gigacages should start allocations from a slide"
​https://bugs.webkit.org/show_bug.cgi?id=193523
​https://trac.webkit.org/changeset/240160

Location:
trunk/Source
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r240160 r240171  
     12019-01-18  Matt Lewis  <jlewis3@apple.com>
     2
     3        Unreviewed, rolling out r240160.
     4
     5        This broke multiple internal builds.
     6
     7        Reverted changeset:
     8
     9        "Gigacages should start allocations from a slide"
     10        https://bugs.webkit.org/show_bug.cgi?id=193523
     11        https://trac.webkit.org/changeset/240160
     12
    1132019-01-18  Keith Miller  <keith_miller@apple.com>
    214

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r240160 r240171  
    13161316    btiz t0, IsArray, .opGetByIdSlow
    13171317    btiz t0, IndexingShapeMask, .opGetByIdSlow
    1318     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr Gigacage::jsValueGigacageMask, JSObject::m_butterfly[t3], t0, t1)
     1318    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr JSVALUE_GIGACAGE_MASK, JSObject::m_butterfly[t3], t0, t1)
    13191319    loadi -sizeof IndexingHeader + IndexingHeader::u.lengths.publicLength[t0], t0
    13201320    bilt t0, 0, .opGetByIdSlow
    … …  
    14391439    sxi2q t1, t1
    14401440
    1441     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr Gigacage::jsValueGigacageMask, JSObject::m_butterfly[t0], t3, tagTypeNumber)
     1441    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr JSVALUE_GIGACAGE_MASK, JSObject::m_butterfly[t0], t3, tagTypeNumber)
    14421442    move TagTypeNumber, tagTypeNumber
    14431443
    … …  
    15051505
    15061506    # We have Int8ArrayType.
    1507     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1507    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15081508    loadbs [t3, t1], t0
    15091509    finishIntGetByVal(t0, t1)
    … …  
    15131513
    15141514    # We have Uint8ArrayType.
    1515     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1515    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15161516    loadb [t3, t1], t0
    15171517    finishIntGetByVal(t0, t1)
    … …  
    15191519.opGetByValUint8ClampedArray:
    15201520    # We have Uint8ClampedArrayType.
    1521     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1521    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15221522    loadb [t3, t1], t0
    15231523    finishIntGetByVal(t0, t1)
    … …  
    15281528
    15291529    # We have Int16ArrayType.
    1530     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1530    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15311531    loadhs [t3, t1, 2], t0
    15321532    finishIntGetByVal(t0, t1)
    … …  
    15341534.opGetByValUint16Array:
    15351535    # We have Uint16ArrayType.
    1536     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1536    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15371537    loadh [t3, t1, 2], t0
    15381538    finishIntGetByVal(t0, t1)
    … …  
    15461546
    15471547    # We have Int32ArrayType.
    1548     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1548    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15491549    loadi [t3, t1, 4], t0
    15501550    finishIntGetByVal(t0, t1)
    … …  
    15521552.opGetByValUint32Array:
    15531553    # We have Uint32ArrayType.
    1554     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1554    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15551555    # This is the hardest part because of large unsigned values.
    15561556    loadi [t3, t1, 4], t0
    … …  
    15641564
    15651565    # We have Float64ArrayType.
    1566     loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr Gigacage::primitiveGigacageMask, JSArrayBufferView::m_vector[t0], t3, t2)
     1566    loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::primitive, constexpr PRIMITIVE_GIGACAGE_MASK, JSArrayBufferView::m_vector[t0], t3, t2)
    15671567    loadd [t3, t1, 8], ft0
    15681568    bdnequn ft0, ft0, .opGetByValSlow
    … …  
    16001600        loadConstantOrVariableInt32(size, t0, t3, .opPutByValSlow)
    16011601        sxi2q t3, t3
    1602         loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr Gigacage::jsValueGigacageMask, JSObject::m_butterfly[t1], t0, tagTypeNumber)
     1602        loadCaged(_g_gigacageBasePtrs + Gigacage::BasePtrs::jsValue, constexpr JSVALUE_GIGACAGE_MASK, JSObject::m_butterfly[t1], t0, tagTypeNumber)
    16031603        move TagTypeNumber, tagTypeNumber
    16041604        btinz t2, CopyOnWrite, .opPutByValSlow

  • trunk/Source/WTF/ChangeLog

    r240160 r240171  
     12019-01-18  Matt Lewis  <jlewis3@apple.com>
     2
     3        Unreviewed, rolling out r240160.
     4
     5        This broke multiple internal builds.
     6
     7        Reverted changeset:
     8
     9        "Gigacages should start allocations from a slide"
     10        https://bugs.webkit.org/show_bug.cgi?id=193523
     11        https://trac.webkit.org/changeset/240160
     12
    1132019-01-18  Keith Miller  <keith_miller@apple.com>
    214

  • trunk/Source/WTF/wtf/Gigacage.cpp

    r240160 r240171  
    3333#if defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC
    3434
     35alignas(void*) char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
     36
    3537namespace Gigacage {
    36 
    37 alignas(void*) char g_gigacageBasePtrs[gigacageBasePtrsSize];
    3838
    3939void* tryMalloc(Kind, size_t size)
    … …  
    6262
    6363} // namespace Gigacage
    64 #else // defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC
     64#else
    6565#include <bmalloc/bmalloc.h>
    6666

  • trunk/Source/WTF/wtf/Gigacage.h

    r240160 r240171  
    2727
    2828#include <wtf/FastMalloc.h>
    29 #include <wtf/StdLibExtras.h>
    3029
    3130#if defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC
    3231#define GIGACAGE_ENABLED 0
     32#define PRIMITIVE_GIGACAGE_MASK 0
     33#define JSVALUE_GIGACAGE_MASK 0
     34#define GIGACAGE_BASE_PTRS_SIZE 8192
     35
     36extern "C" {
     37alignas(void*) extern WTF_EXPORT_PRIVATE char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
     38}
    3339
    3440namespace Gigacage {
    35 
    36 const size_t primitiveGigacageMask = 0;
    37 const size_t jsValueGigacageMask = 0;
    38 const size_t gigacageBasePtrsSize = 8 * KB;
    39 
    40 extern "C" alignas(void*) WTF_EXPORT_PRIVATE char g_gigacageBasePtrs[gigacageBasePtrsSize];
    4141
    4242struct BasePtrs {

  • trunk/Source/bmalloc/ChangeLog

    r240160 r240171  
     12019-01-18  Matt Lewis  <jlewis3@apple.com>
     2
     3        Unreviewed, rolling out r240160.
     4
     5        This broke multiple internal builds.
     6
     7        Reverted changeset:
     8
     9        "Gigacages should start allocations from a slide"
     10        https://bugs.webkit.org/show_bug.cgi?id=193523
     11        https://trac.webkit.org/changeset/240160
     12
    1132019-01-18  Keith Miller  <keith_miller@apple.com>
    214

  • trunk/Source/bmalloc/bmalloc/Gigacage.cpp

    r240160 r240171  
    3636#include <mutex>
    3737
    38 #if GIGACAGE_ENABLED
    39 
    40 namespace Gigacage {
    41 
    4238// This is exactly 32GB because inside JSC, indexed accesses for arrays, typed arrays, etc,
    4339// use unsigned 32-bit ints as indices. The items those indices access are 8 bytes or less
    … …  
    4541// bounds, the access is guaranteed to land somewhere else in the cage or inside the runway.
    4642// If this were less than 32GB, those OOB accesses could reach outside of the cage.
    47 constexpr size_t gigacageRunway = 32llu * 1024 * 1024 * 1024;
     43#define GIGACAGE_RUNWAY (32llu * 1024 * 1024 * 1024)
    4844
    4945// Note: g_gigacageBasePtrs[0] is reserved for storing the wasEnabled flag.
    … …  
    5147// This is done so that the wasEnabled flag will also be protected along with the
    5248// gigacageBasePtrs.
    53 alignas(gigacageBasePtrsSize) char g_gigacageBasePtrs[gigacageBasePtrsSize];
     49alignas(GIGACAGE_BASE_PTRS_SIZE) char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
    5450
    5551using namespace bmalloc;
     52
     53namespace Gigacage {
    5654
    5755namespace {
    … …  
    6462    // We might only get page size alignment, but that's also the minimum we need.
    6563    RELEASE_BASSERT(!(basePtrs & (vmPageSize() - 1)));
    66     mprotect(g_gigacageBasePtrs, gigacageBasePtrsSize, PROT_READ);
     64    mprotect(g_gigacageBasePtrs, GIGACAGE_BASE_PTRS_SIZE, PROT_READ);
    6765}
    6866
    6967void unprotectGigacageBasePtrs()
    7068{
    71     mprotect(g_gigacageBasePtrs, gigacageBasePtrsSize, PROT_READ | PROT_WRITE);
     69    mprotect(g_gigacageBasePtrs, GIGACAGE_BASE_PTRS_SIZE, PROT_READ | PROT_WRITE);
    7270}
    7371
    … …  
    104102};
    105103
     104#if GIGACAGE_ENABLED
    106105size_t runwaySize(Kind kind)
    107106{
    … …  
    110109        RELEASE_BASSERT_NOT_REACHED();
    111110    case Kind::Primitive:
    112         return gigacageRunway;
     111        return static_cast<size_t>(GIGACAGE_RUNWAY);
    113112    case Kind::JSValue:
    114         return 0;
    115     }
    116     return 0;
    117 }
     113        return static_cast<size_t>(0);
     114    }
     115    return static_cast<size_t>(0);
     116}
     117#endif
    118118
    119119} // anonymous namespace
    … …  
    121121void ensureGigacage()
    122122{
     123#if GIGACAGE_ENABLED
    123124    static std::once_flag onceFlag;
    124125    std::call_once(
    … …  
    189190            protectGigacageBasePtrs();
    190191        });
     192#endif // GIGACAGE_ENABLED
    191193}
    192194
    … …  
    264266{
    265267    static bool cached = false;
     268
     269#if GIGACAGE_ENABLED
    266270    static std::once_flag onceFlag;
    267271    std::call_once(
    … …  
    285289            cached = true;
    286290        });
     291#endif // GIGACAGE_ENABLED
     292   
    287293    return cached;
    288294}
    … …  
    290296} // namespace Gigacage
    291297
    292 #endif // GIGACAGE_ENABLED
    293 
    294 
     298
     299

  • trunk/Source/bmalloc/bmalloc/Gigacage.h

    r240160 r240171  
    3131#include "BInline.h"
    3232#include "BPlatform.h"
    33 #include "Sizes.h"
    3433#include <cstddef>
    3534#include <inttypes.h>
    3635
     36#if BCPU(ARM64)
     37#define PRIMITIVE_GIGACAGE_SIZE 0x80000000llu
     38#define JSVALUE_GIGACAGE_SIZE 0x40000000llu
     39#define GIGACAGE_ALLOCATION_CAN_FAIL 1
     40#else
     41#define PRIMITIVE_GIGACAGE_SIZE 0x800000000llu
     42#define JSVALUE_GIGACAGE_SIZE 0x400000000llu
     43#define GIGACAGE_ALLOCATION_CAN_FAIL 0
     44#endif
     45
     46// In Linux, if `vm.overcommit_memory = 2` is specified, mmap with large size can fail if it exceeds the size of RAM.
     47// So we specify GIGACAGE_ALLOCATION_CAN_FAIL = 1.
     48#if BOS(LINUX)
     49#undef GIGACAGE_ALLOCATION_CAN_FAIL
     50#define GIGACAGE_ALLOCATION_CAN_FAIL 1
     51#endif
     52
     53static_assert(bmalloc::isPowerOfTwo(PRIMITIVE_GIGACAGE_SIZE), "");
     54static_assert(bmalloc::isPowerOfTwo(JSVALUE_GIGACAGE_SIZE), "");
     55
     56#define GIGACAGE_SIZE_TO_MASK(size) ((size) - 1)
     57
     58#define PRIMITIVE_GIGACAGE_MASK GIGACAGE_SIZE_TO_MASK(PRIMITIVE_GIGACAGE_SIZE)
     59#define JSVALUE_GIGACAGE_MASK GIGACAGE_SIZE_TO_MASK(JSVALUE_GIGACAGE_SIZE)
     60
    3761#if ((BOS(DARWIN) || BOS(LINUX)) && \
    38 (BCPU(X86_64) || (BCPU(ARM64) && !defined(__ILP32__) && (!BPLATFORM(IOS_FAMILY) || BPLATFORM(IOS)))))
     62    (BCPU(X86_64) || (BCPU(ARM64) && !defined(__ILP32__) && (!BPLATFORM(IOS_FAMILY) || BPLATFORM(IOS)))))
    3963#define GIGACAGE_ENABLED 1
    4064#else
    … …  
    4266#endif
    4367
     68#if BCPU(ARM64)
     69#define GIGACAGE_BASE_PTRS_SIZE 16384
     70#else
     71#define GIGACAGE_BASE_PTRS_SIZE 4096
     72#endif
     73
     74extern "C" alignas(GIGACAGE_BASE_PTRS_SIZE) BEXPORT char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
    4475
    4576namespace Gigacage {
     77
     78BINLINE bool wasEnabled() { return g_gigacageBasePtrs[0]; }
     79BINLINE void setWasEnabled() { g_gigacageBasePtrs[0] = true; }
     80
     81struct BasePtrs {
     82    uintptr_t reservedForFlags;
     83    void* primitive;
     84    void* jsValue;
     85};
    4686
    4787enum Kind {
    … …  
    5090    JSValue,
    5191};
     92
     93static_assert(offsetof(BasePtrs, primitive) == Kind::Primitive * sizeof(void*), "");
     94static_assert(offsetof(BasePtrs, jsValue) == Kind::JSValue * sizeof(void*), "");
     95
     96static constexpr unsigned numKinds = 2;
     97
     98BEXPORT void ensureGigacage();
     99
     100BEXPORT void disablePrimitiveGigacage();
     101
     102// This will call the disable callback immediately if the Primitive Gigacage is currently disabled.
     103BEXPORT void addPrimitiveDisableCallback(void (*)(void*), void*);
     104BEXPORT void removePrimitiveDisableCallback(void (*)(void*), void*);
     105
     106BEXPORT void disableDisablingPrimitiveGigacageIfShouldBeEnabled();
     107
     108BEXPORT bool isDisablingPrimitiveGigacageDisabled();
     109inline bool isPrimitiveGigacagePermanentlyEnabled() { return isDisablingPrimitiveGigacageDisabled(); }
     110inline bool canPrimitiveGigacageBeDisabled() { return !isDisablingPrimitiveGigacageDisabled(); }
    52111
    53112BINLINE const char* name(Kind kind)
    … …  
    65124}
    66125
    67 #if GIGACAGE_ENABLED
    68 
    69 #if BCPU(ARM64)
    70 constexpr size_t primitiveGigacageSize = 2 * bmalloc::Sizes::GB;
    71 constexpr size_t jsValueGigacageSize = 1 * bmalloc::Sizes::GB;
    72 constexpr size_t gigacageBasePtrsSize = 16 * bmalloc::Sizes::kB;
    73 constexpr size_t minimumCageSizeAfterSlide = bmalloc::Sizes::GB / 2;
    74 #define GIGACAGE_ALLOCATION_CAN_FAIL 1
    75 #else
    76 constexpr size_t primitiveGigacageSize = 32 * bmalloc::Sizes::GB;
    77 constexpr size_t jsValueGigacageSize = 16 * bmalloc::Sizes::GB;
    78 constexpr size_t gigacageBasePtrsSize = 4 * bmalloc::Sizes::kB;
    79 constexpr size_t minimumCageSizeAfterSlide = 4 * bmalloc::Sizes::GB;
    80 #define GIGACAGE_ALLOCATION_CAN_FAIL 0
    81 #endif
    82 
    83 // In Linux, if `vm.overcommit_memory = 2` is specified, mmap with large size can fail if it exceeds the size of RAM.
    84 // So we specify GIGACAGE_ALLOCATION_CAN_FAIL = 1.
    85 #if BOS(LINUX)
    86 #undef GIGACAGE_ALLOCATION_CAN_FAIL
    87 #define GIGACAGE_ALLOCATION_CAN_FAIL 1
    88 #endif
    89 
    90 
    91 static_assert(bmalloc::isPowerOfTwo(primitiveGigacageSize), "");
    92 static_assert(bmalloc::isPowerOfTwo(jsValueGigacageSize), "");
    93 static_assert(primitiveGigacageSize > minimumCageSizeAfterSlide, "");
    94 static_assert(jsValueGigacageSize > minimumCageSizeAfterSlide, "");
    95 
    96 constexpr size_t gigacageSizeToMask(size_t size) { return size - 1; }
    97 
    98 constexpr size_t primitiveGigacageMask = gigacageSizeToMask(primitiveGigacageSize);
    99 constexpr size_t jsValueGigacageMask = gigacageSizeToMask(jsValueGigacageSize);
    100 
    101 extern "C" alignas(gigacageBasePtrsSize) BEXPORT char g_gigacageBasePtrs[gigacageBasePtrsSize];
    102 
    103 BINLINE bool wasEnabled() { return g_gigacageBasePtrs[0]; }
    104 BINLINE void setWasEnabled() { g_gigacageBasePtrs[0] = true; }
    105 
    106 struct BasePtrs {
    107     uintptr_t reservedForFlags;
    108     void* primitive;
    109     void* jsValue;
    110 };
    111 
    112 static_assert(offsetof(BasePtrs, primitive) == Kind::Primitive * sizeof(void*), "");
    113 static_assert(offsetof(BasePtrs, jsValue) == Kind::JSValue * sizeof(void*), "");
    114 
    115 constexpr unsigned numKinds = 2;
    116 
    117 BEXPORT void ensureGigacage();
    118 
    119 BEXPORT void disablePrimitiveGigacage();
    120 
    121 // This will call the disable callback immediately if the Primitive Gigacage is currently disabled.
    122 BEXPORT void addPrimitiveDisableCallback(void (*)(void*), void*);
    123 BEXPORT void removePrimitiveDisableCallback(void (*)(void*), void*);
    124 
    125 BEXPORT void disableDisablingPrimitiveGigacageIfShouldBeEnabled();
    126 
    127 BEXPORT bool isDisablingPrimitiveGigacageDisabled();
    128 inline bool isPrimitiveGigacagePermanentlyEnabled() { return isDisablingPrimitiveGigacageDisabled(); }
    129 inline bool canPrimitiveGigacageBeDisabled() { return !isDisablingPrimitiveGigacageDisabled(); }
    130 
    131126BINLINE void*& basePtr(BasePtrs& basePtrs, Kind kind)
    132127{
    … …  
    164159        RELEASE_BASSERT_NOT_REACHED();
    165160    case Primitive:
    166         return static_cast<size_t>(primitiveGigacageSize);
     161        return static_cast<size_t>(PRIMITIVE_GIGACAGE_SIZE);
    167162    case JSValue:
    168         return static_cast<size_t>(jsValueGigacageSize);
     163        return static_cast<size_t>(JSVALUE_GIGACAGE_SIZE);
    169164    }
    170165    BCRASH();
    … …  
    179174BINLINE size_t mask(Kind kind)
    180175{
    181     return gigacageSizeToMask(size(kind));
     176    return GIGACAGE_SIZE_TO_MASK(size(kind));
    182177}
    183178
    … …  
    208203BEXPORT bool shouldBeEnabled();
    209204
    210 #else // GIGACAGE_ENABLED
    211 
    212 BINLINE void*& basePtr(Kind)
    213 {
    214     BCRASH();
    215     static void* unreachable;
    216     return unreachable;
    217 }
    218 BINLINE size_t size(Kind) { BCRASH(); return 0; }
    219 BINLINE void ensureGigacage() { }
    220 BINLINE bool wasEnabled() { return false; }
    221 BINLINE bool isCaged(Kind, const void*) { return true; }
    222 template<typename T> BINLINE T* caged(Kind, T* ptr) { return ptr; }
    223 BINLINE void disableDisablingPrimitiveGigacageIfShouldBeEnabled() { }
    224 BINLINE void disablePrimitiveGigacage() { }
    225 BINLINE void addPrimitiveDisableCallback(void (*)(void*), void*) { }
    226 BINLINE void removePrimitiveDisableCallback(void (*)(void*), void*) { }
    227 
    228 #endif // GIGACAGE_ENABLED
    229 
    230205} // namespace Gigacage
    231206
    232207
    233 

  • trunk/Source/bmalloc/bmalloc/Heap.cpp

    r240160 r240171  
    3030#include "BumpAllocator.h"
    3131#include "Chunk.h"
    32 #include "CryptoRandom.h"
    3332#include "Environment.h"
    3433#include "Gigacage.h"
    … …  
    6362        if (usingGigacage()) {
    6463            RELEASE_BASSERT(gigacageBasePtr());
    65             uint64_t random;
    66             cryptoRandom(reinterpret_cast<unsigned char*>(&random), sizeof(random));
    67             ptrdiff_t offset = random % (gigacageSize() - Gigacage::minimumCageSizeAfterSlide);
    68             offset = reinterpret_cast<ptrdiff_t>(roundDownToMultipleOf(vmPageSize(), reinterpret_cast<void*>(offset)));
    69             void* base = reinterpret_cast<unsigned char*>(gigacageBasePtr()) + offset;
    70             m_largeFree.add(LargeRange(base, gigacageSize() - offset, 0, 0));
     64            m_largeFree.add(LargeRange(gigacageBasePtr(), gigacageSize(), 0, 0));
    7165        }
    7266#endif

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

    r240160 r240171  
    4141
    4242namespace Sizes {
    43 static constexpr size_t kB = 1024;
    44 static constexpr size_t MB = kB * kB;
    45 static constexpr size_t GB = kB * kB * kB;
     43    static const size_t kB = 1024;
     44    static const size_t MB = kB * kB;
    4645
    47 static constexpr size_t alignment = 8;
    48 static constexpr size_t alignmentMask = alignment - 1ul;
     46    static const size_t alignment = 8;
     47    static const size_t alignmentMask = alignment - 1ul;
    4948
    50 static constexpr size_t chunkSize = 1 * MB;
    51 static constexpr size_t chunkMask = ~(chunkSize - 1ul);
     49    static const size_t chunkSize = 1 * MB;
     50    static const size_t chunkMask = ~(chunkSize - 1ul);
    5251
    53 static constexpr size_t smallLineSize = 256;
    54 static constexpr size_t smallPageSize = 4 * kB;
    55 static constexpr size_t smallPageLineCount = smallPageSize / smallLineSize;
     52    static const size_t smallLineSize = 256;
     53    static const size_t smallPageSize = 4 * kB;
     54    static const size_t smallPageLineCount = smallPageSize / smallLineSize;
    5655
    57 static constexpr size_t maskSizeClassMax = 512;
    58 static constexpr size_t smallMax = 32 * kB;
     56    static const size_t maskSizeClassMax = 512;
     57    static const size_t smallMax = 32 * kB;
    5958
    60 static constexpr size_t pageSizeMax = smallMax * 2;
    61 static constexpr size_t pageClassCount = pageSizeMax / smallPageSize;
     59    static const size_t pageSizeMax = smallMax * 2;
     60    static const size_t pageClassCount = pageSizeMax / smallPageSize;
    6261
    63 static constexpr size_t pageSizeWasteFactor = 8;
    64 static constexpr size_t logWasteFactor = 8;
     62    static const size_t pageSizeWasteFactor = 8;
     63    static const size_t logWasteFactor = 8;
    6564
    66 static constexpr size_t largeAlignment = smallMax / pageSizeWasteFactor;
    67 static constexpr size_t largeAlignmentMask = largeAlignment - 1;
     65    static const size_t largeAlignment = smallMax / pageSizeWasteFactor;
     66    static const size_t largeAlignmentMask = largeAlignment - 1;
    6867
    69 static constexpr size_t deallocatorLogCapacity = 512;
    70 static constexpr size_t bumpRangeCacheCapacity = 3;
     68    static const size_t deallocatorLogCapacity = 512;
     69    static const size_t bumpRangeCacheCapacity = 3;
     70   
     71    static const size_t scavengerBytesPerMemoryPressureCheck = 16 * MB;
     72    static const double memoryPressureThreshold = 0.75;
     73   
     74    static const size_t maskSizeClassCount = maskSizeClassMax / alignment;
    7175
    72 static constexpr size_t scavengerBytesPerMemoryPressureCheck = 16 * MB;
    73 static constexpr double memoryPressureThreshold = 0.75;
     76    constexpr size_t maskSizeClass(size_t size)
     77    {
     78        // We mask to accommodate zero.
     79        return mask((size - 1) / alignment, maskSizeClassCount - 1);
     80    }
    7481
    75 static constexpr size_t maskSizeClassCount = maskSizeClassMax / alignment;
     82    inline size_t maskObjectSize(size_t maskSizeClass)
     83    {
     84        return (maskSizeClass + 1) * alignment;
     85    }
    7686
    77 constexpr size_t maskSizeClass(size_t size)
    78 {
    79     // We mask to accommodate zero.
    80     return mask((size - 1) / alignment, maskSizeClassCount - 1);
     87    static const size_t logAlignmentMin = maskSizeClassMax / logWasteFactor;
     88
     89    static const size_t logSizeClassCount = (log2(smallMax) - log2(maskSizeClassMax)) * logWasteFactor;
     90
     91    inline size_t logSizeClass(size_t size)
     92    {
     93        size_t base = log2(size - 1) - log2(maskSizeClassMax);
     94        size_t offset = (size - 1 - (maskSizeClassMax << base));
     95        return base * logWasteFactor + offset / (logAlignmentMin << base);
     96    }
     97
     98    inline size_t logObjectSize(size_t logSizeClass)
     99    {
     100        size_t base = logSizeClass / logWasteFactor;
     101        size_t offset = logSizeClass % logWasteFactor;
     102        return (maskSizeClassMax << base) + (offset + 1) * (logAlignmentMin << base);
     103    }
     104
     105    static const size_t sizeClassCount = maskSizeClassCount + logSizeClassCount;
     106
     107    inline size_t sizeClass(size_t size)
     108    {
     109        if (size <= maskSizeClassMax)
     110            return maskSizeClass(size);
     111        return maskSizeClassCount + logSizeClass(size);
     112    }
     113
     114    inline size_t objectSize(size_t sizeClass)
     115    {
     116        if (sizeClass < maskSizeClassCount)
     117            return maskObjectSize(sizeClass);
     118        return logObjectSize(sizeClass - maskSizeClassCount);
     119    }
     120   
     121    inline size_t pageSize(size_t pageClass)
     122    {
     123        return (pageClass + 1) * smallPageSize;
     124    }
    81125}
    82 
    83 inline size_t maskObjectSize(size_t maskSizeClass)
    84 {
    85     return (maskSizeClass + 1) * alignment;
    86 }
    87 
    88 static constexpr size_t logAlignmentMin = maskSizeClassMax / logWasteFactor;
    89 
    90 static constexpr size_t logSizeClassCount = (log2(smallMax) - log2(maskSizeClassMax)) * logWasteFactor;
    91 
    92 inline size_t logSizeClass(size_t size)
    93 {
    94     size_t base = log2(size - 1) - log2(maskSizeClassMax);
    95     size_t offset = (size - 1 - (maskSizeClassMax << base));
    96     return base * logWasteFactor + offset / (logAlignmentMin << base);
    97 }
    98 
    99 inline size_t logObjectSize(size_t logSizeClass)
    100 {
    101     size_t base = logSizeClass / logWasteFactor;
    102     size_t offset = logSizeClass % logWasteFactor;
    103     return (maskSizeClassMax << base) + (offset + 1) * (logAlignmentMin << base);
    104 }
    105 
    106 static constexpr size_t sizeClassCount = maskSizeClassCount + logSizeClassCount;
    107 
    108 inline size_t sizeClass(size_t size)
    109 {
    110     if (size <= maskSizeClassMax)
    111         return maskSizeClass(size);
    112     return maskSizeClassCount + logSizeClass(size);
    113 }
    114 
    115 inline size_t objectSize(size_t sizeClass)
    116 {
    117     if (sizeClass < maskSizeClassCount)
    118         return maskObjectSize(sizeClass);
    119     return logObjectSize(sizeClass - maskSizeClassCount);
    120 }
    121 
    122 inline size_t pageSize(size_t pageClass)
    123 {
    124     return (pageClass + 1) * smallPageSize;
    125 }
    126 } // namespace Sizes
    127126
    128127using namespace Sizes;
Note: See TracChangeset for help on using the changeset viewer.