Terminate event handler thread on isolate shutdown.

runtime/bin/eventhandler_macos.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/eventhandler.h"
 
 #include <errno.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 14 matching lines @@
     UNREACHABLE();
     return 0;
   }
   return ((static_cast<int64_t>(tv.tv_sec) * 1000000) + tv.tv_usec) / 1000;
 }
 
 
 static const int kInterruptMessageSize = sizeof(InterruptMessage);
 static const int kInfinityTimeout = -1;
 static const int kTimerId = -1;
+static const int kShutdownId = -2;
 
 
 bool SocketData::HasReadEvent() {
   return !IsClosedRead() && ((mask_ & (1 << kInEvent)) != 0);
 }
 
 
 bool SocketData::HasWriteEvent() {
   return !IsClosedWrite() && ((mask_ & (1 << kOutEvent)) != 0);
 }
@@ skipping 71 matching lines @@
 EventHandlerImplementation::EventHandlerImplementation()
     : socket_map_(&HashMap::SamePointerValue, 16) {
   intptr_t result;
   result = TEMP_FAILURE_RETRY(pipe(interrupt_fds_));
   if (result != 0) {
     FATAL("Pipe creation failed");
   }
   FDUtils::SetNonBlocking(interrupt_fds_[0]);
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
+  shutdown_ = false;
 
   kqueue_fd_ = TEMP_FAILURE_RETRY(kqueue());
   if (kqueue_fd_ == -1) {
     FATAL("Failed creating kqueue");
   }
   // Register the interrupt_fd with the kqueue.
   struct kevent event;
   EV_SET(&event, interrupt_fds_[0], EVFILT_READ, EV_ADD, 0, 0, NULL);
   int status = TEMP_FAILURE_RETRY(kevent(kqueue_fd_, &event, 1, NULL, 0, NULL));
   if (status == -1) {
@@ skipping 62 matching lines @@
   }
   return (total_read == kInterruptMessageSize) ? true : false;
 }
 
 void EventHandlerImplementation::HandleInterruptFd() {
   InterruptMessage msg;
   while (GetInterruptMessage(&msg)) {
     if (msg.id == kTimerId) {
       timeout_ = msg.data;
       timeout_port_ = msg.dart_port;
+    } else if (msg.id == kShutdownId) {
+      shutdown_ = true;
     } else {
       SocketData* sd = GetSocketData(msg.id);
       if ((msg.data & (1 << kShutdownReadCommand)) != 0) {
         ASSERT(msg.data == (1 << kShutdownReadCommand));
         // Close the socket for reading.
         sd->ShutdownRead();
         UpdateKqueue(kqueue_fd_, sd);
       } else if ((msg.data & (1 << kShutdownWriteCommand)) != 0) {
         ASSERT(msg.data == (1 << kShutdownWriteCommand));
         // Close the socket for writing.
@@ skipping 132 matching lines @@
   }
 }
 
 
 void EventHandlerImplementation::EventHandlerEntry(uword args) {
   static const intptr_t kMaxEvents = 16;
   struct kevent events[kMaxEvents];
   EventHandlerImplementation* handler =
       reinterpret_cast<EventHandlerImplementation*>(args);
   ASSERT(handler != NULL);
-  while (1) {
+  while (!handler->shutdown_) {
     intptr_t millis = handler->GetTimeout();
     // NULL pointer timespec for infinite timeout.
     ASSERT(kInfinityTimeout < 0);
     struct timespec* timeout = NULL;
     struct timespec ts;
     if (millis >= 0) {
       ts.tv_sec = millis / 1000;
       ts.tv_nsec = (millis - (ts.tv_sec * 1000)) * 1000000;
       timeout = &ts;
     }
     intptr_t result = TEMP_FAILURE_RETRY(kevent(handler->kqueue_fd_,
                                                 NULL,
                                                 0,
                                                 events,
                                                 kMaxEvents,
                                                 timeout));
     if (result == -1) {
       FATAL1("kevent failed %s\n", strerror(errno));
     } else {
       handler->HandleTimeout();
       handler->HandleEvents(events, result);
     }
   }
 }
 
 
-void EventHandlerImplementation::StartEventHandler() {
+void EventHandlerImplementation::Start() {
   int result =
       dart::Thread::Start(&EventHandlerImplementation::EventHandlerEntry,
                           reinterpret_cast<uword>(this));
   if (result != 0) {
     FATAL1("Failed to start event handler thread %d", result);
   }
 }
 
 
+void EventHandlerImplementation::Shutdown() {
+  SendData(kShutdownId, 0, 0);
+}
+
+
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 
 void* EventHandlerImplementation::GetHashmapKeyFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return reinterpret_cast<void*>(fd + 1);
 }
 
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }