Use the event-handler for timers.

src/vm/event_handler_linux.cc

 // Copyright (c) 2015, the Fletch 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.md file.
 
 #if defined(FLETCH_TARGET_OS_LINUX)
 
 #include "src/vm/event_handler.h"
 
 #include <sys/epoll.h>
+#include <sys/timerfd.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 
+#include "src/shared/utils.h"
 #include "src/vm/thread.h"
+#include "src/vm/vector.h"
 
 // Some versions of android sys/epoll does not define
 // EPOLLRDHUP. However, it works as intended, so we just
 // define it if it is not there.
 #if !defined(EPOLLRDHUP)
 #define EPOLLRDHUP 0x2000
 #endif  // !defined(EPOLLRDHUP)
 
 namespace fletch {
 
 int EventHandler::Create() {
   int fd = epoll_create(1);
   int status = fcntl(fd, F_SETFD, FD_CLOEXEC);
   if (status == -1) FATAL("Failed making epoll descriptor close on exec.");
   return fd;
 }
 
 void EventHandler::Run() {
   struct epoll_event event;
-  event.events = EPOLLHUP | EPOLLRDHUP;
+  event.events = EPOLLHUP | EPOLLRDHUP | EPOLLIN;
   event.data.fd = read_fd_;
   epoll_ctl(fd_, EPOLL_CTL_ADD, read_fd_, &event);
   while (true) {
-    int status = epoll_wait(fd_, &event, 1, -1);
+    int64 next_timeout;
+    {
+      ScopedMonitorLock locker(monitor_);
+      next_timeout = next_timeout_;
+    }
+
+    if (next_timeout == INT64_MAX) {
+      next_timeout = -1;
+    } else {
+      next_timeout -= Platform::GetMicroseconds() / 1000LL;
+      if (next_timeout < 0) next_timeout = 0;
+    }
+
+    int status = epoll_wait(fd_, &event, 1, next_timeout);
+
+    {
+      // Check timeouts.
+      int64 current_time = Platform::GetMicroseconds() / 1000LL;
+      ScopedMonitorLock scoped_lock(monitor_);
+      if (next_timeout_ <= current_time) {
+        int64 next_timeout = INT64_MAX;
+        // TODO(ajohnsen): We could consider a heap structure to avoid O(n^2) in
+        // this case?
+        while (true) {

[Mads Ager (google), 2015/10/01 14:08:37]

Would this be easier to read if it was a do-while?

bool found = false;
do {
  for (...) {
    ...
  }
} while (found);

Maybe add a comment that you are doing the O(n^2) iteration here to avoid
modification during iteration on the hashmap.

[Anders Johnsen, 2015/10/02 00:25:14]

I need to reset found to false, so sadly not a real gain. Added comment.

+          bool found = false;
+          for (auto it = timeouts_.Begin(); it != timeouts_.End(); ++it) {
+            if (it->second <= current_time) {
+              Send(it->first, 0);
+              timeouts_.Erase(it);
+              found = true;
+              break;
+            } else {
+              next_timeout = Utils::Minimum(next_timeout, it->second);
+            }
+          }
+          if (!found) break;
+        }
+        next_timeout_ = next_timeout;
+      }
+    }
+
     if (status != 1) continue;
 
+    int events = event.events;
+
     if (event.data.fd == read_fd_) {
-      close(read_fd_);
-      close(fd_);
+      if ((events & EPOLLIN) != 0) {
+        char b;
+        read(read_fd_, &b, 1);
+        continue;
+      } else {
+        close(read_fd_);
+        close(fd_);
 
-      ScopedMonitorLock locker(monitor_);
-      fd_ = -1;
-      monitor_->Notify();
-      return;
+        ScopedMonitorLock locker(monitor_);
+        fd_ = -1;
+        monitor_->Notify();
+        return;
+      }
     }
 
-    int events = event.events;
     word mask = 0;
     if ((events & EPOLLIN) != 0) mask |= READ_EVENT;
     if ((events & EPOLLOUT) != 0) mask |= WRITE_EVENT;
     if ((events & EPOLLRDHUP) != 0) mask |= CLOSE_EVENT;
     if ((events & EPOLLHUP) != 0) mask |= CLOSE_EVENT;
     if ((events & EPOLLERR) != 0) mask |= ERROR_EVENT;
 
     Port* port = reinterpret_cast<Port*>(event.data.ptr);
     Send(port, mask);
   }
 }
 
 }  // namespace fletch
 
 #endif  // defined(FLETCH_TARGET_OS_LINUX)