evdispatch 0.2.5 → 0.2.6

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/ev.h

@@ -100,6 +100,8 @@ struct ev_loop;
 # define EV_P_ EV_P,
 # define EV_A loop
 # define EV_A_ EV_A,
+# define EV_DEFAULT_UC ev_default_loop_uc ()
+# define EV_DEFAULT_UC_ EV_DEFAULT_UC,
 # define EV_DEFAULT ev_default_loop (0)
 # define EV_DEFAULT_ EV_DEFAULT,
 #else
@@ -109,28 +111,37 @@ struct ev_loop;
 # define EV_A_
 # define EV_DEFAULT
 # define EV_DEFAULT_
-
+# define EV_DEFAULT_UC
+# define EV_DEFAULT_UC_
 # undef EV_EMBED_ENABLE
 #endif
 
+#if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3
+# define EV_INLINE static inline
+#else
+# define EV_INLINE static
+#endif
+
+/*****************************************************************************/
+
 /* eventmask, revents, events... */
-#define EV_UNDEF            -1L /* guaranteed to be invalid */
-#define EV_NONE           0x00L /* no events */
-#define EV_READ           0x01L /* ev_io detected read will not block */
-#define EV_WRITE          0x02L /* ev_io detected write will not block */
-#define EV_IOFDSET        0x80L /* internal use only */
-#define EV_TIMEOUT  0x00000100L /* timer timed out */
-#define EV_PERIODIC 0x00000200L /* periodic timer timed out */
-#define EV_SIGNAL   0x00000400L /* signal was received */
-#define EV_CHILD    0x00000800L /* child/pid had status change */
-#define EV_STAT     0x00001000L /* stat data changed */
-#define EV_IDLE     0x00002000L /* event loop is idling */
-#define EV_PREPARE  0x00004000L /* event loop about to poll */
-#define EV_CHECK    0x00008000L /* event loop finished poll */
-#define EV_EMBED    0x00010000L /* embedded event loop needs sweep */
-#define EV_FORK     0x00020000L /* event loop resumed in child */
-#define EV_ASYNC    0x00040000L /* async intra-loop signal */
-#define EV_ERROR    0x80000000L /* sent when an error occurs */
+#define EV_UNDEF            -1 /* guaranteed to be invalid */
+#define EV_NONE           0x00 /* no events */
+#define EV_READ           0x01 /* ev_io detected read will not block */
+#define EV_WRITE          0x02 /* ev_io detected write will not block */
+#define EV_IOFDSET        0x80 /* internal use only */
+#define EV_TIMEOUT  0x00000100 /* timer timed out */
+#define EV_PERIODIC 0x00000200 /* periodic timer timed out */
+#define EV_SIGNAL   0x00000400 /* signal was received */
+#define EV_CHILD    0x00000800 /* child/pid had status change */
+#define EV_STAT     0x00001000 /* stat data changed */
+#define EV_IDLE     0x00002000 /* event loop is idling */
+#define EV_PREPARE  0x00004000 /* event loop about to poll */
+#define EV_CHECK    0x00008000 /* event loop finished poll */
+#define EV_EMBED    0x00010000 /* embedded event loop needs sweep */
+#define EV_FORK     0x00020000 /* event loop resumed in child */
+#define EV_ASYNC    0x00040000 /* async intra-loop signal */
+#define EV_ERROR    0x80000000 /* sent when an error occurs */
 
 /* can be used to add custom fields to all watchers, while losing binary compatibility */
 #ifndef EV_COMMON
@@ -327,7 +338,7 @@ typedef struct ev_async
   EV_ATOMIC_T sent; /* private */
 } ev_async;
 
-# define ev_async_pending(w) (((w)->sent + 0)
+# define ev_async_pending(w) ((w)->sent + 0)
 #endif
 
 /* the presence of this union forces similar struct layout */
@@ -355,24 +366,24 @@ union ev_any_watcher
 #if EV_EMBED_ENABLE
   struct ev_embed embed;
 #endif
-#if EV_ASYND_ENABLE
+#if EV_ASYNC_ENABLE
   struct ev_async async;
 #endif
 };
 
 /* bits for ev_default_loop and ev_loop_new */
 /* the default */
-#define EVFLAG_AUTO       0x00000000UL /* not quite a mask */
+#define EVFLAG_AUTO       0x00000000U /* not quite a mask */
 /* flag bits */
-#define EVFLAG_NOENV      0x01000000UL /* do NOT consult environment */
-#define EVFLAG_FORKCHECK  0x02000000UL /* check for a fork in each iteration */
+#define EVFLAG_NOENV      0x01000000U /* do NOT consult environment */
+#define EVFLAG_FORKCHECK  0x02000000U /* check for a fork in each iteration */
 /* method bits to be ored together */
-#define EVBACKEND_SELECT  0x00000001UL /* about anywhere */
-#define EVBACKEND_POLL    0x00000002UL /* !win */
-#define EVBACKEND_EPOLL   0x00000004UL /* linux */
-#define EVBACKEND_KQUEUE  0x00000008UL /* bsd */
-#define EVBACKEND_DEVPOLL 0x00000010UL /* solaris 8 */ /* NYI */
-#define EVBACKEND_PORT    0x00000020UL /* solaris 10 */
+#define EVBACKEND_SELECT  0x00000001U /* about anywhere */
+#define EVBACKEND_POLL    0x00000002U /* !win */
+#define EVBACKEND_EPOLL   0x00000004U /* linux */
+#define EVBACKEND_KQUEUE  0x00000008U /* bsd */
+#define EVBACKEND_DEVPOLL 0x00000010U /* solaris 8 */ /* NYI */
+#define EVBACKEND_PORT    0x00000020U /* solaris 10 */
 
 #if EV_PROTOTYPES
 int ev_version_major (void);
@@ -400,18 +411,29 @@ void ev_set_allocator (void *(*cb)(void *ptr, long size));
 void ev_set_syserr_cb (void (*cb)(const char *msg));
 
 # if EV_MULTIPLICITY
+EV_INLINE struct ev_loop *
+ev_default_loop_uc (void)
+{
+  extern struct ev_loop *ev_default_loop_ptr;
+
+  return ev_default_loop_ptr;
+}
+
 /* the default loop is the only one that handles signals and child watchers */
 /* you can call this as often as you like */
-static struct ev_loop *
+EV_INLINE struct ev_loop *
 ev_default_loop (unsigned int flags)
 {
-  extern struct ev_loop *ev_default_loop_ptr;
-  extern struct ev_loop *ev_default_loop_init (unsigned int flags);
+  struct ev_loop *loop = ev_default_loop_uc ();
 
-  if (!ev_default_loop_ptr)
-    ev_default_loop_init (flags);
+  if (!loop)
+    {
+      extern struct ev_loop *ev_default_loop_init (unsigned int flags);
 
-  return ev_default_loop_ptr;
+      loop = ev_default_loop_init (flags);
+    }
+
+  return loop;
 }
 
 /* create and destroy alternative loops that don't handle signals */
@@ -425,7 +447,7 @@ ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after
 
 int ev_default_loop (unsigned int flags); /* returns true when successful */
 
-static ev_tstamp
+EV_INLINE ev_tstamp
 ev_now (void)
 {
   extern ev_tstamp ev_rt_now;
@@ -434,7 +456,7 @@ ev_now (void)
 }
 # endif
 
-static int
+EV_INLINE int
 ev_is_default_loop (EV_P)
 {
 #if EV_MULTIPLICITY

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/ev.pod

@@ -198,18 +198,21 @@ See the description of C<ev_embed> watchers for more info.
 =item ev_set_allocator (void *(*cb)(void *ptr, long size))
 
 Sets the allocation function to use (the prototype is similar - the
-semantics is identical - to the realloc C function). It is used to
-allocate and free memory (no surprises here). If it returns zero when
-memory needs to be allocated, the library might abort or take some
-potentially destructive action. The default is your system realloc
-function.
+semantics are identical to the C<realloc> C89/SuS/POSIX function). It is
+used to allocate and free memory (no surprises here). If it returns zero
+when memory needs to be allocated (C<size != 0>), the library might abort
+or take some potentially destructive action.
+
+Since some systems (at least OpenBSD and Darwin) fail to implement
+correct C<realloc> semantics, libev will use a wrapper around the system
+C<realloc> and C<free> functions by default.
 
 You could override this function in high-availability programs to, say,
 free some memory if it cannot allocate memory, to use a special allocator,
 or even to sleep a while and retry until some memory is available.
 
 Example: Replace the libev allocator with one that waits a bit and then
-retries).
+retries (example requires a standards-compliant C<realloc>).
 
    static void *
    persistent_realloc (void *ptr, size_t size)
@@ -258,13 +261,6 @@ An event loop is described by a C<struct ev_loop *>. The library knows two
 types of such loops, the I<default> loop, which supports signals and child
 events, and dynamically created loops which do not.
 
