rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/logging/log_buffer.cc

@@ -1,91 +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 "logging/log_buffer.h"
-
-#include "port/port.h"
-#include "port/sys_time.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-LogBuffer::LogBuffer(const InfoLogLevel log_level, Logger* info_log)
-    : log_level_(log_level), info_log_(info_log) {}
-
-void LogBuffer::AddLogToBuffer(size_t max_log_size, const char* format,
-                               va_list ap) {
-  if (!info_log_ || log_level_ < info_log_->GetInfoLogLevel()) {
-    // Skip the level because of its level.
-    return;
-  }
-
-  char* alloc_mem = arena_.AllocateAligned(max_log_size);
-  BufferedLog* buffered_log = new (alloc_mem) BufferedLog();
-  char* p = buffered_log->message;
-  char* limit = alloc_mem + max_log_size - 1;
-
-  // store the time
-  port::GetTimeOfDay(&(buffered_log->now_tv), nullptr);
-
-  // Print the message
-  if (p < limit) {
-    va_list backup_ap;
-    va_copy(backup_ap, ap);
-    auto n = vsnprintf(p, limit - p, format, backup_ap);
-#ifndef OS_WIN
-    // MS reports -1 when the buffer is too short
-    assert(n >= 0);
-#endif
-    if (n > 0) {
-      p += n;
-    } else {
-      p = limit;
-    }
-    va_end(backup_ap);
-  }
-
-  if (p > limit) {
-    p = limit;
-  }
-
-  // Add '\0' to the end
-  *p = '\0';
-
-  logs_.push_back(buffered_log);
-}
-
-void LogBuffer::FlushBufferToLog() {
-  for (BufferedLog* log : logs_) {
-    const time_t seconds = log->now_tv.tv_sec;
-    struct tm t;
-    if (port::LocalTimeR(&seconds, &t) != nullptr) {
-      Log(log_level_, info_log_,
-          "(Original Log Time %04d/%02d/%02d-%02d:%02d:%02d.%06d) %s",
-          t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min,
-          t.tm_sec, static_cast<int>(log->now_tv.tv_usec), log->message);
-    }
-  }
-  logs_.clear();
-}
-
-void LogToBuffer(LogBuffer* log_buffer, size_t max_log_size, const char* format,
-                 ...) {
-  if (log_buffer != nullptr) {
-    va_list ap;
-    va_start(ap, format);
-    log_buffer->AddLogToBuffer(max_log_size, format, ap);
-    va_end(ap);
-  }
-}
-
-void LogToBuffer(LogBuffer* log_buffer, const char* format, ...) {
-  if (log_buffer != nullptr) {
-    va_list ap;
-    va_start(ap, format);
-    log_buffer->AddLogToBuffer(LogBuffer::kDefaultMaxLogSize, format, ap);
-    va_end(ap);
-  }
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/logging/log_buffer.h

@@ -1,57 +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 <ctime>
-
-#include "memory/arena.h"
-#include "port/sys_time.h"
-#include "rocksdb/env.h"
-#include "util/autovector.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Logger;
-
-// A class to buffer info log entries and flush them in the end.
-class LogBuffer {
- public:
-  // log_level: the log level for all the logs
-  // info_log:  logger to write the logs to
-  LogBuffer(const InfoLogLevel log_level, Logger* info_log);
-
-  // Add a log entry to the buffer. Use default max_log_size.
-  // max_log_size indicates maximize log size, including some metadata.
-  void AddLogToBuffer(size_t max_log_size, const char* format, va_list ap);
-
-  size_t IsEmpty() const { return logs_.empty(); }
-
-  // Flush all buffered log to the info log.
-  void FlushBufferToLog();
-  static const size_t kDefaultMaxLogSize = 512;
-
- private:
-  // One log entry with its timestamp
-  struct BufferedLog {
-    port::TimeVal now_tv;  // Timestamp of the log
-    char message[1];       // Beginning of log message
-  };
-
-  const InfoLogLevel log_level_;
-  Logger* info_log_;
-  Arena arena_;
-  autovector<BufferedLog*> logs_;
-};
-
-// Add log to the LogBuffer for a delayed info logging. It can be used when
-// we want to add some logs inside a mutex.
-// max_log_size indicates maximize log size, including some metadata.
-void LogToBuffer(LogBuffer* log_buffer, size_t max_log_size, const char* format,
-                 ...);
-// Same as previous function, but with default max log size.
-void LogToBuffer(LogBuffer* log_buffer, const char* format, ...);
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/logging/logging.h

@@ -1,62 +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.
-//
-// Must not be included from any .h files to avoid polluting the namespace
-// with macros.
-
-#pragma once
-
-// Helper macros that include information about file name and line number
-#define ROCKS_LOG_STRINGIFY(x) #x
-#define ROCKS_LOG_TOSTRING(x) ROCKS_LOG_STRINGIFY(x)
-#define ROCKS_LOG_PREPEND_FILE_LINE(FMT) \
-  ("[%s:" ROCKS_LOG_TOSTRING(__LINE__) "] " FMT)
-
-inline const char* RocksLogShorterFileName(const char* file) {
-  // 18 is the length of "logging/logging.h".
-  // If the name of this file changed, please change this number, too.
-  return file + (sizeof(__FILE__) > 18 ? sizeof(__FILE__) - 18 : 0);
-}
-
-// Don't inclide file/line info in HEADER level
-#define ROCKS_LOG_HEADER(LGR, FMT, ...) \
-  ROCKSDB_NAMESPACE::Log(InfoLogLevel::HEADER_LEVEL, LGR, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_AT_LEVEL(LGR, LVL, FMT, ...)                           \
-  ROCKSDB_NAMESPACE::Log((LVL), (LGR), ROCKS_LOG_PREPEND_FILE_LINE(FMT), \
-                         RocksLogShorterFileName(__FILE__), ##__VA_ARGS__)
-
-#define ROCKS_LOG_DEBUG(LGR, FMT, ...) \
-  ROCKS_LOG_AT_LEVEL((LGR), InfoLogLevel::DEBUG_LEVEL, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_INFO(LGR, FMT, ...) \
-  ROCKS_LOG_AT_LEVEL((LGR), InfoLogLevel::INFO_LEVEL, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_WARN(LGR, FMT, ...) \
-  ROCKS_LOG_AT_LEVEL((LGR), InfoLogLevel::WARN_LEVEL, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_ERROR(LGR, FMT, ...) \
-  ROCKS_LOG_AT_LEVEL((LGR), InfoLogLevel::ERROR_LEVEL, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_FATAL(LGR, FMT, ...) \
-  ROCKS_LOG_AT_LEVEL((LGR), InfoLogLevel::FATAL_LEVEL, FMT, ##__VA_ARGS__)
-
-#define ROCKS_LOG_BUFFER(LOG_BUF, FMT, ...)                                 \
-  ROCKSDB_NAMESPACE::LogToBuffer(LOG_BUF, ROCKS_LOG_PREPEND_FILE_LINE(FMT), \
-                                 RocksLogShorterFileName(__FILE__),         \
-                                 ##__VA_ARGS__)
-
-#define ROCKS_LOG_BUFFER_MAX_SZ(LOG_BUF, MAX_LOG_SIZE, FMT, ...) \
-  ROCKSDB_NAMESPACE::LogToBuffer(                                \
-      LOG_BUF, MAX_LOG_SIZE, ROCKS_LOG_PREPEND_FILE_LINE(FMT),   \
-      RocksLogShorterFileName(__FILE__), ##__VA_ARGS__)
-
-#define ROCKS_LOG_DETAILS(LGR, FMT, ...) \
-  ;  // due to overhead by default skip such lines
-// ROCKS_LOG_DEBUG(LGR, FMT, ##__VA_ARGS__)

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

@@ -1,58 +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.
-//
-// Abstract interface for allocating memory in blocks. This memory is freed
-// when the allocator object is destroyed. See the Arena class for more info.
-
-#pragma once
-#include <cerrno>
-#include <cstddef>
-
-#include "rocksdb/write_buffer_manager.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Logger;
-
-class Allocator {
- public:
-  virtual ~Allocator() {}
-
-  virtual char* Allocate(size_t bytes) = 0;
-  virtual char* AllocateAligned(size_t bytes, size_t huge_page_size = 0,
-                                Logger* logger = nullptr) = 0;
-
-  virtual size_t BlockSize() const = 0;
-};
-
-class AllocTracker {
- public:
-  explicit AllocTracker(WriteBufferManager* write_buffer_manager);
-  // No copying allowed
-  AllocTracker(const AllocTracker&) = delete;
-  void operator=(const AllocTracker&) = delete;
-
-  ~AllocTracker();
-  void Allocate(size_t bytes);
-  // Call when we're finished allocating memory so we can free it from
-  // the write buffer's limit.
-  void DoneAllocating();
-
-  void FreeMem();
-
-  bool is_freed() const { return write_buffer_manager_ == nullptr || freed_; }
-
- private:
-  WriteBufferManager* write_buffer_manager_;
-  std::atomic<size_t> bytes_allocated_;
-  bool done_allocating_;
-  bool freed_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,170 +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.
-
-#include "memory/arena.h"
-
-#include <algorithm>
-
-#include "logging/logging.h"
-#include "port/malloc.h"
-#include "port/port.h"
-#include "rocksdb/env.h"
-#include "test_util/sync_point.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-size_t Arena::OptimizeBlockSize(size_t block_size) {
-  // Make sure block_size is in optimal range
-  block_size = std::max(Arena::kMinBlockSize, block_size);
-  block_size = std::min(Arena::kMaxBlockSize, block_size);
-
-  // make sure block_size is the multiple of kAlignUnit
-  if (block_size % kAlignUnit != 0) {
-    block_size = (1 + block_size / kAlignUnit) * kAlignUnit;
-  }
-
-  return block_size;
-}
-
-Arena::Arena(size_t block_size, AllocTracker* tracker, size_t huge_page_size)
-    : kBlockSize(OptimizeBlockSize(block_size)), tracker_(tracker) {
-  assert(kBlockSize >= kMinBlockSize && kBlockSize <= kMaxBlockSize &&
-         kBlockSize % kAlignUnit == 0);
-  TEST_SYNC_POINT_CALLBACK("Arena::Arena:0", const_cast<size_t*>(&kBlockSize));
-  alloc_bytes_remaining_ = sizeof(inline_block_);
-  blocks_memory_ += alloc_bytes_remaining_;
-  aligned_alloc_ptr_ = inline_block_;
-  unaligned_alloc_ptr_ = inline_block_ + alloc_bytes_remaining_;
-  if (MemMapping::kHugePageSupported) {
-    hugetlb_size_ = huge_page_size;
-    if (hugetlb_size_ && kBlockSize > hugetlb_size_) {
-      hugetlb_size_ = ((kBlockSize - 1U) / hugetlb_size_ + 1U) * hugetlb_size_;
-    }
-  }
-  if (tracker_ != nullptr) {
-    tracker_->Allocate(kInlineSize);
-  }
-}
-
-Arena::~Arena() {
-  if (tracker_ != nullptr) {
-    assert(tracker_->is_freed());
-    tracker_->FreeMem();
-  }
-}
-
-char* Arena::AllocateFallback(size_t bytes, bool aligned) {
-  if (bytes > kBlockSize / 4) {
-    ++irregular_block_num;
-    // Object is more than a quarter of our block size.  Allocate it separately
-    // to avoid wasting too much space in leftover bytes.
-    return AllocateNewBlock(bytes);
-  }
-
-  // We waste the remaining space in the current block.
-  size_t size = 0;
-  char* block_head = nullptr;
-  if (MemMapping::kHugePageSupported && hugetlb_size_ > 0) {
-    size = hugetlb_size_;
-    block_head = AllocateFromHugePage(size);
-  }
-  if (!block_head) {
-    size = kBlockSize;
-    block_head = AllocateNewBlock(size);
-  }
-  alloc_bytes_remaining_ = size - bytes;
-
-  if (aligned) {
-    aligned_alloc_ptr_ = block_head + bytes;
-    unaligned_alloc_ptr_ = block_head + size;
-    return block_head;
-  } else {
-    aligned_alloc_ptr_ = block_head;
-    unaligned_alloc_ptr_ = block_head + size - bytes;
-    return unaligned_alloc_ptr_;
-  }
-}
-
-char* Arena::AllocateFromHugePage(size_t bytes) {
-  MemMapping mm = MemMapping::AllocateHuge(bytes);
-  auto addr = static_cast<char*>(mm.Get());
-  if (addr) {
-    huge_blocks_.push_back(std::move(mm));
-    blocks_memory_ += bytes;
-    if (tracker_ != nullptr) {
-      tracker_->Allocate(bytes);
-    }
-  }
-  return addr;
-}
-
-char* Arena::AllocateAligned(size_t bytes, size_t huge_page_size,
-                             Logger* logger) {
-  if (MemMapping::kHugePageSupported && hugetlb_size_ > 0 &&
-      huge_page_size > 0 && bytes > 0) {
-    // Allocate from a huge page TLB table.
-    size_t reserved_size =
-        ((bytes - 1U) / huge_page_size + 1U) * huge_page_size;
-    assert(reserved_size >= bytes);
-
-    char* addr = AllocateFromHugePage(reserved_size);
-    if (addr == nullptr) {
-      ROCKS_LOG_WARN(logger,
-                     "AllocateAligned fail to allocate huge TLB pages: %s",
-                     errnoStr(errno).c_str());
-      // fail back to malloc
-    } else {
-      return addr;
-    }
-  }
-
-  size_t current_mod =
-      reinterpret_cast<uintptr_t>(aligned_alloc_ptr_) & (kAlignUnit - 1);
-  size_t slop = (current_mod == 0 ? 0 : kAlignUnit - current_mod);
-  size_t needed = bytes + slop;
-  char* result;
-  if (needed <= alloc_bytes_remaining_) {
-    result = aligned_alloc_ptr_ + slop;
-    aligned_alloc_ptr_ += needed;
-    alloc_bytes_remaining_ -= needed;
-  } else {
-    // AllocateFallback always returns aligned memory
-    result = AllocateFallback(bytes, true /* aligned */);
-  }
-  assert((reinterpret_cast<uintptr_t>(result) & (kAlignUnit - 1)) == 0);
-  return result;
-}
-
-char* Arena::AllocateNewBlock(size_t block_bytes) {
-  // NOTE: std::make_unique zero-initializes the block so is not appropriate
-  // here
-  char* block = new char[block_bytes];
-  blocks_.push_back(std::unique_ptr<char[]>(block));
-
-  size_t allocated_size;
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-  allocated_size = malloc_usable_size(block);
-#ifndef NDEBUG
-  // It's hard to predict what malloc_usable_size() returns.
-  // A callback can allow users to change the costed size.
-  std::pair<size_t*, size_t*> pair(&allocated_size, &block_bytes);
-  TEST_SYNC_POINT_CALLBACK("Arena::AllocateNewBlock:0", &pair);
-#endif  // NDEBUG
-#else
-  allocated_size = block_bytes;
-#endif  // ROCKSDB_MALLOC_USABLE_SIZE
-  blocks_memory_ += allocated_size;
-  if (tracker_ != nullptr) {
-    tracker_->Allocate(allocated_size);
-  }
-  return block;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,146 +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.
-
-// Arena is an implementation of Allocator class. For a request of small size,
-// it allocates a block with pre-defined block size. For a request of big
-// size, it uses malloc to directly get the requested size.
-
-#pragma once
-
-#include <cstddef>
-#include <deque>
-
-#include "memory/allocator.h"
-#include "port/mmap.h"
-#include "rocksdb/env.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Arena : public Allocator {
- public:
-  // No copying allowed
-  Arena(const Arena&) = delete;
-  void operator=(const Arena&) = delete;
-
-  static constexpr size_t kInlineSize = 2048;
-  static constexpr size_t kMinBlockSize = 4096;
-  static constexpr size_t kMaxBlockSize = 2u << 30;
-
-  static constexpr unsigned kAlignUnit = alignof(std::max_align_t);
-  static_assert((kAlignUnit & (kAlignUnit - 1)) == 0,
-                "Pointer size should be power of 2");
-
-  // huge_page_size: if 0, don't use huge page TLB. If > 0 (should set to the
-  // supported hugepage size of the system), block allocation will try huge
-  // page TLB first. If allocation fails, will fall back to normal case.
-  explicit Arena(size_t block_size = kMinBlockSize,
-                 AllocTracker* tracker = nullptr, size_t huge_page_size = 0);
-  ~Arena();
-
-  char* Allocate(size_t bytes) override;
-
-  // huge_page_size: if >0, will try to allocate from huage page TLB.
-  // The argument will be the size of the page size for huge page TLB. Bytes
-  // will be rounded up to multiple of the page size to allocate through mmap
-  // anonymous option with huge page on. The extra  space allocated will be
-  // wasted. If allocation fails, will fall back to normal case. To enable it,
-  // need to reserve huge pages for it to be allocated, like:
-  //     sysctl -w vm.nr_hugepages=20
-  // See linux doc Documentation/vm/hugetlbpage.txt for details.
-  // huge page allocation can fail. In this case it will fail back to
-  // normal cases. The messages will be logged to logger. So when calling with
-  // huge_page_tlb_size > 0, we highly recommend a logger is passed in.
-  // Otherwise, the error message will be printed out to stderr directly.
-  char* AllocateAligned(size_t bytes, size_t huge_page_size = 0,
-                        Logger* logger = nullptr) override;
-
-  // Returns an estimate of the total memory usage of data allocated
-  // by the arena (exclude the space allocated but not yet used for future
-  // allocations).
-  size_t ApproximateMemoryUsage() const {
-    return blocks_memory_ + blocks_.size() * sizeof(char*) -
-           alloc_bytes_remaining_;
-  }
-
-  size_t MemoryAllocatedBytes() const { return blocks_memory_; }
-
-  size_t AllocatedAndUnused() const { return alloc_bytes_remaining_; }
-
-  // If an allocation is too big, we'll allocate an irregular block with the
-  // same size of that allocation.
-  size_t IrregularBlockNum() const { return irregular_block_num; }
-
-  size_t BlockSize() const override { return kBlockSize; }
-
-  bool IsInInlineBlock() const {
-    return blocks_.empty() && huge_blocks_.empty();
-  }
-
-  // check and adjust the block_size so that the return value is
-  //  1. in the range of [kMinBlockSize, kMaxBlockSize].
-  //  2. the multiple of align unit.
-  static size_t OptimizeBlockSize(size_t block_size);
-
- private:
-  alignas(std::max_align_t) char inline_block_[kInlineSize];
-  // Number of bytes allocated in one block
-  const size_t kBlockSize;
-  // Allocated memory blocks
-  std::deque<std::unique_ptr<char[]>> blocks_;
-  // Huge page allocations
-  std::deque<MemMapping> huge_blocks_;
-  size_t irregular_block_num = 0;
-
-  // Stats for current active block.
-  // For each block, we allocate aligned memory chucks from one end and
-  // allocate unaligned memory chucks from the other end. Otherwise the
-  // memory waste for alignment will be higher if we allocate both types of
-  // memory from one direction.
-  char* unaligned_alloc_ptr_ = nullptr;
-  char* aligned_alloc_ptr_ = nullptr;
-  // How many bytes left in currently active block?
-  size_t alloc_bytes_remaining_ = 0;
-
-  size_t hugetlb_size_ = 0;
-
-  char* AllocateFromHugePage(size_t bytes);
-  char* AllocateFallback(size_t bytes, bool aligned);
-  char* AllocateNewBlock(size_t block_bytes);
-
-  // Bytes of memory in blocks allocated so far
-  size_t blocks_memory_ = 0;
-  // Non-owned
-  AllocTracker* tracker_;
-};
-
-inline char* Arena::Allocate(size_t bytes) {
-  // The semantics of what to return are a bit messy if we allow
-  // 0-byte allocations, so we disallow them here (we don't need
-  // them for our internal use).
-  assert(bytes > 0);
-  if (bytes <= alloc_bytes_remaining_) {
-    unaligned_alloc_ptr_ -= bytes;
-    alloc_bytes_remaining_ -= bytes;
-    return unaligned_alloc_ptr_;
-  }
-  return AllocateFallback(bytes, false /* unaligned */);
-}
-
-// Like std::destroy_at but a callable type
-template <typename T>
-struct Destroyer {
-  void operator()(T* ptr) { ptr->~T(); }
-};
-
-// Like std::unique_ptr but only placement-deletes the object (for
-// objects allocated on an arena).
-template <typename T>
-using ScopedArenaPtr = std::unique_ptr<T, Destroyer<T>>;
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,45 +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.
-
-#include "memory/concurrent_arena.h"
-
-#include <thread>
-
-#include "port/port.h"
-#include "util/random.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-thread_local size_t ConcurrentArena::tls_cpuid = 0;
-
-namespace {
-// If the shard block size is too large, in the worst case, every core
-// allocates a block without populate it. If the shared block size is
-// 1MB, 64 cores will quickly allocate 64MB, and may quickly trigger a
-// flush. Cap the size instead.
-const size_t kMaxShardBlockSize = size_t{128 * 1024};
-}  // namespace
-
-ConcurrentArena::ConcurrentArena(size_t block_size, AllocTracker* tracker,
-                                 size_t huge_page_size)
-    : shard_block_size_(std::min(kMaxShardBlockSize, block_size / 8)),
-      shards_(),
-      arena_(block_size, tracker, huge_page_size) {
-  Fixup();
-}
-
-ConcurrentArena::Shard* ConcurrentArena::Repick() {
-  auto shard_and_index = shards_.AccessElementAndIndex();
-  // even if we are cpu 0, use a non-zero tls_cpuid so we can tell we
-  // have repicked
-  tls_cpuid = shard_and_index.second | shards_.Size();
-  return shard_and_index.first;
-}
-
-}  // namespace ROCKSDB_NAMESPACE