Another optimization to keep down gdb-remote traffic. If we have suspended a thread while

running, don't request the thread status when deciding why we stopped.

llvm-svn: 252355

2 files changed, 25 insertions, 6 deletions

diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp
index a1a91a58c28..629943644db 100644
--- a/lldb/source/Target/Thread.cpp
+++ b/lldb/source/Target/Thread.cpp
@@ -726,14 +726,17 @@ Thread::ShouldResume (StateType resume_state)
     m_discarded_plan_stack.clear();
     m_override_should_notify = eLazyBoolCalculate;
 
-    m_temporary_resume_state = resume_state;
+    StateType prev_resume_state = GetTemporaryResumeState();
+
+    SetTemporaryResumeState(resume_state);
     
     lldb::ThreadSP backing_thread_sp (GetBackingThread ());
     if (backing_thread_sp)
-        backing_thread_sp->m_temporary_resume_state = resume_state;
+        backing_thread_sp->SetTemporaryResumeState(resume_state);
 
-    // Make sure m_stop_info_sp is valid
-    GetPrivateStopInfo();
+    // Make sure m_stop_info_sp is valid.  Don't do this for threads we suspended in the previous run.
+    if (prev_resume_state != eStateSuspended)
+        GetPrivateStopInfo();
     
     // This is a little dubious, but we are trying to limit how often we actually fetch stop info from
     // the target, 'cause that slows down single stepping.  So assume that if we got to the point where
diff --git a/lldb/source/Target/ThreadList.cpp b/lldb/source/Target/ThreadList.cpp
index a342b8ae5f9..c06f7a6ccc4 100644
--- a/lldb/source/Target/ThreadList.cpp
+++ b/lldb/source/Target/ThreadList.cpp
@@ -257,7 +257,20 @@ ThreadList::ShouldStop (Event *event_ptr)
         Mutex::Locker locker(GetMutex());
 
         m_process->UpdateThreadListIfNeeded();
-        threads_copy = m_threads;
+        for (lldb::ThreadSP thread_sp : m_threads)
+        {
+            // This is an optimization...  If we didn't let a thread run in between the previous stop and this
+            // one, we shouldn't have to consult it for ShouldStop.  So just leave it off the list we are going to
+            // inspect.
+            if (thread_sp->GetTemporaryResumeState () != eStateSuspended)
+                threads_copy.push_back(thread_sp);
+        }
+
+        // It is possible the threads we were allowing to run all exited and then maybe the user interrupted
+        // or something, then fall back on looking at all threads:
+
+        if (threads_copy.size() == 0)
+            threads_copy = m_threads;
     }
 
     collection::iterator pos, end = threads_copy.end();
@@ -265,7 +278,10 @@ ThreadList::ShouldStop (Event *event_ptr)
     if (log)
     {
         log->PutCString("");
-        log->Printf ("ThreadList::%s: %" PRIu64 " threads", __FUNCTION__, (uint64_t)m_threads.size());
+        log->Printf ("ThreadList::%s: %" PRIu64 " threads, %" PRIu64 " unsuspended threads",
+                     __FUNCTION__,
+                     (uint64_t)m_threads.size(),
+                     (uint64_t)threads_copy.size());
     }
 
     bool did_anybody_stop_for_a_reason = false;