Get rid of some shared_ptrs

Summary:
I went through all remaining shared_ptrs and removed the ones that I found not-necessary. Only GenerateCachePrefix() is called fairly often, so don't expect much perf wins.

The ones that are left are accessed infrequently and I think we're fine with keeping them.

Test Plan: make asan_check

Reviewers: dhruba, haobo

Reviewed By: dhruba

CC: leveldb

Differential Revision: https://reviews.facebook.net/D14427

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),

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<MemTableRepFactory> mem_rep_factory_;
+  MemTableRepFactory* mem_rep_factory_;
   MemTable* mem_;
   MemTableList imm_;             // Memtable that are not changing
   uint64_t logfile_number_;

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* 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() {

db/memtable.cc

@@ -33,7 +33,7 @@ struct hash<rocksdb::Slice> {
 namespace rocksdb {
 
 MemTable::MemTable(const InternalKeyComparator& cmp,
-                   std::shared_ptr<MemTableRepFactory> 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<MemTableRep::Iterator> iter(
-    table_.get()->GetIterator(lkey.user_key()));
+    table_->GetIterator(lkey.user_key()));
   iter->Seek(memkey.data());
 
   if (iter->Valid()) {

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<MemTableRepFactory> table_factory,
+    MemTableRepFactory* table_factory,
     int numlevel = 7,
     const Options& options = Options());
 

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;

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<SkipListFactory>();
-  MemTable* mem = new MemTable(cmp, factory);
+  MemTable* mem = new MemTable(cmp, factory.get());
   mem->Ref();
   std::string state;
   Options options;