[inspector] collect old async stack traces 20% faster

src/inspector/v8-debugger.cc

 // Copyright 2016 the V8 project 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 "src/inspector/v8-debugger.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
@@ skipping 115 matching lines @@
                          func->GetScriptColumnNumber());
   }
   v8::Local<v8::debug::Script> script;
   if (!generatorObject->Script().ToLocal(&script))
     return v8::MaybeLocal<v8::Object>();
   v8::debug::Location suspendedLocation = generatorObject->SuspendedLocation();
   return buildLocation(context, script->Id(), suspendedLocation.GetLineNumber(),
                        suspendedLocation.GetColumnNumber());
 }
 
+template <typename Map>
+void cleanupExpiredWeakPointers(Map& map) {
+  for (auto it = map.begin(); it != map.end();) {
+    if (it->second.expired()) {
+      it = map.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace
 
 static bool inLiveEditScope = false;
 
 v8::MaybeLocal<v8::Value> V8Debugger::callDebuggerMethod(
     const char* functionName, int argc, v8::Local<v8::Value> argv[],
     bool catchExceptions) {
   v8::MicrotasksScope microtasks(m_isolate,
                                  v8::MicrotasksScope::kDoNotRunMicrotasks);
   DCHECK(m_isolate->InContext());
@@ skipping 864 matching lines @@
 }
 
 void V8Debugger::collectOldAsyncStacksIfNeeded() {
   if (m_asyncStacksCount <= m_maxAsyncCallStacks) return;
   int halfOfLimitRoundedUp =
       m_maxAsyncCallStacks / 2 + m_maxAsyncCallStacks % 2;
   while (m_asyncStacksCount > halfOfLimitRoundedUp) {
     m_allAsyncStacks.pop_front();
     --m_asyncStacksCount;
   }
-  removeOldAsyncTasks(m_asyncTaskStacks);
-  removeOldAsyncTasks(m_asyncTaskCreationStacks);
-  protocol::HashSet<void*> recurringLeft;
-  for (auto task : m_recurringTasks) {
-    if (m_asyncTaskStacks.find(task) == m_asyncTaskStacks.end()) continue;
-    recurringLeft.insert(task);
+  cleanupExpiredWeakPointers(m_asyncTaskStacks);
+  cleanupExpiredWeakPointers(m_asyncTaskCreationStacks);
+  for (auto it = m_recurringTasks.begin(); it != m_recurringTasks.end();) {
+    if (m_asyncTaskStacks.find(*it) == m_asyncTaskStacks.end()) {
+      it = m_recurringTasks.erase(it);
+    } else {
+      ++it;
+    }
   }
-  m_recurringTasks.swap(recurringLeft);
-  protocol::HashMap<void*, void*> parentLeft;
-  for (auto it : m_parentTask) {
-    if (m_asyncTaskCreationStacks.find(it.second) ==
+  for (auto it = m_parentTask.begin(); it != m_parentTask.end();) {
+    if (m_asyncTaskCreationStacks.find(it->second) ==
         m_asyncTaskCreationStacks.end()) {
-      continue;
+      it = m_parentTask.erase(it);
+    } else {
+      ++it;
     }
-    parentLeft.insert(it);
   }
-  m_parentTask.swap(parentLeft);
-  std::map<int, std::weak_ptr<StackFrame>> framesCache;
-  for (auto it : m_framesCache) {
-    if (!it.second.expired()) framesCache.insert(it);
-  }
-  m_framesCache.swap(framesCache);
-}
-
-void V8Debugger::removeOldAsyncTasks(AsyncTaskToStackTrace& map) {
-  AsyncTaskToStackTrace cleanCopy;
-  for (auto it : map) {
-    if (!it.second.expired()) cleanCopy.insert(it);
-  }
-  map.swap(cleanCopy);
+  cleanupExpiredWeakPointers(m_framesCache);
 }
 
 std::shared_ptr<StackFrame> V8Debugger::symbolize(
     v8::Local<v8::StackFrame> v8Frame) {
   auto it = m_framesCache.end();
   int frameId = 0;
   if (m_maxAsyncCallStackDepth) {
     frameId = v8::debug::GetStackFrameId(v8Frame);
     it = m_framesCache.find(frameId);
   }
@@ skipping 18 matching lines @@
   fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
   fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
   fprintf(stdout, "Created async tasks: %zu\n",
           m_asyncTaskCreationStacks.size());
   fprintf(stdout, "Async tasks with parent: %zu\n", m_parentTask.size());
   fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
   fprintf(stdout, "\n");
 }
 
 }  // namespace v8_inspector