[NativeProcessLinux] Get rid of the thread state coordinator thread

[labath]

Summary

This change removes the thread state coordinator thread by making all the operations it was
performing synchronous. In order to prevent deadlock, NativeProcessLinux must now always call
m_monitor->DoOperation with the m_threads_mutex released. This is needed because HandleWait
callbacks lock the mutex (which means the monitor thread will block waiting on whoever holds the
lock). If the other thread now requests a monitor operation, it will wait for the monitor thread
do process it, creating a deadlock.

In order to preserve this invariant, I have made several NPL methods into operations, so that
they aquire the lock inside the monitor thread.

[labath]

Fix up TSC unit tests.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

There has to be a better way to do this. Is it not possible to acquire the lock without being an operation?

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

It might be a better idea for these to be actual operation classes, and not a lambda.

[labath]

I guess I should provide some more meta-info about this patch series:

All of the ThreadStateCoordinator patches need to be applied serially. The order is D9227->D9254->D9296->D9321 (basically, just follow increasing revision numbers).
Of these, the most important is the first one, where I remove the thread that was executing the TSC and make processing of all of TSC events synchronous. After this, a lot of the code which deals with the piping of data between threads (and between TSC and NativeProcessLinux) becomes redundant, so in the rest of the patches, I am slowly cleaning things up. These changes should not change the functionality, but at the end of it, I expect to save about 1000 lines of code and get rid of the ThreadStateCoordinator completely.

Oh and the series is not complete yet - I have a couple of changes queued locally and I will be pushing them slowly, and I also intend to make further simplifications. However, I wanted to get early feedback, so that I can simplify rebasing.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

I don't see a way to avoid this (without some employing some radically different design). Basically, here we have two resources here: execution time on the privileged monitor thread and the m_threads_mutex.

a) processing waitpid events happens on the monitor thread, so it acquires the first resource first. Then for successful processing of some (all?) of the events you need to update the thread metadata, so you need to acquire the second resource. This creates a dependency execution_time -> mutex.

b) In resume, we were first acquiring the thread mutex, so we could safely iterate over the threads. Then we wanted to resume the threads, which means we needed some execution time on the privileged thread (second resource). Here, we have the dependency order reversed, which is bound to create a deadlock at some point.

I suspect this was the main reason for the existence of the TSC thread. When TSC was in a separate thread, the dependency cycle was broken, because you were simply queuing the requests for execution time in the TSC, which was then asynchronously executing them when the resource became available. However, this asynchronous execution made the codebase much more complicated, because you needed a lot of code to deal with passing data between threads. Also, because of the asynchronous nature of the execution it was possible to have individual resume request from this big resume operation interleaved with waitpid events of threads stopping. This lead to situations where you were halfway through resuming the threads, but you were already processing stop events for those threads and queuing operations to stop them. I believe this design, where you first resume the threads in a single atomic operation and then deal with the fallout (waitpid events) makes it much clearer what is going on. I think having a couple more "Operations" is a small price to pay for such clarity.

What do you think?

[labath]

Fix null pointer error during destruction

An error would occur if we tried to destroy the Monitor while it was in the middle of processing
a waitpid request. This happened because the processing could result in a Monitor operation being
executed through the now-null m_monitor_up. This is a bad design (we have the same problem with
NativeProcessLinux), and I plan to fix it in the future, but for now I fix it by delaying the
destruction of the Monitor. Instead, I introduce the Terminate method, which stops the monitor
thread when we need it.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

About the operation class comment:
If you think having a separate operation class will make things clearer, I can go ahead and do it. However, I find it makes it easier to read the code if the lambda (which is the actual meat of the function) is in the function declaration. If I have a separate operation class I have to scroll from e.g. ReadRegisterValue to ReadRegOperation to ReadRegOperation::Execute to find the actual implementation.

I guess it's a matter of taste but I eventually wanted get rid of the Operation class altogether and morph the code into something like this:

Error
NPL::Monitor::DoOperation(std::function<Error()> lambda);

Error
NPL::ReadRegisterValue(...)
{

return monitor_up->DoOperation([&] {
  // actual code goes here
});

}

However, I did not want to mess with this in this patch, so I postponed it, and created LambdaOperation as a temporary placeholder. What do you think about that? I can also do the DoOperation modification before this patch if you think it works better...

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3873 ↗

