diff --git a/db/db_impl.cc b/db/db_impl.cc index ad189a2e5..61f03327c 100644 --- a/db/db_impl.cc +++ b/db/db_impl.cc @@ -235,7 +235,7 @@ DBImpl::DBImpl(const Options& options, const std::string& dbname) mutex_(options.use_adaptive_mutex), shutting_down_(nullptr), bg_cv_(&mutex_), - mem_rep_factory_(options_.memtable_factory), + mem_rep_factory_(options_.memtable_factory.get()), mem_(new MemTable(internal_comparator_, mem_rep_factory_, NumberLevels(), options_)), logfile_number_(0), diff --git a/db/db_impl.h b/db/db_impl.h index 7d0fadb61..15b6013d0 100644 --- a/db/db_impl.h +++ b/db/db_impl.h @@ -315,7 +315,7 @@ class DBImpl : public DB { port::Mutex mutex_; port::AtomicPointer shutting_down_; port::CondVar bg_cv_; // Signalled when background work finishes - std::shared_ptr mem_rep_factory_; + MemTableRepFactory* mem_rep_factory_; MemTable* mem_; MemTableList imm_; // Memtable that are not changing uint64_t logfile_number_; diff --git a/db/db_iter.cc b/db/db_iter.cc index 89eaf0949..596a9f651 100644 --- a/db/db_iter.cc +++ b/db/db_iter.cc @@ -61,7 +61,7 @@ class DBIter: public Iterator { const Comparator* cmp, Iterator* iter, SequenceNumber s) : dbname_(dbname), env_(env), - logger_(options.info_log), + logger_(options.info_log.get()), user_comparator_(cmp), user_merge_operator_(options.merge_operator.get()), iter_(iter), @@ -122,7 +122,7 @@ class DBIter: public Iterator { const std::string* const dbname_; Env* const env_; - shared_ptr logger_; + Logger* logger_; const Comparator* const user_comparator_; const MergeOperator* const user_merge_operator_; Iterator* const iter_; @@ -293,7 +293,7 @@ void DBIter::MergeValuesNewToOld() { // ignore corruption if there is any. const Slice value = iter_->value(); user_merge_operator_->FullMerge(ikey.user_key, &value, operands, - &saved_value_, logger_.get()); + &saved_value_, logger_); // iter_ is positioned after put iter_->Next(); return; @@ -310,7 +310,7 @@ void DBIter::MergeValuesNewToOld() { Slice(operands[0]), Slice(operands[1]), &merge_result, - logger_.get())) { + logger_)) { operands.pop_front(); swap(operands.front(), merge_result); } else { @@ -327,7 +327,7 @@ void DBIter::MergeValuesNewToOld() { // feed null as the existing value to the merge operator, such that // client can differentiate this scenario and do things accordingly. user_merge_operator_->FullMerge(saved_key_, nullptr, operands, - &saved_value_, logger_.get()); + &saved_value_, logger_); } void DBIter::Prev() { diff --git a/db/memtable.cc b/db/memtable.cc index ac589a563..f86af4e33 100644 --- a/db/memtable.cc +++ b/db/memtable.cc @@ -33,7 +33,7 @@ struct hash { namespace rocksdb { MemTable::MemTable(const InternalKeyComparator& cmp, - std::shared_ptr table_factory, + MemTableRepFactory* table_factory, int numlevel, const Options& options) : comparator_(cmp), @@ -274,7 +274,7 @@ bool MemTable::Update(SequenceNumber seq, ValueType type, Slice memkey = lkey.memtable_key(); std::shared_ptr iter( - table_.get()->GetIterator(lkey.user_key())); + table_->GetIterator(lkey.user_key())); iter->Seek(memkey.data()); if (iter->Valid()) { diff --git a/db/memtable.h b/db/memtable.h index 5648b7716..7a0d6b343 100644 --- a/db/memtable.h +++ b/db/memtable.h @@ -35,7 +35,7 @@ class MemTable { // is zero and the caller must call Ref() at least once. explicit MemTable( const InternalKeyComparator& comparator, - std::shared_ptr table_factory, + MemTableRepFactory* table_factory, int numlevel = 7, const Options& options = Options()); diff --git a/db/repair.cc b/db/repair.cc index 230be565e..fc9ba282d 100644 --- a/db/repair.cc +++ b/db/repair.cc @@ -196,7 +196,7 @@ class Repairer { std::string scratch; Slice record; WriteBatch batch; - MemTable* mem = new MemTable(icmp_, options_.memtable_factory, + MemTable* mem = new MemTable(icmp_, options_.memtable_factory.get(), options_.num_levels); mem->Ref(); int counter = 0; diff --git a/db/write_batch_test.cc b/db/write_batch_test.cc index 6b66e9293..ff9aa63ee 100644 --- a/db/write_batch_test.cc +++ b/db/write_batch_test.cc @@ -22,7 +22,7 @@ namespace rocksdb { static std::string PrintContents(WriteBatch* b) { InternalKeyComparator cmp(BytewiseComparator()); auto factory = std::make_shared(); - MemTable* mem = new MemTable(cmp, factory); + MemTable* mem = new MemTable(cmp, factory.get()); mem->Ref(); std::string state; Options options; diff --git a/table/block_based_table_builder.cc b/table/block_based_table_builder.cc index f846b1ffd..a5e546be8 100644 --- a/table/block_based_table_builder.cc +++ b/table/block_based_table_builder.cc @@ -127,9 +127,10 @@ BlockBasedTableBuilder::BlockBasedTableBuilder( rep_->filter_block->StartBlock(0); } if (options.block_cache_compressed.get() != nullptr) { - BlockBasedTable::GenerateCachePrefix(options.block_cache_compressed, file, - &rep_->compressed_cache_key_prefix[0], - &rep_->compressed_cache_key_prefix_size); + BlockBasedTable::GenerateCachePrefix( + options.block_cache_compressed.get(), file, + &rep_->compressed_cache_key_prefix[0], + &rep_->compressed_cache_key_prefix_size); } } diff --git a/table/block_based_table_reader.cc b/table/block_based_table_reader.cc index 095c2999c..dcb55fc36 100644 --- a/table/block_based_table_reader.cc +++ b/table/block_based_table_reader.cc @@ -95,18 +95,18 @@ void BlockBasedTable::SetupCacheKeyPrefix(Rep* rep) { rep->cache_key_prefix_size = 0; rep->compressed_cache_key_prefix_size = 0; if (rep->options.block_cache != nullptr) { - GenerateCachePrefix(rep->options.block_cache, rep->file.get(), + GenerateCachePrefix(rep->options.block_cache.get(), rep->file.get(), &rep->cache_key_prefix[0], &rep->cache_key_prefix_size); } if (rep->options.block_cache_compressed != nullptr) { - GenerateCachePrefix(rep->options.block_cache_compressed, rep->file.get(), - &rep->compressed_cache_key_prefix[0], + GenerateCachePrefix(rep->options.block_cache_compressed.get(), + rep->file.get(), &rep->compressed_cache_key_prefix[0], &rep->compressed_cache_key_prefix_size); } } -void BlockBasedTable::GenerateCachePrefix(shared_ptr cc, +void BlockBasedTable::GenerateCachePrefix(Cache* cc, RandomAccessFile* file, char* buffer, size_t* size) { // generate an id from the file @@ -120,7 +120,7 @@ void BlockBasedTable::GenerateCachePrefix(shared_ptr cc, } } -void BlockBasedTable::GenerateCachePrefix(shared_ptr cc, +void BlockBasedTable::GenerateCachePrefix(Cache* cc, WritableFile* file, char* buffer, size_t* size) { // generate an id from the file diff --git a/table/block_based_table_reader.h b/table/block_based_table_reader.h index 02bbfd74c..66f63fc59 100644 --- a/table/block_based_table_reader.h +++ b/table/block_based_table_reader.h @@ -167,9 +167,9 @@ class BlockBasedTable : public TableReader { rep_ = rep; } // Generate a cache key prefix from the file - static void GenerateCachePrefix(shared_ptr cc, + static void GenerateCachePrefix(Cache* cc, RandomAccessFile* file, char* buffer, size_t* size); - static void GenerateCachePrefix(shared_ptr cc, + static void GenerateCachePrefix(Cache* cc, WritableFile* file, char* buffer, size_t* size); // The longest prefix of the cache key used to identify blocks. diff --git a/table/table_test.cc b/table/table_test.cc index 2214c25a1..e4aab1f69 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -370,7 +370,7 @@ class MemTableConstructor: public Constructor { : Constructor(cmp), internal_comparator_(cmp), table_factory_(new SkipListFactory) { - memtable_ = new MemTable(internal_comparator_, table_factory_); + memtable_ = new MemTable(internal_comparator_, table_factory_.get()); memtable_->Ref(); } ~MemTableConstructor() { @@ -378,7 +378,7 @@ class MemTableConstructor: public Constructor { } virtual Status FinishImpl(const Options& options, const KVMap& data) { delete memtable_->Unref(); - memtable_ = new MemTable(internal_comparator_, table_factory_); + memtable_ = new MemTable(internal_comparator_, table_factory_.get()); memtable_->Ref(); int seq = 1; for (KVMap::const_iterator it = data.begin(); @@ -930,19 +930,19 @@ TEST(TableTest, NumBlockStat) { class BlockCacheProperties { public: - explicit BlockCacheProperties(std::shared_ptr statistics) { + explicit BlockCacheProperties(Statistics* statistics) { block_cache_miss = - statistics.get()->getTickerCount(BLOCK_CACHE_MISS); + statistics->getTickerCount(BLOCK_CACHE_MISS); block_cache_hit = - statistics.get()->getTickerCount(BLOCK_CACHE_HIT); + statistics->getTickerCount(BLOCK_CACHE_HIT); index_block_cache_miss = - statistics.get()->getTickerCount(BLOCK_CACHE_INDEX_MISS); + statistics->getTickerCount(BLOCK_CACHE_INDEX_MISS); index_block_cache_hit = - statistics.get()->getTickerCount(BLOCK_CACHE_INDEX_HIT); + statistics->getTickerCount(BLOCK_CACHE_INDEX_HIT); data_block_cache_miss = - statistics.get()->getTickerCount(BLOCK_CACHE_DATA_MISS); + statistics->getTickerCount(BLOCK_CACHE_DATA_MISS); data_block_cache_hit = - statistics.get()->getTickerCount(BLOCK_CACHE_DATA_HIT); + statistics->getTickerCount(BLOCK_CACHE_DATA_HIT); } // Check if the fetched props matches the expected ones. @@ -993,7 +993,7 @@ TEST(TableTest, BlockCacheTest) { // At first, no block will be accessed. { - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); // index will be added to block cache. props.AssertEqual( 1, // index block miss @@ -1006,7 +1006,7 @@ TEST(TableTest, BlockCacheTest) { // Only index block will be accessed { iter.reset(c.NewIterator()); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); // NOTE: to help better highlight the "detla" of each ticker, I use // + to indicate the increment of changed // value; other numbers remain the same. @@ -1021,7 +1021,7 @@ TEST(TableTest, BlockCacheTest) { // Only data block will be accessed { iter->SeekToFirst(); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); props.AssertEqual( 1, 1, @@ -1034,7 +1034,7 @@ TEST(TableTest, BlockCacheTest) { { iter.reset(c.NewIterator()); iter->SeekToFirst(); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); props.AssertEqual( 1, 1 + 1, // index block hit @@ -1054,7 +1054,7 @@ TEST(TableTest, BlockCacheTest) { iter.reset(c.NewIterator()); iter->SeekToFirst(); ASSERT_EQ("key", iter->key().ToString()); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); // Nothing is affected at all props.AssertEqual(0, 0, 0, 0); } @@ -1065,7 +1065,7 @@ TEST(TableTest, BlockCacheTest) { options.block_cache = NewLRUCache(1); c.Reopen(options); { - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); props.AssertEqual( 1, // index block miss 0, @@ -1080,7 +1080,7 @@ TEST(TableTest, BlockCacheTest) { // It first cache index block then data block. But since the cache size // is only 1, index block will be purged after data block is inserted. iter.reset(c.NewIterator()); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); props.AssertEqual( 1 + 1, // index block miss 0, @@ -1093,7 +1093,7 @@ TEST(TableTest, BlockCacheTest) { // SeekToFirst() accesses data block. With similar reason, we expect data // block's cache miss. iter->SeekToFirst(); - BlockCacheProperties props(options.statistics); + BlockCacheProperties props(options.statistics.get()); props.AssertEqual( 2, 0, @@ -1268,7 +1268,7 @@ class MemTableTest { }; TEST(MemTableTest, Simple) { InternalKeyComparator cmp(BytewiseComparator()); auto table_factory = std::make_shared(); - MemTable* memtable = new MemTable(cmp, table_factory); + MemTable* memtable = new MemTable(cmp, table_factory.get()); memtable->Ref(); WriteBatch batch; Options options;