andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

dynamic inplace_update options

Browse Source 
Summary:
Make inplace_update_support and inplace_update_num_locks dynamic.
inplace_callback becomes immutable
We are almost free of references to cfd->options() in db_impl

Test Plan: unit test

Reviewers: igor, yhchiang, rven, sdong

Reviewed By: sdong

Subscribers: leveldb

Differential Revision: https://reviews.facebook.net/D25293
This commit is contained in:
Lei Jin 2014-10-27 12:10:13 -07:00
parent bc3bc4bc2f
commit f1841985e4
14 changed files with 70 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
db/column_family.cc
View File

@ -388,12 +388,13 @@ const EnvOptions* ColumnFamilyData::soptions() const {
void ColumnFamilyData::SetCurrent(Version* current) { current_ = current; } void ColumnFamilyData::SetCurrent(Version* current) { current_ = current; }
void ColumnFamilyData::CreateNewMemtable(const MemTableOptions& moptions) { void ColumnFamilyData::CreateNewMemtable(
const MutableCFOptions& mutable_cf_options) {
assert(current_ != nullptr); assert(current_ != nullptr);
if (mem_ != nullptr) { if (mem_ != nullptr) {
delete mem_->Unref(); delete mem_->Unref();
} }
mem_ = new MemTable(internal_comparator_, ioptions_, moptions); mem_ = new MemTable(internal_comparator_, ioptions_, mutable_cf_options);
mem_->Ref(); mem_->Ref();
} }

2
db/column_family.h
View File

@ -198,7 +198,7 @@ class ColumnFamilyData {
Version* dummy_versions() { return dummy_versions_; } Version* dummy_versions() { return dummy_versions_; }
void SetMemtable(MemTable* new_mem) { mem_ = new_mem; } void SetMemtable(MemTable* new_mem) { mem_ = new_mem; }
void SetCurrent(Version* current); void SetCurrent(Version* current);
void CreateNewMemtable(const MemTableOptions& moptions); void CreateNewMemtable(const MutableCFOptions& mutable_cf_options);
TableCache* table_cache() const { return table_cache_.get(); } TableCache* table_cache() const { return table_cache_.get(); }

16
db/db_impl.cc
View File

@ -1228,8 +1228,7 @@ Status DBImpl::Recover(
if (!s.ok()) { if (!s.ok()) {
// Clear memtables if recovery failed // Clear memtables if recovery failed
for (auto cfd : *versions_->GetColumnFamilySet()) { for (auto cfd : *versions_->GetColumnFamilySet()) {
cfd->CreateNewMemtable(MemTableOptions( cfd->CreateNewMemtable(*cfd->GetLatestMutableCFOptions());
*cfd->GetLatestMutableCFOptions(), *cfd->options()));
} }
} }
} }
@ -1360,8 +1359,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
// file-systems cause the DB::Open() to fail. // file-systems cause the DB::Open() to fail.
return status; return status;
} }
cfd->CreateNewMemtable(MemTableOptions( cfd->CreateNewMemtable(*cfd->GetLatestMutableCFOptions());
*cfd->GetLatestMutableCFOptions(), *cfd->options()));
} }
} }
} }
@ -1398,8 +1396,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
// Recovery failed // Recovery failed
break; break;
} }
cfd->CreateNewMemtable(MemTableOptions( cfd->CreateNewMemtable(*cfd->GetLatestMutableCFOptions());
*cfd->GetLatestMutableCFOptions(), *cfd->options()));
} }
// write MANIFEST with update // write MANIFEST with update
@ -2749,7 +2746,7 @@ Status DBImpl::ProcessKeyValueCompaction(
ColumnFamilyData* cfd = compact->compaction->column_family_data(); ColumnFamilyData* cfd = compact->compaction->column_family_data();
MergeHelper merge( MergeHelper merge(
cfd->user_comparator(), cfd->ioptions()->merge_operator, cfd->user_comparator(), cfd->ioptions()->merge_operator,
db_options_.info_log.get(), cfd->options()->min_partial_merge_operands, db_options_.info_log.get(), cfd->ioptions()->min_partial_merge_operands,
false /* internal key corruption is expected */); false /* internal key corruption is expected */);
auto compaction_filter = cfd->ioptions()->compaction_filter; auto compaction_filter = cfd->ioptions()->compaction_filter;
std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr; std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
@ -4281,9 +4278,8 @@ Status DBImpl::SetNewMemtableAndNewLogFile(ColumnFamilyData* cfd,
} }
if (s.ok()) { if (s.ok()) {
new_mem = new MemTable(cfd->internal_comparator(), new_mem = new MemTable(cfd->internal_comparator(), *cfd->ioptions(),
*cfd->ioptions(), MemTableOptions(mutable_cf_options, mutable_cf_options);
*cfd->options()));
new_superversion = new SuperVersion(); new_superversion = new SuperVersion();
} }
} }

