[memory-infra] Implement peak detection logic

base/trace_event/memory_dump_scheduler.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/trace_event/memory_dump_scheduler.h"
 
+#include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "build/build_config.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 // Threshold on increase in memory from last dump beyond which a new dump must
 // be triggered.
-int64_t kMemoryIncreaseThreshold = 50 * 1024 * 1024;  // 50MiB
+int64_t kDefaultMemoryIncreaseThreshold = 50 * 1024 * 1024;  // 50MiB
 const uint32_t kMemoryTotalsPollingInterval = 25;
 uint32_t g_polling_interval_ms_for_testing = 0;
 }  // namespace
 
 MemoryDumpScheduler::MemoryDumpScheduler(
     MemoryDumpManager* mdm,
     scoped_refptr<SingleThreadTaskRunner> polling_task_runner)
-    : mdm_(mdm), polling_state_(polling_task_runner) {}
+    : mdm_(mdm), polling_state_(polling_task_runner) {
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || \

[Primiano Tucci (use gerrit), 2017/03/10 10:19:33]

if it's not a problem can you move this into NotifyPollingSupported() behind a
if(!memory_increase_threshold) ?
GetSystemMemoryinfo might involve some syscall and IIRC the MDS can be
constructed during early startup.
Since we don't really need (I think) the threshold until later, would be nice to
avoid to add a syscall to the browser startup if we don't really need it.

[ssid, 2017/03/10 19:49:01]

Agreed.

+    defined(OS_ANDROID)
+  // Set threshold to 1% of total system memory.
+  SystemMemoryInfoKB meminfo;
+  bool res = GetSystemMemoryInfo(&meminfo);
+  if (res)
+    polling_state_.memory_increase_threshold = (meminfo.total / 100) * 1024;
+#endif
+}
 
 MemoryDumpScheduler::~MemoryDumpScheduler() {}
 
 void MemoryDumpScheduler::AddTrigger(MemoryDumpType trigger_type,
                                      MemoryDumpLevelOfDetail level_of_detail,
                                      uint32_t min_time_between_dumps_ms) {
   if (trigger_type == MemoryDumpType::PEAK_MEMORY_USAGE) {
     DCHECK(!periodic_state_.is_configured);
     DCHECK(!polling_state_.is_configured);
     DCHECK_NE(0u, min_time_between_dumps_ms);
@@ skipping 41 matching lines @@
   periodic_state_.timer.Start(
       FROM_HERE,
       TimeDelta::FromMilliseconds(periodic_state_.min_timer_period_ms),
       Bind(&MemoryDumpScheduler::RequestPeriodicGlobalDump, Unretained(this)));
 }
 
 void MemoryDumpScheduler::NotifyPollingSupported() {
   if (!polling_state_.is_configured || polling_state_.is_polling_enabled)
     return;
   polling_state_.is_polling_enabled = true;
+  for (uint32_t i = 0;
+       i < PollingTriggerState::kNumTotalsTrackedForPeakDetection; ++i) {
+    polling_state_.last_memory_totals_kb[i] = 0;
+  }
+  polling_state_.last_memory_totals_kb_index = 0;
   polling_state_.num_polls_from_last_dump = 0;
   polling_state_.last_dump_memory_total = 0;
   polling_state_.polling_task_runner->PostTask(
       FROM_HERE,
       Bind(&MemoryDumpScheduler::PollMemoryOnPollingThread, Unretained(this)));
 }
 
 void MemoryDumpScheduler::DisableAllTriggers() {
   if (periodic_state_.timer.IsRunning())
     periodic_state_.timer.Stop();
@@ skipping 75 matching lines @@
   if (polling_state_.last_dump_memory_total == 0) {
     // If it's first sample then trigger memory dump.
     should_dump = true;
   } else if (polling_state_.min_polls_between_dumps >
              polling_state_.num_polls_from_last_dump) {
     return false;
   }
 
   int64_t increase_from_last_dump =
       current_memory_total - polling_state_.last_dump_memory_total;
-  should_dump |= increase_from_last_dump > kMemoryIncreaseThreshold;
+  should_dump |=
+      increase_from_last_dump > polling_state_.memory_increase_threshold;
+  should_dump |= IsCurrentSamplePeak(current_memory_total);
   if (should_dump) {
     polling_state_.last_dump_memory_total = current_memory_total;
     polling_state_.num_polls_from_last_dump = 0;
+    for (uint32_t i = 0;
+         i < PollingTriggerState::kNumTotalsTrackedForPeakDetection; ++i) {

[Primiano Tucci (use gerrit), 2017/03/10 10:19:34]

maybe if you call this kNumPeakSamples those if-s will become shorter.
(I guess this is my naming paranoia that is slowly inducing you into pick longer
name, sorry, I always complain :P) 

[ssid, 2017/03/10 19:49:01]

Done.

+      polling_state_.last_memory_totals_kb[i] = 0;
+    }
+    polling_state_.last_memory_totals_kb_index = 0;
   }
   return should_dump;
 }
 
+bool MemoryDumpScheduler::IsCurrentSamplePeak(
+    uint64_t current_memory_total_bytes) {
+  uint64_t current_memory_total_kb = current_memory_total_bytes / 1024;
+  polling_state_.last_memory_totals_kb_index =
+      (polling_state_.last_memory_totals_kb_index + 1) %
+      PollingTriggerState::kNumTotalsTrackedForPeakDetection;
+  uint64_t mean = 0;
+  for (uint32_t i = 0;
+       i < PollingTriggerState::kNumTotalsTrackedForPeakDetection; ++i) {
+    if (polling_state_.last_memory_totals_kb[i] == 0) {
+      // Not enough samples to detect peaks.
+      polling_state_
+          .last_memory_totals_kb[polling_state_.last_memory_totals_kb_index] =
+          current_memory_total_kb;

[Primiano Tucci (use gerrit), 2017/03/10 10:19:33]

you are storing this anyways, in this if and below.
Shouldn't you just move this up before the for loop?

[ssid, 2017/03/10 19:49:01]

I am trying to compute the mean and stddev without the current sample. So, doing
it before inserting new element. Do not want to complicate code with N+1 array
and not include "index" element.
Also, early return looked better here.

+      return false;
+    }
+    mean += polling_state_.last_memory_totals_kb[i];
+  }
+  mean = mean / PollingTriggerState::kNumTotalsTrackedForPeakDetection;
+  uint64_t variance = 0;
+  for (uint32_t i = 0;
+       i < PollingTriggerState::kNumTotalsTrackedForPeakDetection; ++i) {
+    variance += (polling_state_.last_memory_totals_kb[i] - mean) *
+                (polling_state_.last_memory_totals_kb[i] - mean);
+  }
+  variance = variance / PollingTriggerState::kNumTotalsTrackedForPeakDetection;
+
+  polling_state_
+      .last_memory_totals_kb[polling_state_.last_memory_totals_kb_index] =
+      current_memory_total_kb;
+
+  // If stddev is less than 0.2% then we consider that the process is inactive.
+  bool is_stddev_low = variance < mean / 500 * mean / 500;
+  if (is_stddev_low)
+    return false;
+
+  // (mean + 3.69 * stddev) corresponds to a value that is higher than current
+  // sample with 99.99% probability.
+  return (current_memory_total_kb - mean) * (current_memory_total_kb - mean) >
+         (3.69 * 3.69 * variance);
+}
+
 MemoryDumpScheduler::PeriodicTriggerState::PeriodicTriggerState()
     : is_configured(false),
       dump_count(0),
       min_timer_period_ms(std::numeric_limits<uint32_t>::max()),
       light_dumps_rate(0),
       heavy_dumps_rate(0),
       light_dump_period_ms(0),
       heavy_dump_period_ms(0) {}
 
 MemoryDumpScheduler::PeriodicTriggerState::~PeriodicTriggerState() {
   DCHECK(!timer.IsRunning());
 }
 
 MemoryDumpScheduler::PollingTriggerState::PollingTriggerState(
     scoped_refptr<SingleThreadTaskRunner> polling_task_runner)
     : is_configured(false),
       is_polling_enabled(false),
       level_of_detail(MemoryDumpLevelOfDetail::FIRST),
       polling_task_runner(polling_task_runner),
       polling_interval_ms(g_polling_interval_ms_for_testing
                               ? g_polling_interval_ms_for_testing
                               : kMemoryTotalsPollingInterval),
       min_polls_between_dumps(0),
       num_polls_from_last_dump(0),
-      last_dump_memory_total(0) {}
+      last_dump_memory_total(0),
+      memory_increase_threshold(kDefaultMemoryIncreaseThreshold),
+      last_memory_totals_kb_index(0) {}
 
 MemoryDumpScheduler::PollingTriggerState::~PollingTriggerState() {
   DCHECK(!polling_task_runner);
 }
 
 }  // namespace trace_event
 }  // namespace base