Method cleanup

src/process.cpp:3086–3172

void ProcessManager::cleanup(ProcessBase* process)
{
  VLOG(3) << "Cleaning up " << process->pid;

  // Invariant today is that all processes must be initialized and
  // have their state transition to READY before being terminated.
  CHECK(process->state.load() == ProcessBase::State::READY);

  // First, set the terminating state so no more events will get
  // enqueued and then decomission the event queue which will also
  // delete all the pending events. We want to delete the events
  // before we hold `processes_mutex` because deleting an event could
  // cause code outside libprocess to get executed which might cause a
  // deadlock with `processes_mutex`. Also, deleting the events now
  // rather than later has the nice property of making sure that any
  // _new_ events that might have gotten enqueued _BACK_ onto this
  // process due to the deleting of the pending events will get
  // dropped since this process is now TERMINATING, which eliminates
  // the potential of these new events from getting enqueued onto a
  // _new_ process that gets spawned with the same PID.
  process->state.store(ProcessBase::State::TERMINATING);

  process->events->consumer.decomission();

  // Remove help strings for all installed routes for this process.
  dispatch(help, &Help::remove, process->pid.id);

    // Possible gate non-libprocess threads are waiting at.
  std::shared_ptr<Gate> gate = process->gate;

  // Remove process.
  synchronized (processes_mutex) {
    // Reset the reference so that we don't keep giving out references
    // in `ProcessManager::use`.
    //
    // NOTE: this must be done from within the `processes_mutex` since
    // that is where we read it and this is considered a write.
    process->reference.reset();

    // Wait for all process references to get cleaned up.
    CHECK_SOME(process->pid.reference);
    while (!process->pid.reference->expired()) {
#if defined(__i386__) || defined(__x86_64__)
      asm ("pause");
#endif
    }

    processes.erase(process->pid.id);

    // Note that we don't remove the process from the clock during
    // cleanup, but rather the clock is reset for a process when it is
    // created (see ProcessBase::ProcessBase). We do this so that
    // `SocketManager::exited()` can access the current time of the
    // process to "order" exited events. TODO(benh): It might make
    // sense to consider storing the time of the process as a field of
    // the class instead. It probably also makes sense to pass the
    // time to `SocketManager::exited()` rather than expect it to call
    // into the clock.