[memory-infra] Add support for polling memory totals in MemoryDumpManager

base/trace_event/memory_dump_manager.cc

 // Copyright 2015 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_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/allocator/features.h"
@@ skipping 266 matching lines @@
       new MemoryDumpProviderInfo(mdp, name, std::move(task_runner), options,
                                  whitelisted_for_background_mode);
 
   {
     AutoLock lock(lock_);
     bool already_registered = !dump_providers_.insert(mdpinfo).second;
     // This actually happens in some tests which don't have a clean tear-down
     // path for RenderThreadImpl::Init().
     if (already_registered)
       return;
+
+    // The list of polling MDPs is populated OnTraceLogEnabled(). This code
+    // deals with the case of a MDP capable of fast polling that is registered
+    // after the OnTraceLogEnabled()
+    if (options.is_fast_polling_supported && dump_thread_ && session_state_ &&
+        session_state_->is_polling_enabled()) {
+      dump_thread_->task_runner()->PostTask(
+          FROM_HERE, Bind(&MemoryDumpManager::RegisterPollingMDPOnDumpThread,
+                          Unretained(this), mdpinfo));
+    }
   }
 
   if (heap_profiling_enabled_)
     mdp->OnHeapProfilingEnabled(true);
 }
 
 void MemoryDumpManager::UnregisterDumpProvider(MemoryDumpProvider* mdp) {
   UnregisterDumpProviderInternal(mdp, false /* delete_async */);
 }
 
@@ skipping 18 matching lines @@
   }
 
   if (mdp_iter == dump_providers_.end())
     return;  // Not registered / already unregistered.
 
   if (take_mdp_ownership_and_delete_async) {
     // The MDP will be deleted whenever the MDPInfo struct will, that is either:
     // - At the end of this function, if no dump is in progress.
     // - Either in SetupNextMemoryDump() or InvokeOnMemoryDump() when MDPInfo is
     //   removed from |pending_dump_providers|.
+    // - When the provider is removed from |dumps_providers_for_polling_|.
     DCHECK(!(*mdp_iter)->owned_dump_provider);
     (*mdp_iter)->owned_dump_provider = std::move(owned_mdp);
   } else if (subtle::NoBarrier_Load(&memory_tracing_enabled_)) {
     // If you hit this DCHECK, your dump provider has a bug.
     // Unregistration of a MemoryDumpProvider is safe only if:
     // - The MDP has specified a sequenced task runner affinity AND the
     //   unregistration happens on the same task runner. So that the MDP cannot
     //   unregister and be in the middle of a OnMemoryDump() at the same time.
     // - The MDP has NOT specified a task runner affinity and its ownership is
     //   transferred via UnregisterAndDeleteDumpProviderSoon().
     // In all the other cases, it is not possible to guarantee that the
     // unregistration will not race with OnMemoryDump() calls.
     DCHECK((*mdp_iter)->task_runner &&
            (*mdp_iter)->task_runner->RunsTasksOnCurrentThread())
         << "MemoryDumpProvider \"" << (*mdp_iter)->name << "\" attempted to "
         << "unregister itself in a racy way. Please file a crbug.";
   }
 
+  if ((*mdp_iter)->options.is_fast_polling_supported && dump_thread_ &&
+      session_state_ && session_state_->is_polling_enabled()) {
+    DCHECK(take_mdp_ownership_and_delete_async)
+        << "MemoryDumpProviders capable of fast polling must NOT be thread "
+           "bound and hence destroyed using "

[Primiano Tucci (use gerrit), 2016/12/16 12:34:40]

+"must be" before destroyed. Otherwise is not clear where the "destroyed" part
refers to "must NOT".

[ssid, 2016/12/16 18:58:22]

Done.

+           "UnregisterAndDeleteDumpProviderSoon()";
+    dump_thread_->task_runner()->PostTask(
+        FROM_HERE, Bind(&MemoryDumpManager::UnregisterPollingMDPOnDumpThread,
+                        Unretained(this), *mdp_iter));
+  }
+
   // The MDPInfo instance can still be referenced by the
   // |ProcessMemoryDumpAsyncState.pending_dump_providers|. For this reason
   // the MDPInfo is flagged as disabled. It will cause InvokeOnMemoryDump()
   // to just skip it, without actually invoking the |mdp|, which might be
   // destroyed by the caller soon after this method returns.
   (*mdp_iter)->disabled = true;
   dump_providers_.erase(mdp_iter);
 }
 
+void MemoryDumpManager::RegisterPollingMDPOnDumpThread(
+    scoped_refptr<MemoryDumpManager::MemoryDumpProviderInfo> mdpinfo) {
+  DCHECK(!mdpinfo->task_runner);
+  mdpinfo->dump_provider->SetFastMemoryPollingEnabled(true);
+
+  AutoLock lock(lock_);
+  dumps_providers_for_polling_.insert(mdpinfo);
+}
+
+void MemoryDumpManager::UnregisterPollingMDPOnDumpThread(
+    scoped_refptr<MemoryDumpManager::MemoryDumpProviderInfo> mdpinfo) {
+  mdpinfo->dump_provider->SetFastMemoryPollingEnabled(false);
+
+  AutoLock lock(lock_);
+  dumps_providers_for_polling_.erase(mdpinfo);
+}
+
 void MemoryDumpManager::RequestGlobalDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
     const MemoryDumpCallback& callback) {
   // Bail out immediately if tracing is not enabled at all or if the dump mode
   // is not allowed.
   if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_)) ||
       !IsDumpModeAllowed(level_of_detail)) {
     VLOG(1) << kLogPrefix << " failed because " << kTraceCategory
             << " tracing category is not enabled or the requested dump mode is "
@@ skipping 233 matching lines @@
                                                                   args);
     bool dump_successful = mdpinfo->dump_provider->OnMemoryDump(args, pmd);
     mdpinfo->consecutive_failures =
         dump_successful ? 0 : mdpinfo->consecutive_failures + 1;
   }
 
   pmd_async_state->pending_dump_providers.pop_back();
   SetupNextMemoryDump(std::move(pmd_async_state));
 }
 
