d66908091d
Summary: Right now block based table iterator is used as both of iterating data for block based table, and for the index iterator for partitioend index. This was initially convenient for introducing a new iterator and block type for new index format, while reducing code change. However, these two usage doesn't go with each other very well. For example, Prev() is never called for partitioned index iterator, and some other complexity is maintained in block based iterators, which is not needed for index iterator but maintainers will always need to reason about it. Furthermore, the template usage is not following Google C++ Style which we are following, and makes a large chunk of code tangled together. This commit separate the two iterators. Right now, here is what it is done: 1. Copy the block based iterator code into partitioned index iterator, and de-template them. 2. Remove some code not needed for partitioned index. The upper bound check and tricks are removed. We never tested performance for those tricks when partitioned index is enabled in the first place. It's unlikelyl to generate performance regression, as creating new partitioned index block is much rarer than data blocks. 3. Separate out the prefetch logic to a helper class and both classes call them. This commit will enable future follow-ups. One direction is that we might separate index iterator interface for data blocks and index blocks, as they are quite different. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6531 Test Plan: build using make and cmake. And build release Differential Revision: D20473108 fbshipit-source-id: e48011783b339a4257c204cc07507b171b834b0f
57 lines
2.6 KiB
C++
57 lines
2.6 KiB
C++
// 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/block_prefetcher.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
|
|
const BlockHandle& handle,
|
|
size_t readahead_size,
|
|
bool is_for_compaction) {
|
|
if (!is_for_compaction) {
|
|
if (readahead_size == 0) {
|
|
// Implicit auto readahead
|
|
num_file_reads_++;
|
|
if (num_file_reads_ >
|
|
BlockBasedTable::kMinNumFileReadsToStartAutoReadahead) {
|
|
if (!rep->file->use_direct_io() &&
|
|
(handle.offset() + static_cast<size_t>(block_size(handle)) >
|
|
readahead_limit_)) {
|
|
// Buffered I/O
|
|
// Discarding the return status of Prefetch calls intentionally, as
|
|
// we can fallback to reading from disk if Prefetch fails.
|
|
rep->file->Prefetch(handle.offset(), readahead_size_);
|
|
readahead_limit_ =
|
|
static_cast<size_t>(handle.offset() + readahead_size_);
|
|
// Keep exponentially increasing readahead size until
|
|
// kMaxAutoReadaheadSize.
|
|
readahead_size_ = std::min(BlockBasedTable::kMaxAutoReadaheadSize,
|
|
readahead_size_ * 2);
|
|
} else if (rep->file->use_direct_io() && !prefetch_buffer_) {
|
|
// Direct I/O
|
|
// Let FilePrefetchBuffer take care of the readahead.
|
|
rep->CreateFilePrefetchBuffer(BlockBasedTable::kInitAutoReadaheadSize,
|
|
BlockBasedTable::kMaxAutoReadaheadSize,
|
|
&prefetch_buffer_);
|
|
}
|
|
}
|
|
} else if (!prefetch_buffer_) {
|
|
// Explicit user requested readahead
|
|
// The actual condition is:
|
|
// if (readahead_size != 0 && !prefetch_buffer_)
|
|
rep->CreateFilePrefetchBuffer(readahead_size, readahead_size,
|
|
&prefetch_buffer_);
|
|
}
|
|
} else if (!prefetch_buffer_) {
|
|
rep->CreateFilePrefetchBuffer(compaction_readahead_size_,
|
|
compaction_readahead_size_,
|
|
&prefetch_buffer_);
|
|
}
|
|
}
|
|
} // namespace ROCKSDB_NAMESPACE
|