rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/table/block_based/cachable_entry.h

@@ -1,249 +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) 2012 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 <cassert>
-#include <type_traits>
-
-#include "port/likely.h"
-#include "rocksdb/advanced_cache.h"
-#include "rocksdb/cleanable.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// CachableEntry is a handle to an object that may or may not be in the block
-// cache. It is used in a variety of ways:
-//
-// 1) It may refer to an object in the block cache. In this case, cache_ and
-// cache_handle_ are not nullptr, and the cache handle has to be released when
-// the CachableEntry is destroyed (the lifecycle of the cached object, on the
-// other hand, is managed by the cache itself).
-// 2) It may uniquely own the (non-cached) object it refers to (examples include
-// a block read directly from file, or uncompressed blocks when there is a
-// compressed block cache but no uncompressed block cache). In such cases, the
-// object has to be destroyed when the CachableEntry is destroyed.
-// 3) It may point to an object (cached or not) without owning it. In this case,
-// no action is needed when the CachableEntry is destroyed.
-// 4) Sometimes, management of a cached or owned object (see #1 and #2 above)
-// is transferred to some other object. This is used for instance with iterators
-// (where cleanup is performed using a chain of cleanup functions,
-// see Cleanable).
-//
-// Because of #1 and #2 above, copying a CachableEntry is not safe (and thus not
-// allowed); hence, this is a move-only type, where a move transfers the
-// management responsibilities, and leaves the source object in an empty state.
-
-template <class T>
-class CachableEntry {
- public:
-  CachableEntry() = default;
-
-  CachableEntry(T* value, Cache* cache, Cache::Handle* cache_handle,
-                bool own_value)
-      : value_(value),
-        cache_(cache),
-        cache_handle_(cache_handle),
-        own_value_(own_value) {
-    assert(value_ != nullptr ||
-           (cache_ == nullptr && cache_handle_ == nullptr && !own_value_));
-    assert(!!cache_ == !!cache_handle_);
-    assert(!cache_handle_ || !own_value_);
-  }
-
-  CachableEntry(const CachableEntry&) = delete;
-  CachableEntry& operator=(const CachableEntry&) = delete;
-
-  CachableEntry(CachableEntry&& rhs) noexcept
-      : value_(rhs.value_),
-        cache_(rhs.cache_),
-        cache_handle_(rhs.cache_handle_),
-        own_value_(rhs.own_value_) {
-    assert(value_ != nullptr ||
-           (cache_ == nullptr && cache_handle_ == nullptr && !own_value_));
-    assert(!!cache_ == !!cache_handle_);
-    assert(!cache_handle_ || !own_value_);
-
-    rhs.ResetFields();
-  }
-
-  CachableEntry& operator=(CachableEntry&& rhs) noexcept {
-    if (UNLIKELY(this == &rhs)) {
-      return *this;
-    }
-
-    ReleaseResource(/*erase_if_last_ref=*/false);
-
-    value_ = rhs.value_;
-    cache_ = rhs.cache_;
-    cache_handle_ = rhs.cache_handle_;
-    own_value_ = rhs.own_value_;
-
-    assert(value_ != nullptr ||
-           (cache_ == nullptr && cache_handle_ == nullptr && !own_value_));
-    assert(!!cache_ == !!cache_handle_);
-    assert(!cache_handle_ || !own_value_);
-
-    rhs.ResetFields();
-
-    return *this;
-  }
-
-  ~CachableEntry() { ReleaseResource(/*erase_if_last_ref=*/false); }
-
-  bool IsEmpty() const {
-    return value_ == nullptr && cache_ == nullptr && cache_handle_ == nullptr &&
-           !own_value_;
-  }
-
-  bool IsCached() const {
-    assert(!!cache_ == !!cache_handle_);
-
-    return cache_handle_ != nullptr;
-  }
-
-  T* GetValue() const { return value_; }
-  Cache* GetCache() const { return cache_; }
-  Cache::Handle* GetCacheHandle() const { return cache_handle_; }
-  bool GetOwnValue() const { return own_value_; }
-
-  void Reset() {
-    ReleaseResource(/*erase_if_last_ref=*/false);
-    ResetFields();
-  }
-
-  void ResetEraseIfLastRef() {
-    ReleaseResource(/*erase_if_last_ref=*/true);
-    ResetFields();
-  }
-
-  void TransferTo(Cleanable* cleanable) {
-    if (cleanable) {
-      if (cache_handle_ != nullptr) {
-        assert(cache_ != nullptr);
-        cleanable->RegisterCleanup(&ReleaseCacheHandle, cache_, cache_handle_);
-      } else if (own_value_) {
-        cleanable->RegisterCleanup(&DeleteValue, value_, nullptr);
-      }
-    }
-
-    ResetFields();
-  }
-
-  void SetOwnedValue(std::unique_ptr<T>&& value) {
-    assert(value.get() != nullptr);
-
-    if (UNLIKELY(value_ == value.get() && own_value_)) {
-      assert(cache_ == nullptr && cache_handle_ == nullptr);
-      return;
-    }
-
-    Reset();
-
-    value_ = value.release();
-    own_value_ = true;
-  }
-
-  void SetUnownedValue(T* value) {
-    assert(value != nullptr);
-
-    if (UNLIKELY(value_ == value && cache_ == nullptr &&
-                 cache_handle_ == nullptr && !own_value_)) {
-      return;
-    }
-
-    Reset();
-
-    value_ = value;
-    assert(!own_value_);
-  }
-
-  void SetCachedValue(T* value, Cache* cache, Cache::Handle* cache_handle) {
-    assert(cache != nullptr);
-    assert(cache_handle != nullptr);
-
-    if (UNLIKELY(value_ == value && cache_ == cache &&
-                 cache_handle_ == cache_handle && !own_value_)) {
-      return;
-    }
-
-    Reset();
-
-    value_ = value;
-    cache_ = cache;
-    cache_handle_ = cache_handle;
-    assert(!own_value_);
-  }
-
-  // Since this class is essentially an elaborate pointer, it's sometimes
-  // useful to be able to upcast or downcast the base type of the pointer,
-  // especially when interacting with typed_cache.h.
-  template <class TWrapper>
-  std::enable_if_t<sizeof(TWrapper) == sizeof(T) &&
-                       (std::is_base_of_v<TWrapper, T> ||
-                        std::is_base_of_v<T, TWrapper>),
-                   /* Actual return type */
-                   CachableEntry<TWrapper>&>
-  As() {
-    CachableEntry<TWrapper>* result_ptr =
-        reinterpret_cast<CachableEntry<TWrapper>*>(this);
-    // Ensure no weirdness in template instantiations
-    assert(static_cast<void*>(&this->value_) ==
-           static_cast<void*>(&result_ptr->value_));
-    assert(&this->cache_handle_ == &result_ptr->cache_handle_);
-    // This function depends on no arithmetic involved in the pointer
-    // conversion, which is not statically checkable.
-    assert(static_cast<void*>(this->value_) ==
-           static_cast<void*>(result_ptr->value_));
-    return *result_ptr;
-  }
-
- private:
-  void ReleaseResource(bool erase_if_last_ref) noexcept {
-    if (LIKELY(cache_handle_ != nullptr)) {
-      assert(cache_ != nullptr);
-      cache_->Release(cache_handle_, erase_if_last_ref);
-    } else if (own_value_) {
-      delete value_;
-    }
-  }
-
-  void ResetFields() noexcept {
-    value_ = nullptr;
-    cache_ = nullptr;
-    cache_handle_ = nullptr;
-    own_value_ = false;
-  }
-
-  static void ReleaseCacheHandle(void* arg1, void* arg2) {
-    Cache* const cache = static_cast<Cache*>(arg1);
-    assert(cache);
-
-    Cache::Handle* const cache_handle = static_cast<Cache::Handle*>(arg2);
-    assert(cache_handle);
-
-    cache->Release(cache_handle);
-  }
-
-  static void DeleteValue(void* arg1, void* /* arg2 */) {
-    delete static_cast<T*>(arg1);
-  }
-
- private:
-  // Have to be your own best friend
-  template <class TT>
-  friend class CachableEntry;
-
-  T* value_ = nullptr;
-  Cache* cache_ = nullptr;
-  Cache::Handle* cache_handle_ = nullptr;
-  bool own_value_ = false;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/data_block_footer.cc

@@ -1,59 +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 "table/block_based/data_block_footer.h"
-
-#include "rocksdb/table.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-const int kDataBlockIndexTypeBitShift = 31;
-
-// 0x7FFFFFFF
-const uint32_t kMaxNumRestarts = (1u << kDataBlockIndexTypeBitShift) - 1u;
-
-// 0x7FFFFFFF
-const uint32_t kNumRestartsMask = (1u << kDataBlockIndexTypeBitShift) - 1u;
-
-uint32_t PackIndexTypeAndNumRestarts(
-    BlockBasedTableOptions::DataBlockIndexType index_type,
-    uint32_t num_restarts) {
-  if (num_restarts > kMaxNumRestarts) {
-    assert(0);  // mute travis "unused" warning
-  }
-
-  uint32_t block_footer = num_restarts;
-  if (index_type == BlockBasedTableOptions::kDataBlockBinaryAndHash) {
-    block_footer |= 1u << kDataBlockIndexTypeBitShift;
-  } else if (index_type != BlockBasedTableOptions::kDataBlockBinarySearch) {
-    assert(0);
-  }
-
-  return block_footer;
-}
-
-void UnPackIndexTypeAndNumRestarts(
-    uint32_t block_footer,
-    BlockBasedTableOptions::DataBlockIndexType* index_type,
-    uint32_t* num_restarts) {
-  if (index_type) {
-    if (block_footer & 1u << kDataBlockIndexTypeBitShift) {
-      *index_type = BlockBasedTableOptions::kDataBlockBinaryAndHash;
-    } else {
-      *index_type = BlockBasedTableOptions::kDataBlockBinarySearch;
-    }
-  }
-
-  if (num_restarts) {
-    *num_restarts = block_footer & kNumRestartsMask;
-    assert(*num_restarts <= kMaxNumRestarts);
-  }
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/data_block_footer.h

@@ -1,25 +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 "rocksdb/table.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-uint32_t PackIndexTypeAndNumRestarts(
-    BlockBasedTableOptions::DataBlockIndexType index_type,
-    uint32_t num_restarts);
-
-void UnPackIndexTypeAndNumRestarts(
-    uint32_t block_footer,
-    BlockBasedTableOptions::DataBlockIndexType* index_type,
-    uint32_t* num_restarts);
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/data_block_hash_index.cc

@@ -1,94 +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 "table/block_based/data_block_hash_index.h"
-
-#include <string>
-#include <vector>
-
-#include "rocksdb/slice.h"
-#include "util/coding.h"
-#include "util/hash.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-void DataBlockHashIndexBuilder::Add(const Slice& key,
-                                    const size_t restart_index) {
-  assert(Valid());
-  if (restart_index > kMaxRestartSupportedByHashIndex) {
-    valid_ = false;
-    return;
-  }
-
-  uint32_t hash_value = GetSliceHash(key);
-  hash_and_restart_pairs_.emplace_back(hash_value,
-                                       static_cast<uint8_t>(restart_index));
-  estimated_num_buckets_ += bucket_per_key_;
-}
-
-void DataBlockHashIndexBuilder::Finish(std::string& buffer) {
-  assert(Valid());
-  uint16_t num_buckets = static_cast<uint16_t>(estimated_num_buckets_);
-
-  if (num_buckets == 0) {
-    num_buckets = 1;  // sanity check
-  }
-
-  // The build-in hash cannot well distribute strings when into different
-  // buckets when num_buckets is power of two, resulting in high hash
-  // collision.
-  // We made the num_buckets to be odd to avoid this issue.
-  num_buckets |= 1;
-
-  std::vector<uint8_t> buckets(num_buckets, kNoEntry);
-  // write the restart_index array
-  for (auto& entry : hash_and_restart_pairs_) {
-    uint32_t hash_value = entry.first;
-    uint8_t restart_index = entry.second;
-    uint16_t buck_idx = static_cast<uint16_t>(hash_value % num_buckets);
-    if (buckets[buck_idx] == kNoEntry) {
-      buckets[buck_idx] = restart_index;
-    } else if (buckets[buck_idx] != restart_index) {
-      // same bucket cannot store two different restart_index, mark collision
-      buckets[buck_idx] = kCollision;
-    }
-  }
-
-  for (uint8_t restart_index : buckets) {
-    buffer.append(
-        const_cast<const char*>(reinterpret_cast<char*>(&restart_index)),
-        sizeof(restart_index));
-  }
-
-  // write NUM_BUCK
-  PutFixed16(&buffer, num_buckets);
-
-  assert(buffer.size() <= kMaxBlockSizeSupportedByHashIndex);
-}
-
-void DataBlockHashIndexBuilder::Reset() {
-  estimated_num_buckets_ = 0;
-  valid_ = true;
-  hash_and_restart_pairs_.clear();
-}
-
-void DataBlockHashIndex::Initialize(const char* data, uint16_t size,
-                                    uint16_t* map_offset) {
-  assert(size >= sizeof(uint16_t));  // NUM_BUCKETS
-  num_buckets_ = DecodeFixed16(data + size - sizeof(uint16_t));
-  assert(num_buckets_ > 0);
-  assert(size > num_buckets_ * sizeof(uint8_t));
-  *map_offset = static_cast<uint16_t>(size - sizeof(uint16_t) -
-                                      num_buckets_ * sizeof(uint8_t));
-}
-
-uint8_t DataBlockHashIndex::Lookup(const char* data, uint32_t map_offset,
-                                   const Slice& key) const {
-  uint32_t hash_value = GetSliceHash(key);
-  uint16_t idx = static_cast<uint16_t>(hash_value % num_buckets_);
-  const char* bucket_table = data + map_offset;
-  return static_cast<uint8_t>(*(bucket_table + idx * sizeof(uint8_t)));
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/data_block_hash_index.h

@@ -1,137 +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 <cstdint>
-#include <string>
-#include <vector>
-
-#include "rocksdb/slice.h"
-
-namespace ROCKSDB_NAMESPACE {
-// This is an experimental feature aiming to reduce the CPU utilization of
-// point-lookup within a data-block. It is only used in data blocks, and not
-// in meta-data blocks or per-table index blocks.
-//
-// It only used to support BlockBasedTable::Get().
-//
-// A serialized hash index is appended to the data-block. The new block data
-// format is as follows:
-//
-// DATA_BLOCK: [RI RI RI ... RI RI_IDX HASH_IDX FOOTER]
-//
-// RI:       Restart Interval (the same as the default data-block format)
-// RI_IDX:   Restart Interval index (the same as the default data-block format)
-// HASH_IDX: The new data-block hash index feature.
-// FOOTER:   A 32bit block footer, which is the NUM_RESTARTS with the MSB as
-//           the flag indicating if this hash index is in use. Note that
-//           given a data block < 32KB, the MSB is never used. So we can
-//           borrow the MSB as the hash index flag. Therefore, this format is
-//           compatible with the legacy data-blocks with num_restarts < 32768,
-//           as the MSB is 0.
-//
-// The format of the data-block hash index is as follows:
-//
-// HASH_IDX: [B B B ... B NUM_BUCK]
-//
-// B:         bucket, an array of restart index. Each buckets is uint8_t.
-// NUM_BUCK:  Number of buckets, which is the length of the bucket array.
-//
-// We reserve two special flag:
-//    kNoEntry=255,
-//    kCollision=254.
-//
-// Therefore, the max number of restarts this hash index can supoport is 253.
-//
-// Buckets are initialized to be kNoEntry.
-//
-// When storing a key in the hash index, the key is first hashed to a bucket.
-// If there the bucket is empty (kNoEntry), the restart index is stored in
-// the bucket. If there is already a restart index there, we will update the
-// existing restart index to a collision marker (kCollision). If the
-// the bucket is already marked as collision, we do not store the restart
-// index either.
-//
-// During query process, a key is first hashed to a bucket. Then we examine if
-// the buckets store nothing (kNoEntry) or the bucket had a collision
-// (kCollision). If either of those happens, we get the restart index of
-// the key and will directly go to the restart interval to search the key.
-//
-// Note that we only support blocks with #restart_interval < 254. If a block
-// has more restart interval than that, hash index will not be create for it.
-
-const uint8_t kNoEntry = 255;
-const uint8_t kCollision = 254;
-const uint8_t kMaxRestartSupportedByHashIndex = 253;
-
-// Because we use uint16_t address, we only support block no more than 64KB
-const size_t kMaxBlockSizeSupportedByHashIndex = 1u << 16;
-const double kDefaultUtilRatio = 0.75;
-
-class DataBlockHashIndexBuilder {
- public:
-  DataBlockHashIndexBuilder()
-      : bucket_per_key_(-1 /*uninitialized marker*/),
-        estimated_num_buckets_(0),
-        valid_(false) {}
-
-  void Initialize(double util_ratio) {
-    if (util_ratio <= 0) {
-      util_ratio = kDefaultUtilRatio;  // sanity check
-    }
-    bucket_per_key_ = 1 / util_ratio;
-    valid_ = true;
-  }
-
-  inline bool Valid() const { return valid_ && bucket_per_key_ > 0; }
-  void Add(const Slice& key, const size_t restart_index);
-  void Finish(std::string& buffer);
-  void Reset();
-  inline size_t EstimateSize() const {
-    uint16_t estimated_num_buckets =
-        static_cast<uint16_t>(estimated_num_buckets_);
-
-    // Maching the num_buckets number in DataBlockHashIndexBuilder::Finish.
-    estimated_num_buckets |= 1;
-
-    return sizeof(uint16_t) +
-           static_cast<size_t>(estimated_num_buckets * sizeof(uint8_t));
-  }
-
- private:
-  double bucket_per_key_;  // is the multiplicative inverse of util_ratio_
-  double estimated_num_buckets_;
-
-  // Now the only usage for `valid_` is to mark false when the inserted
-  // restart_index is larger than supported. In this case HashIndex is not
-  // appended to the block content.
-  bool valid_;
-
-  std::vector<std::pair<uint32_t, uint8_t>> hash_and_restart_pairs_;
-  friend class DataBlockHashIndex_DataBlockHashTestSmall_Test;
-};
-
-class DataBlockHashIndex {
- public:
-  DataBlockHashIndex() : num_buckets_(0) {}
-
-  void Initialize(const char* data, uint16_t size, uint16_t* map_offset);
-
-  uint8_t Lookup(const char* data, uint32_t map_offset, const Slice& key) const;
-
-  inline bool Valid() { return num_buckets_ != 0; }
-
- private:
-  // To make the serialized hash index compact and to save the space overhead,
-  // here all the data fields persisted in the block are in uint16 format.
-  // We find that a uint16 is large enough to index every offset of a 64KiB
-  // block.
-  // So in other words, DataBlockHashIndex does not support block size equal
-  // or greater then 64KiB.
-  uint16_t num_buckets_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE