Browse Source

- add non-os-assisted ev_stat watcher

- add some EV_MINIMAL, exg made me do it
master
Marc Alexander Lehmann 13 years ago
parent
commit
1f297ad879
4 changed files with 203 additions and 68 deletions
  1. +117
    -45
      ev.c
  2. +65
    -19
      ev.h
  3. +20
    -3
      ev.pod
  4. +1
    -1
      ev_vars.h

+ 117
- 45
ev.c View File

@ -113,9 +113,9 @@ extern "C" {
#include <signal.h>
#ifndef _WIN32
# include <unistd.h>
# include <sys/time.h>
# include <sys/wait.h>
# include <unistd.h>
#else
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
@ -189,10 +189,19 @@ extern "C" {
#if __GNUC__ >= 3
# define expect(expr,value) __builtin_expect ((expr),(value))
# define inline static inline
# define inline_size static inline /* inline for codesize */
# if EV_MINIMAL
# define noinline __attribute__ ((noinline))
# define inline_speed static noinline
# else
# define noinline
# define inline_speed static inline
# endif
#else
# define expect(expr,value) (expr)
# define inline static
# define inline_speed static
# define inline_minimal static
# define noinline
#endif
#define expect_false(expr) expect ((expr) != 0, 0)
@ -308,7 +317,7 @@ typedef struct
/*****************************************************************************/
ev_tstamp
ev_tstamp noinline
ev_time (void)
{
#if EV_USE_REALTIME
@ -322,7 +331,7 @@ ev_time (void)
#endif
}
inline ev_tstamp
ev_tstamp inline_size
get_clock (void)
{
#if EV_USE_MONOTONIC
@ -375,7 +384,7 @@ ev_now (EV_P)
/*****************************************************************************/
static void
void inline_size
anfds_init (ANFD *base, int count)
{
while (count--)
@ -388,7 +397,7 @@ anfds_init (ANFD *base, int count)
}
}
void
void noinline
ev_feed_event (EV_P_ void *w, int revents)
{
W w_ = (W)w;
@ -414,7 +423,7 @@ queue_events (EV_P_ W *events, int eventcnt, int type)
ev_feed_event (EV_A_ events [i], type);
}
inline void
void inline_speed
fd_event (EV_P_ int fd, int revents)
{
ANFD *anfd = anfds + fd;
@ -437,7 +446,7 @@ ev_feed_fd_event (EV_P_ int fd, int revents)
/*****************************************************************************/
inline void
void inline_size
fd_reify (EV_P)
{
int i;
@ -471,7 +480,7 @@ fd_reify (EV_P)
fdchangecnt = 0;
}
static void
void inline_size
fd_change (EV_P_ int fd)
{
if (expect_false (anfds [fd].reify))
@ -484,7 +493,7 @@ fd_change (EV_P_ int fd)
fdchanges [fdchangecnt - 1] = fd;
}
static void
void inline_speed
fd_kill (EV_P_ int fd)
{
ev_io *w;
@ -496,7 +505,7 @@ fd_kill (EV_P_ int fd)
}
}
inline int
int inline_size
fd_valid (int fd)
{
#ifdef _WIN32
@ -507,7 +516,7 @@ fd_valid (int fd)
}
/* called on EBADF to verify fds */
static void
static void noinline
fd_ebadf (EV_P)
{
int fd;
@ -519,7 +528,7 @@ fd_ebadf (EV_P)
}
/* called on ENOMEM in select/poll to kill some fds and retry */
static void
static void noinline
fd_enomem (EV_P)
{
int fd;
@ -533,7 +542,7 @@ fd_enomem (EV_P)
}
/* usually called after fork if backend needs to re-arm all fds from scratch */
static void
static void noinline
fd_rearm_all (EV_P)
{
int fd;
@ -549,7 +558,7 @@ fd_rearm_all (EV_P)
/*****************************************************************************/
static void
void inline_speed
upheap (WT *heap, int k)
{
WT w = heap [k];
@ -566,7 +575,7 @@ upheap (WT *heap, int k)
}
static void
void inline_speed
downheap (WT *heap, int N, int k)
{
WT w = heap [k];
@ -590,7 +599,7 @@ downheap (WT *heap, int N, int k)
((W)heap [k])->active = k + 1;
}
inline void
void inline_size
adjustheap (WT *heap, int N, int k)
{
upheap (heap, k);
@ -612,7 +621,7 @@ static int sigpipe [2];
static sig_atomic_t volatile gotsig;
static ev_io sigev;
static void
void inline_size
signals_init (ANSIG *base, int count)
{
while (count--)
@ -642,7 +651,7 @@ sighandler (int signum)
}
}
void
void noinline
ev_feed_signal_event (EV_P_ int signum)
{
WL w;
@ -675,7 +684,7 @@ sigcb (EV_P_ ev_io *iow, int revents)
ev_feed_signal_event (EV_A_ signum + 1);
}
static void
void inline_size
fd_intern (int fd)
{
#ifdef _WIN32
@ -687,7 +696,7 @@ fd_intern (int fd)
#endif
}
static void
static void noinline
siginit (EV_P)
{
fd_intern (sigpipe [0]);
@ -710,7 +719,7 @@ static ev_signal childev;
# define WCONTINUED 0
#endif
static void
void inline_speed
child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
{
ev_child *w;
@ -774,7 +783,7 @@ ev_version_minor (void)
}
/* return true if we are running with elevated privileges and should ignore env variables */
static int
int inline_size
enable_secure (void)
{
#ifdef _WIN32
@ -906,7 +915,7 @@ loop_destroy (EV_P)
/* have to use the microsoft-never-gets-it-right macro */
array_free (fdchange, EMPTY0);
array_free (timer, EMPTY0);
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
array_free (periodic, EMPTY0);
#endif
array_free (idle, EMPTY0);
@ -1052,7 +1061,7 @@ ev_default_fork (void)
/*****************************************************************************/
static int
int inline_size
any_pending (EV_P)
{
int pri;
@ -1064,7 +1073,7 @@ any_pending (EV_P)
return 0;
}
inline void
void inline_speed
call_pending (EV_P)
{
int pri;
@ -1084,7 +1093,7 @@ call_pending (EV_P)
}
}
inline void
void inline_size
timers_reify (EV_P)
{
while (timercnt && ((WT)timers [0])->at <= mn_now)
@ -1111,8 +1120,8 @@ timers_reify (EV_P)
}
}
#if EV_PERIODICS
inline void
#if EV_PERIODIC_ENABLE
void inline_size
periodics_reify (EV_P)
{
while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
@ -1141,7 +1150,7 @@ periodics_reify (EV_P)
}
}
static void
static void noinline
periodics_reschedule (EV_P)
{
int i;
@ -1163,7 +1172,7 @@ periodics_reschedule (EV_P)
}
#endif
inline int
int inline_size
time_update_monotonic (EV_P)
{
mn_now = get_clock ();
@ -1181,7 +1190,7 @@ time_update_monotonic (EV_P)
}
}
inline void
void inline_size
time_update (EV_P)
{
int i;
@ -1213,7 +1222,7 @@ time_update (EV_P)
now_floor = mn_now;
}
# if EV_PERIODICS
# if EV_PERIODIC_ENABLE
periodics_reschedule (EV_A);
# endif
/* no timer adjustment, as the monotonic clock doesn't jump */
@ -1227,7 +1236,7 @@ time_update (EV_P)
if (expect_false (mn_now > ev_rt_now || mn_now < ev_rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
{
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
periodics_reschedule (EV_A);
#endif
@ -1304,7 +1313,7 @@ ev_loop (EV_P_ int flags)
if (block > to) block = to;
}
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
if (periodiccnt)
{
ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge;
@ -1323,7 +1332,7 @@ ev_loop (EV_P_ int flags)
/* queue pending timers and reschedule them */
timers_reify (EV_A); /* relative timers called last */
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
periodics_reify (EV_A); /* absolute timers called first */
#endif
@ -1353,14 +1362,14 @@ ev_unloop (EV_P_ int how)
/*****************************************************************************/
inline void
void inline_size
wlist_add (WL *head, WL elem)
{
elem->next = *head;
*head = elem;
}
inline void
void inline_size
wlist_del (WL *head, WL elem)
{
while (*head)
@ -1375,7 +1384,7 @@ wlist_del (WL *head, WL elem)
}
}
inline void
void inline_speed
ev_clear_pending (EV_P_ W w)
{
if (w->pending)
@ -1385,7 +1394,7 @@ ev_clear_pending (EV_P_ W w)
}
}
inline void
void inline_speed
ev_start (EV_P_ W w, int active)
{
if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
@ -1395,7 +1404,7 @@ ev_start (EV_P_ W w, int active)
ev_ref (EV_A);
}
inline void
void inline_size
ev_stop (EV_P_ W w)
{
ev_unref (EV_A);
@ -1494,7 +1503,7 @@ ev_timer_again (EV_P_ ev_timer *w)
}
}
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
void
ev_periodic_start (EV_P_ ev_periodic *w)
{
@ -1697,8 +1706,8 @@ ev_child_stop (EV_P_ ev_child *w)
ev_stop (EV_A_ (W)w);
}
#if EV_MULTIPLICITY
void
#if EV_EMBED_ENABLE
void noinline
ev_embed_sweep (EV_P_ ev_embed *w)
{
ev_loop (w->loop, EVLOOP_NONBLOCK);
@ -1729,6 +1738,7 @@ ev_embed_start (EV_P_ ev_embed *w)
ev_set_priority (&w->io, ev_priority (w));
ev_io_start (EV_A_ &w->io);
ev_start (EV_A_ (W)w, 1);
}
@ -1740,6 +1750,68 @@ ev_embed_stop (EV_P_ ev_embed *w)
return;
ev_io_stop (EV_A_ &w->io);
ev_stop (EV_A_ (W)w);
}
#endif
#if EV_STAT_ENABLE
# ifdef _WIN32
# define lstat(a,b) stat(a,b)
# endif
void
ev_stat_stat (EV_P_ ev_stat *w)
{
if (lstat (w->path, &w->attr) < 0)
w->attr.st_nlink = 0;
else if (!w->attr.st_nlink)
w->attr.st_nlink = 1;
}
static void
stat_timer_cb (EV_P_ ev_timer *w_, int revents)
{
ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
/* we copy this here each the time so that */
/* prev has the old value when the callback gets invoked */
w->prev = w->attr;
ev_stat_stat (EV_A_ w);
if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))
ev_feed_event (EV_A_ w, EV_STAT);
}
void
ev_stat_start (EV_P_ ev_stat *w)
{
if (expect_false (ev_is_active (w)))
return;
/* since we use memcmp, we need to clear any padding data etc. */
memset (&w->prev, 0, sizeof (ev_statdata));
memset (&w->attr, 0, sizeof (ev_statdata));
ev_stat_stat (EV_A_ w);
ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
ev_set_priority (&w->timer, ev_priority (w));
ev_timer_start (EV_A_ &w->timer);
ev_start (EV_A_ (W)w, 1);
}
void
ev_stat_stop (EV_P_ ev_stat *w)
{
ev_clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
return;
ev_timer_stop (EV_A_ &w->timer);
ev_stop (EV_A_ (W)w);
}
#endif


