folly::SimpleAllocator Class Reference

#include <CacheLocality.h>

Public Member Functions
	SimpleAllocator (size_t allocSize, size_t sz)
	~SimpleAllocator ()
void *	allocateHard ()
void *	allocate ()
void	deallocate (void *mem)

Private Attributes
std::mutex	m_
uint8_t *	mem_ {nullptr}
uint8_t *	end_ {nullptr}
void *	freelist_ {nullptr}
size_t	allocSize_
size_t	sz_
std::vector< void * >	blocks_

Detailed Description

A simple freelist allocator. Allocates things of size sz, from slabs of size allocSize. Takes a lock on each allocation/deallocation.

Definition at line 394 of file CacheLocality.h.

Constructor & Destructor Documentation

folly::SimpleAllocator::SimpleAllocator	(	size_t	allocSize,
		size_t	sz
	)

Definition at line 238 of file CacheLocality.cpp.

References sz_.

    : allocSize_{allocSize}, sz_(sz) {}

folly::SimpleAllocator::~SimpleAllocator

(

)

Definition at line 241 of file CacheLocality.cpp.

References folly::aligned_free(), blocks_, g(), and m_.

                                  {
  std::lock_guard<std::mutex> g(m_);
  for (auto& block : blocks_) {
    folly::aligned_free(block);
  }
}

Member Function Documentation

void* folly::SimpleAllocator::allocate ( )

inline

Definition at line 409 of file CacheLocality.h.

References end_, g(), folly::max_align_v, and min.

                   {
    std::lock_guard<std::mutex> g(m_);
    // Freelist allocation.
    if (freelist_) {
      auto mem = freelist_;
      freelist_ = *static_cast<void**>(freelist_);
      return mem;
    }

    // Bump-ptr allocation.
    if (intptr_t(mem_) % 128 == 0) {
      // Avoid allocating pointers that may look like malloc
      // pointers.
      mem_ += std::min(sz_, max_align_v);
    }
    if (mem_ && (mem_ + sz_ <= end_)) {
      auto mem = mem_;
      mem_ += sz_;

      assert(intptr_t(mem) % 128 != 0);
      return mem;
    }

    return allocateHard();
  }

void * folly::SimpleAllocator::allocateHard

(

)

Definition at line 248 of file CacheLocality.cpp.

References folly::aligned_malloc(), allocSize_, blocks_, end_, folly::max_align_v, mem_, min, sz_, and uint8_t.

                                    {
  // Allocate a new slab.
  mem_ = static_cast<uint8_t*>(folly::aligned_malloc(allocSize_, allocSize_));
  if (!mem_) {
    throw_exception<std::bad_alloc>();
  }
  end_ = mem_ + allocSize_;
  blocks_.push_back(mem_);

  // Install a pointer to ourselves as the allocator.
  *reinterpret_cast<SimpleAllocator**>(mem_) = this;
  static_assert(max_align_v >= sizeof(SimpleAllocator*), "alignment too small");
  mem_ += std::min(sz_, max_align_v);

  // New allocation.
  auto mem = mem_;
  mem_ += sz_;
  assert(intptr_t(mem) % 128 != 0);
  return mem;
}

void folly::SimpleAllocator::deallocate ( void *  mem )

inline

Definition at line 434 of file CacheLocality.h.

References g().

Referenced by folly::CoreRawAllocator< Stripes >::Allocator::deallocate().

                             {
    std::lock_guard<std::mutex> g(m_);
    *static_cast<void**>(mem) = freelist_;
    freelist_ = mem;
  }

Member Data Documentation

size_t folly::SimpleAllocator::allocSize_

private

Definition at line 399 of file CacheLocality.h.

Referenced by allocateHard().

std::vector<void*> folly::SimpleAllocator::blocks_

private

Definition at line 401 of file CacheLocality.h.

Referenced by allocateHard(), and ~SimpleAllocator().

uint8_t* folly::SimpleAllocator::end_ {nullptr}

private

Definition at line 397 of file CacheLocality.h.

Referenced by allocateHard().

void* folly::SimpleAllocator::freelist_ {nullptr}

private

Definition at line 398 of file CacheLocality.h.

std::mutex folly::SimpleAllocator::m_

private

Definition at line 395 of file CacheLocality.h.

Referenced by ~SimpleAllocator().

uint8_t* folly::SimpleAllocator::mem_ {nullptr}

private

Definition at line 396 of file CacheLocality.h.

Referenced by allocateHard().

size_t folly::SimpleAllocator::sz_

private

Definition at line 400 of file CacheLocality.h.

Referenced by allocateHard(), and SimpleAllocator().

---

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

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