One event handler for all isolates

runtime/bin/eventhandler_linux.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_LINUX)
 
 #include "bin/eventhandler.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 93 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;
   // The initial size passed to epoll_create is ignore on newer (>=
   // 2.6.8) Linux versions
   static const int kEpollInitialSize = 64;
   epoll_fd_ = TEMP_FAILURE_RETRY(epoll_create(kEpollInitialSize));
   if (epoll_fd_ == -1) {
     FATAL("Failed creating epoll file descriptor");
   }
   FDUtils::SetCloseOnExec(epoll_fd_);
   // Register the interrupt_fd with the epoll instance.
@@ skipping 65 matching lines @@
     bytes_read = TEMP_FAILURE_RETRY(read(interrupt_fds_[0],
                                          dst + total_read,
                                          kInterruptMessageSize - total_read));
     if (bytes_read > 0) {
       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();
         UpdateEpollInstance(epoll_fd_, sd);
       } else if ((msg.data & (1 << kShutdownWriteCommand)) != 0) {
@@ skipping 141 matching lines @@
       }
     }
   }
   // Handle after socket events, so we avoid closing a socket before we handle
   // the current events.
   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());
+      // Remove current from queue.
+      timeout_queue_.RemoveCurrent();
     }
   }
 }
 
 
 void EventHandlerImplementation::Poll(uword args) {
   static const intptr_t kMaxEvents = 16;
   struct epoll_event events[kMaxEvents];
   EventHandler* handler = reinterpret_cast<EventHandler*>(args);
   EventHandlerImplementation* handler_impl = &handler->delegate_;
@@ skipping 49 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_LINUX)