-If you use threads, a common model is to run the default event loop
-in your main thread (or in a separate thread) and for each thread you
-create, you also create another event loop. Libev itself does no locking
-whatsoever, so if you mix calls to the same event loop in different
-threads, make sure you lock (this is usually a bad idea, though, even if
-done correctly, because it's hideous and inefficient).
-
 =over 4
 
 =item struct ev_loop *ev_default_loop (unsigned int flags)
@@ -360,7 +356,7 @@ but it scales phenomenally better. While poll and select usually scale
 like O(total_fds) where n is the total number of fds (or the highest fd),
 epoll scales either O(1) or O(active_fds). The epoll design has a number
 of shortcomings, such as silently dropping events in some hard-to-detect
-cases and rewiring a syscall per fd change, no fork support and bad
+cases and requiring a syscall per fd change, no fork support and bad
 support for dup.
 
 While stopping, setting and starting an I/O watcher in the same iteration
@@ -2384,6 +2380,9 @@ it a private API).
 will fail and all watchers will have the same priority, even though there
 is an ev_pri field.
 
+=item * In libevent, the last base created gets the signals, in libev, the
+first base created (== the default loop) gets the signals.
+
 =item * Other members are not supported.
 
 =item * The libev emulation is I<not> ABI compatible to libevent, you need
@@ -2635,6 +2634,16 @@ suitable for use with C<EV_A>.
 Similar to the other two macros, this gives you the value of the default
 loop, if multiple loops are supported ("ev loop default").
 
+=item C<EV_DEFAULT_UC>, C<EV_DEFAULT_UC_>
+
+Usage identical to C<EV_DEFAULT> and C<EV_DEFAULT_>, but requires that the
+default loop has been initialised (C<UC> == unchecked). Their behaviour
+is undefined when the default loop has not been initialised by a previous
+execution of C<EV_DEFAULT>, C<EV_DEFAULT_> or C<ev_default_init (...)>.
+
+It is often prudent to use C<EV_DEFAULT> when initialising the first
+watcher in a function but use C<EV_DEFAULT_UC> afterwards.
+
 =back
 
 Example: Declare and initialise a check watcher, utilising the above
@@ -2739,9 +2748,9 @@ For this of course you need the m4 file:
 
 =head2 PREPROCESSOR SYMBOLS/MACROS
 
-Libev can be configured via a variety of preprocessor symbols you have to define
-before including any of its files. The default is not to build for multiplicity
-and only include the select backend.
+Libev can be configured via a variety of preprocessor symbols you have to
+define before including any of its files. The default in the absense of
+autoconf is noted for every option.
 
 =over 4
 
@@ -2777,6 +2786,14 @@ note about libraries in the description of C<EV_USE_MONOTONIC>, though.
 If defined to be C<1>, libev will assume that C<nanosleep ()> is available
 and will use it for delays. Otherwise it will use C<select ()>.
 
+=item EV_USE_EVENTFD
+
+If defined to be C<1>, then libev will assume that C<eventfd ()> is
+available and will probe for kernel support at runtime. This will improve
+C<ev_signal> and C<ev_async> performance and reduce resource consumption.
+If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
+
 =item EV_USE_SELECT
 
 If undefined or defined to be C<1>, libev will compile in support for the
@@ -2822,8 +2839,9 @@ takes precedence over select.
 
 If defined to be C<1>, libev will compile in support for the Linux
 C<epoll>(7) backend. Its availability will be detected at runtime,
-otherwise another method will be used as fallback. This is the
-preferred backend for GNU/Linux systems.
+otherwise another method will be used as fallback. This is the preferred
+backend for GNU/Linux systems. If undefined, it will be enabled if the
+headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 
 =item EV_USE_KQUEUE
 
@@ -2852,7 +2870,8 @@ reserved for future expansion, works like the USE symbols above.
 
 If defined to be C<1>, libev will compile in support for the Linux inotify
 interface to speed up C<ev_stat> watchers. Its actual availability will
-be detected at runtime.
+be detected at runtime. If undefined, it will be enabled if the headers
+indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 
 =item EV_ATOMIC_T
 
@@ -3049,6 +3068,63 @@ And a F<ev_cpp.C> implementation file that contains libev proper and is compiled
   #include "ev.c"
 
 
