One event handler for all isolates

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 "platform/globals.h"
 #if defined(TARGET_OS_MACOS)
 
 #include "bin/eventhandler.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 112 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]);
   FDUtils::SetCloseOnExec(interrupt_fds_[0]);
   FDUtils::SetCloseOnExec(interrupt_fds_[1]);
-  timeout_ = kInfinityTimeout;
-  timeout_port_ = 0;
   shutdown_ = false;
 
   kqueue_fd_ = TEMP_FAILURE_RETRY(kqueue());
   if (kqueue_fd_ == -1) {
     FATAL("Failed creating kqueue");
   }
   FDUtils::SetCloseOnExec(kqueue_fd_);
   // Register the interrupt_fd with the kqueue.
   struct kevent event;
   EV_SET(&event, interrupt_fds_[0], EVFILT_READ, EV_ADD, 0, 0, NULL);
@@ skipping 63 matching lines @@
       total_read = total_read + bytes_read;
     }
   }
   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;
+      timeout_queue_.UpdateTimeout(msg.dart_port, msg.data);
     } 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) {
@@ skipping 123 matching lines @@
         ASSERT(port != 0);
         DartUtils::PostInt32(port, event_mask);
       }
     }
   }
   HandleInterruptFd();
 }
 
 
 int64_t EventHandlerImplementation::GetTimeout() {
-  if (timeout_ == kInfinityTimeout) {
+  if (!timeout_queue_.HasTimeout()) {
     return kInfinityTimeout;
   }
-  int64_t millis = timeout_ - TimerUtils::GetCurrentTimeMilliseconds();
+  int64_t millis = timeout_queue_.CurrentTimeout() -
+      TimerUtils::GetCurrentTimeMilliseconds();
   return (millis < 0) ? 0 : millis;
 }
 
 
 void EventHandlerImplementation::HandleTimeout() {
-  if (timeout_ != kInfinityTimeout) {
-    int64_t millis = timeout_ - TimerUtils::GetCurrentTimeMilliseconds();
+  if (timeout_queue_.HasTimeout()) {
+    int64_t millis = timeout_queue_.CurrentTimeout() -
+        TimerUtils::GetCurrentTimeMilliseconds();
     if (millis <= 0) {
-      DartUtils::PostNull(timeout_port_);
-      timeout_ = kInfinityTimeout;
-      timeout_port_ = 0;
+      DartUtils::PostNull(timeout_queue_.CurrentPort());
+      timeout_queue_.RemoveCurrent();
     }
   }
 }
 
 
 void EventHandlerImplementation::EventHandlerEntry(uword args) {
   static const intptr_t kMaxEvents = 16;
   struct kevent events[kMaxEvents];
   EventHandler* handler = reinterpret_cast<EventHandler*>(args);
   EventHandlerImplementation* handler_impl = &handler->delegate_;
@@ skipping 58 matching lines @@
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_MACOS)