(On Diff #24625)

Please ignore this comment. Phabricator won't let me delete.

2977 ↗

(On Diff #24369)

I believe this design, where you first resume the threads in a single atomic operation and then deal with the fallout (waitpid events) makes it much clearer what is going on

Agreed, but if we could unlocked the thread mutex before using the privileged thread, we have the option of doing that for the moment, until we can come up with a better design.

I find it makes it easier to read the code if the lambda (which is the actual meat of the function) is in the function declaration.

I just feel uneasy about putting large chunks of code in lambdas (at least use explicit capturing). Another thing is that the class name encapsulates important information about its purpose. I would much rather run into a ResumeOperation object than a LambdaOperation object while debugging.

FWIW, this also works:

Error
NPL::Resume(...)
{
    Error error;
    class ResumeOperation : public Operation
    {
        ...
    } op{error};
    m_monitor_up->DoOperation(&op);
    return error;
}

It might be a good idea if we can get some more opinions on this.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

I believe this design, where you first resume the threads in a single atomic operation and then deal with the fallout (waitpid events) makes it much clearer what is going on

Agreed, but if we could unlocked the thread mutex before using the privileged thread, we have the option of doing that for the moment, >until we can come up with a better design.

I don't see how that is possible, without compromising the atomicity of the resume. Even if you unlock the mutex right before the call to the privileged thread, you will still have the possibility of some waitpid event sneaking through and changing the list of threads (stopping, creating new threads, ...) from under you.

I have been contemplating one other solution. What do you think about a design like this:

Error NPL::Resume(...)
{
  m_monitor_op->BeginOperationBlock();
  ...
  m_monitor_op->EndOperationBlock();
  return error;
}

Here, the efect of BeginOperationBlock() would be that it locks the privileged thread into a loop where it just executes operation requests. Any waitpid processing gets deferred until we execute EndOperationBlock(). We could easily have these nest if we needed to and we can make a ScopedOperationLocker (or something) to make sure we don't forget to execute the End operation.

What do you make of that? I think I'm starting to prefer this solution myself....

I find it makes it easier to read the code if the lambda (which is the actual meat of the function) is in the function declaration.

I just feel uneasy about putting large chunks of code in lambdas (at least use explicit capturing). Another thing is that the class name encapsulates important information about its purpose. I would much rather run into a ResumeOperation object than a LambdaOperation object while debugging.

I can add explicit capturing if you like. I agree with the debugging point, but I don't have a good answer for that. But hey, at least the name of the lambda would be something like NPL::Resume::unreadable_mess_of_characters, so you have _some_ chance of figuring it out :)

FWIW, this also works:
...

It works, but it's still too much visual noise for my taste...

It might be a good idea if we can get some more opinions on this.

Feel free to show this to anyone over there. Everyone in london is on holiday.

Guys, are you reading this? Any thoughts?

[labath]

Alternative proposal to prevent monitor thread <-> m_thread_mutex deadlock.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3887 ↗

(On Diff #24692)

I have an idea how to get rid of these as well.

We need to make the process of acquiring m_threads_mutex virtual in the base class. Then we can override this behaviour to acquire monitor lock as well. This should be relatively easy and it should make things future-proof. However, I will leave that for a separate patch.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

I don't see how that is possible, without compromising the atomicity of the resume.

If I understood correctly, ThreadStateCoordinator::RequestThreadResume originally only enqueued the event to executed it asynchronously, so it must have not depended on the thread mutex. I do agree that it would be ideal to make all of these operations atomic, but I think this CL should focus on removing the TSC, and leave the atomic operations update for a later CL. You are right that waitpid events could sneak through in between, but that probability should have already existed before your change so there's no regression.

I have been contemplating one other solution. What do you think about a design like this:

You're still going to do m_monitor_up->DoOperation(&op) (or a lambda instead of op) eventually and there's no way around it. So this seems like an added layer of complexity with not much benefit.

We should use either only Operation classes (no lambdas), or only lambdas (no Operation classes). Which to use eventually is up to debate, but currently everything is done with Operation classes, so we should stick with that for now (since the focus right now is removing TSC).

A more "correct" solution seems to be to refactor the code so that the locking of the thread mutex always happens within the privileged thread, and avoid nesting the DoOperation calls. But this is not a trivial task, so It's best if we separate it from this CL.

It works, but it's still too much visual noise for my taste...

Agreed, let's not use that.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

If I understood correctly, ThreadStateCoordinator::RequestThreadResume originally only enqueued the event to executed it asynchronously, so it must have not depended on the thread mutex. I do agree that it would be ideal to make all of these operations atomic, but I think this CL should focus on removing the TSC, and leave the atomic operations update for a later CL. You are right that waitpid events could sneak through in between, but that probability should have already existed before your change so there's no regression.

I don't think we can separate the two things.. The Resume operation was atomic (with respect to the m_threads list) before this change, so if we made it non-atomic now, it would be a step backwards. The reason why it did not deadlock before was because the events were just queued and not executed immediately. This way, waitpid could happen while you are processing the event, but not while you are queueing them. Then, the waitpid would queue some events of it's own, which would get processed after the Resume events, so _in theory_ everything was nice and serialized. It was a very clever design, but it was easy to get things wrong (e.g. processing of waitpid had the queue events which were "correct" no matter what events were queued before or after it. And it could not depend on the state of the threads to help it determine the correct sequence of events because the threads' state could change before its events got a chance to execute).

Now that we are making the processing of events synchronous, things are easier because our internal state of threads exactly reflects the state of threads in the system. However, we still need to make sure that operations on this state are atomic.

You're still going to do m_monitor_up->DoOperation(&op) (or a lambda instead of op) eventually and there's no way around it. So this seems like an added layer of complexity with not much benefit.

Yes, I will be doing the operations, but this way they will be atomic, which is exactly what we want. It complicates the implementation a little bit, but not by much. And the usage of it is actually very easy - it behaves just like a mutex, check out the new version of this patch. So in essence, all the user needs to know is "when I want to execute a sequence of operations, I need to lock this 'mutex'".

We should use either only Operation classes (no lambdas), or only lambdas (no Operation classes). Which to use eventually is up to debate, but currently everything is done with Operation classes, so we should stick with that for now (since the focus right now is removing TSC).

Agreed. The new version does not use lambdas any more.

A more "correct" solution seems to be to refactor the code so that the locking of the thread mutex always happens within the privileged thread, and avoid nesting the DoOperation calls. But this is not a trivial task, so It's best if we separate it from this CL.

I have considered making sure DoOperation calls do not nest, but this is not easy, since some operations (e.g. ReadMemory) are used from within other operations and are also external interfaces. So you would need two versions of them... So, right now, I chose to allow nesting of operations, but this is also not a new concept. Recursive mutexes exist exactly for this purpose, so you can think of this OperationLocker as a recursive mutex. In fact, the m_threads_mutex is a recursive mutex precisely because of this - you don't need a special version of functions for when you already hold the mutex.

Hm... where do we go from now? I'm happy with either of these versions (making big operations (without lamdas) or using operation mutexes) and can go with whichever you prefer. Or we can try to discuss this online to come up with some alternative... What do you think?

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2977 ↗

(On Diff #24369)

I don't think we can separate the two things.. The Resume operation was atomic (with respect to the m_threads list) before this change, so if we made it non-atomic now, it would be a step backwards. The reason why it did not deadlock before was because the events were just queued and not executed immediately. This way, waitpid could happen while you are processing the event, but not while you are queueing them. Then, the waitpid would queue some events of it's own, which would get processed after the Resume events, so _in theory_ everything was nice and serialized. It was a very clever design, but it was easy to get things wrong (e.g. processing of waitpid had the queue events which were "correct" no matter what events were queued before or after it. And it could not depend on the state of the threads to help it determine the correct sequence of events because the threads' state could change before its events got a chance to execute).

Ah, then I didn't understand correctly. Sorry, please forget everything I said about a separate CL for atomicity.

I have considered making sure DoOperation calls do not nest, but this is not easy, since some operations (e.g. ReadMemory) are used from within other operations and are also external interfaces. So you would need two versions of them...

I don't have an issue with nesting DoOperation's in and of itself, but in the specific case of NPL::Resume, there's already a ResumeOperation that supposedly implements NPL::Resume, I was thinking of moving the bulk of NPL::Resume (that involves locking the thread mutex) into the already existing ResumeOperation.

Could we make m_operation_mutex accessible from NPL? And make Handle{Signal, Wait} trylock m_operation_mutex before proceeding (and skip if the trylock fails). Since the operations will be synchronous, it doesn't seem like we'll be needing it in DoOperation either.

Or we can try to discuss this online to come up with some alternative... What do you think?

Yes, please. The communication latency is really making this take longer than necessary.

[chaoren]

LGTM. Sorry it took this long.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3047 ↗

(On Diff #24692)

This is so much nicer.

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         UpdateThreads () override;
 
         bool
         GetArchitecture (ArchSpec &arch) const override;
 
         Error
         SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) override;
 
+        Error
+        SetWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware) override;
+
+        Error
+        RemoveWatchpoint (lldb::addr_t addr) override;
+
         void
         DoStopIDBumped (uint32_t newBumpId) override;
 
         void
         Terminate () override;
 
         // ---------------------------------------------------------------------
         // Interface used by NativeRegisterContext-derived classes.
private:
 
         std::unique_ptr<Monitor> m_monitor_up;
 
         LazyBool m_supports_mem_region;
         std::vector<MemoryRegionInfo> m_mem_region_cache;
         Mutex m_mem_region_cache_mutex;
 
         std::unique_ptr<ThreadStateCoordinator> m_coordinator_up;
-        HostThread m_coordinator_thread;
 
         // List of thread ids stepping with a breakpoint with the address of
         // the relevan breakpoint
         std::map<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
 
         /// @class LauchArgs
         ///
         /// @brief Simple structure to pass data to the thread responsible for
#if 0
 
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGFPE(const siginfo_t *info);
 
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGBUS(const siginfo_t *info);
 #endif
 
-        Error
-        StartCoordinatorThread ();
-
-        static void*
-        CoordinatorThread (void *arg);
-
-        void
-        StopCoordinatorThread ();
-
-        /// Stops monitoring the child process thread.
-        void
-        StopMonitor();
-
         bool
         HasThreadNoLock (lldb::tid_t thread_id);
 
         NativeThreadProtocolSP
         MaybeGetThreadNoLock (lldb::tid_t thread_id);
 
         bool
         StopTrackingThread (lldb::tid_t thread_id);

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

private:
         lldb::tid_t m_tid;
     };
 
     void
     DetachOperation::Execute(NativeProcessLinux *monitor)
     {
         PTRACE(PTRACE_DETACH, m_tid, nullptr, 0, 0, m_error);
     }
-
 } // end of anonymous namespace
 
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
 static Error
 EnsureFDFlags(int fd, int flags)
 {
     Error error;

 //   - SIGCHLD (delivered over a signalfd file descriptor): These signals notify us of events in
 //     the inferior process. Upon receiving this signal we do a waitpid to get more information
 //     and dispatch to NativeProcessLinux::MonitorCallback.
 //   - requests for ptrace operations: These initiated via the DoOperation method, which funnels
 //     them to the Monitor thread via m_operation member. The Monitor thread is signaled over a
 //     pipe, and the completion of the operation is signalled over the semaphore.
 //   - thread exit event: this is signaled from the Monitor destructor by closing the write end
 //     of the command pipe.
-class NativeProcessLinux::Monitor {
+class NativeProcessLinux::Monitor
+{
 private:
     // The initial monitor operation (launch or attach). It returns a inferior process id.
     std::unique_ptr<InitialOperation> m_initial_operation_up;
 
     ::pid_t                           m_child_pid = -1;
     NativeProcessLinux              * m_native_process;
 
     enum { READ, WRITE };
     int        m_pipefd[2] = {-1, -1};
     int        m_signal_fd = -1;
     HostThread m_thread;
 
     // current operation which must be executed on the priviliged thread
     Mutex      m_operation_mutex;
     Operation *m_operation = nullptr;
     sem_t      m_operation_sem;
     Error      m_operation_error;
 
-    static constexpr char operation_command = 'o';
+    unsigned   m_operation_nesting_level = 0;
+
+    static constexpr char operation_command   = 'o';
+    static constexpr char begin_block_command = '{';
+    static constexpr char end_block_command   = '}';
 
     void
     HandleSignals();
 
     void
     HandleWait();
 
     // Returns true if the thread should exit.
     bool
     HandleCommands();
 
     void
     MainLoop();
 
     static void *
     RunMonitor(void *arg);
 
     Error
-    WaitForOperation();
+    WaitForAck();
+
+    void
+    BeginOperationBlock()
+    {
+        write(m_pipefd[WRITE], &begin_block_command, sizeof operation_command);
+        WaitForAck();
+    }
+
+    void
+    EndOperationBlock()
+    {
+        write(m_pipefd[WRITE], &end_block_command, sizeof operation_command);
+        WaitForAck();
+    }
+
 public:
     Monitor(const InitialOperation &initial_operation,
             NativeProcessLinux *native_process)
         : m_initial_operation_up(new InitialOperation(initial_operation)),
           m_native_process(native_process)
     {
         sem_init(&m_operation_sem, 0, 0);
     }
 
     ~Monitor();
 
     Error
     Initialize();
 
     void
+    Terminate();
+
+    void
     DoOperation(Operation *op);
+
+    class ScopedOperationLock {
+        Monitor &m_monitor;
+
+    public:
+        ScopedOperationLock(Monitor &monitor)
+            : m_monitor(monitor)
+        { m_monitor.BeginOperationBlock(); }
+
+        ~ScopedOperationLock()
+        { m_monitor.EndOperationBlock(); }
+    };
 };
 constexpr char NativeProcessLinux::Monitor::operation_command;
+constexpr char NativeProcessLinux::Monitor::begin_block_command;
+constexpr char NativeProcessLinux::Monitor::end_block_command;
 
 Error
 NativeProcessLinux::Monitor::Initialize()
 {
     Error error;
 
     // We get a SIGCHLD every time something interesting happens with the inferior. We shall be
     // listening for these signals over a signalfd file descriptors. This allows us to wait for
NativeProcessLinux::Monitor::Initialize()
     }
 
     static const char g_thread_name[] = "lldb.process.nativelinux.monitor";
     m_thread = ThreadLauncher::LaunchThread(g_thread_name, Monitor::RunMonitor, this, nullptr);
     if (!m_thread.IsJoinable())
         return Error("Failed to create monitor thread for NativeProcessLinux.");
 
     // Wait for initial operation to complete.
-    return WaitForOperation();
+    return WaitForAck();
 }
 
 void
 NativeProcessLinux::Monitor::DoOperation(Operation *op)
 {
     if (m_thread.EqualsThread(pthread_self())) {
         // If we're on the Monitor thread, we can simply execute the operation.
         op->Execute(m_native_process);
         return;
     }
 
     // Otherwise we need to pass the operation to the Monitor thread so it can handle it.
     Mutex::Locker lock(m_operation_mutex);
 
     m_operation = op;
 
     // notify the thread that an operation is ready to be processed
     write(m_pipefd[WRITE], &operation_command, sizeof operation_command);
 
-    WaitForOperation();
+    WaitForAck();
 }
 
-NativeProcessLinux::Monitor::~Monitor()
+void
+NativeProcessLinux::Monitor::Terminate()
 {
     if (m_pipefd[WRITE] >= 0)
+    {
         close(m_pipefd[WRITE]);
+        m_pipefd[WRITE] = -1;
+    }
     if (m_thread.IsJoinable())
         m_thread.Join(nullptr);
+}
+
+NativeProcessLinux::Monitor::~Monitor()
+{
+    Terminate();
     if (m_pipefd[READ] >= 0)
         close(m_pipefd[READ]);
     if (m_signal_fd >= 0)
         close(m_signal_fd);
     sem_destroy(&m_operation_sem);
 }
 
 void
while (true)
             if (log)
                 log->Printf("NativeProcessLinux::Monitor::%s exiting because read from command file descriptor failed: %s", __FUNCTION__, strerror(errno));
             return true;
         }
         if (size == 0) // end of file - write end closed
         {
             if (log)
                 log->Printf("NativeProcessLinux::Monitor::%s exit command received, exiting...", __FUNCTION__);
+            assert(m_operation_nesting_level == 0 && "Unbalanced begin/end block commands detected");
             return true; // We are done.
         }
 
         switch (command)
         {
         case operation_command:
             m_operation->Execute(m_native_process);
-
-            // notify calling thread that operation is complete
-            sem_post(&m_operation_sem);
+            break;
+        case begin_block_command:
+            ++m_operation_nesting_level;
+            break;
+        case end_block_command:
+            assert(m_operation_nesting_level > 0);
+            --m_operation_nesting_level;
             break;
         default:
             if (log)
                 log->Printf("NativeProcessLinux::Monitor::%s received unknown command '%c'",
                         __FUNCTION__, command);
         }
+
+        // notify calling thread that the command has been processed
+        sem_post(&m_operation_sem);
     }
 }
 
 void
 NativeProcessLinux::Monitor::MainLoop()
 {
     ::pid_t child_pid = (*m_initial_operation_up)(m_operation_error);
     m_initial_operation_up.reset();
     m_child_pid = -getpgid(child_pid),
     sem_post(&m_operation_sem);
 
     while (true)
     {
         fd_set fds;
         FD_ZERO(&fds);
+        // Only process waitpid events if we are outside of an operation block. Any pending
+        // events will be processed after we leave the block.
+        if (m_operation_nesting_level == 0)
             FD_SET(m_signal_fd, &fds);
         FD_SET(m_pipefd[READ], &fds);
 
         int max_fd = std::max(m_signal_fd, m_pipefd[READ]) + 1;
         int r = select(max_fd, &fds, nullptr, nullptr, nullptr);
         if (r < 0)
         {
             Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
             if (log)
while (true)
         {
             HandleSignals();
             HandleWait();
         }
     }
 }
 
 Error
-NativeProcessLinux::Monitor::WaitForOperation()
+NativeProcessLinux::Monitor::WaitForAck()
 {
     Error error;
     while (sem_wait(&m_operation_sem) != 0)
     {
         if (errno == EINTR)
             continue;
 
         error.SetErrorToErrno();

 // -----------------------------------------------------------------------------
 
 NativeProcessLinux::NativeProcessLinux () :
     NativeProcessProtocol (LLDB_INVALID_PROCESS_ID),
     m_arch (),
     m_supports_mem_region (eLazyBoolCalculate),
     m_mem_region_cache (),
     m_mem_region_cache_mutex (),
-    m_coordinator_up (new ThreadStateCoordinator (GetThreadLoggerFunction ())),
-    m_coordinator_thread ()
+    m_coordinator_up (new ThreadStateCoordinator (GetThreadLoggerFunction ()))
 {
 }
 
 //------------------------------------------------------------------------------
 // NativeProcessLinux spawns a new thread which performs all operations on the inferior process.
 // Refer to Monitor and Operation classes to see why this is necessary.
 //------------------------------------------------------------------------------
 void
std::unique_ptr<LaunchArgs> args(
         new LaunchArgs(
             module, argv, envp,
             stdin_path, stdout_path, stderr_path,
             working_dir, launch_info));
 
     StartMonitorThread ([&] (Error &e) { return Launch(args.get(), e); }, error);
     if (!error.Success ())
         return;
-
-    error = StartCoordinatorThread ();
-    if (!error.Success ())
-        return;
 }
 
 void
 NativeProcessLinux::AttachToInferior (lldb::pid_t pid, Error &error)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ")", __FUNCTION__, pid);
if (log)
         log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ") detected architecture %s", __FUNCTION__, pid, m_arch.GetArchitectureName ());
 
     m_pid = pid;
     SetState(eStateAttaching);
 
     StartMonitorThread ([=] (Error &e) { return Attach(pid, e); }, error);
     if (!error.Success ())
         return;
-
-    error = StartCoordinatorThread ();
-    if (!error.Success ())
-        return;
 }
 
 void
 NativeProcessLinux::Terminate ()
 {
-    StopMonitor();
+    m_monitor_up->Terminate();
 }
 
 ::pid_t
 NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
 {
     assert (args && "null args");
 
     const char **argv = args->m_argv;
NativeProcessLinux::Resume (const ResumeActionList &resume_actions)
 
     lldb::tid_t deferred_signal_tid = LLDB_INVALID_THREAD_ID;
     lldb::tid_t deferred_signal_skip_tid = LLDB_INVALID_THREAD_ID;
     int deferred_signo = 0;
     NativeThreadProtocolSP deferred_signal_thread_sp;
     bool stepping = false;
     bool software_single_step = !SupportHardwareSingleStepping();
 
+    Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
     Mutex::Locker locker (m_threads_mutex);
 
     if (software_single_step)
     {
         for (auto thread_sp : m_threads)
         {
             assert (thread_sp && "thread list should not contain NULL threads");
 

 {
     Error error;
 
     // Tell ptrace to detach from the process.
     if (GetID () != LLDB_INVALID_PROCESS_ID)
         error = Detach (GetID ());
 
     // Stop monitoring the inferior.
-    StopMonitor ();
+    m_monitor_up->Terminate();
 
     // No error.
     return error;
 }
 
 Error
 NativeProcessLinux::Signal (int signo)
 {
NativeProcessLinux::Interrupt ()
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     NativeThreadProtocolSP running_thread_sp;
     NativeThreadProtocolSP stopped_thread_sp;
         
     if (log)
         log->Printf ("NativeProcessLinux::%s selecting running thread for interrupt target", __FUNCTION__);
 
+    Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
     Mutex::Locker locker (m_threads_mutex);
 
     for (auto thread_sp : m_threads)
     {
         // The thread shouldn't be null but lets just cover that here.
         if (!thread_sp)
             continue;
 
CallAfterRunningThreadsStop (deferred_signal_thread_sp->GetID (),
                                      SetCurrentThreadID (deferred_notification_tid);
 
                                      // Set the thread state as stopped by the deferred signo.
                                      std::static_pointer_cast<NativeThreadLinux> (deferred_signal_thread_sp)->SetStoppedBySignal (SIGSTOP);
 
                                      // Tell the process delegate that the process is in a stopped state.
                                      SetState (StateType::eStateStopped, true);
                                  });
+
     return Error();
 }
 
 Error
 NativeProcessLinux::Kill ()
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
case BUS_OBJERR:
         break;
     }
 
     return reason;
 }
 #endif
 
 Error
-NativeProcessLinux::ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
+NativeProcessLinux::SetWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware)
+{
+    // The base SetWatchpoint will end up executing monitor operations. Let's lock the monitor
+    // for it.
+    Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
+    return NativeProcessProtocol::SetWatchpoint(addr, size, watch_flags, hardware);
+}
+
+Error
+NativeProcessLinux::RemoveWatchpoint (lldb::addr_t addr)
+{
+    // The base RemoveWatchpoint will end up executing monitor operations. Let's lock the monitor
+    // for it.
+    Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
+    return NativeProcessProtocol::RemoveWatchpoint(addr);
+}
+
+Error
+NativeProcessLinux::ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read)
 {
     ReadOperation op(addr, buf, size, bytes_read);
     m_monitor_up->DoOperation(&op);
     return op.GetError ();
 }
 
 Error
 NativeProcessLinux::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)

 {
     m_monitor_up.reset(new Monitor(initial_operation, this));
     error = m_monitor_up->Initialize();
     if (error.Fail()) {
         m_monitor_up.reset();
     }
 }
 