+ 65
- 19
ev.h View File

@ -48,8 +48,22 @@ typedef double ev_tstamp;
# define EV_MULTIPLICITY 1
#endif
#ifndef EV_PERIODICS
# define EV_PERIODICS 1
#ifndef EV_PERIODIC_ENABLE
# define EV_PERIODIC_ENABLE 1
#endif
#ifndef EV_STAT_ENABLE
# define EV_STAT_ENABLE 1
#endif
#ifndef EV_EMBED_ENABLE
# define EV_EMBED_ENABLE 1
#endif
/*****************************************************************************/
#if EV_STAT_ENABLE
# include <sys/stat.h>
#endif
/* support multiple event loops? */
@ -68,22 +82,25 @@ struct ev_loop;
# define EV_A_
# define EV_DEFAULT_A
# define EV_DEFAULT_A_
# undef EV_EMBED_ENABLE
#endif
/* eventmask, revents, events... */
#define EV_UNDEF -1L /* guaranteed to be invalid */
#define EV_NONE 0x00L
#define EV_READ 0x01L /* io only */
#define EV_WRITE 0x02L /* io only */
#define EV_TIMEOUT 0x000100L /* timer only */
#define EV_PERIODIC 0x000200L /* periodic timer only */
#define EV_SIGNAL 0x000400L /* signal only */
#define EV_IDLE 0x000800L /* idle only */
#define EV_CHECK 0x001000L /* check only */
#define EV_PREPARE 0x002000L /* prepare only */
#define EV_CHILD 0x004000L /* child/pid only */
#define EV_EMBED 0x008000L /* embedded event loop */
#define EV_ERROR 0x800000L /* sent when an error occurs */
#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_TIMEOUT 0x00000100L /* timer timed out */
#define EV_PERIODIC 0x00000200L /* periodic timer timed out */
#define EV_SIGNAL 0x00000400L /* signal was received */
#define EV_IDLE 0x00000800L /* event loop is idling */
#define EV_PREPARE 0x00001000L /* event loop about to poll */
#define EV_CHECK 0x00002000L /* event loop finished poll */
#define EV_CHILD 0x00004000L /* child/pid had status change */
#define EV_EMBED 0x00008000L /* embedded event loop needs sweep */
#define EV_STAT 0x00010000L /* stat data changed */
#define EV_ERROR 0x80000000L /* sent when an error occurs */
/* can be used to add custom fields to all watchers, while losing binary compatibility */
#ifndef EV_COMMON
@ -216,7 +233,7 @@ typedef struct ev_child
int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
} ev_child;
#if EV_MULTIPLICITY
#if EV_EMBED_ENABLE
/* used to embed an event loop inside another */
/* the callback gets invoked when the event loop has handled events, and can be 0 */
typedef struct ev_embed
@ -228,6 +245,24 @@ typedef struct ev_embed
} ev_embed;
#endif
#if EV_STAT_ENABLE
/* st_nlink = 0 means missing file or other error */
typedef struct stat ev_statdata;
/* invoked each time the stat data changes for a given path */
/* revent EV_STAT */
typedef struct ev_stat
{
EV_WATCHER (ev_stat)
ev_timer timer; /* private */
ev_tstamp interval; /* rw */
const char *path; /* ro */
ev_statdata prev; /* ro */
ev_statdata attr; /* ro */
} ev_stat;
#endif
/* the presence of this union forces similar struct layout */
union ev_any_watcher
{
@ -242,9 +277,12 @@ union ev_any_watcher
struct ev_check check;
struct ev_signal signal;
struct ev_child child;
#if EV_MULTIPLICITY
#if EV_EMBED_ENABLE
struct ev_embed embed;
#endif
#if EV_STAT_ENABLE
struct ev_stat stat;
#endif
};
/* bits for ev_default_loop and ev_loop_new */
@ -370,6 +408,7 @@ void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revent
#define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
#define ev_child_set(ev,pid_) do { (ev)->pid = (pid_); } while (0)
#define ev_embed_set(ev,loop_) do { (ev)->loop = (loop_); } while (0)
#define ev_stat_set(ev,path_,interval_) do { (ev)->path = (path_); (ev)->interval = (interval_); } while (0)
#define ev_io_init(ev,cb,fd,events) do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
#define ev_timer_init(ev,cb,after,repeat) do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
@ -380,6 +419,7 @@ void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revent
#define ev_check_init(ev,cb) do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
#define ev_child_init(ev,cb,pid) do { ev_init ((ev), (cb)); ev_child_set ((ev),(pid)); } while (0)
#define ev_embed_init(ev,cb,loop) do { ev_init ((ev), (cb)); ev_embed_set ((ev),(loop)); } while (0)
#define ev_stat_init(ev,cb,path,interval) do { ev_init ((ev), (cb)); ev_path_set ((ev),(path),(interval)); } while (0)
#define ev_is_pending(ev) (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
#define ev_is_active(ev) (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
@ -410,7 +450,7 @@ void ev_timer_stop (EV_P_ ev_timer *w);
/* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
void ev_timer_again (EV_P_ ev_timer *w);
#if EV_PERIODICS
#if EV_PERIODIC_ENABLE
void ev_periodic_start (EV_P_ ev_periodic *w);
void ev_periodic_stop (EV_P_ ev_periodic *w);
void ev_periodic_again (EV_P_ ev_periodic *w);
@ -433,13 +473,19 @@ void ev_signal_stop (EV_P_ ev_signal *w);
void ev_child_start (EV_P_ ev_child *w);
void ev_child_stop (EV_P_ ev_child *w);
# if EV_MULTIPLICITY
# if EV_EMBED_ENABLE
/* only supported when loop to be embedded is in fact embeddable */
void ev_embed_start (EV_P_ ev_embed *w);
void ev_embed_stop (EV_P_ ev_embed *w);
void ev_embed_sweep (EV_P_ ev_embed *w);
# endif
# if EV_STAT_ENABLE
void ev_stat_start (EV_P_ ev_stat *w);
void ev_stat_stop (EV_P_ ev_stat *w);
void ev_stat_stat (EV_P_ ev_stat *w);
# endif
#endif
#ifdef __cplusplus


