Use timerfd to handler timeouts on Linux.

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
 #include <pthread.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/epoll.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
+#include <sys/timerfd.h>  // NOLINT
 #include <unistd.h>  // NOLINT
 #include <fcntl.h>  // NOLINT
 
 #include "bin/dartutils.h"
 #include "bin/fdutils.h"
 #include "bin/log.h"
 #include "bin/utils.h"
 #include "platform/hashmap.h"
 #include "platform/thread.h"
 #include "platform/utils.h"
 
 
 namespace dart {
 namespace bin {
 
 static const int kInterruptMessageSize = sizeof(InterruptMessage);
-static const int kInfinityTimeout = -1;
 static const int kTimerId = -1;
 static const int kShutdownId = -2;
 
 
 intptr_t SocketData::GetPollEvents() {
   // Do not ask for EPOLLERR and EPOLLHUP explicitly as they are
   // triggered anyway.
   intptr_t events = 0;
   if (!IsClosedRead()) {
     if ((mask_ & (1 << kInEvent)) != 0) {
@@ skipping 84 matching lines @@
   struct epoll_event event;
   event.events = EPOLLIN;
   event.data.ptr = NULL;
   int status = TEMP_FAILURE_RETRY(epoll_ctl(epoll_fd_,
                                             EPOLL_CTL_ADD,
                                             interrupt_fds_[0],
                                             &event));
   if (status == -1) {
     FATAL("Failed adding interrupt fd to epoll instance");
   }
+  timer_fd_ = TEMP_FAILURE_RETRY(timerfd_create(CLOCK_REALTIME,
+                                                TFD_NONBLOCK | TFD_CLOEXEC));
+  if (epoll_fd_ == -1) {
+    FATAL("Failed creating timerfd file descriptor");
+  }
+  // Register the timer_fd_ with the epoll instance.
+  event.events = EPOLLIN;
+  event.data.fd = timer_fd_;
+  status = TEMP_FAILURE_RETRY(epoll_ctl(epoll_fd_,
+                                        EPOLL_CTL_ADD,
+                                        timer_fd_,
+                                        &event));
+  if (status == -1) {
+    FATAL("Failed adding timerfd fd to epoll instance");
+  }
 }
 
 
 EventHandlerImplementation::~EventHandlerImplementation() {
   TEMP_FAILURE_RETRY(close(epoll_fd_));
+  TEMP_FAILURE_RETRY(close(timer_fd_));
   TEMP_FAILURE_RETRY(close(interrupt_fds_[0]));
   TEMP_FAILURE_RETRY(close(interrupt_fds_[1]));
 }
 
 
 SocketData* EventHandlerImplementation::GetSocketData(intptr_t fd) {
   ASSERT(fd >= 0);
   HashMap::Entry* entry = socket_map_.Lookup(
       GetHashmapKeyFromFd(fd), GetHashmapHashFromFd(fd), true);
   ASSERT(entry != NULL);
@@ skipping 30 matching lines @@
   }
 }
 
 
 void EventHandlerImplementation::HandleInterruptFd() {
   const intptr_t MAX_MESSAGES = kInterruptMessageSize;
   InterruptMessage msg[MAX_MESSAGES];
   ssize_t bytes = TEMP_FAILURE_RETRY(
       read(interrupt_fds_[0], msg, MAX_MESSAGES * kInterruptMessageSize));
   for (ssize_t i = 0; i < bytes / kInterruptMessageSize; i++) {
     if (msg[i].id == kTimerId) {

[Søren Gjesse, 2013/12/05 07:39:34]

With this approach do we even need to send this through the pipe?

[Anders Johnsen, 2013/12/05 09:18:28]

The alternative is to have a FD per isolate, but then we need a isolate-shutdown
hook. Let's keep it as this for now, but it may be worth looking into the
alternative in the future.

       timeout_queue_.UpdateTimeout(msg[i].dart_port, msg[i].data);
+      struct itimerspec it;
+      memset(&it, 0, sizeof(it));
+      if (timeout_queue_.HasTimeout()) {
+        int64_t millis = timeout_queue_.CurrentTimeout();
+        it.it_value.tv_sec = millis / 1000;
+        it.it_value.tv_nsec = (millis % 1000) * 1000000;
+      }
+      timerfd_settime(timer_fd_, TFD_TIMER_ABSTIME, &it, NULL);

[Søren Gjesse, 2013/12/05 07:39:34]

If the abs time set here has just passed will the timer still fire?

[Anders Johnsen, 2013/12/05 09:18:28]

Yes, from spec:

  "If the specified absolute time has
   already passed, then the timer expires immediately, and the 
   overrun count (see timer_getoverrun(2)) will be set correctly"

     } else if (msg[i].id == kShutdownId) {
       shutdown_ = true;
     } else {
       SocketData* sd = GetSocketData(msg[i].id);
       if ((msg[i].data & (1 << kShutdownReadCommand)) != 0) {
         ASSERT(msg[i].data == (1 << kShutdownReadCommand));
         // Close the socket for reading.
         sd->ShutdownRead();
         UpdateEpollInstance(epoll_fd_, sd);
       } else if ((msg[i].data & (1 << kShutdownWriteCommand)) != 0) {
@@ skipping 127 matching lines @@
   return event_mask;
 }
 
 
 void EventHandlerImplementation::HandleEvents(struct epoll_event* events,
                                               int size) {
   bool interrupt_seen = false;
   for (int i = 0; i < size; i++) {
     if (events[i].data.ptr == NULL) {
       interrupt_seen = true;
+    } else if (events[i].data.fd == timer_fd_) {
+      int64_t val;
+      VOID_TEMP_FAILURE_RETRY(read(timer_fd_, &val, 8));

[Søren Gjesse, 2013/12/05 07:39:34]

Should we have a constant for '8' here just to indicate what this is? Maybe
there is one in the .h file.

[Anders Johnsen, 2013/12/05 09:18:28]

I'll use sizeof val.

+      if (timeout_queue_.HasTimeout()) {
+        DartUtils::PostNull(timeout_queue_.CurrentPort());
+        timeout_queue_.RemoveCurrent();
+      }
     } else {
       SocketData* sd = reinterpret_cast<SocketData*>(events[i].data.ptr);
       intptr_t event_mask = GetPollEvents(events[i].events, sd);
       if (event_mask == 0) {
         // Event not handled, re-add to epoll.
         UpdateEpollInstance(epoll_fd_, sd);
       } else {
         Dart_Port port = sd->port();
         ASSERT(port != 0);
         DartUtils::PostInt32(port, event_mask);
       }
     }
   }
   if (interrupt_seen) {
     // Handle after socket events, so we avoid closing a socket before we handle
     // the current events.
     HandleInterruptFd();
   }
 }
 
 
-int64_t EventHandlerImplementation::GetTimeout() {
-  if (!timeout_queue_.HasTimeout()) {
-    return kInfinityTimeout;
-  }
-  int64_t millis = timeout_queue_.CurrentTimeout() -
-      TimerUtils::GetCurrentTimeMilliseconds();
-  return (millis < 0) ? 0 : millis;
-}
-
-
-void EventHandlerImplementation::HandleTimeout() {
-  if (timeout_queue_.HasTimeout()) {
-    int64_t millis = timeout_queue_.CurrentTimeout() -
-        TimerUtils::GetCurrentTimeMilliseconds();
-    if (millis <= 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_;
   ASSERT(handler_impl != NULL);
   while (!handler_impl->shutdown_) {
-    int64_t millis = handler_impl->GetTimeout();
-    ASSERT(millis == kInfinityTimeout || millis >= 0);
-    if (millis > kMaxInt32) millis = kMaxInt32;
     intptr_t result = TEMP_FAILURE_RETRY(epoll_wait(handler_impl->epoll_fd_,
                                                     events,
                                                     kMaxEvents,
-                                                    millis));
+                                                    -1));

[Søren Gjesse, 2013/12/05 07:39:34]

Is there a constant for infinite?

[Anders Johnsen, 2013/12/05 09:18:28]

-1 is special-case for epoll_wait, to wait forever. I think we should keep it
like this, as it's strictly related to the epoll call.

     ASSERT(EAGAIN == EWOULDBLOCK);
-    if (result == -1) {
+    if (result <= 0) {
       if (errno != EWOULDBLOCK) {
         perror("Poll failed");
       }
-    } else if (result == 0) {
-      handler_impl->HandleTimeout();
     } else {
       handler_impl->HandleEvents(events, result);
     }
   }
   delete handler;
 }
 
 
 void EventHandlerImplementation::Start(EventHandler* handler) {
   int result = dart::Thread::Start(&EventHandlerImplementation::Poll,
@@ skipping 24 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)