-void
-NativeProcessLinux::StopMonitor()
-{
-    StopCoordinatorThread ();
-    m_monitor_up.reset();
-}
-
-Error
-NativeProcessLinux::StartCoordinatorThread ()
-{
-    Error error;
-    static const char *g_thread_name = "lldb.process.linux.ts_coordinator";
-    Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
-
-    // Skip if thread is already running
-    if (m_coordinator_thread.IsJoinable())
-    {
-        error.SetErrorString ("ThreadStateCoordinator's run loop is already running");
-        if (log)
-            log->Printf ("NativeProcessLinux::%s %s", __FUNCTION__, error.AsCString ());
-        return error;
-    }
-
-    // Enable verbose logging if lldb thread logging is enabled.
-    m_coordinator_up->LogEnableEventProcessing (log != nullptr);
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s launching ThreadStateCoordinator thread for pid %" PRIu64, __FUNCTION__, GetID ());
-    m_coordinator_thread = ThreadLauncher::LaunchThread(g_thread_name, CoordinatorThread, this, &error);
-    return error;
-}
-
-void *
-NativeProcessLinux::CoordinatorThread (void *arg)
-{
-    Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
-
-    NativeProcessLinux *const process = static_cast<NativeProcessLinux*> (arg);
-    assert (process && "null process passed to CoordinatorThread");
-    if (!process)
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s null process, exiting ThreadStateCoordinator processing loop", __FUNCTION__);
-        return nullptr;
-    }
-
-    // Run the thread state coordinator loop until it is done.  This call uses
-    // efficient waiting for an event to be ready.
-    while (process->m_coordinator_up->ProcessNextEvent () == ThreadStateCoordinator::eventLoopResultContinue)
-    {
-    }
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " exiting ThreadStateCoordinator processing loop due to coordinator indicating completion", __FUNCTION__, process->GetID ());
-
-    return nullptr;
-}
-
-void
-NativeProcessLinux::StopCoordinatorThread()
-{
-    Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
-    if (log)
-        log->Printf ("NativeProcessLinux::%s requesting ThreadStateCoordinator stop for pid %" PRIu64, __FUNCTION__, GetID ());
-
-    // Tell the coordinator we're done.  This will cause the coordinator
-    // run loop thread to exit when the processing queue hits this message.
-    m_coordinator_up->StopCoordinator ();
-    m_coordinator_thread.Join (nullptr);
-}
-
 bool
 NativeProcessLinux::HasThreadNoLock (lldb::tid_t thread_id)
 {
     for (auto thread_sp : m_threads)
     {
         assert (thread_sp && "thread list should not contain NULL threads");
         if (thread_sp->GetID () == thread_id)
         {

lldb/trunk/source/Plugins/Process/Linux/ThreadStateCoordinator.h

 //===-- ThreadStateCoordinator.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_ThreadStateCoordinator_h
 #define lldb_ThreadStateCoordinator_h
 
-#include <condition_variable>
 #include <functional>
 #include <mutex>
-#include <queue>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/Error.h"
 
 namespace lldb_private {
public:
         // does not trigger an error in that case.
         void
         RequestThreadResumeAsNeeded (lldb::tid_t tid,
                                      const ResumeThreadFunction &request_thread_resume_function,
                                      const ErrorFunction &error_function);
 
         // Indicate the calling process did an exec and that the thread state
         // should be 100% cleared.
-        //
-        // Note this will clear out any pending notifications, but will not stop
-        // a notification currently in progress via ProcessNextEvent().
         void
         ResetForExec ();
 
-        // Indicate when the coordinator should shut down.
-        void
-        StopCoordinator ();
-
-        // Process the next event, returning false when the coordinator is all done.
-        // This call is synchronous and blocks when there are no events pending.
-        // Expected usage is to run this in a separate thread until the function
-        // returns false.  Always call this from the same thread.  The processing
-        // logic assumes the execution of this is implicitly serialized.
-        EventLoopResult
-        ProcessNextEvent ();
-
         // Enable/disable verbose logging of event processing.
         void
         LogEnableEventProcessing (bool enabled);
 
     private:
 
         // Typedefs.
         class EventBase;
 
         class EventCallAfterThreadsStop;
         class EventThreadStopped;
         class EventThreadCreate;
         class EventThreadDeath;
         class EventRequestResume;
 
-        class EventStopCoordinator;
         class EventReset;
 
         typedef std::shared_ptr<EventBase> EventBaseSP;
 
-        typedef std::queue<EventBaseSP> QueueType;
-
         enum class ThreadState
         {
             Running,
             Stopped
         };
 
         struct ThreadContext
         {
             ThreadState m_state;
             bool m_stop_requested = false;
             ResumeThreadFunction m_request_resume_function;
         };
         typedef std::unordered_map<lldb::tid_t, ThreadContext> TIDContextMap;
 
 
-        // Private member functions.
-        void
-        EnqueueEvent (EventBaseSP event_sp);
+        std::mutex m_event_mutex; // Serializes execution of ProcessEvent.
 
-        EventBaseSP
-        DequeueEventWithWait ();
+        void
+        ProcessEvent (const EventBaseSP &event_sp);
 
         void
         SetPendingNotification (const EventBaseSP &event_sp);
 
         void
         ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs, ErrorFunction &error_function);
 
         void
private:
         Log (const char *format, ...);
 
         EventCallAfterThreadsStop *
         GetPendingThreadStopNotification ();
 
         // Member variables.
         LogFunction m_log_function;
 
-        QueueType m_event_queue;
-        // For now we do simple read/write lock strategy with efficient wait-for-data.
-        // We can replace with an entirely non-blocking queue later but we still want the
-        // reader to sleep when nothing is available - this will be a bursty but infrequent
-        // event mechanism.
-        std::condition_variable m_queue_condition;
-        std::mutex m_queue_mutex;
-
         EventBaseSP m_pending_notification_sp;
 
         // Maps known TIDs to ThreadContext.
         TIDContextMap m_tid_map;
 
         bool m_log_event_processing;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif

lldb/trunk/source/Plugins/Process/Linux/ThreadStateCoordinator.cpp

public:
 
     // Return false if the coordinator should terminate running.
     virtual EventLoopResult
     ProcessEvent (ThreadStateCoordinator &coordinator) = 0;
 };
 
 //===----------------------------------------------------------------------===//
 
-class ThreadStateCoordinator::EventStopCoordinator : public ThreadStateCoordinator::EventBase
-{
-public:
-    EventStopCoordinator ():
-        EventBase ()
-    {
-    }
-
-    EventLoopResult
-    ProcessEvent(ThreadStateCoordinator &coordinator) override
-    {
-        return eventLoopResultStop;
-    }
-
-    std::string
-    GetDescription () override
-    {
-        return "EventStopCoordinator";
-    }
-};
-
-//===----------------------------------------------------------------------===//
-
 class ThreadStateCoordinator::EventCallAfterThreadsStop : public ThreadStateCoordinator::EventBase
 {
 public:
     EventCallAfterThreadsStop (lldb::tid_t triggering_tid,
                                const ThreadIDSet &wait_for_stop_tids,
                                const StopThreadFunction &request_thread_stop_function,
                                const ThreadIDFunction &call_after_function,
                                const ErrorFunction &error_function):
private:
     ErrorFunction m_error_function;
     const bool m_error_when_already_running;
 };
 
 //===----------------------------------------------------------------------===//
 
 ThreadStateCoordinator::ThreadStateCoordinator (const LogFunction &log_function) :
     m_log_function (log_function),
-    m_event_queue (),
-    m_queue_condition (),
-    m_queue_mutex (),
     m_tid_map (),
     m_log_event_processing (false)
 {
 }
 
 void
-ThreadStateCoordinator::EnqueueEvent (EventBaseSP event_sp)
-{
-    std::lock_guard<std::mutex> lock (m_queue_mutex);
-
-    m_event_queue.push (event_sp);
-    if (m_log_event_processing)
-        Log ("ThreadStateCoordinator::%s enqueued event: %s", __FUNCTION__, event_sp->GetDescription ().c_str ());
-
-    m_queue_condition.notify_one ();
-}
-
-ThreadStateCoordinator::EventBaseSP
-ThreadStateCoordinator::DequeueEventWithWait ()
-{
-    // Wait for an event to be present.
-    std::unique_lock<std::mutex> lock (m_queue_mutex);
-    m_queue_condition.wait (lock,
-                            [this] { return !m_event_queue.empty (); });
-
-    // Grab the event and pop it off the queue.
-    EventBaseSP event_sp = m_event_queue.front ();
-    m_event_queue.pop ();
-
-    return event_sp;
-}
-
-void
 ThreadStateCoordinator::SetPendingNotification (const EventBaseSP &event_sp)
 {
     assert (event_sp && "null event_sp");
     if (!event_sp)
         return;
 
     const EventCallAfterThreadsStop *new_call_after_event = static_cast<EventCallAfterThreadsStop*> (event_sp.get ());
 

 
 void
 ThreadStateCoordinator::CallAfterThreadsStop (const lldb::tid_t triggering_tid,
                                               const ThreadIDSet &wait_for_stop_tids,
                                               const StopThreadFunction &request_thread_stop_function,
                                               const ThreadIDFunction &call_after_function,
                                               const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventCallAfterThreadsStop (triggering_tid,
-                                                              wait_for_stop_tids,
-                                                              request_thread_stop_function,
-                                                              call_after_function,
-                                                              error_function)));
+    ProcessEvent(EventBaseSP(new EventCallAfterThreadsStop (triggering_tid,
 }
 
 void
 ThreadStateCoordinator::CallAfterRunningThreadsStop (const lldb::tid_t triggering_tid,
                                                      const StopThreadFunction &request_thread_stop_function,
                                                      const ThreadIDFunction &call_after_function,
                                                      const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventCallAfterThreadsStop (triggering_tid,
-                                                              request_thread_stop_function,
-                                                              call_after_function,
-                                                              error_function)));
+    ProcessEvent(EventBaseSP(new EventCallAfterThreadsStop (triggering_tid,
 }
 
 void
 ThreadStateCoordinator::CallAfterRunningThreadsStopWithSkipTIDs (lldb::tid_t triggering_tid,
                                                                  const ThreadIDSet &skip_stop_request_tids,
                                                                  const StopThreadFunction &request_thread_stop_function,
                                                                  const ThreadIDFunction &call_after_function,
                                                                  const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventCallAfterThreadsStop (triggering_tid,
-                                                              request_thread_stop_function,
-                                                              call_after_function,
-                                                              skip_stop_request_tids,
-                                                              error_function)));
+    ProcessEvent(EventBaseSP(new EventCallAfterThreadsStop (triggering_tid,
 }
 
 
 void
 ThreadStateCoordinator::ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs, ErrorFunction &error_function)
 {
     // Ensure we know about the thread.
     auto find_it = m_tid_map.find (tid);
ThreadStateCoordinator::Log (const char *format, ...)
     va_end (args);
 }
 
 void
 ThreadStateCoordinator::NotifyThreadStop (lldb::tid_t tid,
                                           bool initiated_by_llgs,
                                           const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventThreadStopped (tid, initiated_by_llgs, error_function)));
+    ProcessEvent(EventBaseSP(new EventThreadStopped (tid, initiated_by_llgs, error_function)));
 }
 
 void
 ThreadStateCoordinator::RequestThreadResume (lldb::tid_t tid,
                                              const ResumeThreadFunction &request_thread_resume_function,
                                              const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventRequestResume (tid, request_thread_resume_function, error_function, true)));
+    ProcessEvent(EventBaseSP(new EventRequestResume (tid, request_thread_resume_function, error_function, true)));
 }
 
 void
 ThreadStateCoordinator::RequestThreadResumeAsNeeded (lldb::tid_t tid,
                                                      const ResumeThreadFunction &request_thread_resume_function,
                                                      const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventRequestResume (tid, request_thread_resume_function, error_function, false)));
