folly::CoreRawAllocator< Stripes >::Allocator Class Reference

#include <CacheLocality.h>

Public Member Functions
void *	allocate (size_t size)
void	deallocate (void *mem, size_t=0)

Private Member Functions
uint8_t	sizeClass (size_t size)

Private Attributes
std::array< SimpleAllocator, 4 >	allocators_

Static Private Attributes
static constexpr size_t	AllocSize {4096}

Detailed Description

template<size_t Stripes>
class folly::CoreRawAllocator< Stripes >::Allocator

Definition at line 458 of file CacheLocality.h.

Member Function Documentation

template<size_t Stripes>

void* folly::CoreRawAllocator< Stripes >::Allocator::allocate ( size_t  size )

inline

Definition at line 479 of file CacheLocality.h.

References folly::aligned_malloc(), and folly::hardware_destructive_interference_size.

                                {
      auto cl = sizeClass(size);
      if (cl == 4) {
        // Align to a cacheline
        size = size + (hardware_destructive_interference_size - 1);
        size &= ~size_t(hardware_destructive_interference_size - 1);
        void* mem =
            aligned_malloc(size, hardware_destructive_interference_size);
        if (!mem) {
          throw_exception<std::bad_alloc>();
        }
        return mem;
      }
      return allocators_[cl].allocate();
    }

template<size_t Stripes>

void folly::CoreRawAllocator< Stripes >::Allocator::deallocate ( void *  mem, size_t  = 0  )

inline

Definition at line 494 of file CacheLocality.h.

References addr, folly::aligned_free(), and folly::SimpleAllocator::deallocate().

                                           {
      if (!mem) {
        return;
      }

      // See if it came from this allocator or malloc.
      if (intptr_t(mem) % 128 != 0) {
        auto addr =
            reinterpret_cast<void*>(intptr_t(mem) & ~intptr_t(AllocSize - 1));
        auto allocator = *static_cast<SimpleAllocator**>(addr);
        allocator->deallocate(mem);
      } else {
        aligned_free(mem);
      }
    }

template<size_t Stripes>

uint8_t folly::CoreRawAllocator< Stripes >::Allocator::sizeClass ( size_t  size )

inlineprivate

Definition at line 461 of file CacheLocality.h.

                                   {
      if (size <= 8) {
        return 0;
      } else if (size <= 16) {
        return 1;
      } else if (size <= 32) {
        return 2;
      } else if (size <= 64) {
        return 3;
      } else { // punt to malloc.
        return 4;
      }
    }

Member Data Documentation

template<size_t Stripes>

std::array<SimpleAllocator, 4> folly::CoreRawAllocator< Stripes >::Allocator::allocators_

private

Initial value:

{
        {{AllocSize, 8}, {AllocSize, 16}, {AllocSize, 32}, {AllocSize, 64}}}

Definition at line 475 of file CacheLocality.h.

template<size_t Stripes>

constexpr size_t folly::CoreRawAllocator< Stripes >::Allocator::AllocSize {4096}

staticprivate

Definition at line 459 of file CacheLocality.h.

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/concurrency/CacheLocality.h