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

Comparing libev/ev.c (file contents):
Revision 1.291 by root, Mon Jun 29 04:44:18 2009 UTC vs.
Revision 1.302 by root, Thu Jul 16 15:08:08 2009 UTC

… …
391# define inline_speed static noinline 391# define inline_speed static noinline
392#else 392#else
393# define inline_speed static inline 393# define inline_speed static inline
394#endif 394#endif
395 395
396#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1) 396#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
397
398#if EV_MINPRI == EV_MAXPRI
399# define ABSPRI(w) (((W)w), 0)
400#else
397#define ABSPRI(w) (((W)w)->priority - EV_MINPRI) 401# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
402#endif
398 403
399#define EMPTY /* required for microsofts broken pseudo-c compiler */ 404#define EMPTY /* required for microsofts broken pseudo-c compiler */
400#define EMPTY2(a,b) /* used to suppress some warnings */ 405#define EMPTY2(a,b) /* used to suppress some warnings */
401 406
402typedef ev_watcher *W; 407typedef ev_watcher *W;
… …
485#define ev_malloc(size) ev_realloc (0, (size)) 490#define ev_malloc(size) ev_realloc (0, (size))
486#define ev_free(ptr) ev_realloc ((ptr), 0) 491#define ev_free(ptr) ev_realloc ((ptr), 0)
487 492
488/*****************************************************************************/ 493/*****************************************************************************/
489 494
495/* set in reify when reification needed */
496#define EV_ANFD_REIFY 1
497
490/* file descriptor info structure */ 498/* file descriptor info structure */
491typedef struct 499typedef struct
492{ 500{
493 WL head; 501 WL head;
494 unsigned char events; /* the events watched for */ 502 unsigned char events; /* the events watched for */
495 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) */
496 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 */
497 unsigned char unused; 505 unsigned char unused;
498#if EV_USE_EPOLL 506#if EV_USE_EPOLL
499 unsigned int egen; /* generation counter to counter epoll bugs */ 507 unsigned int egen; /* generation counter to counter epoll bugs */
500#endif 508#endif
… …
562 570
563 static int ev_default_loop_ptr; 571 static int ev_default_loop_ptr;
564 572
565#endif 573#endif
566 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
567/*****************************************************************************/ 587/*****************************************************************************/
568 588
589#ifndef EV_HAVE_EV_TIME
569ev_tstamp 590ev_tstamp
570ev_time (void) 591ev_time (void)
571{ 592{
572#if EV_USE_REALTIME 593#if EV_USE_REALTIME
573 if (expect_true (have_realtime)) 594 if (expect_true (have_realtime))
… …
580 601
581 struct timeval tv; 602 struct timeval tv;
582 gettimeofday (&tv, 0); 603 gettimeofday (&tv, 0);
583 return tv.tv_sec + tv.tv_usec * 1e-6; 604 return tv.tv_sec + tv.tv_usec * 1e-6;
584} 605}
606#endif
585 607
586inline_size ev_tstamp 608inline_size ev_tstamp
587get_clock (void) 609get_clock (void)
588{ 610{
589#if EV_USE_MONOTONIC 611#if EV_USE_MONOTONIC
… …
625 647
626 tv.tv_sec = (time_t)delay; 648 tv.tv_sec = (time_t)delay;
627 tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6); 649 tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
628 650
629 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */ 651 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
630 /* somehting nto guaranteed by newer posix versions, but guaranteed */ 652 /* something not guaranteed by newer posix versions, but guaranteed */
631 /* by older ones */ 653 /* by older ones */
632 select (0, 0, 0, 0, &tv); 654 select (0, 0, 0, 0, &tv);
633#endif 655#endif
634 } 656 }
635} 657}
… …
743} 765}
744 766
745/*****************************************************************************/ 767/*****************************************************************************/
746 768
747inline_speed void 769inline_speed void
748fd_event (EV_P_ int fd, int revents) 770fd_event_nc (EV_P_ int fd, int revents)
749{ 771{
750 ANFD *anfd = anfds + fd; 772 ANFD *anfd = anfds + fd;
751 ev_io *w; 773 ev_io *w;
752 774
753 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)
… …
757 if (ev) 779 if (ev)
758 ev_feed_event (EV_A_ (W)w, ev); 780 ev_feed_event (EV_A_ (W)w, ev);
759 } 781 }
760} 782}
761 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
762void 795void
763ev_feed_fd_event (EV_P_ int fd, int revents) 796ev_feed_fd_event (EV_P_ int fd, int revents)
764{ 797{
765 if (fd >= 0 && fd < anfdmax) 798 if (fd >= 0 && fd < anfdmax)
766 fd_event (EV_A_ fd, revents); 799 fd_event_nc (EV_A_ fd, revents);
767} 800}
768 801
769/* make sure the external fd watch events are in-sync */ 802/* make sure the external fd watch events are in-sync */
770/* with the kernel/libev internal state */ 803/* with the kernel/libev internal state */
771inline_size void 804inline_size void
… …
886 for (fd = 0; fd < anfdmax; ++fd) 919 for (fd = 0; fd < anfdmax; ++fd)
887 if (anfds [fd].events) 920 if (anfds [fd].events)
888 { 921 {
889 anfds [fd].events = 0; 922 anfds [fd].events = 0;
890 anfds [fd].emask = 0; 923 anfds [fd].emask = 0;
891 fd_change (EV_A_ fd, EV__IOFDSET | 1); 924 fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
892 } 925 }
893} 926}
894 927
895/*****************************************************************************/ 928/*****************************************************************************/
896 929
… …
1350ev_backend (EV_P) 1383ev_backend (EV_P)
1351{ 1384{
1352 return backend; 1385 return backend;
1353} 1386}
1354 1387
1388#if EV_MINIMAL < 2
1355unsigned int 1389unsigned int
1356ev_loop_count (EV_P) 1390ev_loop_count (EV_P)
1357{ 1391{
1358 return loop_count; 1392 return loop_count;
1359} 1393}
1360 1394
1395unsigned int
1396ev_loop_depth (EV_P)
1397{
1398 return loop_depth;
1399}
1400
1361void 1401void
1362ev_set_io_collect_interval (EV_P_ ev_tstamp interval) 1402ev_set_io_collect_interval (EV_P_ ev_tstamp interval)
1363{ 1403{
1364 io_blocktime = interval; 1404 io_blocktime = interval;
1365} 1405}
… …
1367void 1407void
1368ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 1408ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)
1369{ 1409{
1370 timeout_blocktime = interval; 1410 timeout_blocktime = interval;
1371} 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
1372 1436
1373/* initialise a loop structure, must be zero-initialised */ 1437/* initialise a loop structure, must be zero-initialised */
1374static void noinline 1438static void noinline
1375loop_init (EV_P_ unsigned int flags) 1439loop_init (EV_P_ unsigned int flags)
1376{ 1440{
… …
1398 1462
1399 ev_rt_now = ev_time (); 1463 ev_rt_now = ev_time ();
1400 mn_now = get_clock (); 1464 mn_now = get_clock ();
1401 now_floor = mn_now; 1465 now_floor = mn_now;
1402 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
1403 1470
1404 io_blocktime = 0.; 1471 io_blocktime = 0.;
1405 timeout_blocktime = 0.; 1472 timeout_blocktime = 0.;
1406 backend = 0; 1473 backend = 0;
1407 backend_fd = -1; 1474 backend_fd = -1;
… …
1601void 1668void
1602ev_loop_fork (EV_P) 1669ev_loop_fork (EV_P)
1603{ 1670{
1604 postfork = 1; /* must be in line with ev_default_fork */ 1671 postfork = 1; /* must be in line with ev_default_fork */
1605} 1672}
1673#endif /* multiplicity */
1606 1674
1607#if EV_VERIFY 1675#if EV_VERIFY
1608static void noinline 1676static void noinline
1609verify_watcher (EV_P_ W w) 1677verify_watcher (EV_P_ W w)
1610{ 1678{
… …
1638 verify_watcher (EV_A_ ws [cnt]); 1706 verify_watcher (EV_A_ ws [cnt]);
1639 } 1707 }
1640} 1708}
1641#endif 1709#endif
1642 1710
1711#if EV_MINIMAL < 2
1643void 1712void
1644ev_loop_verify (EV_P) 1713ev_loop_verify (EV_P)
1645{ 1714{
1646#if EV_VERIFY 1715#if EV_VERIFY
1647 int i; 1716 int i;
… …
1700 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)
1701 for (signum = signalmax; signum--; ) if (signals [signum].gotsig) 1770 for (signum = signalmax; signum--; ) if (signals [signum].gotsig)
1702# endif 1771# endif
1703#endif 1772#endif
1704} 1773}
1705 1774#endif
1706#endif /* multiplicity */
1707 1775
1708#if EV_MULTIPLICITY 1776#if EV_MULTIPLICITY
1709struct ev_loop * 1777struct ev_loop *
1710ev_default_loop_init (unsigned int flags) 1778ev_default_loop_init (unsigned int flags)
1711#else 1779#else
… …
1772ev_invoke (EV_P_ void *w, int revents) 1840ev_invoke (EV_P_ void *w, int revents)
1773{ 1841{
1774 EV_CB_INVOKE ((W)w, revents); 1842 EV_CB_INVOKE ((W)w, revents);
1775} 1843}
1776 1844
1777inline_speed void 1845unsigned int
1778call_pending (EV_P) 1846ev_pending_count (EV_P)
1847{
1848 int pri;
1849 unsigned int count = 0;
1850
1851 for (pri = NUMPRI; pri--; )
1852 count += pendingcnt [pri];
1853
1854 return count;
1855}
1856
1857void noinline
1858ev_invoke_pending (EV_P)
1779{ 1859{
1780 int pri; 1860 int pri;
1781 1861
1782 for (pri = NUMPRI; pri--; ) 1862 for (pri = NUMPRI; pri--; )
1783 while (pendingcnt [pri]) 1863 while (pendingcnt [pri])
… …
2018 2098
2019 mn_now = ev_rt_now; 2099 mn_now = ev_rt_now;
2020 } 2100 }
2021} 2101}
2022 2102
2023static int loop_done;
2024
2025void 2103void
2026ev_loop (EV_P_ int flags) 2104ev_loop (EV_P_ int flags)
2027{ 2105{
2106#if EV_MINIMAL < 2
2107 ++loop_depth;
2108#endif
2109
2110 assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE));
2111
2028 loop_done = EVUNLOOP_CANCEL; 2112 loop_done = EVUNLOOP_CANCEL;
2029 2113
2030 call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */ 2114 EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */
2031 2115
2032 do 2116 do
2033 { 2117 {
2034#if EV_VERIFY >= 2 2118#if EV_VERIFY >= 2
2035 ev_loop_verify (EV_A); 2119 ev_loop_verify (EV_A);
… …
2048 /* we might have forked, so queue fork handlers */ 2132 /* we might have forked, so queue fork handlers */
2049 if (expect_false (postfork)) 2133 if (expect_false (postfork))
2050 if (forkcnt) 2134 if (forkcnt)
2051 { 2135 {
2052 queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK); 2136 queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
2053 call_pending (EV_A); 2137 EV_INVOKE_PENDING;
2054 } 2138 }
2055#endif 2139#endif
2056 2140
2057 /* queue prepare watchers (and execute them) */ 2141 /* queue prepare watchers (and execute them) */
2058 if (expect_false (preparecnt)) 2142 if (expect_false (preparecnt))
2059 { 2143 {
2060 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); 2144 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
2061 call_pending (EV_A); 2145 EV_INVOKE_PENDING;
2062 } 2146 }
2147
2148 if (expect_false (loop_done))
2149 break;
2063 2150
2064 /* we might have forked, so reify kernel state if necessary */ 2151 /* we might have forked, so reify kernel state if necessary */
2065 if (expect_false (postfork)) 2152 if (expect_false (postfork))
2066 loop_fork (EV_A); 2153 loop_fork (EV_A);
2067 2154
… …
2073 ev_tstamp waittime = 0.; 2160 ev_tstamp waittime = 0.;
2074 ev_tstamp sleeptime = 0.; 2161 ev_tstamp sleeptime = 0.;
2075 2162
2076 if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt))) 2163 if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt)))
2077 { 2164 {
2165 /* remember old timestamp for io_blocktime calculation */
2166 ev_tstamp prev_mn_now = mn_now;
2167
2078 /* update time to cancel out callback processing overhead */ 2168 /* update time to cancel out callback processing overhead */
2079 time_update (EV_A_ 1e100); 2169 time_update (EV_A_ 1e100);
2080 2170
2081 waittime = MAX_BLOCKTIME; 2171 waittime = MAX_BLOCKTIME;
2082 2172
… …
2092 ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge; 2182 ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge;
2093 if (waittime > to) waittime = to; 2183 if (waittime > to) waittime = to;
2094 } 2184 }
2095#endif 2185#endif
2096 2186
2187 /* don't let timeouts decrease the waittime below timeout_blocktime */
2097 if (expect_false (waittime < timeout_blocktime)) 2188 if (expect_false (waittime < timeout_blocktime))
2098 waittime = timeout_blocktime; 2189 waittime = timeout_blocktime;
2099 2190
2100 sleeptime = waittime - backend_fudge; 2191 /* extra check because io_blocktime is commonly 0 */
2101
2102 if (expect_true (sleeptime > io_blocktime)) 2192 if (expect_false (io_blocktime))
2103 sleeptime = io_blocktime;
2104
2105 if (sleeptime)
2106 { 2193 {
2194 sleeptime = io_blocktime - (mn_now - prev_mn_now);
2195
2196 if (sleeptime > waittime - backend_fudge)
2197 sleeptime = waittime - backend_fudge;
2198
2199 if (expect_true (sleeptime > 0.))
2200 {
2107 ev_sleep (sleeptime); 2201 ev_sleep (sleeptime);
2108 waittime -= sleeptime; 2202 waittime -= sleeptime;
2203 }
2109 } 2204 }
2110 } 2205 }
2111 2206
2207#if EV_MINIMAL < 2
2112 ++loop_count; 2208 ++loop_count;
2209#endif
2210 assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */
2113 backend_poll (EV_A_ waittime); 2211 backend_poll (EV_A_ waittime);
2212 assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */
2114 2213
2115 /* update ev_rt_now, do magic */ 2214 /* update ev_rt_now, do magic */
2116 time_update (EV_A_ waittime + sleeptime); 2215 time_update (EV_A_ waittime + sleeptime);
2117 } 2216 }
2118 2217
… …
2129 2228
2130 /* queue check watchers, to be executed first */ 2229 /* queue check watchers, to be executed first */
2131 if (expect_false (checkcnt)) 2230 if (expect_false (checkcnt))
2132 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); 2231 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
2133 2232
2134 call_pending (EV_A); 2233 EV_INVOKE_PENDING;
2135 } 2234 }
2136 while (expect_true ( 2235 while (expect_true (
2137 activecnt 2236 activecnt
2138 && !loop_done 2237 && !loop_done
2139 && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)) 2238 && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
2140 )); 2239 ));
2141 2240
2142 if (loop_done == EVUNLOOP_ONE) 2241 if (loop_done == EVUNLOOP_ONE)
2143 loop_done = EVUNLOOP_CANCEL; 2242 loop_done = EVUNLOOP_CANCEL;
2243
2244#if EV_MINIMAL < 2
2245 --loop_depth;
2246#endif
2144} 2247}
2145 2248
2146void 2249void
2147ev_unloop (EV_P_ int how) 2250ev_unloop (EV_P_ int how)
2148{ 2251{
… …
2240} 2343}
2241 2344
2242inline_size void 2345inline_size void
2243pri_adjust (EV_P_ W w) 2346pri_adjust (EV_P_ W w)
2244{ 2347{
2245 int pri = w->priority; 2348 int pri = ev_priority (w);
2246 pri = pri < EV_MINPRI ? EV_MINPRI : pri; 2349 pri = pri < EV_MINPRI ? EV_MINPRI : pri;
2247 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri; 2350 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
2248 w->priority = pri; 2351 ev_set_priority (w, pri);
2249} 2352}
2250 2353
2251inline_speed void 2354inline_speed void
2252ev_start (EV_P_ W w, int active) 2355ev_start (EV_P_ W w, int active)
2253{ 2356{
… …
2280 2383
2281 ev_start (EV_A_ (W)w, 1); 2384 ev_start (EV_A_ (W)w, 1);
2282 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 2385 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
2283 wlist_add (&anfds[fd].head, (WL)w); 2386 wlist_add (&anfds[fd].head, (WL)w);
2284 2387
2285 fd_change (EV_A_ fd, w->events & EV__IOFDSET | 1); 2388 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
2286 w->events &= ~EV__IOFDSET; 2389 w->events &= ~EV__IOFDSET;
2287 2390
2288 EV_FREQUENT_CHECK; 2391 EV_FREQUENT_CHECK;
2289} 2392}
2290 2393
… …
2384 } 2487 }
2385 2488
2386 EV_FREQUENT_CHECK; 2489 EV_FREQUENT_CHECK;
2387} 2490}
2388 2491
2492ev_tstamp
2493ev_timer_remaining (EV_P_ ev_timer *w)
2494{
2495 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
2496}
2497
2389#if EV_PERIODIC_ENABLE 2498#if EV_PERIODIC_ENABLE
2390void noinline 2499void noinline
2391ev_periodic_start (EV_P_ ev_periodic *w) 2500ev_periodic_start (EV_P_ ev_periodic *w)
2392{ 2501{
2393 if (expect_false (ev_is_active (w))) 2502 if (expect_false (ev_is_active (w)))
… …
2494 if (!((WL)w)->next) 2603 if (!((WL)w)->next)
2495 { 2604 {
2496#if _WIN32 2605#if _WIN32
2497 signal (w->signum, ev_sighandler); 2606 signal (w->signum, ev_sighandler);
2498#else 2607#else
2499 struct sigaction sa; 2608 struct sigaction sa = { };
2500 sa.sa_handler = ev_sighandler; 2609 sa.sa_handler = ev_sighandler;
2501 sigfillset (&sa.sa_mask); 2610 sigfillset (&sa.sa_mask);
2502 sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */ 2611 sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
2503 sigaction (w->signum, &sa, 0); 2612 sigaction (w->signum, &sa, 0);
2504#endif 2613#endif

Diff Legend

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