Revert of [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 kHeavyDumpsRate = 8;  // 250 ms * 8 = 2000 ms.
+const int kHeavyMmapsDumpsRate = 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() {
-  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)
+  MemoryDumpType dump_type = g_periodic_dumps_count == 0
+                                 ? MemoryDumpType::PERIODIC_INTERVAL_WITH_MMAPS
+                                 : MemoryDumpType::PERIODIC_INTERVAL;
+  if (++g_periodic_dumps_count == kHeavyMmapsDumpsRate)
     g_periodic_dumps_count = 0;
 
-  MemoryDumpArgs dump_args = {dump_level_of_detail};
-  MemoryDumpManager::GetInstance()->RequestGlobalDump(
-      MemoryDumpType::PERIODIC_INTERVAL, dump_args);
+  MemoryDumpManager::GetInstance()->RequestGlobalDump(dump_type);
 }
 
 }  // namespace
 
 // static
 const char* const MemoryDumpManager::kTraceCategoryForTesting = kTraceCategory;
 
 // static
 const int MemoryDumpManager::kMaxConsecutiveFailuresCount = 3;
 
@@ skipping 36 matching lines @@
 
   if (skip_core_dumpers_auto_registration_for_testing_)
     return;
 
   // Enable the core dump providers.
 #if !defined(OS_NACL)
   RegisterDumpProvider(ProcessMemoryTotalsDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
-  RegisterDumpProvider(ProcessMemoryMapsDumpProvider::GetInstance());
+  g_mmaps_dump_provider = ProcessMemoryMapsDumpProvider::GetInstance();
+  RegisterDumpProvider(g_mmaps_dump_provider);
   RegisterDumpProvider(MallocDumpProvider::GetInstance());
   system_allocator_pool_name_ = MallocDumpProvider::kAllocatedObjects;
 #endif
 
 #if defined(OS_ANDROID)
   RegisterDumpProvider(JavaHeapDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_WIN)
   RegisterDumpProvider(WinHeapDumpProvider::GetInstance());
@@ skipping 40 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 MemoryDumpArgs& dump_args,
-                                          const MemoryDumpCallback& callback) {
+void MemoryDumpManager::RequestGlobalDump(
+    MemoryDumpType dump_type,
+    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, dump_args};
+    MemoryDumpRequestArgs args = {guid, dump_type};
     delegate->RequestGlobalMemoryDump(args, callback);
   } else if (!callback.is_null()) {
     callback.Run(guid, false /* success */);
   }
 }
 
-void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type,
-                                          const MemoryDumpArgs& dump_args) {
-  RequestGlobalDump(dump_type, dump_args, MemoryDumpCallback());
+void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type) {
+  RequestGlobalDump(dump_type, 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) {
-    dump_successful = mdp->OnMemoryDump(pmd_async_state->req_args.dump_args,
-                                        &pmd_async_state->process_memory_dump);
+    MemoryDumpArgs dump_args = {MemoryDumpArgs::LEVEL_OF_DETAIL_HIGH};
+    dump_successful =
+        mdp->OnMemoryDump(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