webkit  2cdf99a9e3038c7e01b3c37e8ad903ecbe5eecf1
https://github.com/WebKit/webkit
Namespaces | Classes | Typedefs | Enumerations | Functions
bmalloc Namespace Reference

Namespaces

 api
 
 Sizes
 

Classes

class  Allocator
 
class  AsyncTask
 
class  BumpAllocator
 
struct  BumpRange
 
class  Cache
 
class  Chunk
 
struct  ChunkHash
 
class  Deallocator
 
class  DebugHeap
 
class  Environment
 
class  FixedVector
 
class  Heap
 
class  LargeMap
 
class  LargeRange
 
struct  LineMetadata
 
class  List
 
struct  ListNode
 
class  Map
 
class  Mutex
 
class  Object
 
class  PerProcess
 
class  PerThread
 
struct  PerThreadStorage
 
class  Range
 
class  ScopeExit
 
class  SmallLine
 
class  SmallPage
 
class  StaticMutex
 
class  Vector
 
class  VMHeap
 
class  Zone
 

Typedefs

typedef FixedVector< BumpRange, bumpRangeCacheCapacity > BumpRangeCache
 

Enumerations

enum  ObjectType : unsigned char { ObjectType::Small, ObjectType::Large, ObjectType::Small, ObjectType::Large }
 
enum  ObjectType : unsigned char { ObjectType::Small, ObjectType::Large, ObjectType::Small, ObjectType::Large }
 

Functions

template<typename T >
constexpr T max (T a, T b)
 
template<typename T >
constexpr T min (T a, T b)
 
template<typename T >
constexpr T mask (T value, uintptr_t mask)
 
template<typename T >
constexpr bool test (T value, uintptr_t mask)
 
constexpr bool isPowerOfTwo (size_t size)
 
template<typename T >
T roundUpToMultipleOf (size_t divisor, T x)
 
template<size_t divisor, typename T >
constexpr T roundUpToMultipleOf (T x)
 
template<typename T >
T roundDownToMultipleOf (size_t divisor, T x)
 
template<size_t divisor, typename T >
constexpr T roundDownToMultipleOf (T x)
 
template<typename T >
void divideRoundingUp (T numerator, T denominator, T &quotient, T &remainder)
 
template<typename T >
T divideRoundingUp (T numerator, T denominator)
 
template<typename T >
T roundUpToMultipleOfNonPowerOfTwo (size_t divisor, T x)
 
template<typename T >
constexpr size_t sizeOf ()
 
template<typename T >
constexpr size_t bitCount ()
 
constexpr unsigned long log2 (unsigned long value)
 
bool canMerge (const LargeRange &a, const LargeRange &b)
 
LargeRange merge (const LargeRange &a, const LargeRange &b)
 
void logVMFailure ()
 