+=head1 THREADS AND COROUTINES
+
+=head2 THREADS
+
+Libev itself is completely threadsafe, but it uses no locking. This
+means that you can use as many loops as you want in parallel, as long as
+only one thread ever calls into one libev function with the same loop
+parameter.
+
+Or put differently: calls with different loop parameters can be done in
+parallel from multiple threads, calls with the same loop parameter must be
+done serially (but can be done from different threads, as long as only one
+thread ever is inside a call at any point in time, e.g. by using a mutex
+per loop).
+
+If you want to know which design is best for your problem, then I cannot
+help you but by giving some generic advice:
+
+=over 4
+
+=item * most applications have a main thread: use the default libev loop
+in that thread, or create a seperate thread running only the default loop.
+
+This helps integrating other libraries or software modules that use libev
+themselves and don't care/know about threading.
+
+=item * one loop per thread is usually a good model.
+
+Doing this is almost never wrong, sometimes a better-performance model
+exists, but it is always a good start.
+
+=item * other models exist, such as the leader/follower pattern, where one
+loop is handed through multiple threads in a kind of round-robbin fashion.
+
+Chosing a model is hard - look around, learn, know that usually you cna do
+better than you currently do :-)
+
+=item * often you need to talk to some other thread which blocks in the
+event loop - C<ev_async> watchers can be used to wake them up from other
+threads safely (or from signal contexts...).
+
+=back
+
+=head2 COROUTINES
+
+Libev is much more accomodating to coroutines ("cooperative threads"):
+libev fully supports nesting calls to it's functions from different
+coroutines (e.g. you can call C<ev_loop> on the same loop from two
+different coroutines and switch freely between both coroutines running the
+loop, as long as you don't confuse yourself). The only exception is that
+you must not do this from C<ev_periodic> reschedule callbacks.
+
+Care has been invested into making sure that libev does not keep local
+state inside C<ev_loop>, and other calls do not usually allow coroutine
+switches.
+
+
 =head1 COMPLEXITIES
 
 In this section the complexities of (many of) the algorithms used inside

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/ev_poll.c

@@ -86,7 +86,7 @@ poll_modify (EV_P_ int fd, int oev, int nev)
 static void
 poll_poll (EV_P_ ev_tstamp timeout)
 {
-  int i;
+  struct pollfd *p;
   int res = poll (polls, pollcnt, (int)ceil (timeout * 1000.));
 
   if (expect_false (res < 0))
@@ -97,20 +97,23 @@ poll_poll (EV_P_ ev_tstamp timeout)
         fd_enomem (EV_A);
       else if (errno != EINTR)
         syserr ("(libev) poll");
-
-      return;
     }
-
-  for (i = 0; i < pollcnt; ++i)
-    if (expect_false (polls [i].revents & POLLNVAL))
-      fd_kill (EV_A_ polls [i].fd);
-    else
-      fd_event (
-        EV_A_
-        polls [i].fd,
-        (polls [i].revents & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
-        | (polls [i].revents & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
-      );
+  else
+    for (p = polls; res; ++p)
+      if (expect_false (p->revents)) /* this expect is debatable */
+        {
+          --res;
+
+          if (expect_false (p->revents & POLLNVAL))
+            fd_kill (EV_A_ p->fd);
+          else
+            fd_event (
+              EV_A_
+              p->fd,
+              (p->revents & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
+              | (p->revents & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
+            );
+        }
 }
 
 int inline_size

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/ev_vars.h

@@ -55,6 +55,9 @@ VARx(ev_tstamp, backend_fudge) /* assumed typical timer resolution */
 VAR (backend_modify, void (*backend_modify)(EV_P_ int fd, int oev, int nev))
 VAR (backend_poll  , void (*backend_poll)(EV_P_ ev_tstamp timeout))
 
+#if EV_USE_EVENTFD || EV_GENWRAP
+VARx(int, evfd)
+#endif
 VAR (evpipe, int evpipe [2])
 VARx(ev_io, pipeev)
 

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/ev_wrap.h

@@ -13,6 +13,7 @@
 #define backend_fudge ((loop)->backend_fudge)
 #define backend_modify ((loop)->backend_modify)
 #define backend_poll ((loop)->backend_poll)
+#define evfd ((loop)->evfd)
 #define evpipe ((loop)->evpipe)
 #define pipeev ((loop)->pipeev)
 #define curpid ((loop)->curpid)
@@ -84,6 +85,7 @@
 #undef backend_fudge
 #undef backend_modify
 #undef backend_poll
+#undef evfd
 #undef evpipe
 #undef pipeev
 #undef curpid

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/event.c

@@ -359,7 +359,7 @@ int event_base_loopexit (struct event_base *base, struct timeval *tv)
 
   ev_once (EV_A_ -1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);
 
-  return -1;
+  return 0;
 }
 
 struct x_once

data/ext/revdispatch/libdispatch-0.1/{libev-3.2 → libev-3.31}/libev.m4

@@ -2,9 +2,9 @@ dnl this file is part of libev, do not make local modifications
 dnl http://software.schmorp.de/pkg/libev
 
 dnl libev support 
-AC_CHECK_HEADERS(sys/inotify.h sys/epoll.h sys/event.h sys/queue.h port.h poll.h sys/select.h) 
+AC_CHECK_HEADERS(sys/inotify.h sys/epoll.h sys/event.h sys/queue.h port.h poll.h sys/select.h sys/eventfd.h) 
  
-AC_CHECK_FUNCS(inotify_init epoll_ctl kqueue port_create poll select)
+AC_CHECK_FUNCS(inotify_init epoll_ctl kqueue port_create poll select eventfd)
  
 AC_CHECK_FUNC(clock_gettime, [], [ 
    if test -z "$LIBEV_M4_AVOID_LIBRT"; then