+    ProcessEvent(EventBaseSP(new EventRequestResume (tid, request_thread_resume_function, error_function, false)));
 }
 
 void
 ThreadStateCoordinator::NotifyThreadCreate (lldb::tid_t tid,
                                             bool is_stopped,
                                             const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventThreadCreate (tid, is_stopped, error_function)));
+    ProcessEvent(EventBaseSP(new EventThreadCreate (tid, is_stopped, error_function)));
 }
 
 void
 ThreadStateCoordinator::NotifyThreadDeath (lldb::tid_t tid,
                                            const ErrorFunction &error_function)
 {
-    EnqueueEvent (EventBaseSP (new EventThreadDeath (tid, error_function)));
+    ProcessEvent(EventBaseSP(new EventThreadDeath (tid, error_function)));
 }
 
 void
 ThreadStateCoordinator::ResetForExec ()
 {
-    std::lock_guard<std::mutex> lock (m_queue_mutex);
-
-    // Remove everything from the queue.  This is the only
-    // state mutation that takes place outside the processing
-    // loop.
-    QueueType empty_queue;
-    m_event_queue.swap (empty_queue);
-
-    // Do the real clear behavior on the the queue to eliminate
-    // the chance that processing of a dequeued earlier event is
-    // overlapping with the clearing of state here.  Push it
-    // directly because we need to have this happen with the lock,
-    // and so far I only have this one place that needs a no-lock
-    // variant.
-    m_event_queue.push (EventBaseSP (new EventReset ()));
+    ProcessEvent(EventBaseSP(new EventReset()));
 }
 
 void
