folly::JemallocNodumpAllocator Class Reference

#include <JemallocNodumpAllocator.h>

Public Types
enum	State { State::ENABLED, State::DISABLED }

Public Member Functions
	JemallocNodumpAllocator (State state=State::ENABLED)
void *	allocate (size_t size)
void *	reallocate (void *p, size_t size)
void	deallocate (void *p, size_t=0)
unsigned	getArenaIndex () const
int	getFlags () const

Static Public Member Functions
static void	deallocate (void *p, void *userData)

Private Member Functions
bool	extend_and_setup_arena ()

Private Attributes
unsigned	arena_index_ {0}
int	flags_ {0}

Detailed Description

An allocator which uses Jemalloc to create an dedicated arena to allocate memory from. The only special property set on the allocated memory is that the memory is not dump-able.

This is done by setting MADV_DONTDUMP using the madvise system call. A custom hook installed which is called when allocating a new chunk / extent of memory. All it does is call the original jemalloc hook to allocate the memory and then set the advise on it before returning the pointer to the allocated memory. Jemalloc does not use allocated chunks / extents across different arenas, without munmap-ing them first, and the advises are not sticky i.e. they are unset if munmap is done. Also this arena can't be used by any other part of the code by just calling malloc.

If target system doesn't support MADV_DONTDUMP or jemalloc doesn't support custom arena hook, JemallocNodumpAllocator would fall back to using malloc / free. Such behavior can be identified by using !defined(FOLLY_JEMALLOC_NODUMP_ALLOCATOR_SUPPORTED).

Similarly, if binary isn't linked with jemalloc, the logic would fall back to malloc / free.

Definition at line 68 of file JemallocNodumpAllocator.h.

Member Enumeration Documentation

enum folly::JemallocNodumpAllocator::State

strong

Enumerator
ENABLED
DISABLED

Definition at line 70 of file JemallocNodumpAllocator.h.

                   {
    ENABLED,
    DISABLED,
  };

Constructor & Destructor Documentation

folly::JemallocNodumpAllocator::JemallocNodumpAllocator ( State  state = State::ENABLED )

explicit

Definition at line 26 of file JemallocNodumpAllocator.cpp.

References arena_index_, ENABLED, extend_and_setup_arena(), and folly::INFO.

Referenced by folly::globalJemallocNodumpAllocator().

                                                            {
  if (state == State::ENABLED && extend_and_setup_arena()) {
    LOG(INFO) << "Set up arena: " << arena_index_;
  }
}

Member Function Documentation

void * folly::JemallocNodumpAllocator::allocate

(

size_t

size

)

Definition at line 107 of file JemallocNodumpAllocator.cpp.

References flags_, and mallocx.

Referenced by TEST().

                                                   {
  return mallocx != nullptr ? mallocx(size, flags_) : malloc(size);
}

void folly::JemallocNodumpAllocator::deallocate ( void *  p, void *  userData  )

static

Definition at line 158 of file JemallocNodumpAllocator.cpp.

References dallocx, bm::free(), and uint64_t.

Referenced by TEST().

                                                                {
  const uint64_t flags = reinterpret_cast<uint64_t>(userData);
  dallocx != nullptr ? dallocx(p, static_cast<int>(flags)) : free(p);
}

void folly::JemallocNodumpAllocator::deallocate	(	void *	p,
		size_t	= 0
	)

Definition at line 154 of file JemallocNodumpAllocator.cpp.

References dallocx, flags_, and bm::free().

                                                        {
  dallocx != nullptr ? dallocx(p, flags_) : free(p);
}

bool folly::JemallocNodumpAllocator::extend_and_setup_arena ( )

private

Definition at line 32 of file JemallocNodumpAllocator.cpp.

References arena_index_, folly::errnoStr(), folly::FATAL, flags_, mallctl, MALLOCX_ARENA, and MALLOCX_TCACHE_NONE.

