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

Comparing libev/ev.c (file contents):
Revision 1.337 by root, Wed Mar 10 09:18:24 2010 UTC vs.
Revision 1.338 by root, Tue Mar 16 00:20:17 2010 UTC

… …
219# define EV_NSIG 65 219# define EV_NSIG 65
220#endif 220#endif
221 221
222#ifndef EV_USE_CLOCK_SYSCALL 222#ifndef EV_USE_CLOCK_SYSCALL
223# if __linux && __GLIBC__ >= 2 223# if __linux && __GLIBC__ >= 2
224# define EV_USE_CLOCK_SYSCALL 1 224# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
225# else 225# else
226# define EV_USE_CLOCK_SYSCALL 0 226# define EV_USE_CLOCK_SYSCALL 0
227# endif 227# endif
228#endif 228#endif
229 229
230#ifndef EV_USE_MONOTONIC 230#ifndef EV_USE_MONOTONIC
231# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0 231# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
232# define EV_USE_MONOTONIC 1 232# define EV_USE_MONOTONIC EV_FEATURE_OS
233# else 233# else
234# define EV_USE_MONOTONIC 0 234# define EV_USE_MONOTONIC 0
235# endif 235# endif
236#endif 236#endif
237 237
… …
239# define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL 239# define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
240#endif 240#endif
241 241
242#ifndef EV_USE_NANOSLEEP 242#ifndef EV_USE_NANOSLEEP
243# if _POSIX_C_SOURCE >= 199309L 243# if _POSIX_C_SOURCE >= 199309L
244# define EV_USE_NANOSLEEP 1 244# define EV_USE_NANOSLEEP EV_FEATURE_OS
245# else 245# else
246# define EV_USE_NANOSLEEP 0 246# define EV_USE_NANOSLEEP 0
247# endif 247# endif
248#endif 248#endif
249 249
250#ifndef EV_USE_SELECT 250#ifndef EV_USE_SELECT
251# define EV_USE_SELECT 1 251# define EV_USE_SELECT EV_FEATURE_BACKENDS
252#endif 252#endif
253 253
254#ifndef EV_USE_POLL 254#ifndef EV_USE_POLL
255# ifdef _WIN32 255# ifdef _WIN32
256# define EV_USE_POLL 0 256# define EV_USE_POLL 0
257# else 257# else
258# define EV_USE_POLL 1 258# define EV_USE_POLL EV_FEATURE_BACKENDS
259# endif 259# endif
260#endif 260#endif
261 261
262#ifndef EV_USE_EPOLL 262#ifndef EV_USE_EPOLL
263# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4)) 263# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
264# define EV_USE_EPOLL 1 264# define EV_USE_EPOLL EV_FEATURE_BACKENDS
265# else 265# else
266# define EV_USE_EPOLL 0 266# define EV_USE_EPOLL 0
267# endif 267# endif
268#endif 268#endif
269 269
… …
275# define EV_USE_PORT 0 275# define EV_USE_PORT 0
276#endif 276#endif
277 277
278#ifndef EV_USE_INOTIFY 278#ifndef EV_USE_INOTIFY
279# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4)) 279# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
280# define EV_USE_INOTIFY 1 280# define EV_USE_INOTIFY EV_FEATURE_OS
281# else 281# else
282# define EV_USE_INOTIFY 0 282# define EV_USE_INOTIFY 0
283# endif 283# endif
284#endif 284#endif
285 285
286#ifndef EV_PID_HASHSIZE 286#ifndef EV_PID_HASHSIZE
287# if EV_MINIMAL 287# define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
288# define EV_PID_HASHSIZE 1
289# else
290# define EV_PID_HASHSIZE 16
291# endif
292#endif 288#endif
293 289
294#ifndef EV_INOTIFY_HASHSIZE 290#ifndef EV_INOTIFY_HASHSIZE
295# if EV_MINIMAL 291# define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
296# define EV_INOTIFY_HASHSIZE 1
297# else
298# define EV_INOTIFY_HASHSIZE 16
299# endif
300#endif 292#endif
301 293
302#ifndef EV_USE_EVENTFD 294#ifndef EV_USE_EVENTFD
303# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7)) 295# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
304# define EV_USE_EVENTFD 1 296# define EV_USE_EVENTFD EV_FEATURE_OS
305# else 297# else
306# define EV_USE_EVENTFD 0 298# define EV_USE_EVENTFD 0
307# endif 299# endif
308#endif 300#endif
309 301
310#ifndef EV_USE_SIGNALFD 302#ifndef EV_USE_SIGNALFD
311# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7)) 303# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
312# define EV_USE_SIGNALFD 1 304# define EV_USE_SIGNALFD EV_FEATURE_OS
313# else 305# else
314# define EV_USE_SIGNALFD 0 306# define EV_USE_SIGNALFD 0
315# endif 307# endif
316#endif 308#endif
317 309
… …
320# define EV_USE_4HEAP 1 312# define EV_USE_4HEAP 1
321# define EV_HEAP_CACHE_AT 1 313# define EV_HEAP_CACHE_AT 1
322#endif 314#endif
323 315
324#ifndef EV_VERIFY 316#ifndef EV_VERIFY
325# define EV_VERIFY !EV_MINIMAL 317# define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
326#endif 318#endif
327 319
328#ifndef EV_USE_4HEAP 320#ifndef EV_USE_4HEAP
329# define EV_USE_4HEAP !EV_MINIMAL 321# define EV_USE_4HEAP EV_FEATURE_DATA
330#endif 322#endif
331 323
332#ifndef EV_HEAP_CACHE_AT 324#ifndef EV_HEAP_CACHE_AT
333# define EV_HEAP_CACHE_AT !EV_MINIMAL 325# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
334#endif 326#endif
335 327
336/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 328/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
337/* which makes programs even slower. might work on other unices, too. */ 329/* which makes programs even slower. might work on other unices, too. */
338#if EV_USE_CLOCK_SYSCALL 330#if EV_USE_CLOCK_SYSCALL
… …
476 468
477#define expect_false(expr) expect ((expr) != 0, 0) 469#define expect_false(expr) expect ((expr) != 0, 0)
478#define expect_true(expr) expect ((expr) != 0, 1) 470#define expect_true(expr) expect ((expr) != 0, 1)
479#define inline_size static inline 471#define inline_size static inline
480 472
481#if EV_MINIMAL 473#if EV_FEATURE_CODE
474# define inline_speed static inline
475#else
482# define inline_speed static noinline 476# define inline_speed static noinline
483#else
484# define inline_speed static inline
485#endif 477#endif
486 478
487#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1) 479#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
488 480
489#if EV_MINPRI == EV_MAXPRI 481#if EV_MINPRI == EV_MAXPRI
… …
696 688
697 static int ev_default_loop_ptr; 689 static int ev_default_loop_ptr;
698 690
699#endif 691#endif
700 692
701#if EV_MINIMAL < 2 693#if EV_FEATURE_API
702# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A) 694# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
703# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A) 695# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
704# define EV_INVOKE_PENDING invoke_cb (EV_A) 696# define EV_INVOKE_PENDING invoke_cb (EV_A)
705#else 697#else
706# define EV_RELEASE_CB (void)0 698# define EV_RELEASE_CB (void)0
… …
1403child_reap (EV_P_ int chain, int pid, int status) 1395child_reap (EV_P_ int chain, int pid, int status)
1404{ 1396{
1405 ev_child *w; 1397 ev_child *w;
1406 int traced = WIFSTOPPED (status) || WIFCONTINUED (status); 1398 int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
1407 1399
1408 for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) 1400 for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
1409 { 1401 {
1410 if ((w->pid == pid || !w->pid) 1402 if ((w->pid == pid || !w->pid)
1411 && (!traced || (w->flags & 1))) 1403 && (!traced || (w->flags & 1)))
1412 { 1404 {
1413 ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */ 1405 ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
… …
1438 /* make sure we are called again until all children have been reaped */ 1430 /* make sure we are called again until all children have been reaped */
1439 /* we need to do it this way so that the callback gets called before we continue */ 1431 /* we need to do it this way so that the callback gets called before we continue */
1440 ev_feed_event (EV_A_ (W)sw, EV_SIGNAL); 1432 ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
1441 1433
1442 child_reap (EV_A_ pid, pid, status); 1434 child_reap (EV_A_ pid, pid, status);
1443 if (EV_PID_HASHSIZE > 1) 1435 if ((EV_PID_HASHSIZE) > 1)
1444 child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */ 1436 child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
1445} 1437}
1446 1438
1447#endif 1439#endif
1448 1440
… …
1537ev_backend (EV_P) 1529ev_backend (EV_P)
1538{ 1530{
1539 return backend; 1531 return backend;
1540} 1532}
1541 1533
1542#if EV_MINIMAL < 2 1534#if EV_FEATURE_API
1543unsigned int 1535unsigned int
1544ev_loop_count (EV_P) 1536ev_loop_count (EV_P)
1545{ 1537{
1546 return loop_count; 1538 return loop_count;
1547} 1539}
… …
1627 1619
1628 ev_rt_now = ev_time (); 1620 ev_rt_now = ev_time ();
1629 mn_now = get_clock (); 1621 mn_now = get_clock ();
1630 now_floor = mn_now; 1622 now_floor = mn_now;
1631 rtmn_diff = ev_rt_now - mn_now; 1623 rtmn_diff = ev_rt_now - mn_now;
1632#if EV_MINIMAL < 2 1624#if EV_FEATURE_API
1633 invoke_cb = ev_invoke_pending; 1625 invoke_cb = ev_invoke_pending;
1634#endif 1626#endif
1635 1627
1636 io_blocktime = 0.; 1628 io_blocktime = 0.;
1637 timeout_blocktime = 0.; 1629 timeout_blocktime = 0.;
… …
1874 verify_watcher (EV_A_ ws [cnt]); 1866 verify_watcher (EV_A_ ws [cnt]);
1875 } 1867 }
1876} 1868}
1877#endif 1869#endif
1878 1870
1879#if EV_MINIMAL < 2 1871#if EV_FEATURE_API
1880void 1872void
1881ev_loop_verify (EV_P) 1873ev_loop_verify (EV_P)
1882{ 1874{
1883#if EV_VERIFY 1875#if EV_VERIFY
1884 int i; 1876 int i;
… …
1937 array_verify (EV_A_ (W *)checks, checkcnt); 1929 array_verify (EV_A_ (W *)checks, checkcnt);
1938#endif 1930#endif
1939 1931
1940# if 0 1932# if 0
1941#if EV_CHILD_ENABLE 1933#if EV_CHILD_ENABLE
1942 for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) 1934 for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
1943 for (signum = EV_NSIG; signum--; ) if (signals [signum].pending) 1935 for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
1944#endif 1936#endif
1945# endif 1937# endif
1946#endif 1938#endif
1947} 1939}
… …
2275} 2267}
2276 2268
2277void 2269void
2278ev_loop (EV_P_ int flags) 2270ev_loop (EV_P_ int flags)
2279{ 2271{
2280#if EV_MINIMAL < 2 2272#if EV_FEATURE_API
2281 ++loop_depth; 2273 ++loop_depth;
2282#endif 2274#endif
2283 2275
2284 assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE)); 2276 assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE));
2285 2277
… …
2378 waittime -= sleeptime; 2370 waittime -= sleeptime;
2379 } 2371 }
2380 } 2372 }
2381 } 2373 }
2382 2374
2383#if EV_MINIMAL < 2 2375#if EV_FEATURE_API
2384 ++loop_count; 2376 ++loop_count;
2385#endif 2377#endif
2386 assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */ 2378 assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */
2387 backend_poll (EV_A_ waittime); 2379 backend_poll (EV_A_ waittime);
2388 assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */ 2380 assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */
… …
2417 )); 2409 ));
2418 2410
2419 if (loop_done == EVUNLOOP_ONE) 2411 if (loop_done == EVUNLOOP_ONE)
2420 loop_done = EVUNLOOP_CANCEL; 2412 loop_done = EVUNLOOP_CANCEL;
2421 2413
2422#if EV_MINIMAL < 2 2414#if EV_FEATURE_API
2423 --loop_depth; 2415 --loop_depth;
2424#endif 2416#endif
2425} 2417}
2426 2418
2427void 2419void
… …
2877 return; 2869 return;
2878 2870
2879 EV_FREQUENT_CHECK; 2871 EV_FREQUENT_CHECK;
2880 2872
2881 ev_start (EV_A_ (W)w, 1); 2873 ev_start (EV_A_ (W)w, 1);
2882 wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w); 2874 wlist_add (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
2883 2875
2884 EV_FREQUENT_CHECK; 2876 EV_FREQUENT_CHECK;
2885} 2877}
2886 2878
2887void 2879void
… …
2891 if (expect_false (!ev_is_active (w))) 2883 if (expect_false (!ev_is_active (w)))
2892 return; 2884 return;
2893 2885
2894 EV_FREQUENT_CHECK; 2886 EV_FREQUENT_CHECK;
2895 2887
2896 wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w); 2888 wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
2897 ev_stop (EV_A_ (W)w); 2889 ev_stop (EV_A_ (W)w);
2898 2890
2899 EV_FREQUENT_CHECK; 2891 EV_FREQUENT_CHECK;
2900} 2892}
2901 2893
… …
2974 while (w->wd < 0 && (errno == ENOENT || errno == EACCES)); 2966 while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
2975 } 2967 }
2976 } 2968 }
2977 2969
2978 if (w->wd >= 0) 2970 if (w->wd >= 0)
2979 wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w); 2971 wlist_add (&fs_hash [w->wd & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
2980 2972
2981 /* now re-arm timer, if required */ 2973 /* now re-arm timer, if required */
2982 if (ev_is_active (&w->timer)) ev_ref (EV_A); 2974 if (ev_is_active (&w->timer)) ev_ref (EV_A);
2983 ev_timer_again (EV_A_ &w->timer); 2975 ev_timer_again (EV_A_ &w->timer);
2984 if (ev_is_active (&w->timer)) ev_unref (EV_A); 2976 if (ev_is_active (&w->timer)) ev_unref (EV_A);
… …
2992 2984
2993 if (wd < 0) 2985 if (wd < 0)
2994 return; 2986 return;
2995 2987
2996 w->wd = -2; 2988 w->wd = -2;
2997 slot = wd & (EV_INOTIFY_HASHSIZE - 1); 2989 slot = wd & ((EV_INOTIFY_HASHSIZE) - 1);
2998 wlist_del (&fs_hash [slot].head, (WL)w); 2990 wlist_del (&fs_hash [slot].head, (WL)w);
2999 2991
3000 /* remove this watcher, if others are watching it, they will rearm */ 2992 /* remove this watcher, if others are watching it, they will rearm */
3001 inotify_rm_watch (fs_fd, wd); 2993 inotify_rm_watch (fs_fd, wd);
3002} 2994}
… …
3004static void noinline 2996static void noinline
3005infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev) 2997infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
3006{ 2998{
3007 if (slot < 0) 2999 if (slot < 0)
3008 /* overflow, need to check for all hash slots */ 3000 /* overflow, need to check for all hash slots */
3009 for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot) 3001 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
3010 infy_wd (EV_A_ slot, wd, ev); 3002 infy_wd (EV_A_ slot, wd, ev);
3011 else 3003 else
3012 { 3004 {
3013 WL w_; 3005 WL w_;
3014 3006
3015 for (w_ = fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head; w_; ) 3007 for (w_ = fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head; w_; )
3016 { 3008 {
3017 ev_stat *w = (ev_stat *)w_; 3009 ev_stat *w = (ev_stat *)w_;
3018 w_ = w_->next; /* lets us remove this watcher and all before it */ 3010 w_ = w_->next; /* lets us remove this watcher and all before it */
3019 3011
3020 if (w->wd == wd || wd == -1) 3012 if (w->wd == wd || wd == -1)
3021 { 3013 {
3022 if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF)) 3014 if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
3023 { 3015 {
3024 wlist_del (&fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w); 3016 wlist_del (&fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
3025 w->wd = -1; 3017 w->wd = -1;
3026 infy_add (EV_A_ w); /* re-add, no matter what */ 3018 infy_add (EV_A_ w); /* re-add, no matter what */
3027 } 3019 }
3028 3020
3029 stat_timer_cb (EV_A_ &w->timer, 0); 3021 stat_timer_cb (EV_A_ &w->timer, 0);
… …
3143 ev_io_set (&fs_w, fs_fd, EV_READ); 3135 ev_io_set (&fs_w, fs_fd, EV_READ);
3144 ev_io_start (EV_A_ &fs_w); 3136 ev_io_start (EV_A_ &fs_w);
3145 ev_unref (EV_A); 3137 ev_unref (EV_A);
3146 } 3138 }
3147 3139
3148 for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot) 3140 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
3149 { 3141 {
3150 WL w_ = fs_hash [slot].head; 3142 WL w_ = fs_hash [slot].head;
3151 fs_hash [slot].head = 0; 3143 fs_hash [slot].head = 0;
3152 3144
3153 while (w_) 3145 while (w_)
… …
3769 } 3761 }
3770#endif 3762#endif
3771 3763
3772#if EV_CHILD_ENABLE 3764#if EV_CHILD_ENABLE
3773 if (types & EV_CHILD) 3765 if (types & EV_CHILD)
3774 for (i = EV_PID_HASHSIZE; i--; ) 3766 for (i = (EV_PID_HASHSIZE); i--; )
3775 for (wl = childs [i]; wl; ) 3767 for (wl = childs [i]; wl; )
3776 { 3768 {
3777 wn = wl->next; 3769 wn = wl->next;
3778 cb (EV_A_ EV_CHILD, wl); 3770 cb (EV_A_ EV_CHILD, wl);
3779 wl = wn; 3771 wl = wn;

Diff Legend

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