memory-infra: Add peak-detector skeleton.

base/trace_event/memory_peak_detector.cc

Index: base/trace_event/memory_peak_detector.cc
diff --git a/base/trace_event/memory_peak_detector.cc b/base/trace_event/memory_peak_detector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f9fb49a4faae93a00ea42dc005d4677b6cbc57d8
--- /dev/null
+++ b/base/trace_event/memory_peak_detector.cc
@@ -0,0 +1,156 @@
+// 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_peak_detector.h"
+
+#include <stdint.h>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/time/time.h"
+#include "base/trace_event/memory_dump_provider_info.h"
+
+namespace {
+const uint32_t kInitialPollingIntervalMs = 1;
+}  // namespace
+
+namespace base {
+namespace trace_event {
+
+// static
+MemoryPeakDetector* MemoryPeakDetector::GetInstance() {
+  static MemoryPeakDetector* instance = new MemoryPeakDetector();
+  return instance;
+}
+
+MemoryPeakDetector::MemoryPeakDetector()
+    : state_(NOT_INITIALIZED), polling_interval_ms_(0), poll_tasks_count_(0) {}
+
+MemoryPeakDetector::~MemoryPeakDetector() {
+  // This should be hit only in tests. In that case the test should call
+  // TearDownForTesting() first.
+  DCHECK_EQ(NOT_INITIALIZED, state_);
+}
+
+void MemoryPeakDetector::Initialize(
+    const GetDumpProvidersFunction& get_dump_providers_function,
+    const scoped_refptr<SequencedTaskRunner>& task_runner,
+    const OnPeakDetectedCallback& on_peak_detected_callback) {
+  DCHECK(!get_dump_providers_function.is_null());
+  DCHECK(!on_peak_detected_callback.is_null());
+  DCHECK(state_ == NOT_INITIALIZED || state_ == DISABLED);
+  DCHECK(dump_providers_.empty());

[ssid, 2017/04/03 17:55:27]

DCHECK(task_runner)?

[Primiano Tucci (use gerrit), 2017/04/03 20:28:15]

Done.

+  get_dump_providers_function_ = get_dump_providers_function;
+  task_runner_ = task_runner;
+  on_peak_detected_callback_ = on_peak_detected_callback;
+  state_ = DISABLED;
+}
+
+void MemoryPeakDetector::TearDownForTesting() {
+  get_dump_providers_function_.Reset();
+  task_runner_ = nullptr;
+  on_peak_detected_callback_.Reset();
+  dump_providers_.clear();
+  state_ = NOT_INITIALIZED;
+  poll_tasks_count_ = 0;
+}
+
+void MemoryPeakDetector::Start() {
+  task_runner_->PostTask(
+      FROM_HERE, Bind(&MemoryPeakDetector::StartInternal, Unretained(this)));
+}
+
+void MemoryPeakDetector::StartInternal() {
+  DCHECK_EQ(DISABLED, state_);
+  state_ = ENABLED;
+  polling_interval_ms_ = kInitialPollingIntervalMs;
+
+  // If there are any dump providers available, NotifyMemoryDumpProvidersChanged
+  // will fetch them and start the polling. Otherwise this will remain in the
+  // ENABLED state and the actual polling will start on the next call to
+  // ReloadDumpProvidersAndStartPollingIfNeeded().
+  // Depending on the sandbox model, it is possible that no polling-capable dump
+  // providers will be ever available.
+  ReloadDumpProvidersAndStartPollingIfNeeded();
+}
+
+void MemoryPeakDetector::Stop() {
+  task_runner_->PostTask(
+      FROM_HERE, Bind(&MemoryPeakDetector::StopInternal, Unretained(this)));
+}
+
+void MemoryPeakDetector::StopInternal() {
+  DCHECK_NE(NOT_INITIALIZED, state_);
+  state_ = DISABLED;
+  dump_providers_.clear();
+}
+
+void MemoryPeakDetector::NotifyMemoryDumpProvidersChanged() {
+  // It is possible to call this before the first Initialize() call, in which
+  // case we want to just make this a noop. Start() will fetch the MDP list
+  // anyways later.
+  if (!task_runner_)
+    return;
+  task_runner_->PostTask(
+      FROM_HERE,
+      Bind(&MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded,
+           Unretained(this)));
+}
+
+void MemoryPeakDetector::ReloadDumpProvidersAndStartPollingIfNeeded() {

[hjd, 2017/04/03 13:25:30]

I think the following sequence or one like it can put us into a state where we
have multiple timers firing.
Basically if everything is running as normal and we call
NotifyMemoryDumpProvidersChanged() when we have no mdps then in theory the next
time PollMemoryAndDetectPeak is called we will not schedule a new
PollMemoryAndDetectPeak however if we quickly call
NotifyMemoryDumpProvidersChanged() again and this time we have some mdps we'll
never stop the original PollMemoryAndDetectPeak timer thing and we'll call
PollMemoryAndDetectPeak again to start a new timer.

t{1,2} = thread {1,2}

t2: PollMemoryAndDetectPeak()
t2: -> PostDelayedTask(PollMemoryAndDetectPeak) # Delayed task A

t1: NotifyMemoryDumpProvidersChanged()
t1: -> PostTask(ReloadDumpProvidersAndStartPollingIfNeeded)
t2: ReloadDumpProvidersAndStartPollingIfNeeded()
t2: -> get_dump_providers_function_ => [] # No mdps
t2: -> state_ = ENABLED

t1: NotifyMemoryDumpProvidersChanged()
t1: -> PostTask(ReloadDumpProvidersAndStartPollingIfNeeded)
t2: ReloadDumpProvidersAndStartPollingIfNeeded()
t2: -> get_dump_providers_function_ => [mdp] # Some mdps
t2: -> state_ = RUNNING
t2: -> PostTask(PollMemoryAndDetectPeak)
t2: PollMemoryAndDetectPeak()
t2: -> PostDelayedTask(PollMemoryAndDetectPeak) # Delayed task B

t2: PollMemoryAndDetectPeak() # Delayed task A fires and schedules a new task
t2: PollMemoryAndDetectPeak() # Delayed task B fires and schedules a new task

[ssid, 2017/04/03 17:55:27]

We will never have the case where we go from having polling mdp to no polling
mdp. There are dchecks to check this. Basically the current process metrics
provider never unregisters.

[Primiano Tucci (use gerrit), 2017/04/03 20:28:15]

Even if we do, this code should be robust enough to tolerate it (in which case
will just go back to the ENABLED) state, stopping the polling. See tests.

[ssid, 2017/04/04 05:08:35]

hm no. What Hector said was right. If we have a case where we lose all polling
dump providers then it is possible that we start polling twice. This is the
reason why I had explicitly disallowed the unregistering all polling providers.

The case here is:
1. Polling started -> delayed task
2. all dump providers are gone- > state changed to disable.
3. dump provider registered again -> state changed to enable and polling started
again.
4. The delayed task posted at the step one did not see the disable and enable
changes and just sees it's enabled again. so continues polling. 

Now we have two sets of polling tasks.
Maybe it's better to just disable polling for the entire tracing session if dump
providers go away. That is:
if (state_ == RUNNING && dump_providers_.empty())
  state_ = DISABLED;

Or a DCHECK(!dump_providers.empty());

[Primiano Tucci (use gerrit), 2017/04/04 09:14:31]

Okay you were both right. There is a corner case I missed here, which can be
simplified as follows:
- Load one MDP in the list.
- Start -> Stop -> Start -> Stop very quickly (before the first poll happen)
Each start will post a new task that will keep posting the chain.
Thankfully this is easier to test (see the new StartStopQuickly test) and easy
to fix (see the generation_ logic)
Nah I think that the generation_ fixes the problem and keeps the logic robust.
Happy to re-iterate on next patchset.

+  DCHECK_NE(NOT_INITIALIZED, state_);
+  if (state_ == DISABLED)
+    return;  // Start() will re-fetch the MDP list later.
+
+  DCHECK((state_ == RUNNING && !dump_providers_.empty()) ||
+         (state_ == ENABLED && dump_providers_.empty()));
+
+  dump_providers_.clear();
+
+  // This is really MemoryDumpManager::GetDumpProvidersForPolling, % testing.
+  get_dump_providers_function_.Run(&dump_providers_);
+
+  if (state_ == ENABLED && !dump_providers_.empty()) {
+    // It's now time to start polling for realz.
+    state_ = RUNNING;
+    task_runner_->PostTask(
+        FROM_HERE,
+        Bind(&MemoryPeakDetector::PollMemoryAndDetectPeak, Unretained(this)));
+  } else if (state_ == RUNNING && dump_providers_.empty()) {
+    // Will cause the next PollMemoryAndDetectPeak() task to early return.
+    state_ = ENABLED;
+  }
+}
+
+void MemoryPeakDetector::PollMemoryAndDetectPeak() {
+  if (state_ != RUNNING)
+    return;
+
+  // We should never end up in a situation where state_ == RUNNING but all dump
+  // providers are gone.
+  DCHECK(!dump_providers_.empty());
+
+  poll_tasks_count_++;
+  uint64_t memory_total = 0;
+  for (const scoped_refptr<MemoryDumpProviderInfo>& mdp_info :
+       dump_providers_) {
+    DCHECK(mdp_info->options.is_fast_polling_supported);
+    uint64_t value = 0;
+    mdp_info->dump_provider->PollFastMemoryTotal(&value);
+    memory_total += value;
+  }
+  ignore_result(memory_total);  // TODO(primiano): temporary until next CL.
+
+  // TODO(primiano): Move actual peak detection logic from the
+  // MemoryDumpScheduler in next CLs.
+
+  SequencedTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      Bind(&MemoryPeakDetector::PollMemoryAndDetectPeak, Unretained(this)),
+      TimeDelta::FromMilliseconds(polling_interval_ms_));
+}
+
+}  // namespace trace_event
+}  // namespace base