mirrors
/
libev
mirror of /home/gitosis/repositories/libev.git
1
0
Fork 0
Code Releases Activity

more thorough renaming, might even work now

master
Marc Alexander Lehmann 2007-11-23 05:13:48 +00:00
parent 04e7d47934
commit 20b899bba0
8 changed files with 55 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
ev.c
View File

@ -460,7 +460,7 @@ fd_reify (EV_P)
anfd->reify = 0;
method_modify (EV_A_ fd, anfd->events, events);
backend_modify (EV_A_ fd, anfd->events, events);
anfd->events = events;
}
@ -528,7 +528,7 @@ fd_enomem (EV_P)
}
}
/* usually called after fork if method needs to re-arm all fds from scratch */
/* usually called after fork if backend needs to re-arm all fds from scratch */
static void
fd_rearm_all (EV_P)
{
@ -783,12 +783,7 @@ enable_secure (void)
unsigned int
ev_supported_backends (void)
{
}
unsigned int
ev_recommended_backends (void)
{
unsigned int flags;
unsigned int flags = 0;
if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
@ -800,7 +795,7 @@ ev_recommended_backends (void)
}
unsigned int
ev_backend (EV_P)
ev_recommended_backends (void)
{
unsigned int flags = ev_recommended_backends ();
@ -817,10 +812,16 @@ ev_backend (EV_P)
return flags;
}
unsigned int
ev_backend (EV_P)
{
return backend;
}
static void
loop_init (EV_P_ unsigned int flags)
{
if (!method)
if (!backend)
{
#if EV_USE_MONOTONIC
{
@ -843,21 +844,21 @@ loop_init (EV_P_ unsigned int flags)
if (!(flags & 0x0000ffffUL))
flags |= ev_recommended_backends ();
method = 0;
backend = 0;
#if EV_USE_PORT
if (!method && (flags & EVBACKEND_PORT )) method = port_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
#endif
#if EV_USE_KQUEUE
if (!method && (flags & EVBACKEND_KQUEUE)) method = kqueue_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
#endif
#if EV_USE_EPOLL
if (!method && (flags & EVBACKEND_EPOLL )) method = epoll_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
#endif
#if EV_USE_POLL
if (!method && (flags & EVBACKEND_POLL )) method = poll_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
#endif
#if EV_USE_SELECT
if (!method && (flags & EVBACKEND_SELECT)) method = select_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
#endif
ev_init (&sigev, sigcb);
@ -871,19 +872,19 @@ loop_destroy (EV_P)
int i;
#if EV_USE_PORT
if (method == EVBACKEND_PORT ) port_destroy (EV_A);
if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
#endif
#if EV_USE_KQUEUE
if (method == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
#endif
#if EV_USE_EPOLL
if (method == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
#endif
#if EV_USE_POLL
if (method == EVBACKEND_POLL ) poll_destroy (EV_A);
if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
#endif
#if EV_USE_SELECT
if (method == EVBACKEND_SELECT) select_destroy (EV_A);
if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
#endif
for (i = NUMPRI; i--; )
@ -899,20 +900,20 @@ loop_destroy (EV_P)
array_free (prepare, EMPTY0);
array_free (check, EMPTY0);
method = 0;
backend = 0;
}
static void
loop_fork (EV_P)
{
#if EV_USE_PORT
if (method == EVBACKEND_PORT ) port_fork (EV_A);
if (backend == EVBACKEND_PORT ) port_fork (EV_A);
#endif
#if EV_USE_KQUEUE
if (method == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
#endif
#if EV_USE_EPOLL
if (method == EVBACKEND_EPOLL ) epoll_fork (EV_A);
if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
#endif
if (ev_is_active (&sigev))
@ -943,7 +944,7 @@ ev_loop_new (unsigned int flags)
loop_init (EV_A_ flags);
if (ev_method (EV_A))
if (ev_backend (EV_A))
return loop;
return 0;
@ -986,7 +987,7 @@ ev_default_loop (unsigned int flags)
loop_init (EV_A_ flags);
if (ev_method (EV_A))
if (ev_backend (EV_A))
{
siginit (EV_A);
@ -1032,7 +1033,7 @@ ev_default_fork (void)
struct ev_loop *loop = ev_default_loop_ptr;
#endif
if (method)
if (backend)
postfork = 1;
}
@ -1274,14 +1275,14 @@ ev_loop (EV_P_ int flags)
if (timercnt)
{
ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge;
if (block > to) block = to;
}
#if EV_PERIODICS
if (periodiccnt)
{
ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + method_fudge;
ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge;
if (block > to) block = to;
}
#endif
@ -1289,7 +1290,7 @@ ev_loop (EV_P_ int flags)
if (expect_false (block < 0.)) block = 0.;
}
method_poll (EV_A_ block);
backend_poll (EV_A_ block);
/* update ev_rt_now, do magic */
time_update (EV_A);

6
ev_epoll.c
View File

@ -89,9 +89,9 @@ epoll_init (EV_P_ int flags)
fcntl (epoll_fd, F_SETFD, FD_CLOEXEC);
method_fudge = 1e-3; /* needed to compensate for epoll returning early */
method_modify = epoll_modify;
method_poll = epoll_poll;
backend_fudge = 1e-3; /* needed to compensate for epoll returning early */
backend_modify = epoll_modify;
backend_poll = epoll_poll;
epoll_eventmax = 64; /* intiial number of events receivable per poll */
epoll_events = (struct epoll_event *)ev_malloc (sizeof (struct epoll_event) * epoll_eventmax);

6
ev_kqueue.c
View File

@ -182,9 +182,9 @@ kqueue_init (EV_P_ int flags)
return 0;
}
method_fudge = 1e-3; /* needed to compensate for kevent returning early */
method_modify = kqueue_modify;
method_poll = kqueue_poll;
backend_fudge = 1e-3; /* needed to compensate for kevent returning early */
backend_modify = kqueue_modify;
backend_poll = kqueue_poll;
kqueue_eventmax = 64; /* intiial number of events receivable per poll */
kqueue_events = (struct kevent *)ev_malloc (sizeof (struct kevent) * kqueue_eventmax);

6
ev_poll.c
View File

@ -108,9 +108,9 @@ poll_poll (EV_P_ ev_tstamp timeout)
static int
poll_init (EV_P_ int flags)
{
method_fudge = 1e-3; /* needed to compensate for select returning early, very conservative */
method_modify = poll_modify;
method_poll = poll_poll;
backend_fudge = 1e-3; /* needed to compensate for select returning early, very conservative */
backend_modify = poll_modify;
backend_poll = poll_poll;
pollidxs = 0; pollidxmax = 0;
polls = 0; pollmax = 0; pollcnt = 0;

6
ev_port.c
View File

@ -111,9 +111,9 @@ port_init (EV_P_ int flags)
fcntl (port_fd, F_SETFD, FD_CLOEXEC); /* not sure if necessary, hopefully doesn't hurt */
method_fudge = 1e-3; /* needed to compensate for port_getn returning early */
method_modify = port_modify;
method_poll = port_poll;
backend_fudge = 1e-3; /* needed to compensate for port_getn returning early */
backend_modify = port_modify;
backend_poll = port_poll;
port_eventmax = 64; /* intiial number of events receivable per poll */
port_events = (port_event_t *)ev_malloc (sizeof (port_event_t) * port_eventmax);

6
ev_select.c
View File

@ -203,9 +203,9 @@ select_poll (EV_P_ ev_tstamp timeout)
static int
select_init (EV_P_ int flags)
{
method_fudge = 1e-2; /* needed to compensate for select returning early, very conservative */
method_modify = select_modify;
method_poll = select_poll;
backend_fudge = 1e-2; /* needed to compensate for select returning early, very conservative */
backend_modify = select_modify;
backend_poll = select_poll;
#if EV_SELECT_USE_FD_SET
vec_max = FD_SETSIZE / 32;

8
ev_vars.h
View File

@ -3,11 +3,11 @@
VARx(ev_tstamp, now_floor) /* last time we refreshed rt_time */
VARx(ev_tstamp, mn_now) /* monotonic clock "now" */
VARx(ev_tstamp, rtmn_diff) /* difference realtime - monotonic time */
VARx(int, method)
VARx(int, backend)
VARx(ev_tstamp, method_fudge) /* assumed typical timer resolution */
VAR (method_modify, void (*method_modify)(EV_P_ int fd, int oev, int nev))
VAR (method_poll , void (*method_poll)(EV_P_ ev_tstamp timeout))
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))
VARx(int, postfork) /* true if we need to recreate kernel state after fork */
VARx(int, activecnt) /* number of active events */

8
ev_wrap.h
View File

@ -2,10 +2,10 @@
#define now_floor ((loop)->now_floor)
#define mn_now ((loop)->mn_now)
#define rtmn_diff ((loop)->rtmn_diff)
#define method ((loop)->method)
#define method_fudge ((loop)->method_fudge)
#define method_modify ((loop)->method_modify)
#define method_poll ((loop)->method_poll)
#define backend ((loop)->backend)
#define backend_fudge ((loop)->backend_fudge)
#define backend_modify ((loop)->backend_modify)
#define backend_poll ((loop)->backend_poll)
#define postfork ((loop)->postfork)
#define activecnt ((loop)->activecnt)
#define vec_ri ((loop)->vec_ri)