[tracing] Throttle rate of heavy dumps and support to request light/heavy dumps

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 "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 25 matching lines @@
 namespace base {
 namespace trace_event {
 
 namespace {
 
 // TODO(primiano): this should be smarter and should do something similar to
 // trace event synthetic delays.
 const char kTraceCategory[] = TRACE_DISABLED_BY_DEFAULT("memory-infra");
 
 // Throttle mmaps at a rate of once every kHeavyMmapsDumpsRate standard dumps.
-const int kHeavyMmapsDumpsRate = 8;  // 250 ms * 8 = 2000 ms.
+const int kHeavyDumpsRate = 8;  // 250 ms * 8 = 2000 ms.
 const int kDumpIntervalMs = 250;
 const int kTraceEventNumArgs = 1;
 const char* kTraceEventArgNames[] = {"dumps"};
 const unsigned char kTraceEventArgTypes[] = {TRACE_VALUE_TYPE_CONVERTABLE};
 
 StaticAtomicSequenceNumber g_next_guid;
 uint32 g_periodic_dumps_count = 0;
 MemoryDumpManager* g_instance_for_testing = nullptr;
 MemoryDumpProvider* g_mmaps_dump_provider = nullptr;
 
 void RequestPeriodicGlobalDump() {
-  MemoryDumpType dump_type = g_periodic_dumps_count == 0
-                                 ? MemoryDumpType::PERIODIC_INTERVAL_WITH_MMAPS
-                                 : MemoryDumpType::PERIODIC_INTERVAL;
-  if (++g_periodic_dumps_count == kHeavyMmapsDumpsRate)
+  MemoryDumpArgs::LevelOfDetail dump_level_of_detail =
+      g_periodic_dumps_count == 0 ? MemoryDumpArgs::LEVEL_OF_DETAIL_HIGH
+                                  : MemoryDumpArgs::LEVEL_OF_DETAIL_LOW;
+  if (++g_periodic_dumps_count == kHeavyDumpsRate)
     g_periodic_dumps_count = 0;
 
-  MemoryDumpManager::GetInstance()->RequestGlobalDump(dump_type);
+  MemoryDumpArgs dump_args = {dump_level_of_detail};
+  MemoryDumpType dump_type = MemoryDumpType::PERIODIC_INTERVAL;

[petrcermak, 2015/08/03 16:15:03]

nit: No need to declare this variable. You could just use the constant directly
on line 67.

[ssid, 2015/08/03 16:24:09]

Done.

+
+  MemoryDumpManager::GetInstance()->RequestGlobalDump(dump_type, dump_args);
 }
 
 }  // namespace
 
 // static
 const char* const MemoryDumpManager::kTraceCategoryForTesting = kTraceCategory;
 
 // static
 const int MemoryDumpManager::kMaxConsecutiveFailuresCount = 3;
 
@@ skipping 98 matching lines @@
   DCHECK_IMPLIES(
       subtle::NoBarrier_Load(&memory_tracing_enabled_),
       mdp_iter->task_runner && mdp_iter->task_runner->BelongsToCurrentThread())
       << "The MemoryDumpProvider attempted to unregister itself in a racy way. "
       << "Please file a crbug.";
 
   dump_providers_.erase(mdp_iter);
   did_unregister_dump_provider_ = true;
 }
 
-void MemoryDumpManager::RequestGlobalDump(
-    MemoryDumpType dump_type,
-    const MemoryDumpCallback& callback) {
+void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type,
+                                          const MemoryDumpArgs& dump_args,
+                                          const MemoryDumpCallback& callback) {
   // Bail out immediately if tracing is not enabled at all.
   if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_))) {
     if (!callback.is_null())
       callback.Run(0u /* guid */, false /* success */);
     return;
   }
 
   const uint64 guid =
       TraceLog::GetInstance()->MangleEventId(g_next_guid.GetNext());
 
   // The delegate_ is supposed to be thread safe, immutable and long lived.
   // No need to keep the lock after we ensure that a delegate has been set.
   MemoryDumpManagerDelegate* delegate;
   {
     AutoLock lock(lock_);
     delegate = delegate_;
   }
 
   if (delegate) {
     // The delegate is in charge to coordinate the request among all the
     // processes and call the CreateLocalDumpPoint on the local process.
-    MemoryDumpRequestArgs args = {guid, dump_type};
+    MemoryDumpRequestArgs args = {guid, dump_type, dump_args};
     delegate->RequestGlobalMemoryDump(args, callback);
   } else if (!callback.is_null()) {
     callback.Run(guid, false /* success */);
   }
 }
 