-ThreadStateCoordinator::StopCoordinator ()
-{
-    EnqueueEvent (EventBaseSP (new EventStopCoordinator ()));
-}
-
-ThreadStateCoordinator::EventLoopResult
-ThreadStateCoordinator::ProcessNextEvent ()
-{
-    // Dequeue the next event, synchronous.
-    if (m_log_event_processing)
-        Log ("ThreadStateCoordinator::%s about to dequeue next event in blocking mode", __FUNCTION__);
-
-    EventBaseSP event_sp = DequeueEventWithWait();
-    assert (event_sp && "event should never be null");
-    if (!event_sp)
-    {
-        Log ("ThreadStateCoordinator::%s error: event_sp was null, signaling exit of event loop.", __FUNCTION__);
-        return eventLoopResultStop;
-    }
+ThreadStateCoordinator::ProcessEvent (const EventBaseSP &event_sp)
+    std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (m_log_event_processing)
     {
         Log ("ThreadStateCoordinator::%s about to process event: %s", __FUNCTION__, event_sp->GetDescription ().c_str ());
     }
 
     // Process the event.
-    const EventLoopResult result = event_sp->ProcessEvent (*this);
+    event_sp->ProcessEvent (*this);
 
     if (m_log_event_processing)
     {
-        Log ("ThreadStateCoordinator::%s event processing returned value %s", __FUNCTION__,
-             result == eventLoopResultContinue ? "eventLoopResultContinue" : "eventLoopResultStop");
+        Log ("ThreadStateCoordinator::%s event processing done", __FUNCTION__);
     }
-
-    return result;
 }
 
 void
 ThreadStateCoordinator::LogEnableEventProcessing (bool enabled)
 {
     m_log_event_processing = enabled;
 }
 

