rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/memory/concurrent_arena.h

@@ -1,215 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <atomic>
-#include <memory>
-#include <utility>
-
-#include "memory/allocator.h"
-#include "memory/arena.h"
-#include "port/lang.h"
-#include "port/likely.h"
-#include "util/core_local.h"
-#include "util/mutexlock.h"
-#include "util/thread_local.h"
-
-// Only generate field unused warning for padding array, or build under
-// GCC 4.8.1 will fail.
-#ifdef __clang__
-#define ROCKSDB_FIELD_UNUSED __attribute__((__unused__))
-#else
-#define ROCKSDB_FIELD_UNUSED
-#endif  // __clang__
-
-namespace ROCKSDB_NAMESPACE {
-
-class Logger;
-
-// ConcurrentArena wraps an Arena.  It makes it thread safe using a fast
-// inlined spinlock, and adds small per-core allocation caches to avoid
-// contention for small allocations.  To avoid any memory waste from the
-// per-core shards, they are kept small, they are lazily instantiated
-// only if ConcurrentArena actually notices concurrent use, and they
-// adjust their size so that there is no fragmentation waste when the
-// shard blocks are allocated from the underlying main arena.
-class ConcurrentArena : public Allocator {
- public:
-  // block_size and huge_page_size are the same as for Arena (and are
-  // in fact just passed to the constructor of arena_.  The core-local
-  // shards compute their shard_block_size as a fraction of block_size
-  // that varies according to the hardware concurrency level.
-  explicit ConcurrentArena(size_t block_size = Arena::kMinBlockSize,
-                           AllocTracker* tracker = nullptr,
-                           size_t huge_page_size = 0);
-
-  char* Allocate(size_t bytes) override {
-    return AllocateImpl(bytes, false /*force_arena*/,
-                        [this, bytes]() { return arena_.Allocate(bytes); });
-  }
-
-  char* AllocateAligned(size_t bytes, size_t huge_page_size = 0,
-                        Logger* logger = nullptr) override {
-    size_t rounded_up = ((bytes - 1) | (sizeof(void*) - 1)) + 1;
-    assert(rounded_up >= bytes && rounded_up < bytes + sizeof(void*) &&
-           (rounded_up % sizeof(void*)) == 0);
-
-    return AllocateImpl(rounded_up, huge_page_size != 0 /*force_arena*/,
-                        [this, rounded_up, huge_page_size, logger]() {
-                          return arena_.AllocateAligned(rounded_up,
-                                                        huge_page_size, logger);
-                        });
-  }
-
-  size_t ApproximateMemoryUsage() const {
-    std::unique_lock<SpinMutex> lock(arena_mutex_, std::defer_lock);
-    lock.lock();
-    return arena_.ApproximateMemoryUsage() - ShardAllocatedAndUnused();
-  }
-
-  size_t MemoryAllocatedBytes() const {
-    return memory_allocated_bytes_.load(std::memory_order_relaxed);
-  }
-
-  size_t AllocatedAndUnused() const {
-    return arena_allocated_and_unused_.load(std::memory_order_relaxed) +
-           ShardAllocatedAndUnused();
-  }
-
-  size_t IrregularBlockNum() const {
-    return irregular_block_num_.load(std::memory_order_relaxed);
-  }
-
-  size_t BlockSize() const override { return arena_.BlockSize(); }
-
- private:
-  struct Shard {
-    char padding[40] ROCKSDB_FIELD_UNUSED;
-    mutable SpinMutex mutex;
-    char* free_begin_;
-    std::atomic<size_t> allocated_and_unused_;
-
-    Shard() : free_begin_(nullptr), allocated_and_unused_(0) {}
-  };
-
-  static thread_local size_t tls_cpuid;
-
-  char padding0[56] ROCKSDB_FIELD_UNUSED;
-
-  size_t shard_block_size_;
-
-  CoreLocalArray<Shard> shards_;
-
-  Arena arena_;
-  mutable SpinMutex arena_mutex_;
-  std::atomic<size_t> arena_allocated_and_unused_;
-  std::atomic<size_t> memory_allocated_bytes_;
-  std::atomic<size_t> irregular_block_num_;
-
-  char padding1[56] ROCKSDB_FIELD_UNUSED;
-
-  Shard* Repick();
-
-  size_t ShardAllocatedAndUnused() const {
-    size_t total = 0;
-    for (size_t i = 0; i < shards_.Size(); ++i) {
-      total += shards_.AccessAtCore(i)->allocated_and_unused_.load(
-          std::memory_order_relaxed);
-    }
-    return total;
-  }
-
-  template <typename Func>
-  char* AllocateImpl(size_t bytes, bool force_arena, const Func& func) {
-    size_t cpu;
-
-    // Go directly to the arena if the allocation is too large, or if
-    // we've never needed to Repick() and the arena mutex is available
-    // with no waiting.  This keeps the fragmentation penalty of
-    // concurrency zero unless it might actually confer an advantage.
-    std::unique_lock<SpinMutex> arena_lock(arena_mutex_, std::defer_lock);
-    if (bytes > shard_block_size_ / 4 || force_arena ||
-        ((cpu = tls_cpuid) == 0 &&
-         !shards_.AccessAtCore(0)->allocated_and_unused_.load(
-             std::memory_order_relaxed) &&
-         arena_lock.try_lock())) {
-      if (!arena_lock.owns_lock()) {
-        arena_lock.lock();
-      }
-      auto rv = func();
-      Fixup();
-      return rv;
-    }
-
-    // pick a shard from which to allocate
-    Shard* s = shards_.AccessAtCore(cpu & (shards_.Size() - 1));
-    if (!s->mutex.try_lock()) {
-      s = Repick();
-      s->mutex.lock();
-    }
-    std::unique_lock<SpinMutex> lock(s->mutex, std::adopt_lock);
-
-    size_t avail = s->allocated_and_unused_.load(std::memory_order_relaxed);
-    if (avail < bytes) {
-      // reload
-      std::lock_guard<SpinMutex> reload_lock(arena_mutex_);
-
-      // If the arena's current block is within a factor of 2 of the right
-      // size, we adjust our request to avoid arena waste.
-      auto exact = arena_allocated_and_unused_.load(std::memory_order_relaxed);
-      assert(exact == arena_.AllocatedAndUnused());
-
-      if (exact >= bytes && arena_.IsInInlineBlock()) {
-        // If we haven't exhausted arena's inline block yet, allocate from arena
-        // directly. This ensures that we'll do the first few small allocations
-        // without allocating any blocks.
-        // In particular this prevents empty memtables from using
-        // disproportionately large amount of memory: a memtable allocates on
-        // the order of 1 KB of memory when created; we wouldn't want to
-        // allocate a full arena block (typically a few megabytes) for that,
-        // especially if there are thousands of empty memtables.
-        auto rv = func();
-        Fixup();
-        return rv;
-      }
-
-      avail = exact >= shard_block_size_ / 2 && exact < shard_block_size_ * 2
-                  ? exact
-                  : shard_block_size_;
-      s->free_begin_ = arena_.AllocateAligned(avail);
-      Fixup();
-    }
-    s->allocated_and_unused_.store(avail - bytes, std::memory_order_relaxed);
-
-    char* rv;
-    if ((bytes % sizeof(void*)) == 0) {
-      // aligned allocation from the beginning
-      rv = s->free_begin_;
-      s->free_begin_ += bytes;
-    } else {
-      // unaligned from the end
-      rv = s->free_begin_ + avail - bytes;
-    }
-    return rv;
-  }
-
-  void Fixup() {
-    arena_allocated_and_unused_.store(arena_.AllocatedAndUnused(),
-                                      std::memory_order_relaxed);
-    memory_allocated_bytes_.store(arena_.MemoryAllocatedBytes(),
-                                  std::memory_order_relaxed);
-    irregular_block_num_.store(arena_.IrregularBlockNum(),
-                               std::memory_order_relaxed);
-  }
-
-  ConcurrentArena(const ConcurrentArena&) = delete;
-  ConcurrentArena& operator=(const ConcurrentArena&) = delete;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/memory/jemalloc_nodump_allocator.cc

@@ -1,304 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "memory/jemalloc_nodump_allocator.h"
-
-#include <string>
-#include <thread>
-
-#include "port/likely.h"
-#include "port/port.h"
-#include "rocksdb/convenience.h"
-#include "rocksdb/utilities/customizable_util.h"
-#include "rocksdb/utilities/object_registry.h"
-#include "rocksdb/utilities/options_type.h"
-#include "util/fastrange.h"
-#include "util/random.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-std::atomic<extent_alloc_t*> JemallocNodumpAllocator::original_alloc_{nullptr};
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
-static std::unordered_map<std::string, OptionTypeInfo> jemalloc_type_info = {
-    {"limit_tcache_size",
-     {offsetof(struct JemallocAllocatorOptions, limit_tcache_size),
-      OptionType::kBoolean, OptionVerificationType::kNormal,
-      OptionTypeFlags::kNone}},
-    {"tcache_size_lower_bound",
-     {offsetof(struct JemallocAllocatorOptions, tcache_size_lower_bound),
-      OptionType::kSizeT, OptionVerificationType::kNormal,
-      OptionTypeFlags::kNone}},
-    {"tcache_size_upper_bound",
-     {offsetof(struct JemallocAllocatorOptions, tcache_size_upper_bound),
-      OptionType::kSizeT, OptionVerificationType::kNormal,
-      OptionTypeFlags::kNone}},
-    {"num_arenas",
-     {offsetof(struct JemallocAllocatorOptions, num_arenas), OptionType::kSizeT,
-      OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-};
-bool JemallocNodumpAllocator::IsSupported(std::string* why) {
-#ifndef ROCKSDB_JEMALLOC
-  *why = "Not compiled with ROCKSDB_JEMALLOC";
-  return false;
-#else
-  static const std::string unsupported =
-      "JemallocNodumpAllocator only available with jemalloc version >= 5 "
-      "and MADV_DONTDUMP is available.";
-  if (!HasJemalloc()) {
-    *why = unsupported;
-    return false;
-  }
-#ifndef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  *why = unsupported;
-  return false;
-#else
-  return true;
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-#endif  // ROCKSDB_MALLOC
-}
-
-JemallocNodumpAllocator::JemallocNodumpAllocator(
-    const JemallocAllocatorOptions& options)
-    : options_(options)
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-      ,
-      tcache_(&JemallocNodumpAllocator::DestroyThreadSpecificCache) {
-#else   // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-{
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  RegisterOptions(&options_, &jemalloc_type_info);
-}
-
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-JemallocNodumpAllocator::~JemallocNodumpAllocator() {
-  // Destroy tcache before destroying arena.
-  autovector<void*> tcache_list;
-  tcache_.Scrape(&tcache_list, nullptr);
-  for (void* tcache_index : tcache_list) {
-    DestroyThreadSpecificCache(tcache_index);
-  }
-  for (auto arena_index : arena_indexes_) {
-    // Destroy arena. Silently ignore error.
-    Status s = DestroyArena(arena_index);
-    assert(s.ok());
-    s.PermitUncheckedError();
-  }
-}
-
-size_t JemallocNodumpAllocator::UsableSize(void* p,
-                                           size_t /*allocation_size*/) const {
-  return malloc_usable_size(static_cast<void*>(p));
-}
-
-void* JemallocNodumpAllocator::Allocate(size_t size) {
-  int tcache_flag = GetThreadSpecificCache(size);
-  uint32_t arena_index = GetArenaIndex();
-  return mallocx(size, MALLOCX_ARENA(arena_index) | tcache_flag);
-}
-
-void JemallocNodumpAllocator::Deallocate(void* p) {
-  // Obtain tcache.
-  size_t size = 0;
-  if (options_.limit_tcache_size) {
-    size = malloc_usable_size(p);
-  }
-  int tcache_flag = GetThreadSpecificCache(size);
-  // No need to pass arena index to dallocx(). Jemalloc will find arena index
-  // from its own metadata.
-  dallocx(p, tcache_flag);
-}
-
-uint32_t JemallocNodumpAllocator::GetArenaIndex() const {
-  if (arena_indexes_.size() == 1) {
-    return arena_indexes_[0];
-  }
-
-  static std::atomic<uint32_t> next_seed = 0;
-  // Core-local may work in place of `thread_local` as we should be able to
-  // tolerate occasional stale reads in thread migration cases. However we need
-  // to make Random thread-safe and prevent cacheline bouncing. Whether this is
-  // worthwhile is still an open question.
-  thread_local Random tl_random(next_seed.fetch_add(1));
-  return arena_indexes_[FastRange32(
-      tl_random.Next(), static_cast<uint32_t>(arena_indexes_.size()))];
-}
-
-Status JemallocNodumpAllocator::InitializeArenas() {
-  assert(!init_);
-  init_ = true;
-
-  for (size_t i = 0; i < options_.num_arenas; i++) {
-    // Create arena.
-    unsigned arena_index;
-    size_t arena_index_size = sizeof(arena_index);
-    int ret =
-        mallctl("arenas.create", &arena_index, &arena_index_size, nullptr, 0);
-    if (ret != 0) {
-      return Status::Incomplete(
-          "Failed to create jemalloc arena, error code: " +
-          std::to_string(ret));
-    }
-    arena_indexes_.push_back(arena_index);
-
-    // Read existing hooks.
-    std::string key =
-        "arena." + std::to_string(arena_indexes_[i]) + ".extent_hooks";
-    extent_hooks_t* hooks;
-    size_t hooks_size = sizeof(hooks);
-    ret = mallctl(key.c_str(), &hooks, &hooks_size, nullptr, 0);
-    if (ret != 0) {
-      return Status::Incomplete("Failed to read existing hooks, error code: " +
-                                std::to_string(ret));
-    }
-
-    // Store existing alloc.
-    extent_alloc_t* original_alloc = hooks->alloc;
-    extent_alloc_t* expected = nullptr;
-    bool success =
-        JemallocNodumpAllocator::original_alloc_.compare_exchange_strong(
-            expected, original_alloc);
-    if (!success && original_alloc != expected) {
-      // This could happen if jemalloc creates new arenas with different initial
-      // values in their `alloc` function pointers. See `original_alloc_` API
-      // doc for more details.
-      return Status::Incomplete("Original alloc conflict.");
-    }
-
-    // Set the custom hook.
-    per_arena_hooks_.emplace_back();
-    per_arena_hooks_.back().reset(new extent_hooks_t(*hooks));
-    per_arena_hooks_.back()->alloc = &JemallocNodumpAllocator::Alloc;
-    extent_hooks_t* hooks_ptr = per_arena_hooks_.back().get();
-    ret = mallctl(key.c_str(), nullptr, nullptr, &hooks_ptr, sizeof(hooks_ptr));
-    if (ret != 0) {
-      return Status::Incomplete("Failed to set custom hook, error code: " +
-                                std::to_string(ret));
-    }
-  }
-  return Status::OK();
-}
-
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
-Status JemallocNodumpAllocator::PrepareOptions(
-    const ConfigOptions& config_options) {
-  std::string message;
-
-  if (!IsSupported(&message)) {
-    return Status::NotSupported(message);
-  } else if (options_.limit_tcache_size &&
-             options_.tcache_size_lower_bound >=
-                 options_.tcache_size_upper_bound) {
-    return Status::InvalidArgument(
-        "tcache_size_lower_bound larger or equal to tcache_size_upper_bound.");
-  } else if (options_.num_arenas < 1) {
-    return Status::InvalidArgument("num_arenas must be a positive integer");
-  } else if (IsMutable()) {
-    Status s = MemoryAllocator::PrepareOptions(config_options);
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-    if (s.ok()) {
-      s = InitializeArenas();
-    }
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-    return s;
-  } else {
-    // Already prepared
-    return Status::OK();
-  }
-}
-
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-int JemallocNodumpAllocator::GetThreadSpecificCache(size_t size) {
-  // We always enable tcache. The only corner case is when there are a ton of
-  // threads accessing with low frequency, then it could consume a lot of
-  // memory (may reach # threads * ~1MB) without bringing too much benefit.
-  if (options_.limit_tcache_size && (size <= options_.tcache_size_lower_bound ||
-                                     size > options_.tcache_size_upper_bound)) {
-    return MALLOCX_TCACHE_NONE;
-  }
-  unsigned* tcache_index = static_cast<unsigned*>(tcache_.Get());
-  if (UNLIKELY(tcache_index == nullptr)) {
-    // Instantiate tcache.
-    tcache_index = new unsigned(0);
-    size_t tcache_index_size = sizeof(unsigned);
-    int ret =
-        mallctl("tcache.create", tcache_index, &tcache_index_size, nullptr, 0);
-    if (ret != 0) {
-      // No good way to expose the error. Silently disable tcache.
-      delete tcache_index;
-      return MALLOCX_TCACHE_NONE;
-    }
-    tcache_.Reset(static_cast<void*>(tcache_index));
-  }
-  return MALLOCX_TCACHE(*tcache_index);
-}
-void* JemallocNodumpAllocator::Alloc(extent_hooks_t* extent, void* new_addr,
-                                     size_t size, size_t alignment, bool* zero,
-                                     bool* commit, unsigned arena_ind) {
-  extent_alloc_t* original_alloc =
-      original_alloc_.load(std::memory_order_relaxed);
-  assert(original_alloc != nullptr);
-  void* result = original_alloc(extent, new_addr, size, alignment, zero, commit,
-                                arena_ind);
-  if (result != nullptr) {
-    int ret = madvise(result, size, MADV_DONTDUMP);
-    if (ret != 0) {
-      fprintf(
-          stderr,
-          "JemallocNodumpAllocator failed to set MADV_DONTDUMP, error code: %d",
-          ret);
-      assert(false);
-    }
-  }
-  return result;
-}
-
-Status JemallocNodumpAllocator::DestroyArena(uint32_t arena_index) {
-  assert(arena_index != 0);
-  std::string key = "arena." + std::to_string(arena_index) + ".destroy";
-  int ret = mallctl(key.c_str(), nullptr, 0, nullptr, 0);
-  if (ret != 0) {
-    return Status::Incomplete("Failed to destroy jemalloc arena, error code: " +
-                              std::to_string(ret));
-  }
-  return Status::OK();
-}
-
-void JemallocNodumpAllocator::DestroyThreadSpecificCache(void* ptr) {
-  assert(ptr != nullptr);
-  unsigned* tcache_index = static_cast<unsigned*>(ptr);
-  size_t tcache_index_size = sizeof(unsigned);
-  int ret __attribute__((__unused__)) =
-      mallctl("tcache.destroy", nullptr, 0, tcache_index, tcache_index_size);
-  // Silently ignore error.
-  assert(ret == 0);
-  delete tcache_index;
-}
-
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
-Status NewJemallocNodumpAllocator(
-    const JemallocAllocatorOptions& options,
-    std::shared_ptr<MemoryAllocator>* memory_allocator) {
-  if (memory_allocator == nullptr) {
-    return Status::InvalidArgument("memory_allocator must be non-null.");
-  }
-#ifndef ROCKSDB_JEMALLOC
-  (void)options;
-  return Status::NotSupported("Not compiled with JEMALLOC");
-#else
-  std::unique_ptr<MemoryAllocator> allocator(
-      new JemallocNodumpAllocator(options));
-  Status s = allocator->PrepareOptions(ConfigOptions());
-  if (s.ok()) {
-    memory_allocator->reset(allocator.release());
-  }
-  return s;
-#endif
-}
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/memory/jemalloc_nodump_allocator.h

@@ -1,99 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <atomic>
-#include <vector>
-
-#include "port/jemalloc_helper.h"
-#include "port/port.h"
-#include "rocksdb/memory_allocator.h"
-#include "util/thread_local.h"
-#include "utilities/memory_allocators.h"
-
-#if defined(ROCKSDB_JEMALLOC) && defined(ROCKSDB_PLATFORM_POSIX)
-
-#include <sys/mman.h>
-
-#if (JEMALLOC_VERSION_MAJOR >= 5) && defined(MADV_DONTDUMP)
-#define ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-#endif  // (JEMALLOC_VERSION_MAJOR >= 5) && MADV_DONTDUMP
-#endif  // ROCKSDB_JEMALLOC && ROCKSDB_PLATFORM_POSIX
-
-namespace ROCKSDB_NAMESPACE {
-
-// Allocation requests are randomly sharded across
-// `JemallocAllocatorOptions::num_arenas` arenas to reduce contention on per-
-// arena mutexes.
-class JemallocNodumpAllocator : public BaseMemoryAllocator {
- public:
-  explicit JemallocNodumpAllocator(const JemallocAllocatorOptions& options);
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  ~JemallocNodumpAllocator();
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
-  static const char* kClassName() { return "JemallocNodumpAllocator"; }
-  const char* Name() const override { return kClassName(); }
-  static bool IsSupported() {
-    std::string unused;
-    return IsSupported(&unused);
-  }
-  static bool IsSupported(std::string* why);
-  bool IsMutable() const { return !init_; }
-
-  Status PrepareOptions(const ConfigOptions& config_options) override;
-
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  void* Allocate(size_t size) override;
-  void Deallocate(void* p) override;
-  size_t UsableSize(void* p, size_t allocation_size) const override;
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
- private:
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  Status InitializeArenas();
-
-  uint32_t GetArenaIndex() const;
-
-  // Custom alloc hook to replace jemalloc default alloc.
-  static void* Alloc(extent_hooks_t* extent, void* new_addr, size_t size,
-                     size_t alignment, bool* zero, bool* commit,
-                     unsigned arena_ind);
-
-  // Destroy arena on destruction of the allocator, or on failure.
-  static Status DestroyArena(uint32_t arena_index);
-
-  // Destroy tcache on destruction of the allocator, or thread exit.
-  static void DestroyThreadSpecificCache(void* ptr);
-
-  // Get or create tcache. Return flag suitable to use with `mallocx`:
-  // either MALLOCX_TCACHE_NONE or MALLOCX_TCACHE(tc).
-  int GetThreadSpecificCache(size_t size);
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  JemallocAllocatorOptions options_;
-
-#ifdef ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-  // A function pointer to jemalloc default alloc. Use atomic to make sure
-  // NewJemallocNodumpAllocator is thread-safe.
-  //
-  // Hack: original_alloc_ needs to be static for Alloc() to access it.
-  // alloc needs to be static to pass to jemalloc as function pointer. We can
-  // use a single process-wide value as long as we assume that any newly created
-  // arena has the same original value in its `alloc` function pointer.
-  static std::atomic<extent_alloc_t*> original_alloc_;
-
-  // Custom hooks has to outlive corresponding arena.
-  std::vector<std::unique_ptr<extent_hooks_t>> per_arena_hooks_;
-
-  // Hold thread-local tcache index.
-  ThreadLocalPtr tcache_;
-
-  std::vector<uint32_t> arena_indexes_;
-#endif  // ROCKSDB_JEMALLOC_NODUMP_ALLOCATOR
-
-  bool init_ = false;
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/memory/memkind_kmem_allocator.cc

@@ -1,44 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  Copyright (c) 2019 Intel Corporation
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#ifdef MEMKIND
-#include <memkind.h>
-#endif  // MEMKIND
-
-#include "memory/memkind_kmem_allocator.h"
-
-namespace ROCKSDB_NAMESPACE {
-Status MemkindKmemAllocator::PrepareOptions(const ConfigOptions& options) {
-  std::string message;
-  if (!IsSupported(&message)) {
-    return Status::NotSupported(message);
-  } else {
-    return MemoryAllocator::PrepareOptions(options);
-  }
-}
-
-#ifdef MEMKIND
-void* MemkindKmemAllocator::Allocate(size_t size) {
-  void* p = memkind_malloc(MEMKIND_DAX_KMEM, size);
-  if (p == NULL) {
-    throw std::bad_alloc();
-  }
-  return p;
-}
-
-void MemkindKmemAllocator::Deallocate(void* p) {
-  memkind_free(MEMKIND_DAX_KMEM, p);
-}
-
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-size_t MemkindKmemAllocator::UsableSize(void* p,
-                                        size_t /*allocation_size*/) const {
-  return memkind_malloc_usable_size(MEMKIND_DAX_KMEM, p);
-}
-#endif  // ROCKSDB_MALLOC_USABLE_SIZE
-#endif  // MEMKIND
-
-}  // namespace ROCKSDB_NAMESPACE