add tcmalloc metrics

Author: kenju

src/yb/tserver/tablet_server.cc

@@ -487,6 +487,8 @@ Status TabletServer::Init() {
 
   RETURN_NOT_OK(DbServerBase::Init());
 
+  MemTracker::InitializeGcMetrics(metric_entity());
+
   RETURN_NOT_OK(path_handlers_->Register(web_server_.get()));
 
   log_prefix_ = Format("P $0: ", permanent_uuid());

src/yb/util/mem_tracker.cc

@@ -119,6 +119,22 @@ DEFINE_RUNTIME_int64(mem_tracker_tcmalloc_gc_release_bytes, -1,
 
 DECLARE_int64(server_tcmalloc_max_total_thread_cache_bytes);
 
+METRIC_DEFINE_counter(server, mem_tracker_gc_tcmalloc_calls,
+                      "MemTracker GC TCMalloc Calls",
+                      yb::MetricUnit::kOperations,
+                      "Number of times MemTracker::GcTcmallocIfNeeded() has been called");
+
+METRIC_DEFINE_counter(server, mem_tracker_gc_tcmalloc_bytes_released,
+                      "MemTracker GC TCMalloc Bytes Released",
+                      yb::MetricUnit::kBytes,
+                      "Total number of bytes released by MemTracker::GcTcmallocIfNeeded()");
+
+METRIC_DEFINE_histogram(server, mem_tracker_gc_tcmalloc_bytes_per_call,
+                        "MemTracker GC TCMalloc Bytes Per Call",
+                        yb::MetricUnit::kBytes,
+                        "Histogram of bytes released per call to MemTracker::GcTcmallocIfNeeded()",
+                        60000000 /* 60MB as max value */, 2 /* 2 digits precision */);
+
 namespace yb {
 
 // NOTE: this class has been adapted from Impala, so the code style varies
@@ -739,6 +755,10 @@ bool MemTracker::GcMemory(int64_t max_consumption) {
 
 void MemTracker::GcTcmallocIfNeeded() {
 #ifdef YB_TCMALLOC_ENABLED
+  if (gc_tcmalloc_calls_metric_) {
+    gc_tcmalloc_calls_metric_->Increment();
+  }
+
   released_memory_since_gc = 0;
   TRACE_EVENT0("process", "MemTracker::GcTcmallocIfNeeded");
 
@@ -748,7 +768,9 @@ void MemTracker::GcTcmallocIfNeeded() {
   // Bytes allocated by the application.
   int64_t bytes_used = GetTCMallocCurrentAllocatedBytes();
 
+  int64_t initial_overhead = bytes_overhead;
   int64_t max_overhead = bytes_used * FLAGS_tcmalloc_max_free_bytes_percentage / 100.0;
+
   if (bytes_overhead > max_overhead) {
     int64_t extra = bytes_overhead - max_overhead;
     while (extra > 0) {
@@ -762,6 +784,19 @@ void MemTracker::GcTcmallocIfNeeded() {
 #endif  // YB_GOOGLE_TCMALLOC
       extra -= 1024 * 1024;
     }
+
+    int64_t final_overhead = GetTCMallocPageHeapFreeBytes();
+    int64_t bytes_released = initial_overhead - final_overhead;
+    if (gc_tcmalloc_bytes_released_metric_ && bytes_released > 0) {
+      gc_tcmalloc_bytes_released_metric_->IncrementBy(bytes_released);
+    }
+    if (gc_tcmalloc_bytes_per_call_metric_ && bytes_released > 0) {
+      gc_tcmalloc_bytes_per_call_metric_->Increment(bytes_released);
+    }
+  } else {
+    if (gc_tcmalloc_bytes_per_call_metric_) {
+      gc_tcmalloc_bytes_per_call_metric_->Increment(0);
+    }
   }
 #endif  // YB_TCMALLOC_ENABLED
 }
@@ -848,6 +883,16 @@ void MemTracker::TEST_SetReleasedMemorySinceGC(int64_t value) {
   released_memory_since_gc = value;
 }
 
+scoped_refptr<Counter> MemTracker::gc_tcmalloc_calls_metric_;
+scoped_refptr<Counter> MemTracker::gc_tcmalloc_bytes_released_metric_;
+scoped_refptr<Histogram> MemTracker::gc_tcmalloc_bytes_per_call_metric_;
+
+void MemTracker::InitializeGcMetrics(const scoped_refptr<MetricEntity>& metric_entity) {
+  gc_tcmalloc_calls_metric_ = METRIC_mem_tracker_gc_tcmalloc_calls.Instantiate(metric_entity);
+  gc_tcmalloc_bytes_released_metric_ = METRIC_mem_tracker_gc_tcmalloc_bytes_released.Instantiate(metric_entity);
+  gc_tcmalloc_bytes_per_call_metric_ = METRIC_mem_tracker_gc_tcmalloc_bytes_per_call.Instantiate(metric_entity);
+}
+
 scoped_refptr<MetricEntity> MemTracker::metric_entity() const {
   return metrics_ ? metrics_->metric_entity_ : nullptr;
 }

src/yb/util/mem_tracker.h

@@ -55,6 +55,8 @@ namespace yb {
 
 class MemTracker;
 class MetricEntity;
+class Counter;
+class Histogram;
 using MemTrackerPtr = std::shared_ptr<MemTracker>;
 
 static const std::string kTCMallocTrackerNamePrefix = "TCMalloc ";
@@ -430,11 +432,17 @@ class MemTracker : public std::enable_shared_from_this<MemTracker> {
   // This is needed in some tests to create deterministic GC behavior.
   static void TEST_SetReleasedMemorySinceGC(int64_t bytes);
 
+  static void InitializeGcMetrics(const scoped_refptr<MetricEntity>& metric_entity);
+
   bool IsRoot() {
     return is_root_tracker_;
   }
 
  private:
+  static scoped_refptr<Counter> gc_tcmalloc_calls_metric_;
+  static scoped_refptr<Counter> gc_tcmalloc_bytes_released_metric_;
+  static scoped_refptr<Histogram> gc_tcmalloc_bytes_per_call_metric_;
+
   template<class GC>
   using GarbageCollectorsContainer = boost::container::small_vector<GC, 8>;
 

src/yb/yql/pggate/pggate.cc

@@ -674,6 +674,8 @@ PgApiImpl::PgApiImpl(
       ybctid_reader_provider_(pg_session_),
       fk_reference_cache_(ybctid_reader_provider_, buffering_settings_, tablespace_map_),
       explicit_row_lock_buffer_(ybctid_reader_provider_, tablespace_map_) {
+  MemTracker::InitializeGcMetrics(metric_entity_);
+
   PgBackendSetupSharedMemory();
   // This is an RCU object, but there are no concurrent updates on PG side, only on tserver, so
   // it's safe to just save the pointer.