mirror of
https://github.com/facebook/rocksdb.git
synced 2024-12-02 01:16:16 +00:00
666a005f9b
Summary: Right now, if direct I/O is enabled, prefetching the last 512KB cannot be applied, except compaction inputs or readahead is enabled for iterators. This can create a lot of I/O for HDD cases. To solve the problem, the 512KB is prefetched in block based table if direct I/O is enabled. The prefetched buffer is passed in totegher with random access file reader, so that we try to read from the buffer before reading from the file. This can be extended in the future to support flexible user iterator readahead too. Closes https://github.com/facebook/rocksdb/pull/2708 Differential Revision: D5593091 Pulled By: siying fbshipit-source-id: ee36ff6d8af11c312a2622272b21957a7b5c81e7
124 lines
4.8 KiB
C++
124 lines
4.8 KiB
C++
// 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.
|
|
|
|
#ifndef ROCKSDB_LITE
|
|
#include "table/adaptive_table_factory.h"
|
|
|
|
#include "table/table_builder.h"
|
|
#include "table/format.h"
|
|
#include "port/port.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
AdaptiveTableFactory::AdaptiveTableFactory(
|
|
std::shared_ptr<TableFactory> table_factory_to_write,
|
|
std::shared_ptr<TableFactory> block_based_table_factory,
|
|
std::shared_ptr<TableFactory> plain_table_factory,
|
|
std::shared_ptr<TableFactory> cuckoo_table_factory)
|
|
: table_factory_to_write_(table_factory_to_write),
|
|
block_based_table_factory_(block_based_table_factory),
|
|
plain_table_factory_(plain_table_factory),
|
|
cuckoo_table_factory_(cuckoo_table_factory) {
|
|
if (!plain_table_factory_) {
|
|
plain_table_factory_.reset(NewPlainTableFactory());
|
|
}
|
|
if (!block_based_table_factory_) {
|
|
block_based_table_factory_.reset(NewBlockBasedTableFactory());
|
|
}
|
|
if (!cuckoo_table_factory_) {
|
|
cuckoo_table_factory_.reset(NewCuckooTableFactory());
|
|
}
|
|
if (!table_factory_to_write_) {
|
|
table_factory_to_write_ = block_based_table_factory_;
|
|
}
|
|
}
|
|
|
|
extern const uint64_t kPlainTableMagicNumber;
|
|
extern const uint64_t kLegacyPlainTableMagicNumber;
|
|
extern const uint64_t kBlockBasedTableMagicNumber;
|
|
extern const uint64_t kLegacyBlockBasedTableMagicNumber;
|
|
extern const uint64_t kCuckooTableMagicNumber;
|
|
|
|
Status AdaptiveTableFactory::NewTableReader(
|
|
const TableReaderOptions& table_reader_options,
|
|
unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
|
|
unique_ptr<TableReader>* table,
|
|
bool prefetch_index_and_filter_in_cache) const {
|
|
Footer footer;
|
|
auto s = ReadFooterFromFile(file.get(), nullptr /* prefetch_buffer */,
|
|
file_size, &footer);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (footer.table_magic_number() == kPlainTableMagicNumber ||
|
|
footer.table_magic_number() == kLegacyPlainTableMagicNumber) {
|
|
return plain_table_factory_->NewTableReader(
|
|
table_reader_options, std::move(file), file_size, table);
|
|
} else if (footer.table_magic_number() == kBlockBasedTableMagicNumber ||
|
|
footer.table_magic_number() == kLegacyBlockBasedTableMagicNumber) {
|
|
return block_based_table_factory_->NewTableReader(
|
|
table_reader_options, std::move(file), file_size, table);
|
|
} else if (footer.table_magic_number() == kCuckooTableMagicNumber) {
|
|
return cuckoo_table_factory_->NewTableReader(
|
|
table_reader_options, std::move(file), file_size, table);
|
|
} else {
|
|
return Status::NotSupported("Unidentified table format");
|
|
}
|
|
}
|
|
|
|
TableBuilder* AdaptiveTableFactory::NewTableBuilder(
|
|
const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
|
|
WritableFileWriter* file) const {
|
|
return table_factory_to_write_->NewTableBuilder(table_builder_options,
|
|
column_family_id, file);
|
|
}
|
|
|
|
std::string AdaptiveTableFactory::GetPrintableTableOptions() const {
|
|
std::string ret;
|
|
ret.reserve(20000);
|
|
const int kBufferSize = 200;
|
|
char buffer[kBufferSize];
|
|
|
|
if (table_factory_to_write_) {
|
|
snprintf(buffer, kBufferSize, " write factory (%s) options:\n%s\n",
|
|
(table_factory_to_write_->Name() ? table_factory_to_write_->Name()
|
|
: ""),
|
|
table_factory_to_write_->GetPrintableTableOptions().c_str());
|
|
ret.append(buffer);
|
|
}
|
|
if (plain_table_factory_) {
|
|
snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
|
plain_table_factory_->Name() ? plain_table_factory_->Name() : "",
|
|
plain_table_factory_->GetPrintableTableOptions().c_str());
|
|
ret.append(buffer);
|
|
}
|
|
if (block_based_table_factory_) {
|
|
snprintf(
|
|
buffer, kBufferSize, " %s options:\n%s\n",
|
|
(block_based_table_factory_->Name() ? block_based_table_factory_->Name()
|
|
: ""),
|
|
block_based_table_factory_->GetPrintableTableOptions().c_str());
|
|
ret.append(buffer);
|
|
}
|
|
if (cuckoo_table_factory_) {
|
|
snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
|
cuckoo_table_factory_->Name() ? cuckoo_table_factory_->Name() : "",
|
|
cuckoo_table_factory_->GetPrintableTableOptions().c_str());
|
|
ret.append(buffer);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
extern TableFactory* NewAdaptiveTableFactory(
|
|
std::shared_ptr<TableFactory> table_factory_to_write,
|
|
std::shared_ptr<TableFactory> block_based_table_factory,
|
|
std::shared_ptr<TableFactory> plain_table_factory,
|
|
std::shared_ptr<TableFactory> cuckoo_table_factory) {
|
|
return new AdaptiveTableFactory(table_factory_to_write,
|
|
block_based_table_factory, plain_table_factory, cuckoo_table_factory);
|
|
}
|
|
|
|
} // namespace rocksdb
|
|
#endif // ROCKSDB_LITE
|