45
db/memtable.cc
View File

@ -32,7 +32,8 @@
namespace rocksdb { namespace rocksdb {
MemTableOptions::MemTableOptions( MemTableOptions::MemTableOptions(
const MutableCFOptions& mutable_cf_options, const Options& options) const ImmutableCFOptions& ioptions,
const MutableCFOptions& mutable_cf_options)
: write_buffer_size(mutable_cf_options.write_buffer_size), : write_buffer_size(mutable_cf_options.write_buffer_size),
arena_block_size(mutable_cf_options.arena_block_size), arena_block_size(mutable_cf_options.arena_block_size),
memtable_prefix_bloom_bits(mutable_cf_options.memtable_prefix_bloom_bits), memtable_prefix_bloom_bits(mutable_cf_options.memtable_prefix_bloom_bits),
@ -40,21 +41,23 @@ MemTableOptions::MemTableOptions(
mutable_cf_options.memtable_prefix_bloom_probes), mutable_cf_options.memtable_prefix_bloom_probes),
memtable_prefix_bloom_huge_page_tlb_size( memtable_prefix_bloom_huge_page_tlb_size(
mutable_cf_options.memtable_prefix_bloom_huge_page_tlb_size), mutable_cf_options.memtable_prefix_bloom_huge_page_tlb_size),
inplace_update_support(options.inplace_update_support), inplace_update_support(ioptions.inplace_update_support),
inplace_update_num_locks(options.inplace_update_num_locks), inplace_update_num_locks(mutable_cf_options.inplace_update_num_locks),
inplace_callback(options.inplace_callback), inplace_callback(ioptions.inplace_callback),
max_successive_merges(mutable_cf_options.max_successive_merges), max_successive_merges(mutable_cf_options.max_successive_merges),
filter_deletes(mutable_cf_options.filter_deletes) {} filter_deletes(mutable_cf_options.filter_deletes),
statistics(ioptions.statistics),
merge_operator(ioptions.merge_operator),
info_log(ioptions.info_log) {}
MemTable::MemTable(const InternalKeyComparator& cmp, MemTable::MemTable(const InternalKeyComparator& cmp,
const ImmutableCFOptions& ioptions, const ImmutableCFOptions& ioptions,
const MemTableOptions& moptions) const MutableCFOptions& mutable_cf_options)
: comparator_(cmp), : comparator_(cmp),
ioptions_(ioptions), moptions_(ioptions, mutable_cf_options),
moptions_(moptions),
refs_(0), refs_(0),
kArenaBlockSize(OptimizeBlockSize(moptions.arena_block_size)), kArenaBlockSize(OptimizeBlockSize(moptions_.arena_block_size)),
arena_(moptions.arena_block_size), arena_(moptions_.arena_block_size),
table_(ioptions.memtable_factory->CreateMemTableRep( table_(ioptions.memtable_factory->CreateMemTableRep(
comparator_, &arena_, ioptions.prefix_extractor, ioptions.info_log)), comparator_, &arena_, ioptions.prefix_extractor, ioptions.info_log)),
num_entries_(0), num_entries_(0),
@ -63,20 +66,20 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
file_number_(0), file_number_(0),
first_seqno_(0), first_seqno_(0),
mem_next_logfile_number_(0), mem_next_logfile_number_(0),
locks_(moptions.inplace_update_support ? moptions.inplace_update_num_locks locks_(moptions_.inplace_update_support ?
: 0), moptions_.inplace_update_num_locks : 0),
prefix_extractor_(ioptions.prefix_extractor), prefix_extractor_(ioptions.prefix_extractor),
should_flush_(ShouldFlushNow()), should_flush_(ShouldFlushNow()),
flush_scheduled_(false) { flush_scheduled_(false) {
// if should_flush_ == true without an entry inserted, something must have // if should_flush_ == true without an entry inserted, something must have
// gone wrong already. // gone wrong already.
assert(!should_flush_); assert(!should_flush_);
if (prefix_extractor_ && moptions.memtable_prefix_bloom_bits > 0) { if (prefix_extractor_ && moptions_.memtable_prefix_bloom_bits > 0) {
prefix_bloom_.reset(new DynamicBloom( prefix_bloom_.reset(new DynamicBloom(
&arena_, &arena_,
moptions.memtable_prefix_bloom_bits, ioptions.bloom_locality, moptions_.memtable_prefix_bloom_bits, ioptions.bloom_locality,
moptions.memtable_prefix_bloom_probes, nullptr, moptions_.memtable_prefix_bloom_probes, nullptr,
moptions.memtable_prefix_bloom_huge_page_tlb_size, moptions_.memtable_prefix_bloom_huge_page_tlb_size,
ioptions.info_log)); ioptions.info_log));
} }
} }
@ -454,10 +457,10 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
saver.status = s; saver.status = s;
saver.mem = this; saver.mem = this;
saver.merge_context = merge_context; saver.merge_context = merge_context;
saver.merge_operator = ioptions_.merge_operator; saver.merge_operator = moptions_.merge_operator;
saver.logger = ioptions_.info_log; saver.logger = moptions_.info_log;
saver.inplace_update_support = moptions_.inplace_update_support; saver.inplace_update_support = moptions_.inplace_update_support;
saver.statistics = ioptions_.statistics; saver.statistics = moptions_.statistics;
table_->Get(key, &saver, SaveValue); table_->Get(key, &saver, SaveValue);
} }
@ -578,12 +581,12 @@ bool MemTable::UpdateCallback(SequenceNumber seq,
memcpy(p, prev_buffer, new_prev_size); memcpy(p, prev_buffer, new_prev_size);
} }
} }
RecordTick(ioptions_.statistics, NUMBER_KEYS_UPDATED); RecordTick(moptions_.statistics, NUMBER_KEYS_UPDATED);
should_flush_ = ShouldFlushNow(); should_flush_ = ShouldFlushNow();
return true; return true;
} else if (status == UpdateStatus::UPDATED) { } else if (status == UpdateStatus::UPDATED) {
Add(seq, kTypeValue, key, Slice(str_value)); Add(seq, kTypeValue, key, Slice(str_value));
RecordTick(ioptions_.statistics, NUMBER_KEYS_WRITTEN); RecordTick(moptions_.statistics, NUMBER_KEYS_WRITTEN);
should_flush_ = ShouldFlushNow(); should_flush_ = ShouldFlushNow();
return true; return true;
} else if (status == UpdateStatus::UPDATE_FAILED) { } else if (status == UpdateStatus::UPDATE_FAILED) {

11
db/memtable.h
View File

@ -32,8 +32,8 @@ class MergeContext;
struct MemTableOptions { struct MemTableOptions {
explicit MemTableOptions( explicit MemTableOptions(
const MutableCFOptions& mutable_cf_options, const ImmutableCFOptions& ioptions,
const Options& options); const MutableCFOptions& mutable_cf_options);
size_t write_buffer_size; size_t write_buffer_size;
size_t arena_block_size; size_t arena_block_size;
uint32_t memtable_prefix_bloom_bits; uint32_t memtable_prefix_bloom_bits;
@ -47,6 +47,9 @@ struct MemTableOptions {
std::string* merged_value); std::string* merged_value);
size_t max_successive_merges; size_t max_successive_merges;
bool filter_deletes; bool filter_deletes;
Statistics* statistics;
MergeOperator* merge_operator;
Logger* info_log;
}; };
class MemTable { class MemTable {
@ -64,7 +67,7 @@ class MemTable {
// is zero and the caller must call Ref() at least once. // is zero and the caller must call Ref() at least once.
explicit MemTable(const InternalKeyComparator& comparator, explicit MemTable(const InternalKeyComparator& comparator,
const ImmutableCFOptions& ioptions, const ImmutableCFOptions& ioptions,
const MemTableOptions& moptions); const MutableCFOptions& mutable_cf_options);
~MemTable(); ~MemTable();
@ -199,7 +202,6 @@ class MemTable {
const Arena& TEST_GetArena() const { return arena_; } const Arena& TEST_GetArena() const { return arena_; }
const ImmutableCFOptions* GetImmutableOptions() const { return &ioptions_; }
const MemTableOptions* GetMemTableOptions() const { return &moptions_; } const MemTableOptions* GetMemTableOptions() const { return &moptions_; }
private: private:
@ -211,7 +213,6 @@ class MemTable {
friend class MemTableList; friend class MemTableList;
KeyComparator comparator_; KeyComparator comparator_;
const ImmutableCFOptions& ioptions_;
const MemTableOptions moptions_; const MemTableOptions moptions_;
int refs_; int refs_;
const size_t kArenaBlockSize; const size_t kArenaBlockSize;

2
db/repair.cc
View File

@ -220,7 +220,7 @@ class Repairer {
Slice record; Slice record;
WriteBatch batch; WriteBatch batch;
MemTable* mem = new MemTable(icmp_, ioptions_, MemTable* mem = new MemTable(icmp_, ioptions_,
MemTableOptions(MutableCFOptions(options_, ioptions_), options_)); MutableCFOptions(options_, ioptions_));
auto cf_mems_default = new ColumnFamilyMemTablesDefault(mem, &options_); auto cf_mems_default = new ColumnFamilyMemTablesDefault(mem, &options_);
mem->Ref(); mem->Ref();
int counter = 0; int counter = 0;

3
db/version_set.cc
View File

@ -2926,8 +2926,7 @@ ColumnFamilyData* VersionSet::CreateColumnFamily(
AppendVersion(new_cfd, v); AppendVersion(new_cfd, v);
// GetLatestMutableCFOptions() is safe here without mutex since the // GetLatestMutableCFOptions() is safe here without mutex since the
// cfd is not available to client // cfd is not available to client
new_cfd->CreateNewMemtable(MemTableOptions( new_cfd->CreateNewMemtable(*new_cfd->GetLatestMutableCFOptions());
*new_cfd->GetLatestMutableCFOptions(), *new_cfd->options()));
new_cfd->SetLogNumber(edit->log_number_); new_cfd->SetLogNumber(edit->log_number_);
return new_cfd; return new_cfd;
} }

17
db/write_batch.cc
View File

@ -349,13 +349,12 @@ class MemTableInserter : public WriteBatch::Handler {
return seek_status; return seek_status;
} }
MemTable* mem = cf_mems_->GetMemTable(); MemTable* mem = cf_mems_->GetMemTable();
auto* ioptions = mem->GetImmutableOptions();
auto* moptions = mem->GetMemTableOptions(); auto* moptions = mem->GetMemTableOptions();
if (!moptions->inplace_update_support) { if (!moptions->inplace_update_support) {
mem->Add(sequence_, kTypeValue, key, value); mem->Add(sequence_, kTypeValue, key, value);
} else if (moptions->inplace_callback == nullptr) { } else if (moptions->inplace_callback == nullptr) {
mem->Update(sequence_, key, value); mem->Update(sequence_, key, value);
RecordTick(ioptions->statistics, NUMBER_KEYS_UPDATED); RecordTick(moptions->statistics, NUMBER_KEYS_UPDATED);
} else { } else {
if (mem->UpdateCallback(sequence_, key, value)) { if (mem->UpdateCallback(sequence_, key, value)) {
} else { } else {
@ -382,11 +381,11 @@ class MemTableInserter : public WriteBatch::Handler {
if (status == UpdateStatus::UPDATED_INPLACE) { if (status == UpdateStatus::UPDATED_INPLACE) {
// prev_value is updated in-place with final value. // prev_value is updated in-place with final value.
mem->Add(sequence_, kTypeValue, key, Slice(prev_buffer, prev_size)); mem->Add(sequence_, kTypeValue, key, Slice(prev_buffer, prev_size));
RecordTick(ioptions->statistics, NUMBER_KEYS_WRITTEN); RecordTick(moptions->statistics, NUMBER_KEYS_WRITTEN);
} else if (status == UpdateStatus::UPDATED) { } else if (status == UpdateStatus::UPDATED) {
// merged_value contains the final value. // merged_value contains the final value.
mem->Add(sequence_, kTypeValue, key, Slice(merged_value)); mem->Add(sequence_, kTypeValue, key, Slice(merged_value));
RecordTick(ioptions->statistics, NUMBER_KEYS_WRITTEN); RecordTick(moptions->statistics, NUMBER_KEYS_WRITTEN);
} }
} }
} }
@ -406,7 +405,6 @@ class MemTableInserter : public WriteBatch::Handler {
return seek_status; return seek_status;
} }
MemTable* mem = cf_mems_->GetMemTable(); MemTable* mem = cf_mems_->GetMemTable();
auto* ioptions = mem->GetImmutableOptions();
auto* moptions = mem->GetMemTableOptions(); auto* moptions = mem->GetMemTableOptions();
bool perform_merge = false; bool perform_merge = false;
@ -441,16 +439,16 @@ class MemTableInserter : public WriteBatch::Handler {
Slice get_value_slice = Slice(get_value); Slice get_value_slice = Slice(get_value);
// 2) Apply this merge // 2) Apply this merge
auto merge_operator = ioptions->merge_operator; auto merge_operator = moptions->merge_operator;
assert(merge_operator); assert(merge_operator);
std::deque<std::string> operands; std::deque<std::string> operands;
operands.push_front(value.ToString()); operands.push_front(value.ToString());
std::string new_value; std::string new_value;
if (!merge_operator->FullMerge(key, &get_value_slice, operands, if (!merge_operator->FullMerge(key, &get_value_slice, operands,
&new_value, ioptions->info_log)) { &new_value, moptions->info_log)) {
// Failed to merge! // Failed to merge!
RecordTick(ioptions->statistics, NUMBER_MERGE_FAILURES); RecordTick(moptions->statistics, NUMBER_MERGE_FAILURES);
// Store the delta in memtable // Store the delta in memtable
perform_merge = false; perform_merge = false;
@ -477,7 +475,6 @@ class MemTableInserter : public WriteBatch::Handler {
return seek_status; return seek_status;
} }
MemTable* mem = cf_mems_->GetMemTable(); MemTable* mem = cf_mems_->GetMemTable();
auto* ioptions = mem->GetImmutableOptions();
auto* moptions = mem->GetMemTableOptions(); auto* moptions = mem->GetMemTableOptions();
if (!dont_filter_deletes_ && moptions->filter_deletes) { if (!dont_filter_deletes_ && moptions->filter_deletes) {
SnapshotImpl read_from_snapshot; SnapshotImpl read_from_snapshot;
@ -490,7 +487,7 @@ class MemTableInserter : public WriteBatch::Handler {
cf_handle = db_->DefaultColumnFamily(); cf_handle = db_->DefaultColumnFamily();
} }
if (!db_->KeyMayExist(ropts, cf_handle, key, &value)) { if (!db_->KeyMayExist(ropts, cf_handle, key, &value)) {
RecordTick(ioptions->statistics, NUMBER_FILTERED_DELETES); RecordTick(moptions->statistics, NUMBER_FILTERED_DELETES);
return Status::OK(); return Status::OK();
} }
} }

2
db/write_batch_test.cc
View File

@ -29,7 +29,7 @@ static std::string PrintContents(WriteBatch* b) {
options.memtable_factory = factory; options.memtable_factory = factory;
ImmutableCFOptions ioptions(options); ImmutableCFOptions ioptions(options);
MemTable* mem = new MemTable(cmp, ioptions, MemTable* mem = new MemTable(cmp, ioptions,
MemTableOptions(MutableCFOptions(options, ioptions), options)); MutableCFOptions(options, ioptions));
mem->Ref(); mem->Ref();
std::string state; std::string state;
ColumnFamilyMemTablesDefault cf_mems_default(mem, &options); ColumnFamilyMemTablesDefault cf_mems_default(mem, &options);

8
include/rocksdb/immutable_options.h
View File

@ -5,6 +5,7 @@
#pragma once #pragma once
#include <string>
#include <vector> #include <vector>
#include "rocksdb/options.h" #include "rocksdb/options.h"
@ -36,6 +37,13 @@ struct ImmutableCFOptions {
CompactionFilterFactoryV2* compaction_filter_factory_v2; CompactionFilterFactoryV2* compaction_filter_factory_v2;
bool inplace_update_support;
UpdateStatus (*inplace_callback)(char* existing_value,
uint32_t* existing_value_size,
Slice delta_value,
std::string* merged_value);
Logger* info_log; Logger* info_log;
Statistics* statistics; Statistics* statistics;

6
table/table_test.cc
View File

@ -439,7 +439,7 @@ class MemTableConstructor: public Constructor {
options.memtable_factory = table_factory_; options.memtable_factory = table_factory_;
ImmutableCFOptions ioptions(options); ImmutableCFOptions ioptions(options);
memtable_ = new MemTable(internal_comparator_, ioptions, memtable_ = new MemTable(internal_comparator_, ioptions,
MemTableOptions(MutableCFOptions(options, ioptions), options)); MutableCFOptions(options, ioptions));
memtable_->Ref(); memtable_->Ref();
} }
~MemTableConstructor() { ~MemTableConstructor() {
@ -455,7 +455,7 @@ class MemTableConstructor: public Constructor {
options.memtable_factory = table_factory_; options.memtable_factory = table_factory_;
ImmutableCFOptions mem_ioptions(options); ImmutableCFOptions mem_ioptions(options);
memtable_ = new MemTable(internal_comparator_, mem_ioptions, memtable_ = new MemTable(internal_comparator_, mem_ioptions,
MemTableOptions(MutableCFOptions(options, mem_ioptions), options)); MutableCFOptions(options, mem_ioptions));
memtable_->Ref(); memtable_->Ref();
int seq = 1; int seq = 1;
for (KVMap::const_iterator it = data.begin(); for (KVMap::const_iterator it = data.begin();
@ -1879,7 +1879,7 @@ TEST(MemTableTest, Simple) {
options.memtable_factory = table_factory; options.memtable_factory = table_factory;
ImmutableCFOptions ioptions(options); ImmutableCFOptions ioptions(options);
MemTable* memtable = new MemTable(cmp, ioptions, MemTable* memtable = new MemTable(cmp, ioptions,
MemTableOptions(MutableCFOptions(options, ioptions), options)); MutableCFOptions(options, ioptions));
memtable->Ref(); memtable->Ref();
WriteBatch batch; WriteBatch batch;
WriteBatchInternal::SetSequence(&batch, 100); WriteBatchInternal::SetSequence(&batch, 100);

3
util/mutable_cf_options.h
View File

@ -22,6 +22,7 @@ struct MutableCFOptions {
options.memtable_prefix_bloom_huge_page_tlb_size), options.memtable_prefix_bloom_huge_page_tlb_size),
max_successive_merges(options.max_successive_merges), max_successive_merges(options.max_successive_merges),
filter_deletes(options.filter_deletes), filter_deletes(options.filter_deletes),
inplace_update_num_locks(options.inplace_update_num_locks),
disable_auto_compactions(options.disable_auto_compactions), disable_auto_compactions(options.disable_auto_compactions),
soft_rate_limit(options.soft_rate_limit), soft_rate_limit(options.soft_rate_limit),
hard_rate_limit(options.hard_rate_limit), hard_rate_limit(options.hard_rate_limit),
@ -53,6 +54,7 @@ struct MutableCFOptions {
memtable_prefix_bloom_huge_page_tlb_size(0), memtable_prefix_bloom_huge_page_tlb_size(0),
max_successive_merges(0), max_successive_merges(0),
filter_deletes(false), filter_deletes(false),
inplace_update_num_locks(0),
disable_auto_compactions(false), disable_auto_compactions(false),
soft_rate_limit(0), soft_rate_limit(0),
hard_rate_limit(0), hard_rate_limit(0),
@ -94,6 +96,7 @@ struct MutableCFOptions {
size_t memtable_prefix_bloom_huge_page_tlb_size; size_t memtable_prefix_bloom_huge_page_tlb_size;
size_t max_successive_merges; size_t max_successive_merges;
bool filter_deletes; bool filter_deletes;
size_t inplace_update_num_locks;
// Compaction related options // Compaction related options
bool disable_auto_compactions; bool disable_auto_compactions;

2
util/options.cc
View File

@ -42,6 +42,8 @@ ImmutableCFOptions::ImmutableCFOptions(const Options& options)
compaction_filter(options.compaction_filter), compaction_filter(options.compaction_filter),
compaction_filter_factory(options.compaction_filter_factory.get()), compaction_filter_factory(options.compaction_filter_factory.get()),
compaction_filter_factory_v2(options.compaction_filter_factory_v2.get()), compaction_filter_factory_v2(options.compaction_filter_factory_v2.get()),
inplace_update_support(options.inplace_update_support),
inplace_callback(options.inplace_callback),
info_log(options.info_log.get()), info_log(options.info_log.get()),
statistics(options.statistics.get()), statistics(options.statistics.get()),
env(options.env), env(options.env),

8
util/options_helper.cc
View File

@ -94,6 +94,8 @@ bool ParseMemtableOptions(const std::string& name, const std::string& value,
new_options->filter_deletes = ParseBoolean(name, value); new_options->filter_deletes = ParseBoolean(name, value);
} else if (name == "max_write_buffer_number") { } else if (name == "max_write_buffer_number") {
new_options->max_write_buffer_number = ParseInt(value); new_options->max_write_buffer_number = ParseInt(value);
} else if (name == "inplace_update_num_locks") {
new_options->inplace_update_num_locks = ParseInt64(value);
} else { } else {
return false; return false;
} }
@ -299,14 +301,12 @@ bool GetColumnFamilyOptionsFromMap(
} else if (o.first == "compaction_options_fifo") { } else if (o.first == "compaction_options_fifo") {
new_options->compaction_options_fifo.max_table_files_size new_options->compaction_options_fifo.max_table_files_size
= ParseUint64(o.second); = ParseUint64(o.second);
} else if (o.first == "inplace_update_support") {
new_options->inplace_update_support = ParseBoolean(o.first, o.second);
} else if (o.first == "inplace_update_num_locks") {
new_options->inplace_update_num_locks = ParseInt64(o.second);
} else if (o.first == "bloom_locality") { } else if (o.first == "bloom_locality") {
new_options->bloom_locality = ParseUint32(o.second); new_options->bloom_locality = ParseUint32(o.second);
} else if (o.first == "min_partial_merge_operands") { } else if (o.first == "min_partial_merge_operands") {
new_options->min_partial_merge_operands = ParseUint32(o.second); new_options->min_partial_merge_operands = ParseUint32(o.second);
} else if (o.first == "inplace_update_support") {
new_options->inplace_update_support = ParseBoolean(o.first, o.second);
} else { } else {
return false; return false;
} }