diff --git a/db/version_set.cc b/db/version_set.cc
@@ -290,7 +290,7 @@ struct Saver {
   std::deque<std::string>* merge_operands;  // the merge operations encountered
   Logger* logger;
   bool didIO;    // did we do any disk io?
-  shared_ptr<Statistics> statistics;
+  Statistics* statistics;
 };
 }
 
@@ -439,7 +439,7 @@ void Version::Get(const ReadOptions& options,
   saver.merge_operands = operands;
   saver.logger = logger.get();
   saver.didIO = false;
-  saver.statistics = db_options.statistics;
+  saver.statistics = db_options.statistics.get();
 
   stats->seek_file = nullptr;
   stats->seek_file_level = -1;
@@ -566,7 +566,7 @@ void Version::Get(const ReadOptions& options,
                                   value, logger.get())) {
       *status = Status::OK();
     } else {
-      RecordTick(db_options.statistics, NUMBER_MERGE_FAILURES);
+      RecordTick(db_options.statistics.get(), NUMBER_MERGE_FAILURES);
       *status = Status::Corruption("could not perform end-of-key merge for ",
                                    user_key);
     }
@@ -1296,10 +1296,12 @@ Status VersionSet::LogAndApply(VersionEdit* edit, port::Mutex* mu,
       }
       if (s.ok()) {
         if (options_->use_fsync) {
-          StopWatch sw(env_, options_->statistics, MANIFEST_FILE_SYNC_MICROS);
+          StopWatch sw(env_, options_->statistics.get(),
+                       MANIFEST_FILE_SYNC_MICROS);
           s = descriptor_log_->file()->Fsync();
         } else {
-          StopWatch sw(env_, options_->statistics, MANIFEST_FILE_SYNC_MICROS);
+          StopWatch sw(env_, options_->statistics.get(),
+                       MANIFEST_FILE_SYNC_MICROS);
           s = descriptor_log_->file()->Sync();
         }
       }

diff --git a/db/write_batch.cc b/db/write_batch.cc
@@ -20,15 +20,14 @@
 //    data: uint8[len]
 
 #include "rocksdb/write_batch.h"
-
 #include "rocksdb/options.h"
-#include "rocksdb/statistics.h"
 #include "db/dbformat.h"
 #include "db/db_impl.h"
 #include "db/memtable.h"
 #include "db/snapshot.h"
 #include "db/write_batch_internal.h"
 #include "util/coding.h"
+#include "util/statistics_imp.h"
 #include <stdexcept>
 
 namespace rocksdb {
@@ -197,7 +196,7 @@ class MemTableInserter : public WriteBatch::Handler {
   virtual void Put(const Slice& key, const Slice& value) {
     if (options_->inplace_update_support
         && mem_->Update(sequence_, kTypeValue, key, value)) {
-      RecordTick(options_->statistics, NUMBER_KEYS_UPDATED);
+      RecordTick(options_->statistics.get(), NUMBER_KEYS_UPDATED);
     } else {
       mem_->Add(sequence_, kTypeValue, key, value);
     }
@@ -215,7 +214,7 @@ class MemTableInserter : public WriteBatch::Handler {
       ropts.snapshot = &read_from_snapshot;
       std::string value;
       if (!db_->KeyMayExist(ropts, key, &value)) {
-        RecordTick(options_->statistics, NUMBER_FILTERED_DELETES);
+        RecordTick(options_->statistics.get(), NUMBER_FILTERED_DELETES);
         return;
       }
     }

diff --git a/include/rocksdb/statistics.h b/include/rocksdb/statistics.h
@@ -276,27 +276,6 @@ class Statistics {
 // Create a concrete DBStatistics object
 std::shared_ptr<Statistics> CreateDBStatistics();
 
-// Ease of Use functions
-inline void RecordTick(std::shared_ptr<Statistics> statistics,
-                       Tickers ticker,
-                       uint64_t count = 1) {
-  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
-  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
-  if (statistics) {
-    statistics->recordTick(ticker, count);
-  }
-}
-
-inline void SetTickerCount(std::shared_ptr<Statistics> statistics,
-                           Tickers ticker,
-                           uint64_t count) {
-  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
-  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
-  if (statistics) {
-    statistics->setTickerCount(ticker, count);
-  }
-}
-
 }  // namespace rocksdb
 
 #endif  // STORAGE_ROCKSDB_INCLUDE_STATISTICS_H_
diff --git a/table/block_based_table_builder.cc b/table/block_based_table_builder.cc
@@ -272,7 +272,8 @@ void BlockBasedTableBuilder::WriteRawBlock(const Slice& block_contents,
                                            CompressionType type,
                                            BlockHandle* handle) {
   Rep* r = rep_;
-  StopWatch sw(r->options.env, r->options.statistics, WRITE_RAW_BLOCK_MICROS);
+  StopWatch sw(r->options.env, r->options.statistics.get(),
+               WRITE_RAW_BLOCK_MICROS);
   handle->set_offset(r->offset);
   handle->set_size(block_contents.size());
   r->status = r->file->Append(block_contents);

diff --git a/table/block_based_table_reader.cc b/table/block_based_table_reader.cc
@@ -200,7 +200,7 @@ Cache::Handle* GetFromBlockCache(
     const Slice& key,
     Tickers block_cache_miss_ticker,
     Tickers block_cache_hit_ticker,
-    std::shared_ptr<Statistics> statistics) {
+    Statistics* statistics) {
   auto cache_handle = block_cache->Lookup(key);
   if (cache_handle != nullptr) {
     BumpPerfCount(&perf_context.block_cache_hit_count);
@@ -515,7 +515,7 @@ Status BlockBasedTable::GetBlock(
     CachableEntry<Block>* entry) {
   bool no_io = options.read_tier == kBlockCacheTier;
   Cache* block_cache = table->rep_->options.block_cache.get();
-  auto statistics = table->rep_->options.statistics;
+  Statistics* statistics = table->rep_->options.statistics.get();
   Status s;
 
   if (block_cache != nullptr) {
@@ -532,7 +532,7 @@ Status BlockBasedTable::GetBlock(
         key,
         block_cache_miss_ticker,
         block_cache_hit_ticker,
-        table->rep_->options.statistics
+        statistics
     );
 
     if (entry->cache_handle != nullptr) {
@@ -593,7 +593,7 @@ Iterator* BlockBasedTable::BlockReader(void* arg,
   Cache* block_cache = table->rep_->options.block_cache.get();
   Cache* block_cache_compressed = table->rep_->options.
                                     block_cache_compressed.get();
-  std::shared_ptr<Statistics> statistics = table->rep_->options.statistics;
+  Statistics* statistics = table->rep_->options.statistics.get();
   Block* block = nullptr;
   Block* cblock = nullptr;
   Cache::Handle* cache_handle = nullptr;
@@ -791,12 +791,13 @@ BlockBasedTable::GetFilter(bool no_io) const {
       cache_key
   );
 
+  Statistics* statistics = rep_->options.statistics.get();
   auto cache_handle = GetFromBlockCache(
     block_cache,
     key,
     BLOCK_CACHE_FILTER_MISS,
     BLOCK_CACHE_FILTER_HIT,
-    rep_->options.statistics
+    statistics
   );
 
   FilterBlockReader* filter = nullptr;
@@ -824,7 +825,7 @@ BlockBasedTable::GetFilter(bool no_io) const {
 
         cache_handle = block_cache->Insert(
           key, filter, filter_size, &DeleteCachedFilter);
-        RecordTick(rep_->options.statistics, BLOCK_CACHE_ADD);
+        RecordTick(statistics, BLOCK_CACHE_ADD);
       }
     }
   }
@@ -945,9 +946,10 @@ bool BlockBasedTable::PrefixMayMatch(const Slice& internal_prefix) {
     filter_entry.Release(rep_->options.block_cache.get());
   }
 
-  RecordTick(rep_->options.statistics, BLOOM_FILTER_PREFIX_CHECKED);
+  Statistics* statistics = rep_->options.statistics.get();
+  RecordTick(statistics, BLOOM_FILTER_PREFIX_CHECKED);
   if (!may_match) {
-    RecordTick(rep_->options.statistics, BLOOM_FILTER_PREFIX_USEFUL);
+    RecordTick(statistics, BLOOM_FILTER_PREFIX_USEFUL);
   }
 
   return may_match;
@@ -997,7 +999,7 @@ Status BlockBasedTable::Get(
       // Not found
       // TODO: think about interaction with Merge. If a user key cannot
       // cross one data block, we should be fine.
-      RecordTick(rep_->options.statistics, BLOOM_FILTER_USEFUL);
+      RecordTick(rep_->options.statistics.get(), BLOOM_FILTER_USEFUL);
       break;
     } else {
       bool didIO = false;

diff --git a/util/statistics_imp.h b/util/statistics_imp.h
@@ -0,0 +1,32 @@
+//  Copyright (c) 2013, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under the BSD-style license found in the
+//  LICENSE file in the root directory of this source tree. An additional grant
+//  of patent rights can be found in the PATENTS file in the same directory.
+//
+#pragma once
+#include "rocksdb/statistics.h"
+
+namespace rocksdb {
+
+// Utility functions
+inline void RecordTick(Statistics* statistics,
+                       Tickers ticker,
+                       uint64_t count = 1) {
+  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
+  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
+  if (statistics) {
+    statistics->recordTick(ticker, count);
+  }
+}
+
+inline void SetTickerCount(Statistics* statistics,
+                           Tickers ticker,
+                           uint64_t count) {
+  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
+  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
+  if (statistics) {
+    statistics->setTickerCount(ticker, count);
+  }
+}
+
+}
diff --git a/util/stop_watch.h b/util/stop_watch.h
@@ -5,16 +5,16 @@
 //
 #pragma once
 #include "rocksdb/env.h"
-#include "rocksdb/statistics.h"
+#include "util/statistics_imp.h"
 
 namespace rocksdb {
 // Auto-scoped.
 // Records the statistic into the corresponding histogram.
 class StopWatch {
  public:
-  StopWatch(
+  explicit StopWatch(
     Env * const env,
-    std::shared_ptr<Statistics> statistics = nullptr,
+    Statistics* statistics = nullptr,
     const Histograms histogram_name = DB_GET) :
       env_(env),
       start_time_(env->NowMicros()),
@@ -36,15 +36,15 @@ class StopWatch {
  private:
   Env* const env_;
   const uint64_t start_time_;
-  std::shared_ptr<Statistics> statistics_;
+  Statistics* statistics_;
   const Histograms histogram_name_;
 
 };
 
 // a nano second precision stopwatch
 class StopWatchNano {
  public:
-  StopWatchNano(Env* const env, bool auto_start = false)
+  explicit StopWatchNano(Env* const env, bool auto_start = false)
       : env_(env), start_(0) {
     if (auto_start) {
       Start();