+void MemoryDumpManager::PollFastMemoryTotal(uint64_t* memory_total) {
+  *memory_total = 0;
+  // Note that we call PollFastMemoryTotal even if the dump provider is disabled
+  // (unregistered). This is to avoid taking lock slowing this method.
+  for (const auto& mdpinfo : dumps_providers_for_polling_) {
+    uint64_t value = 0;
+    mdpinfo->dump_provider->PollFastMemoryTotal(&value);
+    *memory_total += value;
+  }
+  return;
+}
+
 // static
 void MemoryDumpManager::FinalizeDumpAndAddToTrace(
     std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
   HEAP_PROFILER_SCOPED_IGNORE;
   DCHECK(pmd_async_state->pending_dump_providers.empty());
   const uint64_t dump_guid = pmd_async_state->req_args.dump_guid;
   if (!pmd_async_state->callback_task_runner->BelongsToCurrentThread()) {
     scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
         pmd_async_state->callback_task_runner;
     callback_task_runner->PostTask(
@@ skipping 93 matching lines @@
 
   {
     AutoLock lock(lock_);
 
     DCHECK(delegate_);  // At this point we must have a delegate.
     session_state_ = session_state;
 
     DCHECK(!dump_thread_);
     dump_thread_ = std::move(dump_thread);
 
+    dumps_providers_for_polling_.clear();
+    if (session_state_->is_polling_enabled()) {
+      for (const auto& mdpinfo : dump_providers_) {
+        if (mdpinfo->options.is_fast_polling_supported) {
+          dumps_providers_for_polling_.insert(mdpinfo);
+          mdpinfo->dump_provider->SetFastMemoryPollingEnabled(true);
+        }
+      }
+    }
+
     subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 
     // TODO(primiano): This is a temporary hack to disable periodic memory dumps
     // when running memory benchmarks until telemetry uses TraceConfig to
     // enable/disable periodic dumps. See crbug.com/529184 .
     if (!is_coordinator_ ||
         CommandLine::ForCurrentProcess()->HasSwitch(
             "enable-memory-benchmarking")) {
       return;
     }
   }
 
   // Enable periodic dumps if necessary.
   periodic_dump_timer_.Start(trace_config.memory_dump_config().triggers);
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   // There might be a memory dump in progress while this happens. Therefore,
   // ensure that the MDM state which depends on the tracing enabled / disabled
   // state is always accessed by the dumping methods holding the |lock_|.
+  if (!subtle::NoBarrier_Load(&memory_tracing_enabled_))

[Primiano Tucci (use gerrit), 2016/12/16 12:34:40]

why is this required?

[ssid, 2016/12/16 18:58:22]

Not really required, just an optimization to return faster.
In case tracing is enabled without "memory-infra", we will still be holding 2
locks and checking if out members are set. This can just be avoided if we never
enabled memory-infra.
Added this now because extra lock is added.

[Primiano Tucci (use gerrit), 2016/12/16 20:29:10]

Ahh I see the point now, right . Good point. 

+    return;
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
+
   std::unique_ptr<Thread> dump_thread;
   {
     AutoLock lock(lock_);
     dump_thread = std::move(dump_thread_);
-    session_state_ = nullptr;
   }
 
   // Thread stops are blocking and must be performed outside of the |lock_|
   // or will deadlock (e.g., if SetupNextMemoryDump() tries to acquire it).
   periodic_dump_timer_.Stop();
   if (dump_thread)
     dump_thread->Stop();
+
+  // |dumps_providers_for_polling_| must be cleared only after the dump thread
+  // is stopped (polling tasks are done).
+  {
+    AutoLock lock(lock_);
+    if (session_state_ && session_state_->is_polling_enabled()) {
+      for (const auto& mdpinfo : dumps_providers_for_polling_)
+        mdpinfo->dump_provider->SetFastMemoryPollingEnabled(false);
+      dumps_providers_for_polling_.clear();
+    }
+    session_state_ = nullptr;

[Primiano Tucci (use gerrit), 2016/12/16 12:34:40]

let's put this back in place (see my comment on lazy polling and avoiding
setEnabled)

[ssid, 2016/12/16 18:58:22]

Done.

+  }
 }
 
 bool MemoryDumpManager::IsDumpModeAllowed(MemoryDumpLevelOfDetail dump_mode) {
   AutoLock lock(lock_);
   if (!session_state_)
     return false;
   return session_state_->memory_dump_config().allowed_dump_modes.count(
              dump_mode) != 0;
 }
 
@@ skipping 130 matching lines @@
   if (heavy_dump_rate_ > 0 && periodic_dumps_count_ % heavy_dump_rate_ == 0)
     level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
   ++periodic_dumps_count_;
 
   MemoryDumpManager::GetInstance()->RequestGlobalDump(
       MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 }  // namespace trace_event
 }  // namespace base