rocksdb-native 2.6.3 → 2.6.5

package/vendor/librocksdb/vendor/rocksdb/db/external_sst_file_ingestion_job.h

@@ -1,268 +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 <string>
-#include <unordered_set>
-#include <vector>
-
-#include "db/column_family.h"
-#include "db/internal_stats.h"
-#include "db/snapshot_impl.h"
-#include "db/version_edit.h"
-#include "env/file_system_tracer.h"
-#include "logging/event_logger.h"
-#include "options/db_options.h"
-#include "rocksdb/db.h"
-#include "rocksdb/file_system.h"
-#include "rocksdb/sst_file_writer.h"
-#include "util/autovector.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Directories;
-class SystemClock;
-
-struct IngestedFileInfo {
-  // External file path
-  std::string external_file_path;
-  // Smallest internal key in external file
-  InternalKey smallest_internal_key;
-  // Largest internal key in external file
-  InternalKey largest_internal_key;
-  // NOTE: use below two fields for all `*Overlap*` types of checks instead of
-  // smallest_internal_key.user_key() and largest_internal_key.user_key().
-  // The smallest / largest user key contained in the file for key range checks.
-  // These could be different from smallest_internal_key.user_key(), and
-  // largest_internal_key.user_key() when user-defined timestamps are enabled,
-  // because the check is about making sure the user key without timestamps part
-  // does not overlap. To achieve that, the smallest user key will be updated
-  // with the maximum timestamp while the largest user key will be updated with
-  // the min timestamp. It's otherwise the same.
-  std::string start_ukey;
-  std::string limit_ukey;
-  // Sequence number for keys in external file
-  SequenceNumber original_seqno;
-  // Offset of the global sequence number field in the file, will
-  // be zero if version is 1 (global seqno is not supported)
-  size_t global_seqno_offset;
-  // External file size
-  uint64_t file_size;
-  // total number of keys in external file
-  uint64_t num_entries;
-  // total number of range deletions in external file
-  uint64_t num_range_deletions;
-  // Id of column family this file should be ingested into
-  uint32_t cf_id;
-  // TableProperties read from external file
-  TableProperties table_properties;
-  // Version of external file
-  int version;
-
-  // FileDescriptor for the file inside the DB
-  FileDescriptor fd;
-  // file path that we picked for file inside the DB
-  std::string internal_file_path;
-  // Global sequence number that we picked for the file inside the DB
-  SequenceNumber assigned_seqno = 0;
-  // Level inside the DB we picked for the external file.
-  int picked_level = 0;
-  // Whether to copy or link the external sst file. copy_file will be set to
-  // false if ingestion_options.move_files is true and underlying FS
-  // supports link operation. Need to provide a default value to make the
-  // undefined-behavior sanity check of llvm happy. Since
-  // ingestion_options.move_files is false by default, thus copy_file is true
-  // by default.
-  bool copy_file = true;
-  // The checksum of ingested file
-  std::string file_checksum;
-  // The name of checksum function that generate the checksum
-  std::string file_checksum_func_name;
-  // The temperature of the file to be ingested
-  Temperature file_temperature = Temperature::kUnknown;
-  // Unique id of the file to be ingested
-  UniqueId64x2 unique_id{};
-  // Whether the external file should be treated as if it has user-defined
-  // timestamps or not. If this flag is false, and the column family enables
-  // UDT feature, the file will have min-timestamp artificially padded to its
-  // user keys when it's read. Since it will affect how `TableReader` reads a
-  // table file, it's defaulted to optimize for the majority of the case where
-  // the user key's format in the external file matches the column family's
-  // setting.
-  bool user_defined_timestamps_persisted = true;
-};
-
-class ExternalSstFileIngestionJob {
- public:
-  ExternalSstFileIngestionJob(
-      VersionSet* versions, ColumnFamilyData* cfd,
-      const ImmutableDBOptions& db_options,
-      const MutableDBOptions& mutable_db_options, const EnvOptions& env_options,
-      SnapshotList* db_snapshots,
-      const IngestExternalFileOptions& ingestion_options,
-      Directories* directories, EventLogger* event_logger,
-      const std::shared_ptr<IOTracer>& io_tracer)
-      : clock_(db_options.clock),
-        fs_(db_options.fs, io_tracer),
-        versions_(versions),
-        cfd_(cfd),
-        db_options_(db_options),
-        mutable_db_options_(mutable_db_options),
-        env_options_(env_options),
-        db_snapshots_(db_snapshots),
-        ingestion_options_(ingestion_options),
-        directories_(directories),
-        event_logger_(event_logger),
-        job_start_time_(clock_->NowMicros()),
-        consumed_seqno_count_(0),
-        io_tracer_(io_tracer) {
-    assert(directories != nullptr);
-  }
-
-  ~ExternalSstFileIngestionJob() { UnregisterRange(); }
-
-  // Prepare the job by copying external files into the DB.
-  Status Prepare(const std::vector<std::string>& external_files_paths,
-                 const std::vector<std::string>& files_checksums,
-                 const std::vector<std::string>& files_checksum_func_names,
-                 const Temperature& file_temperature, uint64_t next_file_number,
-                 SuperVersion* sv);
-
-  // Check if we need to flush the memtable before running the ingestion job
-  // This will be true if the files we are ingesting are overlapping with any
-  // key range in the memtable.
-  //
-  // @param super_version A referenced SuperVersion that will be held for the
-  //    duration of this function.
-  //
-  // Thread-safe
-  Status NeedsFlush(bool* flush_needed, SuperVersion* super_version);
-
-  // Will execute the ingestion job and prepare edit() to be applied.
-  // REQUIRES: Mutex held
-  Status Run();
-
-  // Register key range involved in this ingestion job
-  // to prevent key range conflict with other ongoing compaction/file ingestion
-  // REQUIRES: Mutex held
-  void RegisterRange();
-
-  // Unregister key range registered for this ingestion job
-  // REQUIRES: Mutex held
-  void UnregisterRange();
-
-  // Update column family stats.
-  // REQUIRES: Mutex held
-  void UpdateStats();
-
-  // Cleanup after successful/failed job
-  void Cleanup(const Status& status);
-
-  VersionEdit* edit() { return &edit_; }
-
-  const autovector<IngestedFileInfo>& files_to_ingest() const {
-    return files_to_ingest_;
-  }
-
-  // How many sequence numbers did we consume as part of the ingestion job?
-  int ConsumedSequenceNumbersCount() const { return consumed_seqno_count_; }
-
- private:
-  Status ResetTableReader(const std::string& external_file,
-                          uint64_t new_file_number,
-                          bool user_defined_timestamps_persisted,
-                          SuperVersion* sv, IngestedFileInfo* file_to_ingest,
-                          std::unique_ptr<TableReader>* table_reader);
-
-  // Read the external file's table properties to do various sanity checks and
-  // populates certain fields in `IngestedFileInfo` according to some table
-  // properties.
-  // In some cases when sanity check passes, `table_reader` could be reset with
-  // different options. For example: when external file does not contain
-  // timestamps while column family enables UDT in Memtables only feature.
-  Status SanityCheckTableProperties(const std::string& external_file,
-                                    uint64_t new_file_number, SuperVersion* sv,
-                                    IngestedFileInfo* file_to_ingest,
-                                    std::unique_ptr<TableReader>* table_reader);
-
-  // Open the external file and populate `file_to_ingest` with all the
-  // external information we need to ingest this file.
-  Status GetIngestedFileInfo(const std::string& external_file,
-                             uint64_t new_file_number,
-                             IngestedFileInfo* file_to_ingest,
-                             SuperVersion* sv);
-
-  // Assign `file_to_ingest` the appropriate sequence number and the lowest
-  // possible level that it can be ingested to according to compaction_style.
-  // REQUIRES: Mutex held
-  Status AssignLevelAndSeqnoForIngestedFile(SuperVersion* sv,
-                                            bool force_global_seqno,
-                                            CompactionStyle compaction_style,
-                                            SequenceNumber last_seqno,
-                                            IngestedFileInfo* file_to_ingest,
-                                            SequenceNumber* assigned_seqno);
-
-  // File that we want to ingest behind always goes to the lowest level;
-  // we just check that it fits in the level, that DB allows ingest_behind,
-  // and that we don't have 0 seqnums at the upper levels.
-  // REQUIRES: Mutex held
-  Status CheckLevelForIngestedBehindFile(IngestedFileInfo* file_to_ingest);
-
-  // Set the file global sequence number to `seqno`
-  Status AssignGlobalSeqnoForIngestedFile(IngestedFileInfo* file_to_ingest,
-                                          SequenceNumber seqno);
-  // Generate the file checksum and store in the IngestedFileInfo
-  IOStatus GenerateChecksumForIngestedFile(IngestedFileInfo* file_to_ingest);
-
-  // Check if `file_to_ingest` can fit in level `level`
-  // REQUIRES: Mutex held
-  bool IngestedFileFitInLevel(const IngestedFileInfo* file_to_ingest,
-                              int level);
-
-  // Helper method to sync given file.
-  template <typename TWritableFile>
-  Status SyncIngestedFile(TWritableFile* file);
-
-  // Create equivalent `Compaction` objects to this file ingestion job
-  // , which will be used to check range conflict with other ongoing
-  // compactions.
-  void CreateEquivalentFileIngestingCompactions();
-
-  // Remove all the internal files created, called when ingestion job fails.
-  void DeleteInternalFiles();
-
-  SystemClock* clock_;
-  FileSystemPtr fs_;
-  VersionSet* versions_;
-  ColumnFamilyData* cfd_;
-  const ImmutableDBOptions& db_options_;
-  const MutableDBOptions& mutable_db_options_;
-  const EnvOptions& env_options_;
-  SnapshotList* db_snapshots_;
-  autovector<IngestedFileInfo> files_to_ingest_;
-  const IngestExternalFileOptions& ingestion_options_;
-  Directories* directories_;
-  EventLogger* event_logger_;
-  VersionEdit edit_;
-  uint64_t job_start_time_;
-  int consumed_seqno_count_;
-  // Set in ExternalSstFileIngestionJob::Prepare(), if true all files are
-  // ingested in L0
-  bool files_overlap_{false};
-  // Set in ExternalSstFileIngestionJob::Prepare(), if true and DB
-  // file_checksum_gen_factory is set, DB will generate checksum each file.
-  bool need_generate_file_checksum_{true};
-  std::shared_ptr<IOTracer> io_tracer_;
-
-  // Below are variables used in (un)registering range for this ingestion job
-  //
-  // FileMetaData used in inputs of compactions equivalent to this ingestion
-  // job
-  std::vector<FileMetaData*> compaction_input_metdatas_;
-  // Compactions equivalent to this ingestion job
-  std::vector<Compaction*> file_ingesting_compactions_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/file_indexer.cc

@@ -1,216 +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 "db/file_indexer.h"
-
-#include <algorithm>
-#include <functional>
-
-#include "db/version_edit.h"
-#include "rocksdb/comparator.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-FileIndexer::FileIndexer(const Comparator* ucmp)
-    : num_levels_(0), ucmp_(ucmp), level_rb_(nullptr) {}
-
-size_t FileIndexer::NumLevelIndex() const { return next_level_index_.size(); }
-
-size_t FileIndexer::LevelIndexSize(size_t level) const {
-  if (level >= next_level_index_.size()) {
-    return 0;
-  }
-  return next_level_index_[level].num_index;
-}
-
-void FileIndexer::GetNextLevelIndex(const size_t level, const size_t file_index,
-                                    const int cmp_smallest,
-                                    const int cmp_largest, int32_t* left_bound,
-                                    int32_t* right_bound) const {
-  assert(level > 0);
-
-  // Last level, no hint
-  if (level == num_levels_ - 1) {
-    *left_bound = 0;
-    *right_bound = -1;
-    return;
-  }
-
-  assert(level < num_levels_ - 1);
-  assert(static_cast<int32_t>(file_index) <= level_rb_[level]);
-
-  const IndexUnit* index_units = next_level_index_[level].index_units;
-  const auto& index = index_units[file_index];
-
-  if (cmp_smallest < 0) {
-    *left_bound = (level > 0 && file_index > 0)
-                      ? index_units[file_index - 1].largest_lb
-                      : 0;
-    *right_bound = index.smallest_rb;
-  } else if (cmp_smallest == 0) {
-    *left_bound = index.smallest_lb;
-    *right_bound = index.smallest_rb;
-  } else if (cmp_largest < 0) {
-    *left_bound = index.smallest_lb;
-    *right_bound = index.largest_rb;
-  } else if (cmp_largest == 0) {
-    *left_bound = index.largest_lb;
-    *right_bound = index.largest_rb;
-  } else {
-    *left_bound = index.largest_lb;
-    *right_bound = level_rb_[level + 1];
-  }
-
-  assert(*left_bound >= 0);
-  assert(*left_bound <= *right_bound + 1);
-  assert(*right_bound <= level_rb_[level + 1]);
-}
-
-void FileIndexer::UpdateIndex(Arena* arena, const size_t num_levels,
-                              std::vector<FileMetaData*>* const files) {
-  if (files == nullptr) {
-    return;
-  }
-  if (num_levels == 0) {  // uint_32 0-1 would cause bad behavior
-    num_levels_ = num_levels;
-    return;
-  }
-  assert(level_rb_ == nullptr);  // level_rb_ should be init here
-
-  num_levels_ = num_levels;
-  next_level_index_.resize(num_levels);
-
-  char* mem = arena->AllocateAligned(num_levels_ * sizeof(int32_t));
-  level_rb_ = new (mem) int32_t[num_levels_];
-  for (size_t i = 0; i < num_levels_; i++) {
-    level_rb_[i] = -1;
-  }
-
-  // L1 - Ln-1
-  for (size_t level = 1; level < num_levels_ - 1; ++level) {
-    const auto& upper_files = files[level];
-    const int32_t upper_size = static_cast<int32_t>(upper_files.size());
-    const auto& lower_files = files[level + 1];
-    level_rb_[level] = static_cast<int32_t>(upper_files.size()) - 1;
-    if (upper_size == 0) {
-      continue;
-    }
-    IndexLevel& index_level = next_level_index_[level];
-    index_level.num_index = upper_size;
-    mem = arena->AllocateAligned(upper_size * sizeof(IndexUnit));
-    index_level.index_units = new (mem) IndexUnit[upper_size];
-
-    CalculateLB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->smallest.user_key(),
-                                                b->largest.user_key());
-        },
-        [](IndexUnit* index, int32_t f_idx) { index->smallest_lb = f_idx; });
-    CalculateLB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->largest.user_key(),
-                                                b->largest.user_key());
-        },
-        [](IndexUnit* index, int32_t f_idx) { index->largest_lb = f_idx; });
-    CalculateRB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->smallest.user_key(),
-                                                b->smallest.user_key());
-        },
-        [](IndexUnit* index, int32_t f_idx) { index->smallest_rb = f_idx; });
-    CalculateRB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->largest.user_key(),
-                                                b->smallest.user_key());
-        },
-        [](IndexUnit* index, int32_t f_idx) { index->largest_rb = f_idx; });
-  }
-
-  level_rb_[num_levels_ - 1] =
-      static_cast<int32_t>(files[num_levels_ - 1].size()) - 1;
-}
-
-void FileIndexer::CalculateLB(
-    const std::vector<FileMetaData*>& upper_files,
-    const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-    std::function<void(IndexUnit*, int32_t)> set_index) {
-  const int32_t upper_size = static_cast<int32_t>(upper_files.size());
-  const int32_t lower_size = static_cast<int32_t>(lower_files.size());
-  int32_t upper_idx = 0;
-  int32_t lower_idx = 0;
-
-  IndexUnit* index = index_level->index_units;
-  while (upper_idx < upper_size && lower_idx < lower_size) {
-    int cmp = cmp_op(upper_files[upper_idx], lower_files[lower_idx]);
-
-    if (cmp == 0) {
-      set_index(&index[upper_idx], lower_idx);
-      ++upper_idx;
-    } else if (cmp > 0) {
-      // Lower level's file (largest) is smaller, a key won't hit in that
-      // file. Move to next lower file
-      ++lower_idx;
-    } else {
-      // Lower level's file becomes larger, update the index, and
-      // move to the next upper file
-      set_index(&index[upper_idx], lower_idx);
-      ++upper_idx;
-    }
-  }
-
-  while (upper_idx < upper_size) {
-    // Lower files are exhausted, that means the remaining upper files are
-    // greater than any lower files. Set the index to be the lower level size.
-    set_index(&index[upper_idx], lower_size);
-    ++upper_idx;
-  }
-}
-
-void FileIndexer::CalculateRB(
-    const std::vector<FileMetaData*>& upper_files,
-    const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-    std::function<void(IndexUnit*, int32_t)> set_index) {
-  const int32_t upper_size = static_cast<int32_t>(upper_files.size());
-  const int32_t lower_size = static_cast<int32_t>(lower_files.size());
-  int32_t upper_idx = upper_size - 1;
-  int32_t lower_idx = lower_size - 1;
-
-  IndexUnit* index = index_level->index_units;
-  while (upper_idx >= 0 && lower_idx >= 0) {
-    int cmp = cmp_op(upper_files[upper_idx], lower_files[lower_idx]);
-
-    if (cmp == 0) {
-      set_index(&index[upper_idx], lower_idx);
-      --upper_idx;
-    } else if (cmp < 0) {
-      // Lower level's file (smallest) is larger, a key won't hit in that
-      // file. Move to next lower file.
-      --lower_idx;
-    } else {
-      // Lower level's file becomes smaller, update the index, and move to
-      // the next the upper file
-      set_index(&index[upper_idx], lower_idx);
-      --upper_idx;
-    }
-  }
-  while (upper_idx >= 0) {
-    // Lower files are exhausted, that means the remaining upper files are
-    // smaller than any lower files. Set it to -1.
-    set_index(&index[upper_idx], -1);
-    --upper_idx;
-  }
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/file_indexer.h

@@ -1,140 +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 <cstdint>
-#include <functional>
-#include <limits>
-#include <vector>
-
-#include "memory/arena.h"
-#include "port/port.h"
-#include "util/autovector.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Comparator;
-struct FileMetaData;
-struct FdWithKeyRange;
-struct FileLevel;
-
-// The file tree structure in Version is prebuilt and the range of each file
-// is known. On Version::Get(), it uses binary search to find a potential file
-// and then check if a target key can be found in the file by comparing the key
-// to each file's smallest and largest key. The results of these comparisons
-// can be reused beyond checking if a key falls into a file's range.
-// With some pre-calculated knowledge, each key comparison that has been done
-// can serve as a hint to narrow down further searches: if a key compared to
-// be smaller than a file's smallest or largest, that comparison can be used
-// to find out the right bound of next binary search. Similarly, if a key
-// compared to be larger than a file's smallest or largest, it can be utilized
-// to find out the left bound of next binary search.
-// With these hints: it can greatly reduce the range of binary search,
-// especially for bottom levels, given that one file most likely overlaps with
-// only N files from level below (where N is max_bytes_for_level_multiplier).
-// So on level L, we will only look at ~N files instead of N^L files on the
-// naive approach.
-class FileIndexer {
- public:
-  explicit FileIndexer(const Comparator* ucmp);
-
-  size_t NumLevelIndex() const;
-
-  size_t LevelIndexSize(size_t level) const;
-
-  // Return a file index range in the next level to search for a key based on
-  // smallest and largest key comparison for the current file specified by
-  // level and file_index. When *left_index < *right_index, both index should
-  // be valid and fit in the vector size.
-  void GetNextLevelIndex(const size_t level, const size_t file_index,
-                         const int cmp_smallest, const int cmp_largest,
-                         int32_t* left_bound, int32_t* right_bound) const;
-
-  void UpdateIndex(Arena* arena, const size_t num_levels,
-                   std::vector<FileMetaData*>* const files);
-
-  enum { kLevelMaxIndex = std::numeric_limits<int32_t>::max() };
-
- private:
-  size_t num_levels_;
-  const Comparator* ucmp_;
-
-  struct IndexUnit {
-    IndexUnit()
-        : smallest_lb(0), largest_lb(0), smallest_rb(-1), largest_rb(-1) {}
-    // During file search, a key is compared against smallest and largest
-    // from a FileMetaData. It can have 3 possible outcomes:
-    // (1) key is smaller than smallest, implying it is also smaller than
-    //     larger. Precalculated index based on "smallest < smallest" can
-    //     be used to provide right bound.
-    // (2) key is in between smallest and largest.
-    //     Precalculated index based on "smallest > greatest" can be used to
-    //     provide left bound.
-    //     Precalculated index based on "largest < smallest" can be used to
-    //     provide right bound.
-    // (3) key is larger than largest, implying it is also larger than smallest.
-    //     Precalculated index based on "largest > largest" can be used to
-    //     provide left bound.
-    //
-    // As a result, we will need to do:
-    // Compare smallest (<=) and largest keys from upper level file with
-    // smallest key from lower level to get a right bound.
-    // Compare smallest (>=) and largest keys from upper level file with
-    // largest key from lower level to get a left bound.
-    //
-    // Example:
-    //    level 1:              [50 - 60]
-    //    level 2:        [1 - 40], [45 - 55], [58 - 80]
-    // A key 35, compared to be less than 50, 3rd file on level 2 can be
-    // skipped according to rule (1). LB = 0, RB = 1.
-    // A key 53, sits in the middle 50 and 60. 1st file on level 2 can be
-    // skipped according to rule (2)-a, but the 3rd file cannot be skipped
-    // because 60 is greater than 58. LB = 1, RB = 2.
-    // A key 70, compared to be larger than 60. 1st and 2nd file can be skipped
-    // according to rule (3). LB = 2, RB = 2.
-    //
-    // Point to a left most file in a lower level that may contain a key,
-    // which compares greater than smallest of a FileMetaData (upper level)
-    int32_t smallest_lb;
-    // Point to a left most file in a lower level that may contain a key,
-    // which compares greater than largest of a FileMetaData (upper level)
-    int32_t largest_lb;
-    // Point to a right most file in a lower level that may contain a key,
-    // which compares smaller than smallest of a FileMetaData (upper level)
-    int32_t smallest_rb;
-    // Point to a right most file in a lower level that may contain a key,
-    // which compares smaller than largest of a FileMetaData (upper level)
-    int32_t largest_rb;
-  };
-
-  // Data structure to store IndexUnits in a whole level
-  struct IndexLevel {
-    size_t num_index;
-    IndexUnit* index_units;
-
-    IndexLevel() : num_index(0), index_units(nullptr) {}
-  };
-
-  void CalculateLB(
-      const std::vector<FileMetaData*>& upper_files,
-      const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-      std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-      std::function<void(IndexUnit*, int32_t)> set_index);
-
-  void CalculateRB(
-      const std::vector<FileMetaData*>& upper_files,
-      const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-      std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-      std::function<void(IndexUnit*, int32_t)> set_index);
-
-  autovector<IndexLevel> next_level_index_;
-  int32_t* level_rb_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE