Allow users to profile a query and see bottleneck of the query

Summary:
Provide a framework to profile a query in detail to figure out latency bottleneck. Currently, in Get(), Put() and iterators, 2-3 simple timing is used. We can easily add more profile counters to the framework later.

Test Plan: Enable this profiling in seveal existing tests.

Reviewers: haobo, dhruba, kailiu, emayanke, vamsi, igor

CC: leveldb

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

Conflicts:
	table/merger.cc

table/merger.cc

@@ -11,8 +11,11 @@
 
 #include "rocksdb/comparator.h"
 #include "rocksdb/iterator.h"
+#include "rocksdb/options.h"
 #include "table/iter_heap.h"
 #include "table/iterator_wrapper.h"
+#include "util/stop_watch.h"
+#include "util/perf_context_imp.h"
 
 #include <vector>
 
@@ -22,11 +25,13 @@ namespace {
 
 class MergingIterator : public Iterator {
  public:
-  MergingIterator(const Comparator* comparator, Iterator** children, int n)
+  MergingIterator(Env* const env, const Comparator* comparator,
+                  Iterator** children, int n)
       : comparator_(comparator),
         children_(n),
         current_(nullptr),
         use_heap_(true),
+        env_(env),
         direction_(kForward),
         maxHeap_(NewMaxIterHeap(comparator_)),
         minHeap_ (NewMinIterHeap(comparator_)) {
@@ -74,8 +79,14 @@ class MergingIterator : public Iterator {
     // Invalidate the heap.
     use_heap_ = false;
     IteratorWrapper* first_child = nullptr;
+    StopWatchNano child_seek_timer(env_, false);
+    StopWatchNano min_heap_timer(env_, false);
     for (auto& child : children_) {
+      StartPerfTimer(&child_seek_timer);
       child.Seek(target);
+      BumpPerfTime(&perf_context.seek_child_seek_time, &child_seek_timer);
+      BumpPerfCount(&perf_context.seek_child_seek_count);
+
       if (child.Valid()) {
         // This child has valid key
         if (!use_heap_) {
@@ -86,24 +97,31 @@ class MergingIterator : public Iterator {
           } else {
             // We have more than one children with valid keys. Initialize
             // the heap and put the first child into the heap.
+            StartPerfTimer(&min_heap_timer);
             ClearHeaps();
+            BumpPerfTime(&perf_context.seek_min_heap_time, &child_seek_timer);
+            StartPerfTimer(&min_heap_timer);
             minHeap_.push(first_child);
+            BumpPerfTime(&perf_context.seek_min_heap_time, &child_seek_timer);
           }
         }
         if (use_heap_) {
+          StartPerfTimer(&min_heap_timer);
           minHeap_.push(&child);
+          BumpPerfTime(&perf_context.seek_min_heap_time, &child_seek_timer);
         }
       }
     }
     if (use_heap_) {
       // If heap is valid, need to put the smallest key to curent_.
+      StartPerfTimer(&min_heap_timer);
       FindSmallest();
+      BumpPerfTime(&perf_context.seek_min_heap_time, &child_seek_timer);
     } else {
       // The heap is not valid, then the current_ iterator is the first
       // one, or null if there is no first child.
       current_ = first_child;
     }
-    direction_ = kForward;
   }
 
   virtual void Next() {
@@ -211,6 +229,7 @@ class MergingIterator : public Iterator {
   // contain valid rows. If it is false, only current_ can possibly contain
   // valid rows.
   bool use_heap_;
+  Env* const env_;
   // Which direction is the iterator moving?
   enum Direction {
     kForward,
@@ -250,14 +269,15 @@ void MergingIterator::ClearHeaps() {
 }
 }  // namespace
 
-Iterator* NewMergingIterator(const Comparator* cmp, Iterator** list, int n) {
+Iterator* NewMergingIterator(Env* const env, const Comparator* cmp,
+                             Iterator** list, int n) {
   assert(n >= 0);
   if (n == 0) {
     return NewEmptyIterator();
   } else if (n == 1) {
     return list[0];
   } else {
-    return new MergingIterator(cmp, list, n);
+    return new MergingIterator(env, cmp, list, n);
   }
 }
 

table/merger.h

@@ -13,6 +13,7 @@ namespace rocksdb {
 
 class Comparator;
 class Iterator;
+class Env;
 
 // Return an iterator that provided the union of the data in
 // children[0,n-1].  Takes ownership of the child iterators and
@@ -23,6 +24,6 @@ class Iterator;
 //
 // REQUIRES: n >= 0
 extern Iterator* NewMergingIterator(
-    const Comparator* comparator, Iterator** children, int n);
+    Env* const env, const Comparator* comparator, Iterator** children, int n);
 
 }  // namespace rocksdb