mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-26 16:30:56 +00:00
230660be73
Summary:
* Checksums are now checked on meta blocks unless specifically
suppressed or not applicable (e.g. plain table). (Was other way around.)
This means a number of cases that were not checking checksums now are,
including direct read TableProperties in Version::GetTableProperties
(fixed in meta_blocks ReadTableProperties), reading any block from
PersistentCache (fixed in BlockFetcher), read TableProperties in
SstFileDumper (ldb/sst_dump/BackupEngine) before table reader open,
maybe more.
* For that to work, I moved the global_seqno+TableProperties checksum
logic to the shared table/ code, because that is used by many utilies
such as SstFileDumper.
* Also for that to work, we have to know when we're dealing with a block
that has a checksum (trailer), so added that capability to Footer based
on magic number, and from there BlockFetcher.
* Knowledge of trailer presence has also fixed a problem where other
table formats were reading blocks including bytes for a non-existant
trailer--and awkwardly kind-of not using them, e.g. no shared code
checking checksums. (BlockFetcher compression type was populated
incorrectly.) Now we only read what is needed.
* Minimized code duplication and differing/incompatible/awkward
abstractions in meta_blocks.{cc,h} (e.g. SeekTo in metaindex block
without parsing block handle)
* Moved some meta block handling code from table_properties*.*
* Moved some code specific to block-based table from shared table/ code
to BlockBasedTable class. The checksum stuff means we can't completely
separate it, but things that don't need to be in shared table/ code
should not be.
* Use unique_ptr rather than raw ptr in more places. (Note: you can
std::move from unique_ptr to shared_ptr.)
Without enhancements to GetPropertiesOfAllTablesTest (see below),
net reduction of roughly 100 lines of code.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9163
Test Plan:
existing tests and
* Enhanced DBTablePropertiesTest.GetPropertiesOfAllTablesTest to verify that
checksums are now checked on direct read of table properties by TableCache
(new test would fail before this change)
* Also enhanced DBTablePropertiesTest.GetPropertiesOfAllTablesTest to test
putting table properties under old meta name
* Also generally enhanced that same test to actually test what it was
supposed to be testing already, by kicking things out of table cache when
we don't want them there.
Reviewed By: ajkr, mrambacher
Differential Revision: D32514757
Pulled By: pdillinger
fbshipit-source-id: 507964b9311d186ae8d1131182290cbd97a99fa9
101 lines
3.7 KiB
C++
101 lines
3.7 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"
|
|
|
|
#include "table/block_based/block_based_table_reader.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 = BlockBasedTable::BlockSizeWithTrailer(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(),
|
|
BlockBasedTable::BlockSizeWithTrailer(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
|