@nxtedition/rocksdb 7.1.30 → 7.1.32

package/deps/rocksdb/rocksdb/table/block_based/index_reader_common.h

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "table/block_based/block_based_table_reader.h"
-
 #include "table/block_based/reader_common.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block_test.cc

@@ -86,7 +86,8 @@ class PartitionedFilterBlockTest
     int num_keys = sizeof(keys) / sizeof(*keys);
     uint64_t max_key_size = 0;
     for (int i = 1; i < num_keys; i++) {
-      max_key_size = std::max(max_key_size, static_cast<uint64_t>(keys[i].size()));
+      max_key_size =
+          std::max(max_key_size, static_cast<uint64_t>(keys[i].size()));
     }
     uint64_t max_index_size = num_keys * (max_key_size + 8 /*handle*/);
     return max_index_size;
@@ -116,11 +117,11 @@ class PartitionedFilterBlockTest
       PartitionedIndexBuilder* const p_index_builder,
       const SliceTransform* prefix_extractor = nullptr) {
     assert(table_options_.block_size_deviation <= 100);
-    auto partition_size = static_cast<uint32_t>(
-             ((table_options_.metadata_block_size *
-               (100 - table_options_.block_size_deviation)) +
-              99) /
-             100);
+    auto partition_size =
+        static_cast<uint32_t>(((table_options_.metadata_block_size *
+                                (100 - table_options_.block_size_deviation)) +
+                               99) /
+                              100);
     partition_size = std::max(partition_size, static_cast<uint32_t>(1));
     const bool kValueDeltaEncoded = true;
     return new PartitionedFilterBlockBuilder(

package/deps/rocksdb/rocksdb/table/block_based/partitioned_index_iterator.h

@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #pragma once
 #include "table/block_based/block_based_table_reader.h"
-
 #include "table/block_based/block_based_table_reader_impl.h"
 #include "table/block_based/block_prefetcher.h"
 #include "table/block_based/reader_common.h"

package/deps/rocksdb/rocksdb/table/block_based/uncompression_dict_reader.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <cassert>
+
 #include "table/block_based/cachable_entry.h"
 #include "table/format.h"
 

package/deps/rocksdb/rocksdb/table/block_fetcher.cc

@@ -147,12 +147,11 @@ inline void BlockFetcher::PrepareBufferForBlockFromFile() {
     // file reader that does not implement mmap reads properly.
     used_buf_ = &stack_buf_[0];
   } else if (maybe_compressed_ && !do_uncompress_) {
-    compressed_buf_ = AllocateBlock(block_size_with_trailer_,
-                                    memory_allocator_compressed_);
+    compressed_buf_ =
+        AllocateBlock(block_size_with_trailer_, memory_allocator_compressed_);
     used_buf_ = compressed_buf_.get();
   } else {
-    heap_buf_ =
-        AllocateBlock(block_size_with_trailer_, memory_allocator_);
+    heap_buf_ = AllocateBlock(block_size_with_trailer_, memory_allocator_);
     used_buf_ = heap_buf_.get();
   }
 }
@@ -187,8 +186,8 @@ inline void BlockFetcher::CopyBufferToHeapBuf() {
 
 inline void BlockFetcher::CopyBufferToCompressedBuf() {
   assert(used_buf_ != compressed_buf_.get());
-  compressed_buf_ = AllocateBlock(block_size_with_trailer_,
-                                  memory_allocator_compressed_);
+  compressed_buf_ =
+      AllocateBlock(block_size_with_trailer_, memory_allocator_compressed_);
   memcpy(compressed_buf_.get(), used_buf_, block_size_with_trailer_);
 #ifndef NDEBUG
   num_compressed_buf_memcpy_++;

package/deps/rocksdb/rocksdb/table/block_fetcher.h

@@ -19,8 +19,8 @@ namespace ROCKSDB_NAMESPACE {
 // Retrieves a single block of a given file. Utilizes the prefetch buffer and/or
 // persistent cache provided (if any) to try to avoid reading from the file
 // directly. Note that both the prefetch buffer and the persistent cache are
-// optional; also, note that the persistent cache may be configured to store either
-// compressed or uncompressed blocks.
+// optional; also, note that the persistent cache may be configured to store
+// either compressed or uncompressed blocks.
 //
 // If the retrieved block is compressed and the do_uncompress flag is set,
 // BlockFetcher uncompresses the block (using the uncompression dictionary,

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder.cc

@@ -7,6 +7,7 @@
 #include "table/cuckoo/cuckoo_table_builder.h"
 
 #include <assert.h>
+
 #include <algorithm>
 #include <limits>
 #include <string>
@@ -26,23 +27,23 @@
 
 namespace ROCKSDB_NAMESPACE {
 const std::string CuckooTablePropertyNames::kEmptyKey =
-      "rocksdb.cuckoo.bucket.empty.key";
+    "rocksdb.cuckoo.bucket.empty.key";
 const std::string CuckooTablePropertyNames::kNumHashFunc =
-      "rocksdb.cuckoo.hash.num";
+    "rocksdb.cuckoo.hash.num";
 const std::string CuckooTablePropertyNames::kHashTableSize =
-      "rocksdb.cuckoo.hash.size";
+    "rocksdb.cuckoo.hash.size";
 const std::string CuckooTablePropertyNames::kValueLength =
-      "rocksdb.cuckoo.value.length";
+    "rocksdb.cuckoo.value.length";
 const std::string CuckooTablePropertyNames::kIsLastLevel =
-      "rocksdb.cuckoo.file.islastlevel";
+    "rocksdb.cuckoo.file.islastlevel";
 const std::string CuckooTablePropertyNames::kCuckooBlockSize =
-      "rocksdb.cuckoo.hash.cuckooblocksize";
+    "rocksdb.cuckoo.hash.cuckooblocksize";
 const std::string CuckooTablePropertyNames::kIdentityAsFirstHash =
-      "rocksdb.cuckoo.hash.identityfirst";
+    "rocksdb.cuckoo.hash.identityfirst";
 const std::string CuckooTablePropertyNames::kUseModuleHash =
-      "rocksdb.cuckoo.hash.usemodule";
+    "rocksdb.cuckoo.hash.usemodule";
 const std::string CuckooTablePropertyNames::kUserKeyLength =
-      "rocksdb.cuckoo.hash.userkeylength";
+    "rocksdb.cuckoo.hash.userkeylength";
 
 // Obtained by running echo rocksdb.table.cuckoo | sha1sum
 extern const uint64_t kCuckooTableMagicNumber = 0x926789d0c5f17873ull;
@@ -174,9 +175,12 @@ bool CuckooTableBuilder::IsDeletedKey(uint64_t idx) const {
 Slice CuckooTableBuilder::GetKey(uint64_t idx) const {
   assert(closed_);
   if (IsDeletedKey(idx)) {
-    return Slice(&deleted_keys_[static_cast<size_t>((idx - num_values_) * key_size_)], static_cast<size_t>(key_size_));
+    return Slice(
+        &deleted_keys_[static_cast<size_t>((idx - num_values_) * key_size_)],
+        static_cast<size_t>(key_size_));
   }
-  return Slice(&kvs_[static_cast<size_t>(idx * (key_size_ + value_size_))], static_cast<size_t>(key_size_));
+  return Slice(&kvs_[static_cast<size_t>(idx * (key_size_ + value_size_))],
+               static_cast<size_t>(key_size_));
 }
 
 Slice CuckooTableBuilder::GetUserKey(uint64_t idx) const {
@@ -190,11 +194,14 @@ Slice CuckooTableBuilder::GetValue(uint64_t idx) const {
     static std::string empty_value(static_cast<unsigned int>(value_size_), 'a');
     return Slice(empty_value);
   }
-  return Slice(&kvs_[static_cast<size_t>(idx * (key_size_ + value_size_) + key_size_)], static_cast<size_t>(value_size_));
+  return Slice(
+      &kvs_[static_cast<size_t>(idx * (key_size_ + value_size_) + key_size_)],
+      static_cast<size_t>(value_size_));
 }
 
 Status CuckooTableBuilder::MakeHashTable(std::vector<CuckooBucket>* buckets) {
-  buckets->resize(static_cast<size_t>(hash_table_size_ + cuckoo_block_size_ - 1));
+  buckets->resize(
+      static_cast<size_t>(hash_table_size_ + cuckoo_block_size_ - 1));
   uint32_t make_space_for_key_call_id = 0;
   for (uint32_t vector_idx = 0; vector_idx < num_entries_; vector_idx++) {
     uint64_t bucket_id = 0;
@@ -202,29 +209,33 @@ Status CuckooTableBuilder::MakeHashTable(std::vector<CuckooBucket>* buckets) {
     autovector<uint64_t> hash_vals;
     Slice user_key = GetUserKey(vector_idx);
     for (uint32_t hash_cnt = 0; hash_cnt < num_hash_func_ && !bucket_found;
-        ++hash_cnt) {
-      uint64_t hash_val = CuckooHash(user_key, hash_cnt, use_module_hash_,
-          hash_table_size_, identity_as_first_hash_, get_slice_hash_);
+         ++hash_cnt) {
+      uint64_t hash_val =
+          CuckooHash(user_key, hash_cnt, use_module_hash_, hash_table_size_,
+                     identity_as_first_hash_, get_slice_hash_);
       // If there is a collision, check next cuckoo_block_size_ locations for
       // empty locations. While checking, if we reach end of the hash table,
       // stop searching and proceed for next hash function.
       for (uint32_t block_idx = 0; block_idx < cuckoo_block_size_;
-          ++block_idx, ++hash_val) {
-        if ((*buckets)[static_cast<size_t>(hash_val)].vector_idx == kMaxVectorIdx) {
+           ++block_idx, ++hash_val) {
+        if ((*buckets)[static_cast<size_t>(hash_val)].vector_idx ==
+            kMaxVectorIdx) {
           bucket_id = hash_val;
           bucket_found = true;
           break;
         } else {
-          if (ucomp_->Compare(user_key,
-                GetUserKey((*buckets)[static_cast<size_t>(hash_val)].vector_idx)) == 0) {
+          if (ucomp_->Compare(
+                  user_key, GetUserKey((*buckets)[static_cast<size_t>(hash_val)]
+                                           .vector_idx)) == 0) {
             return Status::NotSupported("Same key is being inserted again.");
           }
           hash_vals.push_back(hash_val);
         }
       }
     }
-    while (!bucket_found && !MakeSpaceForKey(hash_vals,
-          ++make_space_for_key_call_id, buckets, &bucket_id)) {
+    while (!bucket_found &&
+           !MakeSpaceForKey(hash_vals, ++make_space_for_key_call_id, buckets,
+                            &bucket_id)) {
       // Rehash by increashing number of hash tables.
       if (num_hash_func_ >= max_num_hash_func_) {
         return Status::NotSupported("Too many collisions. Unable to hash.");
@@ -232,11 +243,13 @@ Status CuckooTableBuilder::MakeHashTable(std::vector<CuckooBucket>* buckets) {
       // We don't really need to rehash the entire table because old hashes are
       // still valid and we only increased the number of hash functions.
       uint64_t hash_val = CuckooHash(user_key, num_hash_func_, use_module_hash_,
-          hash_table_size_, identity_as_first_hash_, get_slice_hash_);
+                                     hash_table_size_, identity_as_first_hash_,
+                                     get_slice_hash_);
       ++num_hash_func_;
       for (uint32_t block_idx = 0; block_idx < cuckoo_block_size_;
-          ++block_idx, ++hash_val) {
-        if ((*buckets)[static_cast<size_t>(hash_val)].vector_idx == kMaxVectorIdx) {
+           ++block_idx, ++hash_val) {
+        if ((*buckets)[static_cast<size_t>(hash_val)].vector_idx ==
+            kMaxVectorIdx) {
           bucket_found = true;
           bucket_id = hash_val;
           break;
@@ -259,7 +272,7 @@ Status CuckooTableBuilder::Finish() {
     // Calculate the real hash size if module hash is enabled.
     if (use_module_hash_) {
       hash_table_size_ =
-        static_cast<uint64_t>(num_entries_ / max_hash_table_ratio_);
+          static_cast<uint64_t>(num_entries_ / max_hash_table_ratio_);
     }
     status_ = MakeHashTable(&buckets);
     if (!status_.ok()) {
@@ -300,9 +313,8 @@ Status CuckooTableBuilder::Finish() {
   properties_.num_entries = num_entries_;
   properties_.num_deletions = num_entries_ - num_values_;
   properties_.fixed_key_len = key_size_;
-  properties_.user_collected_properties[
-        CuckooTablePropertyNames::kValueLength].assign(
-        reinterpret_cast<const char*>(&value_size_), sizeof(value_size_));
+  properties_.user_collected_properties[CuckooTablePropertyNames::kValueLength]
+      .assign(reinterpret_cast<const char*>(&value_size_), sizeof(value_size_));
 
   uint64_t bucket_size = key_size_ + value_size_;
   unused_bucket.resize(static_cast<size_t>(bucket_size), 'a');
@@ -332,37 +344,35 @@ Status CuckooTableBuilder::Finish() {
   uint64_t offset = buckets.size() * bucket_size;
   properties_.data_size = offset;
   unused_bucket.resize(static_cast<size_t>(properties_.fixed_key_len));
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kEmptyKey] = unused_bucket;
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kNumHashFunc].assign(
-        reinterpret_cast<char*>(&num_hash_func_), sizeof(num_hash_func_));
-
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kHashTableSize].assign(
-        reinterpret_cast<const char*>(&hash_table_size_),
-        sizeof(hash_table_size_));
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kIsLastLevel].assign(
-        reinterpret_cast<const char*>(&is_last_level_file_),
-        sizeof(is_last_level_file_));
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kCuckooBlockSize].assign(
-        reinterpret_cast<const char*>(&cuckoo_block_size_),
-        sizeof(cuckoo_block_size_));
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kIdentityAsFirstHash].assign(
-        reinterpret_cast<const char*>(&identity_as_first_hash_),
-        sizeof(identity_as_first_hash_));
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kUseModuleHash].assign(
-        reinterpret_cast<const char*>(&use_module_hash_),
-        sizeof(use_module_hash_));
+  properties_.user_collected_properties[CuckooTablePropertyNames::kEmptyKey] =
+      unused_bucket;
+  properties_.user_collected_properties[CuckooTablePropertyNames::kNumHashFunc]
+      .assign(reinterpret_cast<char*>(&num_hash_func_), sizeof(num_hash_func_));
+
+  properties_
+      .user_collected_properties[CuckooTablePropertyNames::kHashTableSize]
+      .assign(reinterpret_cast<const char*>(&hash_table_size_),
+              sizeof(hash_table_size_));
+  properties_.user_collected_properties[CuckooTablePropertyNames::kIsLastLevel]
+      .assign(reinterpret_cast<const char*>(&is_last_level_file_),
+              sizeof(is_last_level_file_));
+  properties_
+      .user_collected_properties[CuckooTablePropertyNames::kCuckooBlockSize]
+      .assign(reinterpret_cast<const char*>(&cuckoo_block_size_),
+              sizeof(cuckoo_block_size_));
+  properties_
+      .user_collected_properties[CuckooTablePropertyNames::kIdentityAsFirstHash]
+      .assign(reinterpret_cast<const char*>(&identity_as_first_hash_),
+              sizeof(identity_as_first_hash_));
+  properties_
+      .user_collected_properties[CuckooTablePropertyNames::kUseModuleHash]
+      .assign(reinterpret_cast<const char*>(&use_module_hash_),
+              sizeof(use_module_hash_));
   uint32_t user_key_len = static_cast<uint32_t>(smallest_user_key_.size());
-  properties_.user_collected_properties[
-    CuckooTablePropertyNames::kUserKeyLength].assign(
-        reinterpret_cast<const char*>(&user_key_len),
-        sizeof(user_key_len));
+  properties_
+      .user_collected_properties[CuckooTablePropertyNames::kUserKeyLength]
+      .assign(reinterpret_cast<const char*>(&user_key_len),
+              sizeof(user_key_len));
 
   // Write meta blocks.
   MetaIndexBuilder meta_index_builder;
@@ -406,9 +416,7 @@ void CuckooTableBuilder::Abandon() {
   closed_ = true;
 }
 
-uint64_t CuckooTableBuilder::NumEntries() const {
-  return num_entries_;
-}
+uint64_t CuckooTableBuilder::NumEntries() const { return num_entries_; }
 
 uint64_t CuckooTableBuilder::FileSize() const {
   if (closed_) {
@@ -418,8 +426,8 @@ uint64_t CuckooTableBuilder::FileSize() const {
   }
 
   if (use_module_hash_) {
-    return static_cast<uint64_t>((key_size_ + value_size_) *
-        num_entries_ / max_hash_table_ratio_);
+    return static_cast<uint64_t>((key_size_ + value_size_) * num_entries_ /
+                                 max_hash_table_ratio_);
   } else {
     // Account for buckets being a power of two.
     // As elements are added, file size remains constant for a while and
@@ -468,7 +476,8 @@ bool CuckooTableBuilder::MakeSpaceForKey(
   // no. of times this will be called is <= max_num_hash_func_ + num_entries_.
   for (uint32_t hash_cnt = 0; hash_cnt < num_hash_func_; ++hash_cnt) {
     uint64_t bid = hash_vals[hash_cnt];
-    (*buckets)[static_cast<size_t>(bid)].make_space_for_key_call_id = make_space_for_key_call_id;
+    (*buckets)[static_cast<size_t>(bid)].make_space_for_key_call_id =
+        make_space_for_key_call_id;
     tree.push_back(CuckooNode(bid, 0, 0));
   }
   bool null_found = false;
@@ -479,24 +488,25 @@ bool CuckooTableBuilder::MakeSpaceForKey(
     if (curr_depth >= max_search_depth_) {
       break;
     }
-    CuckooBucket& curr_bucket = (*buckets)[static_cast<size_t>(curr_node.bucket_id)];
-    for (uint32_t hash_cnt = 0;
-        hash_cnt < num_hash_func_ && !null_found; ++hash_cnt) {
-      uint64_t child_bucket_id = CuckooHash(GetUserKey(curr_bucket.vector_idx),
-          hash_cnt, use_module_hash_, hash_table_size_, identity_as_first_hash_,
-          get_slice_hash_);
+    CuckooBucket& curr_bucket =
+        (*buckets)[static_cast<size_t>(curr_node.bucket_id)];
+    for (uint32_t hash_cnt = 0; hash_cnt < num_hash_func_ && !null_found;
+         ++hash_cnt) {
+      uint64_t child_bucket_id = CuckooHash(
+          GetUserKey(curr_bucket.vector_idx), hash_cnt, use_module_hash_,
+          hash_table_size_, identity_as_first_hash_, get_slice_hash_);
       // Iterate inside Cuckoo Block.
       for (uint32_t block_idx = 0; block_idx < cuckoo_block_size_;
-          ++block_idx, ++child_bucket_id) {
-        if ((*buckets)[static_cast<size_t>(child_bucket_id)].make_space_for_key_call_id ==
-            make_space_for_key_call_id) {
+           ++block_idx, ++child_bucket_id) {
+        if ((*buckets)[static_cast<size_t>(child_bucket_id)]
+                .make_space_for_key_call_id == make_space_for_key_call_id) {
           continue;
         }
-        (*buckets)[static_cast<size_t>(child_bucket_id)].make_space_for_key_call_id =
-          make_space_for_key_call_id;
-        tree.push_back(CuckooNode(child_bucket_id, curr_depth + 1,
-              curr_pos));
-        if ((*buckets)[static_cast<size_t>(child_bucket_id)].vector_idx == kMaxVectorIdx) {
+        (*buckets)[static_cast<size_t>(child_bucket_id)]
+            .make_space_for_key_call_id = make_space_for_key_call_id;
+        tree.push_back(CuckooNode(child_bucket_id, curr_depth + 1, curr_pos));
+        if ((*buckets)[static_cast<size_t>(child_bucket_id)].vector_idx ==
+            kMaxVectorIdx) {
           null_found = true;
           break;
         }
@@ -515,7 +525,7 @@ bool CuckooTableBuilder::MakeSpaceForKey(
     while (bucket_to_replace_pos >= num_hash_func_) {
       CuckooNode& curr_node = tree[bucket_to_replace_pos];
       (*buckets)[static_cast<size_t>(curr_node.bucket_id)] =
-        (*buckets)[static_cast<size_t>(tree[curr_node.parent_pos].bucket_id)];
+          (*buckets)[static_cast<size_t>(tree[curr_node.parent_pos].bucket_id)];
       bucket_to_replace_pos = curr_node.parent_pos;
     }
     *bucket_id = tree[bucket_to_replace_pos].bucket_id;

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder.h

@@ -6,10 +6,12 @@
 #pragma once
 #ifndef ROCKSDB_LITE
 #include <stdint.h>
+
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "db/version_edit.h"
 #include "port/port.h"
 #include "rocksdb/status.h"
@@ -20,7 +22,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-class CuckooTableBuilder: public TableBuilder {
+class CuckooTableBuilder : public TableBuilder {
  public:
   CuckooTableBuilder(
       WritableFileWriter* file, double max_hash_table_ratio,
@@ -78,8 +80,7 @@ class CuckooTableBuilder: public TableBuilder {
 
  private:
   struct CuckooBucket {
-    CuckooBucket()
-      : vector_idx(kMaxVectorIdx), make_space_for_key_call_id(0) {}
+    CuckooBucket() : vector_idx(kMaxVectorIdx), make_space_for_key_call_id(0) {}
     uint32_t vector_idx;
     // This number will not exceed kvs_.size() + max_num_hash_func_.
     // We assume number of items is <= 2^32.
@@ -125,7 +126,7 @@ class CuckooTableBuilder: public TableBuilder {
   bool use_module_hash_;
   bool identity_as_first_hash_;
   uint64_t (*get_slice_hash_)(const Slice& s, uint32_t index,
-    uint64_t max_num_buckets);
+                              uint64_t max_num_buckets);
   std::string largest_user_key_ = "";
   std::string smallest_user_key_ = "";