mirror of
https://github.com/facebook/rocksdb.git
synced 2024-12-04 11:03:22 +00:00
cd79a00903
Summary: RocksDB does auto-readahead for iterators on noticing more than two reads for a table file. The readahead starts at 8KB and doubles on every additional read upto BlockBasedTable::kMaxAutoReadAheadSize which is 256*1024. This PR adds a new option BlockBasedTableOptions::max_auto_readahead_size which replaces BlockBasedTable::kMaxAutoReadAheadSize and the new option can be configured. If max_auto_readahead_size is set 0 then no implicit auto prefetching will be done. If max_auto_readahead_size provided is less than 8KB (which is initial readahead size used by rocksdb in case of auto-readahead), readahead size will remain same as max_auto_readahead_size. Pull Request resolved: https://github.com/facebook/rocksdb/pull/7951 Test Plan: Add new unit test case. Reviewed By: anand1976 Differential Revision: D26568085 Pulled By: akankshamahajan15 fbshipit-source-id: b6543520fc74e97d859f2002328d4c5254d417af
84 lines
3.2 KiB
C++
84 lines
3.2 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_);
|
|
return;
|
|
}
|
|
|
|
// Explicit user requested readahead
|
|
if (readahead_size > 0) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(readahead_size, readahead_size,
|
|
&prefetch_buffer_);
|
|
return;
|
|
}
|
|
|
|
// Implicit auto readahead, which will be enabled if the number of reads
|
|
// reached `kMinNumFileReadsToStartAutoReadahead` (default: 2).
|
|
num_file_reads_++;
|
|
if (num_file_reads_ <=
|
|
BlockBasedTable::kMinNumFileReadsToStartAutoReadahead) {
|
|
return;
|
|
}
|
|
|
|
size_t max_auto_readahead_size = rep->table_options.max_auto_readahead_size;
|
|
size_t initial_auto_readahead_size = BlockBasedTable::kInitAutoReadaheadSize;
|
|
|
|
// If max_auto_readahead_size is set to be 0 by user, no data will be
|
|
// prefetched.
|
|
if (max_auto_readahead_size == 0) {
|
|
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_);
|
|
return;
|
|
}
|
|
|
|
if (handle.offset() + static_cast<size_t>(block_size(handle)) <=
|
|
readahead_limit_) {
|
|
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(), readahead_size_);
|
|
if (s.IsNotSupported()) {
|
|
rep->CreateFilePrefetchBufferIfNotExists(initial_auto_readahead_size,
|
|
max_auto_readahead_size,
|
|
&prefetch_buffer_);
|
|
return;
|
|
}
|
|
readahead_limit_ = static_cast<size_t>(handle.offset() + 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
|