Referenced by getFlags(), and JemallocNodumpAllocator().

                                                     {
#ifdef FOLLY_JEMALLOC_NODUMP_ALLOCATOR_SUPPORTED
  if (mallctl == nullptr) {
    // Not linked with jemalloc.
    return false;
  }

  size_t len = sizeof(arena_index_);
  if (auto ret = mallctl(
#ifdef FOLLY_JEMALLOC_NODUMP_ALLOCATOR_CHUNK
          "arenas.extend"
#else
          "arenas.create"
#endif
          ,
          &arena_index_,
          &len,
          nullptr,
          0)) {
    LOG(FATAL) << "Unable to extend arena: " << errnoStr(ret);
  }
  flags_ = MALLOCX_ARENA(arena_index_) | MALLOCX_TCACHE_NONE;

#ifdef FOLLY_JEMALLOC_NODUMP_ALLOCATOR_CHUNK
  const auto key =
      folly::to<std::string>("arena.", arena_index_, ".chunk_hooks");
  chunk_hooks_t hooks;
  len = sizeof(hooks);
  // Read the existing hooks
  if (auto ret = mallctl(key.c_str(), &hooks, &len, nullptr, 0)) {
    LOG(FATAL) << "Unable to get the hooks: " << errnoStr(ret);
  }
  if (original_alloc_ == nullptr) {
    original_alloc_ = hooks.alloc;
  } else {
    DCHECK_EQ(original_alloc_, hooks.alloc);
  }

  // Set the custom hook
  hooks.alloc = &JemallocNodumpAllocator::alloc;
  if (auto ret =
          mallctl(key.c_str(), nullptr, nullptr, &hooks, sizeof(hooks))) {
    LOG(FATAL) << "Unable to set the hooks: " << errnoStr(ret);
  }
#else
  const auto key =
      folly::to<std::string>("arena.", arena_index_, ".extent_hooks");
  extent_hooks_t* hooks;
  len = sizeof(hooks);
  // Read the existing hooks
  if (auto ret = mallctl(key.c_str(), &hooks, &len, nullptr, 0)) {
    LOG(FATAL) << "Unable to get the hooks: " << errnoStr(ret);
  }
  if (original_alloc_ == nullptr) {
    original_alloc_ = hooks->alloc;
  } else {
    DCHECK_EQ(original_alloc_, hooks->alloc);
  }

  // Set the custom hook
  extent_hooks_ = *hooks;
  extent_hooks_.alloc = &JemallocNodumpAllocator::alloc;
  extent_hooks_t* new_hooks = &extent_hooks_;
  if (auto ret = mallctl(
          key.c_str(), nullptr, nullptr, &new_hooks, sizeof(new_hooks))) {
    LOG(FATAL) << "Unable to set the hooks: " << errnoStr(ret);
  }
#endif

  return true;
#else // FOLLY_JEMALLOC_NODUMP_ALLOCATOR_SUPPORTED
  return false;
#endif // FOLLY_JEMALLOC_NODUMP_ALLOCATOR_SUPPORTED
}

unsigned folly::JemallocNodumpAllocator::getArenaIndex ( ) const

inline

Definition at line 85 of file JemallocNodumpAllocator.h.

References arena_index_.

Referenced by TEST().

                                 {
    return arena_index_;
  }

int folly::JemallocNodumpAllocator::getFlags ( ) const

inline

Definition at line 88 of file JemallocNodumpAllocator.h.

References extend_and_setup_arena(), and flags_.

                       {
    return flags_;
  }

void * folly::JemallocNodumpAllocator::reallocate	(	void *	p,
		size_t	size
	)

Definition at line 111 of file JemallocNodumpAllocator.cpp.

References folly::errnoStr(), flags_, rallocx, and folly::size().

                                                              {
  return rallocx != nullptr ? rallocx(p, size, flags_) : realloc(p, size);
}

Member Data Documentation

unsigned folly::JemallocNodumpAllocator::arena_index_ {0}

private

Definition at line 114 of file JemallocNodumpAllocator.h.

Referenced by extend_and_setup_arena(), getArenaIndex(), and JemallocNodumpAllocator().

int folly::JemallocNodumpAllocator::flags_ {0}

private

Definition at line 115 of file JemallocNodumpAllocator.h.

Referenced by allocate(), deallocate(), extend_and_setup_arena(), getFlags(), and reallocate().

---

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

• proxygen/folly/folly/experimental/JemallocNodumpAllocator.h
• proxygen/folly/folly/experimental/JemallocNodumpAllocator.cpp