+ 20
- 3
ev.pod View File

@ -1702,10 +1702,27 @@ additional independent event loops. Otherwise there will be no support
for multiple event loops and there is no first event loop pointer
argument. Instead, all functions act on the single default loop.
=item EV_PERIODICS
=item EV_PERIODIC_ENABLE
If undefined or defined to be C<1>, then periodic timers are supported,
otherwise not. This saves a few kb of code.
If undefined or defined to be C<1>, then periodic timers are supported. If
defined to be C<0>, then they are not. Disabling them saves a few kB of
code.
=item EV_EMBED_ENABLE
If undefined or defined to be C<1>, then embed watchers are supported. If
defined to be C<0>, then they are not.
=item EV_STAT_ENABLE
If undefined or defined to be C<1>, then stat watchers are supported. If
defined to be C<0>, then they are not.
=item EV_MINIMAL
If you need to shave off some kilobytes of code at the expense of some
speed, define this symbol to C<1>. Currently only used for gcc to override
some inlining decisions, saves roughly 30% codesize of amd64.
=item EV_COMMON


+ 1
- 1
ev_vars.h View File

@ -62,7 +62,7 @@ VARx(struct ev_timer **, timers)
VARx(int, timermax)
VARx(int, timercnt)
#if EV_PERIODICS || EV_GENWRAP
#if EV_PERIODIC_ENABLE || EV_GENWRAP
VARx(struct ev_periodic **, periodics)
VARx(int, periodicmax)
VARx(int, periodiccnt)


Loading…
Cancel
Save