-void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type) {
-  RequestGlobalDump(dump_type, MemoryDumpCallback());
+void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type,
+                                          const MemoryDumpArgs& dump_args) {
+  RequestGlobalDump(dump_type, dump_args, MemoryDumpCallback());
 }
 
 void MemoryDumpManager::CreateProcessDump(const MemoryDumpRequestArgs& args,
                                           const MemoryDumpCallback& callback) {
   scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state;
   {
     AutoLock lock(lock_);
     did_unregister_dump_provider_ = false;
     pmd_async_state.reset(new ProcessMemoryDumpAsyncState(
         args, dump_providers_.begin(), session_state_, callback));
@@ skipping 40 matching lines @@
     if (did_unregister_dump_provider_) {
       return AbortDumpLocked(pmd_async_state->callback,
                              pmd_async_state->task_runner,
                              pmd_async_state->req_args.dump_guid);
     }
 
     auto* mdp_info = &*pmd_async_state->next_dump_provider;
     mdp = mdp_info->dump_provider;
     if (mdp_info->disabled) {
       skip_dump = true;
-    } else if (mdp == g_mmaps_dump_provider &&
-               pmd_async_state->req_args.dump_type !=
-                   MemoryDumpType::PERIODIC_INTERVAL_WITH_MMAPS &&
-               pmd_async_state->req_args.dump_type !=
-                   MemoryDumpType::EXPLICITLY_TRIGGERED) {
-      // Mmaps dumping is very heavyweight and cannot be performed at the same
-      // rate of other dumps. TODO(primiano): this is a hack and should be
-      // cleaned up as part of crbug.com/499731.
-      skip_dump = true;
     } else if (mdp_info->task_runner &&
                !mdp_info->task_runner->BelongsToCurrentThread()) {
       // It's time to hop onto another thread.
 
       // Copy the callback + arguments just for the unlikley case in which
       // PostTask fails. In such case the Bind helper will destroy the
       // pmd_async_state and we must keep a copy of the fields to notify the
       // abort.
       MemoryDumpCallback callback = pmd_async_state->callback;
       scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
@@ skipping 10 matching lines @@
       // disable the dump provider and abort this dump.
       mdp_info->disabled = true;
       return AbortDumpLocked(callback, callback_task_runner, dump_guid);
     }
   }  // AutoLock(lock_)
 
   // Invoke the dump provider without holding the |lock_|.
   bool finalize = false;
   bool dump_successful = false;
 
-  // TODO(ssid): Change RequestGlobalDump to use MemoryDumpArgs along with
-  // MemoryDumpType to get request for light / heavy dump, and remove this
-  // constant.
   if (!skip_dump) {
-    MemoryDumpArgs dump_args = {MemoryDumpArgs::LEVEL_OF_DETAIL_HIGH};
-    dump_successful =
-        mdp->OnMemoryDump(dump_args, &pmd_async_state->process_memory_dump);
+    dump_successful = mdp->OnMemoryDump(pmd_async_state->req_args.dump_args,
+                                        &pmd_async_state->process_memory_dump);
   }
 
   {
     AutoLock lock(lock_);
     if (did_unregister_dump_provider_) {
       return AbortDumpLocked(pmd_async_state->callback,
                              pmd_async_state->task_runner,
                              pmd_async_state->req_args.dump_guid);
     }
     auto* mdp_info = &*pmd_async_state->next_dump_provider;
@@ skipping 150 matching lines @@
       next_dump_provider(next_dump_provider),
       callback(callback),
       task_runner(MessageLoop::current()->task_runner()) {
 }
 
 MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() {
 }
 
 }  // namespace trace_event
 }  // namespace base