lldb/trunk/unittests/Plugins/Process/Linux/ThreadStateCoordinatorTest.cpp

StdoutLogger (const char *format, va_list args)
         // Print to stdout.
         vprintf (format, args);
         printf ("\n");
     }
 
     // These are single-line macros so that IDE integration of gtest results puts
     // the error markers on the correct failure point within the gtest.
 
-#define ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS() ASSERT_EQ (ThreadStateCoordinator::eventLoopResultContinue, m_coordinator.ProcessNextEvent ()); \
+#define ASSERT_PROCESS_EVENT_SUCCEEDED() do { \
 if (HasError ()) { printf ("unexpected error in processing of event, error: %s\n", m_error_string.c_str ()); } \
-ASSERT_EQ (false, HasError ());
+ASSERT_EQ (false, HasError ()); } while(0)
 
-#define ASSERT_PROCESS_NEXT_EVENT_FAILS() ASSERT_EQ (ThreadStateCoordinator::eventLoopResultContinue, m_coordinator.ProcessNextEvent ()); \
-ASSERT_EQ (true, HasError ());
+#define ASSERT_PROCESS_EVENT_FAILED() ASSERT_EQ (true, HasError ())
 
     class ThreadStateCoordinatorTest: public ::testing::Test
     {
     protected:
         // Constants.
         const lldb::tid_t TRIGGERING_TID      = 4105;
         const lldb::tid_t PENDING_STOP_TID    = 3;
         const lldb::tid_t PENDING_STOP_TID_02 = 29016;
protected:
             return m_requested_stop_tids.find (tid) != m_requested_stop_tids.end ();
         }
 
         // Test state initialization helpers.
         void
         SetupKnownRunningThread (lldb::tid_t tid)
         {
             NotifyThreadCreate (tid, false);
-            ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+            ASSERT_PROCESS_EVENT_SUCCEEDED ();
         }
 
         void
         SetupKnownStoppedThread (lldb::tid_t tid)
         {
             NotifyThreadCreate (tid, true);
-            ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+            ASSERT_PROCESS_EVENT_SUCCEEDED ();
         }
 
         // Convenience wrappers for ThreadStateCoordinator, using defaults for expected arguments
         // that plug into the test case handlers.
         void
         CallAfterThreadsStop (lldb::tid_t deferred_tid,
                               const ThreadStateCoordinator::ThreadIDSet &pending_stop_wait_tids)
         {
protected:
         void
         NotifyThreadDeath (lldb::tid_t tid)
         {
             m_coordinator.NotifyThreadDeath (tid, GetErrorFunction ());
         }
     };
 }
 