void reportAssertionFailureWithMessage (const char *file, int line, const char *function, const char *format,...) BATTRIBUTE_PRINTF(4
 
ObjectType objectType (void *)
 
bool mightBeLarge (void *object)
 
bool canMerge (const Range &a, const Range &b)
 
Range merge (const Range &a, const Range &b)
 
size_t vmPageSize ()
 
size_t vmPageShift ()
 
size_t vmSize (size_t size)
 
void vmValidate (size_t vmSize)
 
void vmValidate (void *p, size_t vmSize)
 
size_t vmPageSizePhysical ()
 
void vmValidatePhysical (size_t vmSize)
 
void vmValidatePhysical (void *p, size_t vmSize)
 
void * tryVMAllocate (size_t vmSize)
 
void * vmAllocate (size_t vmSize)
 
void vmDeallocate (void *p, size_t vmSize)
 
void vmRevokePermissions (void *p, size_t vmSize)
 
void * tryVMAllocate (size_t vmAlignment, size_t vmSize)
 
void * vmAllocate (size_t vmAlignment, size_t vmSize)
 
void vmDeallocatePhysicalPages (void *p, size_t vmSize)
 
void vmAllocatePhysicalPages (void *p, size_t vmSize)
 
void vmDeallocatePhysicalPagesSloppy (void *p, size_t size)
 
void vmAllocatePhysicalPagesSloppy (void *p, size_t size)
 
template<typename ExitFunction >
ScopeExit< ExitFunction > makeScopeExit (ExitFunction &&exitFunction)
 

Typedef Documentation

◆ BumpRangeCache

typedef FixedVector< BumpRange, bumpRangeCacheCapacity > bmalloc::BumpRangeCache

Enumeration Type Documentation

◆ ObjectType [1/2]

enum bmalloc::ObjectType : unsigned char
strong
Enumerator
Small 
Large 
Small 
Large 

◆ ObjectType [2/2]

enum bmalloc::ObjectType : unsigned char
strong
Enumerator
Small 
Large 
Small 
Large 

Function Documentation

◆ bitCount()

template<typename T >
constexpr size_t bmalloc::bitCount ( )
inline

◆ canMerge() [1/2]

bool bmalloc::canMerge ( const Range &  a,
const Range &  b 
)
inline

◆ canMerge() [2/2]

bool bmalloc::canMerge ( const LargeRange &  a,
const LargeRange &  b 
)
inline

◆ divideRoundingUp() [1/2]

template<typename T >
void bmalloc::divideRoundingUp ( T  numerator,
T  denominator,
T &  quotient,
T &  remainder 
)
inline

◆ divideRoundingUp() [2/2]

template<typename T >
T bmalloc::divideRoundingUp ( T  numerator,
T  denominator 
)
inline

◆ isPowerOfTwo()

constexpr bool bmalloc::isPowerOfTwo ( size_t  size)
inline

◆ log2()

constexpr unsigned long bmalloc::log2 ( unsigned long  value)
inline

◆ logVMFailure()

void bmalloc::logVMFailure ( )

◆ makeScopeExit()

template<typename ExitFunction >
ScopeExit<ExitFunction> bmalloc::makeScopeExit ( ExitFunction &&  exitFunction)

◆ mask()

template<typename T >
constexpr T bmalloc::mask ( T  value,
uintptr_t  mask 
)
inline

◆ max()

template<typename T >
constexpr T bmalloc::max ( T  a,
T  b 
)
inline

◆ merge() [1/2]

Range bmalloc::merge ( const Range &  a,
const Range &  b 
)
inline

◆ merge() [2/2]

LargeRange bmalloc::merge ( const LargeRange &  a,
const LargeRange &  b 
)
inline

◆ mightBeLarge()

bool bmalloc::mightBeLarge ( void *  object)
inline

◆ min()

template<typename T >
constexpr T bmalloc::min ( T  a,
T  b 
)
inline

◆ objectType()

ObjectType bmalloc::objectType ( void *  )

◆ reportAssertionFailureWithMessage()

void bmalloc::reportAssertionFailureWithMessage ( const char *  file,
int  line,
const char *  function,
const char *  format,
  ... 
)

◆ roundDownToMultipleOf() [1/2]

template<typename T >
T bmalloc::roundDownToMultipleOf ( size_t  divisor,
T  x 
)
inline

◆ roundDownToMultipleOf() [2/2]

template<size_t divisor, typename T >
constexpr T bmalloc::roundDownToMultipleOf ( T  x)
inline

◆ roundUpToMultipleOf() [1/2]

template<typename T >
T bmalloc::roundUpToMultipleOf ( size_t  divisor,
T  x 
)
inline

◆ roundUpToMultipleOf() [2/2]

template<size_t divisor, typename T >
constexpr T bmalloc::roundUpToMultipleOf ( T  x)
inline

◆ roundUpToMultipleOfNonPowerOfTwo()

template<typename T >
T bmalloc::roundUpToMultipleOfNonPowerOfTwo ( size_t  divisor,
T  x 
)
inline

◆ sizeOf()

template<typename T >
constexpr size_t bmalloc::sizeOf ( )
inline

◆ test()

template<typename T >
constexpr bool bmalloc::test ( T  value,
uintptr_t  mask 
)
inline

◆ tryVMAllocate() [1/2]

void * bmalloc::tryVMAllocate ( size_t  vmSize)
inline

◆ tryVMAllocate() [2/2]

void * bmalloc::tryVMAllocate ( size_t  vmAlignment,
size_t  vmSize 
)
inline

◆ vmAllocate() [1/2]

void * bmalloc::vmAllocate ( size_t  vmSize)
inline

◆ vmAllocate() [2/2]

void * bmalloc::vmAllocate ( size_t  vmAlignment,
size_t  vmSize 
)
inline

◆ vmAllocatePhysicalPages()

void bmalloc::vmAllocatePhysicalPages ( void *  p,
size_t  vmSize 
)
inline

◆ vmAllocatePhysicalPagesSloppy()

void bmalloc::vmAllocatePhysicalPagesSloppy ( void *  p,
size_t  size 
)
inline

◆ vmDeallocate()

void bmalloc::vmDeallocate ( void *  p,
size_t  vmSize 
)
inline

◆ vmDeallocatePhysicalPages()

void bmalloc::vmDeallocatePhysicalPages ( void *  p,
size_t  vmSize 
)
inline

◆ vmDeallocatePhysicalPagesSloppy()

void bmalloc::vmDeallocatePhysicalPagesSloppy ( void *  p,
size_t  size 
)
inline

◆ vmPageShift()

size_t bmalloc::vmPageShift ( )
inline

◆ vmPageSize()

size_t bmalloc::vmPageSize ( )
inline

◆ vmPageSizePhysical()

size_t bmalloc::vmPageSizePhysical ( )
inline

◆ vmRevokePermissions()

void bmalloc::vmRevokePermissions ( void *  p,
size_t  vmSize 
)
inline

◆ vmSize()

size_t bmalloc::vmSize ( size_t  size)
inline

◆ vmValidate() [1/2]

void bmalloc::vmValidate ( size_t  vmSize)
inline

◆ vmValidate() [2/2]

void bmalloc::vmValidate ( void *  p,
size_t  vmSize 
)
inline

◆ vmValidatePhysical() [1/2]

void bmalloc::vmValidatePhysical ( size_t  vmSize)
inline

◆ vmValidatePhysical() [2/2]

void bmalloc::vmValidatePhysical ( void *  p,
size_t  vmSize 
)
inline
Generated by   doxygen 1.8.13