e7c434c364
Summary:
Summary:
Added a new option to ColumnFamllyOptions - optimize_filters_for_hits. This option can be used in the case where most
accesses to the store are key hits and we dont need to optimize performance for key misses.
This is useful when you have a very large database and most of your lookups succeed. The option allows the store to
not store and use filters in the last level (the largest level which contains data). These filters can take a large amount of
space for large databases (in memory and on-disk). For the last level, these filters are only useful for key misses and not
for key hits. If we are not optimizing for key misses, we can choose to not store these filters for that level.
This option is only provided for BlockBasedTable. We skip the filters when we are compacting
Test Plan:
1. Modified db_test toalso run tests with an additonal option (skip_filters_on_last_level)
2. Added another unit test to db_test which specifically tests that filters are being skipped
Reviewers: rven, igor, sdong
Reviewed By: sdong
Subscribers: lgalanis, yoshinorim, MarkCallaghan, rven, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D33717
121 lines
4.6 KiB
C++
121 lines
4.6 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/format.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 (!table_factory_to_write_) {
|
|
table_factory_to_write_ = block_based_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());
|
|
}
|
|
}
|
|
|
|
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 ImmutableCFOptions& ioptions, const EnvOptions& env_options,
|
|
const InternalKeyComparator& icomp, unique_ptr<RandomAccessFile>&& file,
|
|
uint64_t file_size, unique_ptr<TableReader>* table) const {
|
|
Footer footer;
|
|
auto s = ReadFooterFromFile(file.get(), file_size, &footer);
|
|
if (!s.ok()) {
|
|
return s;
|
|
}
|
|
if (footer.table_magic_number() == kPlainTableMagicNumber ||
|
|
footer.table_magic_number() == kLegacyPlainTableMagicNumber) {
|
|
return plain_table_factory_->NewTableReader(
|
|
ioptions, env_options, icomp, std::move(file), file_size, table);
|
|
} else if (footer.table_magic_number() == kBlockBasedTableMagicNumber ||
|
|
footer.table_magic_number() == kLegacyBlockBasedTableMagicNumber) {
|
|
return block_based_table_factory_->NewTableReader(
|
|
ioptions, env_options, icomp, std::move(file), file_size, table);
|
|
} else if (footer.table_magic_number() == kCuckooTableMagicNumber) {
|
|
return cuckoo_table_factory_->NewTableReader(
|
|
ioptions, env_options, icomp, std::move(file), file_size, table);
|
|
} else {
|
|
return Status::NotSupported("Unidentified table format");
|
|
}
|
|
}
|
|
|
|
TableBuilder* AdaptiveTableFactory::NewTableBuilder(
|
|
const ImmutableCFOptions& ioptions,
|
|
const InternalKeyComparator& internal_comparator, WritableFile* file,
|
|
const CompressionType compression_type,
|
|
const CompressionOptions& compression_opts,
|
|
const bool skip_filters = false) const {
|
|
return table_factory_to_write_->NewTableBuilder(
|
|
ioptions, internal_comparator, file, compression_type, compression_opts,
|
|
skip_filters);
|
|
}
|
|
|
|
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_->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_->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_->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_->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
|