Limit the number of syscalls made by the Eventhandler.

runtime/bin/eventhandler_android.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_ANDROID)
 
 #include "bin/eventhandler.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 56 matching lines @@
 }
 
 
 // Register the file descriptor for a SocketData structure with epoll
 // if events are requested.
 static void UpdateEpollInstance(intptr_t epoll_fd_, SocketData* sd) {
   struct epoll_event event;
   event.events = sd->GetPollEvents();
   event.data.ptr = sd;
   if (sd->port() != 0 && event.events != 0) {
+    // Only report events once and wait for them to be re-enabled after the
+    // event has been handled by the Dart code.
+    event.events |= EPOLLONESHOT;

[zra, 2013/11/22 22:30:58]

Is this used only in the standalone VM? It isn't breaking the Android Dartium
build, but since EPOLLONESHOT doesn't exit in the NDK, it is breaking the
Android standalone VM build. (Sorry the Android build isn't possible from
build.py, yet. We're working on it. In the meantime maybe it would be best to
add me to CL's with Android changes so I can try them out before they land.)

     int status = 0;
     if (sd->tracked_by_epoll()) {
       status = TEMP_FAILURE_RETRY(epoll_ctl(epoll_fd_,
                                             EPOLL_CTL_MOD,
                                             sd->fd(),
                                             &event));
     } else {
       status = TEMP_FAILURE_RETRY(epoll_ctl(epoll_fd_,
                                             EPOLL_CTL_ADD,
                                             sd->fd(),
@@ skipping 248 matching lines @@
 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 {
       SocketData* sd = reinterpret_cast<SocketData*>(events[i].data.ptr);
       intptr_t event_mask = GetPollEvents(events[i].events, sd);
       if (event_mask != 0) {
-        // Unregister events for the file descriptor. Events will be
-        // registered again when the current event has been handled in
-        // Dart code.
-        RemoveFromEpollInstance(epoll_fd_, sd);
         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();
@@ skipping 35 matching lines @@
     if (millis > kMaxInt32) millis = kMaxInt32;
     intptr_t result = TEMP_FAILURE_RETRY(epoll_wait(handler->epoll_fd_,
                                                     events,
                                                     kMaxEvents,
                                                     millis));
     ASSERT(EAGAIN == EWOULDBLOCK);
     if (result == -1) {
       if (errno != EWOULDBLOCK) {
         perror("Poll failed");
       }
+    } else if (result == 0) {
+      handler->HandleTimeout();
     } else {
-      handler->HandleTimeout();
       handler->HandleEvents(events, result);
     }
   }
 }
 
 
 void EventHandlerImplementation::Start(EventHandler* handler) {
   int result = dart::Thread::Start(&EventHandlerImplementation::Poll,
                                    reinterpret_cast<uword>(handler));
   if (result != 0) {
@@ skipping 22 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_ANDROID)