ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.295 by root, Wed Jul 8 04:29:31 2009 UTC vs.
Revision 1.298 by root, Fri Jul 10 19:10:19 2009 UTC

… …
490#define ev_malloc(size) ev_realloc (0, (size)) 490#define ev_malloc(size) ev_realloc (0, (size))
491#define ev_free(ptr) ev_realloc ((ptr), 0) 491#define ev_free(ptr) ev_realloc ((ptr), 0)
492 492
493/*****************************************************************************/ 493/*****************************************************************************/
494 494
495/* set in reify when reification needed */
496#define EV_ANFD_REIFY 1
497
495/* file descriptor info structure */ 498/* file descriptor info structure */
496typedef struct 499typedef struct
497{ 500{
498 WL head; 501 WL head;
499 unsigned char events; /* the events watched for */ 502 unsigned char events; /* the events watched for */
500 unsigned char reify; /* flag set when this ANFD needs reification */ 503 unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
501 unsigned char emask; /* the epoll backend stores the actual kernel mask in here */ 504 unsigned char emask; /* the epoll backend stores the actual kernel mask in here */
502 unsigned char unused; 505 unsigned char unused;
503#if EV_USE_EPOLL 506#if EV_USE_EPOLL
504 unsigned int egen; /* generation counter to counter epoll bugs */ 507 unsigned int egen; /* generation counter to counter epoll bugs */
505#endif 508#endif
… …
567 570
568 static int ev_default_loop_ptr; 571 static int ev_default_loop_ptr;
569 572
570#endif 573#endif
571 574
575#if EV_MINIMAL < 2
576# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
577# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
578# define EV_INVOKE_PENDING invoke_cb (EV_A)
579#else
580# define EV_RELEASE_CB (void)0
581# define EV_ACQUIRE_CB (void)0
582# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
583#endif
584
585#define EVUNLOOP_RECURSE 0x80
586
572/*****************************************************************************/ 587/*****************************************************************************/
573 588
574#ifndef EV_HAVE_EV_TIME 589#ifndef EV_HAVE_EV_TIME
575ev_tstamp 590ev_tstamp
576ev_time (void) 591ev_time (void)
… …
750} 765}
751 766
752/*****************************************************************************/ 767/*****************************************************************************/
753 768
754inline_speed void 769inline_speed void
755fd_event (EV_P_ int fd, int revents) 770fd_event_nc (EV_P_ int fd, int revents)
756{ 771{
757 ANFD *anfd = anfds + fd; 772 ANFD *anfd = anfds + fd;
758 ev_io *w; 773 ev_io *w;
759 774
760 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next) 775 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
… …
764 if (ev) 779 if (ev)
765 ev_feed_event (EV_A_ (W)w, ev); 780 ev_feed_event (EV_A_ (W)w, ev);
766 } 781 }
767} 782}
768 783
784/* do not submit kernel events for fds that have reify set */
785/* because that means they changed while we were polling for new events */
786inline_speed void
787fd_event (EV_P_ int fd, int revents)
788{
789 ANFD *anfd = anfds + fd;
790
791 if (expect_true (!anfd->reify))
792 fd_event_nc (EV_A_ fd, revents);
793}
794
769void 795void
770ev_feed_fd_event (EV_P_ int fd, int revents) 796ev_feed_fd_event (EV_P_ int fd, int revents)
771{ 797{
772 if (fd >= 0 && fd < anfdmax) 798 if (fd >= 0 && fd < anfdmax)
773 fd_event (EV_A_ fd, revents); 799 fd_event_nc (EV_A_ fd, revents);
774} 800}
775 801
776/* make sure the external fd watch events are in-sync */ 802/* make sure the external fd watch events are in-sync */
777/* with the kernel/libev internal state */ 803/* with the kernel/libev internal state */
778inline_size void 804inline_size void
… …
893 for (fd = 0; fd < anfdmax; ++fd) 919 for (fd = 0; fd < anfdmax; ++fd)
894 if (anfds [fd].events) 920 if (anfds [fd].events)
895 { 921 {
896 anfds [fd].events = 0; 922 anfds [fd].events = 0;
897 anfds [fd].emask = 0; 923 anfds [fd].emask = 0;
898 fd_change (EV_A_ fd, EV__IOFDSET | 1); 924 fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
899 } 925 }
900} 926}
901 927
902/*****************************************************************************/ 928/*****************************************************************************/
903 929
… …
1357ev_backend (EV_P) 1383ev_backend (EV_P)
1358{ 1384{
1359 return backend; 1385 return backend;
1360} 1386}
1361 1387
1388#if EV_MINIMAL < 2
1362unsigned int 1389unsigned int
1363ev_loop_count (EV_P) 1390ev_loop_count (EV_P)
1364{ 1391{
1365 return loop_count; 1392 return loop_count;
1366} 1393}
… …
1380void 1407void
1381ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 1408ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)
1382{ 1409{
1383 timeout_blocktime = interval; 1410 timeout_blocktime = interval;
1384} 1411}
1412
1413void
1414ev_set_userdata (EV_P_ void *data)
1415{
1416 userdata = data;
1417}
1418
1419void *
1420ev_userdata (EV_P)
1421{
1422 return userdata;
1423}
1424
1425void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P))
1426{
1427 invoke_cb = invoke_pending_cb;
1428}
1429
1430void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P))
1431{
1432 release_cb = release;
1433 acquire_cb = acquire;
1434}
1435#endif
1385 1436
1386/* initialise a loop structure, must be zero-initialised */ 1437/* initialise a loop structure, must be zero-initialised */
1387static void noinline 1438static void noinline
1388loop_init (EV_P_ unsigned int flags) 1439loop_init (EV_P_ unsigned int flags)
1389{ 1440{
… …
1411 1462
1412 ev_rt_now = ev_time (); 1463 ev_rt_now = ev_time ();
1413 mn_now = get_clock (); 1464 mn_now = get_clock ();
1414 now_floor = mn_now; 1465 now_floor = mn_now;
1415 rtmn_diff = ev_rt_now - mn_now; 1466 rtmn_diff = ev_rt_now - mn_now;
1467#if EV_MINIMAL < 2
1468 invoke_cb = ev_invoke_pending;
1469#endif
1416 1470
1417 io_blocktime = 0.; 1471 io_blocktime = 0.;
1418 timeout_blocktime = 0.; 1472 timeout_blocktime = 0.;
1419 backend = 0; 1473 backend = 0;
1420 backend_fd = -1; 1474 backend_fd = -1;
… …
1614void 1668void
1615ev_loop_fork (EV_P) 1669ev_loop_fork (EV_P)
1616{ 1670{
1617 postfork = 1; /* must be in line with ev_default_fork */ 1671 postfork = 1; /* must be in line with ev_default_fork */
1618} 1672}
1673#endif /* multiplicity */
1619 1674
1620#if EV_VERIFY 1675#if EV_VERIFY
1621static void noinline 1676static void noinline
1622verify_watcher (EV_P_ W w) 1677verify_watcher (EV_P_ W w)
1623{ 1678{
… …
1651 verify_watcher (EV_A_ ws [cnt]); 1706 verify_watcher (EV_A_ ws [cnt]);
1652 } 1707 }
1653} 1708}
1654#endif 1709#endif
1655 1710
1711#if EV_MINIMAL < 2
1656void 1712void
1657ev_loop_verify (EV_P) 1713ev_loop_verify (EV_P)
1658{ 1714{
1659#if EV_VERIFY 1715#if EV_VERIFY
1660 int i; 1716 int i;
… …
1713 for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) 1769 for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
1714 for (signum = signalmax; signum--; ) if (signals [signum].gotsig) 1770 for (signum = signalmax; signum--; ) if (signals [signum].gotsig)
1715# endif 1771# endif
1716#endif 1772#endif
1717} 1773}
1718 1774#endif
1719#endif /* multiplicity */
1720 1775
1721#if EV_MULTIPLICITY 1776#if EV_MULTIPLICITY
1722struct ev_loop * 1777struct ev_loop *
1723ev_default_loop_init (unsigned int flags) 1778ev_default_loop_init (unsigned int flags)
1724#else 1779#else
… …
1785ev_invoke (EV_P_ void *w, int revents) 1840ev_invoke (EV_P_ void *w, int revents)
1786{ 1841{
1787 EV_CB_INVOKE ((W)w, revents); 1842 EV_CB_INVOKE ((W)w, revents);
1788} 1843}
1789 1844
1790inline_speed void 1845void noinline
1791call_pending (EV_P) 1846ev_invoke_pending (EV_P)
1792{ 1847{
1793 int pri; 1848 int pri;
1794 1849
1795 for (pri = NUMPRI; pri--; ) 1850 for (pri = NUMPRI; pri--; )
1796 while (pendingcnt [pri]) 1851 while (pendingcnt [pri])
… …
2034} 2089}
2035 2090
2036void 2091void
2037ev_loop (EV_P_ int flags) 2092ev_loop (EV_P_ int flags)
2038{ 2093{
2094#if EV_MINIMAL < 2
2039 ++loop_depth; 2095 ++loop_depth;
2096#endif
2097
2098 assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE));
2040 2099
2041 loop_done = EVUNLOOP_CANCEL; 2100 loop_done = EVUNLOOP_CANCEL;
2042 2101
2043 call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */ 2102 EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */
2044 2103
2045 do 2104 do
2046 { 2105 {
2047#if EV_VERIFY >= 2 2106#if EV_VERIFY >= 2
2048 ev_loop_verify (EV_A); 2107 ev_loop_verify (EV_A);
… …
2061 /* we might have forked, so queue fork handlers */ 2120 /* we might have forked, so queue fork handlers */
2062 if (expect_false (postfork)) 2121 if (expect_false (postfork))
2063 if (forkcnt) 2122 if (forkcnt)
2064 { 2123 {
2065 queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK); 2124 queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
2066 call_pending (EV_A); 2125 EV_INVOKE_PENDING;
2067 } 2126 }
2068#endif 2127#endif
2069 2128
2070 /* queue prepare watchers (and execute them) */ 2129 /* queue prepare watchers (and execute them) */
2071 if (expect_false (preparecnt)) 2130 if (expect_false (preparecnt))
2072 { 2131 {
2073 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); 2132 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
2074 call_pending (EV_A); 2133 EV_INVOKE_PENDING;
2075 } 2134 }
2135
2136 if (expect_false (loop_done))
2137 break;
2076 2138
2077 /* we might have forked, so reify kernel state if necessary */ 2139 /* we might have forked, so reify kernel state if necessary */
2078 if (expect_false (postfork)) 2140 if (expect_false (postfork))
2079 loop_fork (EV_A); 2141 loop_fork (EV_A);
2080 2142
… …
2128 waittime -= sleeptime; 2190 waittime -= sleeptime;
2129 } 2191 }
2130 } 2192 }
2131 } 2193 }
2132 2194
2195#if EV_MINIMAL < 2
2133 ++loop_count; 2196 ++loop_count;
2197#endif
2198 assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */
2134 backend_poll (EV_A_ waittime); 2199 backend_poll (EV_A_ waittime);
2200 assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */
2135 2201
2136 /* update ev_rt_now, do magic */ 2202 /* update ev_rt_now, do magic */
2137 time_update (EV_A_ waittime + sleeptime); 2203 time_update (EV_A_ waittime + sleeptime);
2138 } 2204 }
2139 2205
… …
2150 2216
2151 /* queue check watchers, to be executed first */ 2217 /* queue check watchers, to be executed first */
2152 if (expect_false (checkcnt)) 2218 if (expect_false (checkcnt))
2153 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); 2219 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
2154 2220
2155 call_pending (EV_A); 2221 EV_INVOKE_PENDING;
2156 } 2222 }
2157 while (expect_true ( 2223 while (expect_true (
2158 activecnt 2224 activecnt
2159 && !loop_done 2225 && !loop_done
2160 && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)) 2226 && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
2161 )); 2227 ));
2162 2228
2163 if (loop_done == EVUNLOOP_ONE) 2229 if (loop_done == EVUNLOOP_ONE)
2164 loop_done = EVUNLOOP_CANCEL; 2230 loop_done = EVUNLOOP_CANCEL;
2165 2231
2232#if EV_MINIMAL < 2
2166 --loop_depth; 2233 --loop_depth;
2234#endif
2167} 2235}
2168 2236
2169void 2237void
2170ev_unloop (EV_P_ int how) 2238ev_unloop (EV_P_ int how)
2171{ 2239{
… …
2303 2371
2304 ev_start (EV_A_ (W)w, 1); 2372 ev_start (EV_A_ (W)w, 1);
2305 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 2373 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
2306 wlist_add (&anfds[fd].head, (WL)w); 2374 wlist_add (&anfds[fd].head, (WL)w);
2307 2375
2308 fd_change (EV_A_ fd, w->events & EV__IOFDSET | 1); 2376 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
2309 w->events &= ~EV__IOFDSET; 2377 w->events &= ~EV__IOFDSET;
2310 2378
2311 EV_FREQUENT_CHECK; 2379 EV_FREQUENT_CHECK;
2312} 2380}
2313 2381

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines