17ce1ca48b
Summary: RocksDB does auto-readahead for iterators on noticing more than two sequential reads for a table file if user doesn't provide readahead_size. The readahead starts at 8KB and doubles on every additional read up to max_auto_readahead_size. However at each level, if iterator moves over next file, readahead_size starts again from 8KB. This PR introduces a new ReadOption "adaptive_readahead" which when set true will maintain readahead_size at each level. So when iterator moves from one file to another, new file's readahead_size will continue from previous file's readahead_size instead of scratch. However if reads are not sequential it will fall back to 8KB (default) with no prefetching for that block. 1. If block is found in cache but it was eligible for prefetch (block wasn't in Rocksdb's prefetch buffer), readahead_size will decrease by 8KB. 2. It maintains readahead_size for L1 - Ln levels. Pull Request resolved: https://github.com/facebook/rocksdb/pull/9056 Test Plan: Added new unit tests Ran db_bench for "readseq, seekrandom, seekrandomwhilewriting, readrandom" with --adaptive_readahead=true and there was no regression if new feature is enabled. Reviewed By: anand1976 Differential Revision: D31773640 Pulled By: akankshamahajan15 fbshipit-source-id: 7332d16258b846ae5cea773009195a5af58f8f98
98 lines
3.6 KiB
C++
98 lines
3.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) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(compaction_readahead_size_,
|
|
compaction_readahead_size_,
|
|
&prefetch_buffer_, false);
|
|
return;
|
|
}
|
|
|
|
// Explicit user requested readahead.
|
|
if (readahead_size > 0) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(readahead_size, readahead_size,
|
|
&prefetch_buffer_, false);
|
|
return;
|
|
}
|
|
|
|
// Implicit readahead.
|
|
|
|
// If max_auto_readahead_size is set to be 0 by user, no data will be
|
|
// prefetched.
|
|
size_t max_auto_readahead_size = rep->table_options.max_auto_readahead_size;
|
|
if (max_auto_readahead_size == 0) {
|
|
return;
|
|
}
|
|
|
|
size_t len = static_cast<size_t>(block_size(handle));
|
|
size_t offset = handle.offset();
|
|
|
|
// If FS supports prefetching (readahead_limit_ will be non zero in that case)
|
|
// and current block exists in prefetch buffer then return.
|
|
if (offset + len <= readahead_limit_) {
|
|
UpdateReadPattern(offset, len);
|
|
return;
|
|
}
|
|
|
|
if (!IsBlockSequential(offset)) {
|
|
UpdateReadPattern(offset, len);
|
|
ResetValues();
|
|
return;
|
|
}
|
|
UpdateReadPattern(offset, len);
|
|
|
|
// Implicit auto readahead, which will be enabled if the number of reads
|
|
// reached `kMinNumFileReadsToStartAutoReadahead` (default: 2) and scans are
|
|
// sequential.
|
|
num_file_reads_++;
|
|
if (num_file_reads_ <=
|
|
BlockBasedTable::kMinNumFileReadsToStartAutoReadahead) {
|
|
return;
|
|
}
|
|
|
|
if (initial_auto_readahead_size_ > max_auto_readahead_size) {
|
|
initial_auto_readahead_size_ = max_auto_readahead_size;
|
|
}
|
|
|
|
if (rep->file->use_direct_io()) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(initial_auto_readahead_size_,
|
|
max_auto_readahead_size,
|
|
&prefetch_buffer_, true);
|
|
return;
|
|
}
|
|
|
|
if (readahead_size_ > max_auto_readahead_size) {
|
|
readahead_size_ = max_auto_readahead_size;
|
|
}
|
|
|
|
// If prefetch is not supported, fall back to use internal prefetch buffer.
|
|
// Discarding other return status of Prefetch calls intentionally, as
|
|
// we can fallback to reading from disk if Prefetch fails.
|
|
Status s = rep->file->Prefetch(handle.offset(),
|
|
block_size(handle) + readahead_size_);
|
|
if (s.IsNotSupported()) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(initial_auto_readahead_size_,
|
|
max_auto_readahead_size,
|
|
&prefetch_buffer_, true);
|
|
return;
|
|
}
|
|
|
|
readahead_limit_ = offset + len + readahead_size_;
|
|
// Keep exponentially increasing readahead size until
|
|
// max_auto_readahead_size.
|
|
readahead_size_ = std::min(max_auto_readahead_size, readahead_size_ * 2);
|
|
}
|
|
} // namespace ROCKSDB_NAMESPACE
|