-TEST_F (ThreadStateCoordinatorTest, StopCoordinatorWorksNoPriorEvents)
-{
-    m_coordinator.StopCoordinator ();
-    ASSERT_EQ (ThreadStateCoordinator::eventLoopResultStop, m_coordinator.ProcessNextEvent ());
-    ASSERT_EQ (false, HasError ());
-}
-
 TEST_F (ThreadStateCoordinatorTest, NotifyThreadCreateSignalsErrorOnAlreadyKnownThread)
 {
     // Let the coordinator know about our thread.
     SetupKnownStoppedThread (TRIGGERING_TID);
 
     // Notify the thread was created - again.
     NotifyThreadCreate (TRIGGERING_TID, true);
 
     // This should error out.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 }
 
 
 TEST_F (ThreadStateCoordinatorTest, NotifyThreadDeathSignalsErrorOnUnknownThread)
 {
     const lldb::tid_t UNKNOWN_TID = 678;
 
     // Notify an unknown thread has died.
     NotifyThreadDeath (UNKNOWN_TID);
 
     // This should error out.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 }
 
 TEST_F (ThreadStateCoordinatorTest, NotifyThreadStopSignalsErrorOnUnknownThread)
 {
     const lldb::tid_t UNKNOWN_TID = 678;
 
     // Notify an unknown thread has stopped.
     NotifyThreadStop (UNKNOWN_TID);
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterTheadsStopSignalsErrorOnUnknownDeferredThread)
 {
     const lldb::tid_t UNKNOWN_TRIGGER_TID = 678;
 
     // Defer notify for an unknown thread.
     CallAfterThreadsStop (UNKNOWN_TRIGGER_TID,
                           EMPTY_THREAD_ID_SET);
 
     // Shouldn't have fired yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Event should fail because trigger tid is unknown.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 
     // Shouldn't have fired due to error.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterTheadsStopSignalsErrorOnUnknownPendingStopThread)
 {
     // Let the coordinator know about our thread.
     SetupKnownStoppedThread (TRIGGERING_TID);
 
     // Defer notify for an unknown thread.
     const lldb::tid_t UNKNOWN_PENDING_STOP_TID = 7890;
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { UNKNOWN_PENDING_STOP_TID };
 
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
 
     // Shouldn't have fired yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Event should fail because trigger tid is unknown.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 
     // Shouldn't have triggered deferred notification due to error.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Shouldn't have triggered stop request due to unknown tid.
     ASSERT_EQ (0u, GetRequestedStopCount ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenNoPendingStops)
 {
     // Let the coordinator know about our thread.
     SetupKnownStoppedThread (TRIGGERING_TID);
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           EMPTY_THREAD_ID_SET);
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
-    // Notification trigger shouldn't go off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-
-    // Process next event.  This will pick up the call after threads stop event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-
-    // Now the trigger should have fired, since there were no threads that needed to first stop.
+    // The trigger should have fired, since there were no threads that needed to first stop.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenOnePendingStop)
 {
     // Let the coordinator know about our thread.
     SetupKnownStoppedThread (TRIGGERING_TID);
 
     // Let the coordinator know about a currently-running thread we'll wait on.
     SetupKnownRunningThread (PENDING_STOP_TID);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID };
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (false, DidRequestStopForTid (PENDING_STOP_TID));
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-
-    // Now the request thread stop should have been called for the pending stop.
+    // The request thread stop should have been called for the pending stop.
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
 
     // But we still shouldn't have the deferred signal call go off yet.  Need to wait for the stop to be reported.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now report the that the pending stop occurred.
     NotifyThreadStop (PENDING_STOP_TID);
-
-    // Shouldn't take effect until after next processing step.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Deferred signal notification should have fired now.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenTwoPendingStops)
 {
     // Setup threads.
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
     SetupKnownRunningThread (PENDING_STOP_TID_02);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID, PENDING_STOP_TID_02 };
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (0u, GetRequestedStopCount ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-
-    // Now the request thread stops should have been called for the pending stop tids.
+    // The request thread stops should have been called for the pending stop tids.
     ASSERT_EQ (2u, GetRequestedStopCount ());
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID_02));
 
     // But we still shouldn't have the deferred signal call go off yet.  Need to wait for the stop to be reported.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Report the that the first pending stop occurred.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Shouldn't take effect until after both pending threads are notified.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Report the that the first pending stop occurred.
     NotifyThreadStop (PENDING_STOP_TID_02);
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Deferred signal notification should have fired now.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenPendingAlreadyStopped)
 {
     // Setup threads.
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID };
 
     // Tell m_coordinator the pending stop tid is already stopped.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
-
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (false, DidRequestStopForTid (PENDING_STOP_TID));
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // The pending stop should *not* fire because the m_coordinator knows it has already stopped.
     ASSERT_EQ (false, DidRequestStopForTid (PENDING_STOP_TID));
 
     // The deferred signal notification should have fired since all requirements were met.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenTwoPendingOneAlreadyStopped)
 {
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
     SetupKnownRunningThread (PENDING_STOP_TID_02);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID, PENDING_STOP_TID_02 };
 
     // Tell coordinator the pending stop tid is already stopped.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
-
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (0u, GetRequestedStopCount ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // The pending stop should only fire for one of the threads, the one that wasn't already stopped.
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID_02));
     ASSERT_EQ (false, DidRequestStopForTid (PENDING_STOP_TID));
 
     // The deferred signal notification should not yet have fired since all pending thread stops have not yet occurred.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Notify final thread has stopped.
     NotifyThreadStop (PENDING_STOP_TID_02);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // The deferred signal notification should have fired since all requirements were met.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterThreadsStopFiresWhenOnePendingThreadDies)
 {
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID };
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (0u, GetRequestedStopCount ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-
-    // Now the request thread stop should have been called for the pending stop.
+    // The request thread stop should have been called for the pending stop.
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
 
     // But we still shouldn't have the deferred signal call go off yet.  Need to wait for the death to be reported.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now report the that the thread with pending stop dies.
     NotifyThreadDeath (PENDING_STOP_TID);
-
-    // Shouldn't take effect until after next processing step.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Deferred signal notification should have fired now.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, ExistingPendingNotificationRequiresStopFromNewThread)
 {
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_STOP_TID };
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
-
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (0u, GetRequestedStopCount ());
-
-    // Process next event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Now the request thread stop should have been called for the pending stop.
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
 
     // But we still shouldn't have the deferred signal call go off yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Indicate a new thread has just been created.
     SetupKnownRunningThread (NEW_THREAD_TID);
 
     // We should have just received a stop request for the new thread id.
     ASSERT_EQ (2u, GetRequestedStopCount ());
     ASSERT_EQ (true, DidRequestStopForTid (NEW_THREAD_TID));
 
     // Now report the original pending tid stopped.  This should no longer
     // trigger the pending notification because we should now require the
     // new thread to stop too.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now notify the new thread stopped.
     NotifyThreadStop (NEW_THREAD_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Deferred signal notification should have fired now.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
-TEST_F (ThreadStateCoordinatorTest, DeferredNotificationRemovedByResetForExec)
-{
-    SetupKnownStoppedThread (TRIGGERING_TID);
-
-    // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
-    CallAfterThreadsStop (TRIGGERING_TID,
-                          EMPTY_THREAD_ID_SET);
-
-    // Notification trigger shouldn't go off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-
-    // Now indicate an exec occurred, which will invalidate all state about the process and threads.
-    m_coordinator.ResetForExec ();
-
-    // Verify the deferred stop notification does *not* fire with the next
-    // process.  It will handle the reset and not the deferred signaling, which
-    // should now be removed.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-}
-
 TEST_F (ThreadStateCoordinatorTest, RequestThreadResumeSignalsErrorOnUnknownThread)
 {
     const lldb::tid_t UNKNOWN_TID = 411;
 
     // Request a resume.
     lldb::tid_t resumed_tid = 0;
     int resume_call_count = 0;
 
     m_coordinator.RequestThreadResume (UNKNOWN_TID,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
     // Shouldn't be called yet.
     ASSERT_EQ (0, resume_call_count);
 
     // Process next event.  This should fail since the coordinator doesn't know about the thread.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
     ASSERT_EQ (0, resume_call_count);
 }
 
 TEST_F (ThreadStateCoordinatorTest, RequestThreadResumeCallsCallbackWhenThreadIsStopped)
 {
     // Initialize thread to be in stopped state.
     SetupKnownStoppedThread (NEW_THREAD_TID);
 
     // Request a resume.
     lldb::tid_t resumed_tid = 0;
     int resume_call_count = 0;
 
     m_coordinator.RequestThreadResume (NEW_THREAD_TID,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
-    // Shouldn't be called yet.
-    ASSERT_EQ (0, resume_call_count);
-
-    // Process next event.  After that, the resume request call should have fired.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (1, resume_call_count);
     ASSERT_EQ (NEW_THREAD_TID, resumed_tid);
 }
 
 TEST_F (ThreadStateCoordinatorTest, RequestThreadResumeSkipsCallbackOnSecondResumeAttempt)
 {
     // Initialize thread to be in stopped state.
     SetupKnownStoppedThread (NEW_THREAD_TID);
 
     // Request a resume.
     lldb::tid_t resumed_tid = 0;
     int resume_call_count = 0;
 
     m_coordinator.RequestThreadResume (NEW_THREAD_TID,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
-    // Shouldn't be called yet.
-    ASSERT_EQ (0, resume_call_count);
-
-    // Process next event.  After that, the resume request call should have fired.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (1, resume_call_count);
     ASSERT_EQ (NEW_THREAD_TID, resumed_tid);
 
     // Make a second resume request.
     const int initial_resume_call_count = resume_call_count;
     m_coordinator.RequestThreadResume (NEW_THREAD_TID,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
 
-    // Process next event.  This should fail since the thread should already be running.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    // This should fail since the thread should already be running.
+    ASSERT_PROCESS_EVENT_FAILED ();
 
     // And the resume count should not have increased.
     ASSERT_EQ (initial_resume_call_count, resume_call_count);
 }
 
 TEST_F (ThreadStateCoordinatorTest, RequestThreadResumeSignalsErrorOnAlreadyRunningThread)
 {
     const lldb::tid_t TEST_TID = 1234;
     SetupKnownRunningThread (NEW_THREAD_TID);
 
     // Request a resume.
     lldb::tid_t resumed_tid = 0;
     int resume_call_count = 0;
 
     m_coordinator.RequestThreadResume (TEST_TID,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
 
     // Shouldn't be called yet.
     ASSERT_EQ (0, resume_call_count);
 
     // Process next event.  Should be an error.
-    ASSERT_PROCESS_NEXT_EVENT_FAILS ();
+    ASSERT_PROCESS_EVENT_FAILED ();
 
     // The resume request should not have gone off because we think it is already running.
     ASSERT_EQ (0, resume_call_count);
 }
 
 TEST_F (ThreadStateCoordinatorTest, ResumedThreadAlreadyMarkedDoesNotHoldUpPendingStopNotification)
 {
     // We're going to test this scenario:
TEST_F (ThreadStateCoordinatorTest, ResumedThreadAlreadyMarkedDoesNotHoldUpPendingStopNotification)
     SetupKnownRunningThread (PENDING_TID_A);
     SetupKnownRunningThread (PENDING_TID_B);
 
     ThreadStateCoordinator::ThreadIDSet pending_stop_tids { PENDING_TID_A, PENDING_TID_B };
 
     // Notify we have a trigger that needs to be fired when all threads in the wait tid set have stopped.
     CallAfterThreadsStop (TRIGGERING_TID,
                           pending_stop_tids);
-
-    // Neither trigger should have gone off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_EQ (0u, GetRequestedStopCount ());
-
-    // Execute CallAfterThreadsStop.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Both TID A and TID B should have had stop requests made.
     ASSERT_EQ (2u, GetRequestedStopCount ());
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_TID_A));
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_TID_B));
 
     // But we still shouldn't have the deferred signal call go off yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Report thread A stopped.
     NotifyThreadStop (PENDING_TID_A);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now report thread A is resuming.  Ensure the resume is called.
     lldb::tid_t resumed_tid = 0;
     int resume_call_count = 0;
     m_coordinator.RequestThreadResume (PENDING_TID_A,
                                        GetResumeThreadFunction(resumed_tid, resume_call_count),
                                        GetErrorFunction ());
-    ASSERT_EQ (0, resume_call_count);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (1, resume_call_count);
     ASSERT_EQ (PENDING_TID_A, resumed_tid);
 
     // Report thread B stopped.
     NotifyThreadStop (PENDING_TID_B);
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // After notifying thread b stopped, we now have thread a resumed but thread b stopped.
     // However, since thread a had stopped, we now have had both requirements stopped at some point.
     // For now we'll expect this will fire the pending deferred stop notification.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterRunningThreadsStopFiresWhenNoRunningThreads)
 {
     // Let the coordinator know about our thread.
     SetupKnownStoppedThread (TRIGGERING_TID);
 
     // Notify we have a trigger that needs to be fired when all running threads have stopped.
     CallAfterRunningThreadsStop (TRIGGERING_TID);
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
-    // Notification trigger shouldn't go off yet.
-    ASSERT_EQ (false, DidFireDeferredNotification ());
-
-    // Process next event.  This will pick up the call after threads stop event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
-
-    // Now the trigger should have fired, since there were no threads that needed to first stop.
+    // The trigger should have fired, since there were no threads that needed to first stop.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 
     // And no stop requests should have been made.
     ASSERT_EQ (0u, GetRequestedStopCount ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterRunningThreadsStopRequestsTwoPendingStops)
 {
     // Let the coordinator know about our threads.
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
     SetupKnownRunningThread (PENDING_STOP_TID_02);
 
     // Notify we have a trigger that needs to be fired when all running threads have stopped.
     CallAfterRunningThreadsStop (TRIGGERING_TID);
 
     // Notification trigger shouldn't go off yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Process next event.  This will pick up the call after threads stop event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // We should have two stop requests for the two threads currently running.
     ASSERT_EQ (2u, GetRequestedStopCount ());
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID_02));
 
     // But the deferred stop notification should not have fired yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now notify the two threads stopped.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     NotifyThreadStop (PENDING_STOP_TID_02);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Now the trigger should have fired, since there were no threads that needed to first stop.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }
 
 TEST_F (ThreadStateCoordinatorTest, CallAfterRunningThreadsStopRequestsStopTwoOtherThreadsOneRunning)
 {
     // Let the coordinator know about our threads.  PENDING_STOP_TID_02 will already be stopped.
     SetupKnownStoppedThread (TRIGGERING_TID);
     SetupKnownRunningThread (PENDING_STOP_TID);
     SetupKnownStoppedThread (PENDING_STOP_TID_02);
 
     // Notify we have a trigger that needs to be fired when all running threads have stopped.
     CallAfterRunningThreadsStop (TRIGGERING_TID);
 
     // Notification trigger shouldn't go off yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Process next event.  This will pick up the call after threads stop event.
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // We should have two stop requests for the two threads currently running.
     ASSERT_EQ (1u, GetRequestedStopCount ());
     ASSERT_EQ (true, DidRequestStopForTid (PENDING_STOP_TID));
 
     // But the deferred stop notification should not have fired yet.
     ASSERT_EQ (false, DidFireDeferredNotification ());
 
     // Now notify the two threads stopped.
     NotifyThreadStop (PENDING_STOP_TID);
-    ASSERT_PROCESS_NEXT_EVENT_SUCCEEDS ();
+    ASSERT_PROCESS_EVENT_SUCCEEDED ();
 
     // Now the trigger should have fired, since there were no threads that needed to first stop.
     ASSERT_EQ (true, DidFireDeferredNotification ());
     ASSERT_EQ (TRIGGERING_TID, GetDeferredNotificationTID ());
 }