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

Comparing libev/ev.c (file contents):
Revision 1.421 by root, Wed Apr 18 06:06:04 2012 UTC vs.
Revision 1.431 by root, Wed May 9 16:51:33 2012 UTC

… …
201# include <sys/wait.h> 201# include <sys/wait.h>
202# include <unistd.h> 202# include <unistd.h>
203#else 203#else
204# include <io.h> 204# include <io.h>
205# define WIN32_LEAN_AND_MEAN 205# define WIN32_LEAN_AND_MEAN
206# include <winsock2.h>
206# include <windows.h> 207# include <windows.h>
207# ifndef EV_SELECT_IS_WINSOCKET 208# ifndef EV_SELECT_IS_WINSOCKET
208# define EV_SELECT_IS_WINSOCKET 1 209# define EV_SELECT_IS_WINSOCKET 1
209# endif 210# endif
210# undef EV_AVOID_STDIO 211# undef EV_AVOID_STDIO
… …
359#endif 360#endif
360 361
361/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 362/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
362/* which makes programs even slower. might work on other unices, too. */ 363/* which makes programs even slower. might work on other unices, too. */
363#if EV_USE_CLOCK_SYSCALL 364#if EV_USE_CLOCK_SYSCALL
364# include <syscall.h> 365# include <sys/syscall.h>
365# ifdef SYS_clock_gettime 366# ifdef SYS_clock_gettime
366# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts)) 367# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
367# undef EV_USE_MONOTONIC 368# undef EV_USE_MONOTONIC
368# define EV_USE_MONOTONIC 1 369# define EV_USE_MONOTONIC 1
369# else 370# else
… …
408/* some very old inotify.h headers don't have IN_DONT_FOLLOW */ 409/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
409# ifndef IN_DONT_FOLLOW 410# ifndef IN_DONT_FOLLOW
410# undef EV_USE_INOTIFY 411# undef EV_USE_INOTIFY
411# define EV_USE_INOTIFY 0 412# define EV_USE_INOTIFY 0
412# endif 413# endif
413#endif
414
415#if EV_SELECT_IS_WINSOCKET
416# include <winsock.h>
417#endif 414#endif
418 415
419#if EV_USE_EVENTFD 416#if EV_USE_EVENTFD
420/* our minimum requirement is glibc 2.7 which has the stub, but not the header */ 417/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
421# include <stdint.h> 418# include <stdint.h>
… …
1430 w_->pending = ++pendingcnt [pri]; 1427 w_->pending = ++pendingcnt [pri];
1431 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2); 1428 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
1432 pendings [pri][w_->pending - 1].w = w_; 1429 pendings [pri][w_->pending - 1].w = w_;
1433 pendings [pri][w_->pending - 1].events = revents; 1430 pendings [pri][w_->pending - 1].events = revents;
1434 } 1431 }
1432
1433 pendingpri = NUMPRI - 1;
1435} 1434}
1436 1435
1437inline_speed void 1436inline_speed void
1438feed_reverse (EV_P_ W w) 1437feed_reverse (EV_P_ W w)
1439{ 1438{
… …
1844} 1843}
1845 1844
1846inline_speed void 1845inline_speed void
1847evpipe_write (EV_P_ EV_ATOMIC_T *flag) 1846evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1848{ 1847{
1848 ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
1849
1849 if (expect_true (*flag)) 1850 if (expect_true (*flag))
1850 return; 1851 return;
1851 1852
1852 *flag = 1; 1853 *flag = 1;
1853 1854
… …
1872 write (evfd, &counter, sizeof (uint64_t)); 1873 write (evfd, &counter, sizeof (uint64_t));
1873 } 1874 }
1874 else 1875 else
1875#endif 1876#endif
1876 { 1877 {
1877 /* win32 people keep sending patches that change this write() to send() */ 1878#ifdef _WIN32
1878 /* and then run away. but send() is wrong, it wants a socket handle on win32 */ 1879 WSABUF buf;
1879 /* so when you think this write should be a send instead, please find out */ 1880 DWORD sent;
1880 /* where your send() is from - it's definitely not the microsoft send, and */ 1881 buf.buf = &buf;
1881 /* tell me. thank you. */ 1882 buf.len = 1;
1882 /* it might be that your problem is that your environment needs EV_USE_WSASOCKET */ 1883 WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
1883 /* check the ev documentation on how to use this flag */ 1884#else
1884 write (evpipe [1], &(evpipe [1]), 1); 1885 write (evpipe [1], &(evpipe [1]), 1);
1886#endif
1885 } 1887 }
1886 1888
1887 errno = old_errno; 1889 errno = old_errno;
1888 } 1890 }
1889} 1891}
… …
1904 read (evfd, &counter, sizeof (uint64_t)); 1906 read (evfd, &counter, sizeof (uint64_t));
1905 } 1907 }
1906 else 1908 else
1907#endif 1909#endif
1908 { 1910 {
1909 char dummy; 1911 char dummy[4];
1910 /* see discussion in evpipe_write when you think this read should be recv in win32 */ 1912#ifdef _WIN32
1913 WSABUF buf;
1914 DWORD recvd;
1915 buf.buf = dummy;
1916 buf.len = sizeof (dummy);
1917 WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, 0, 0, 0);
1918#else
1911 read (evpipe [0], &dummy, 1); 1919 read (evpipe [0], &dummy, sizeof (dummy));
1920#endif
1912 } 1921 }
1913 } 1922 }
1914 1923
1915 pipe_write_skipped = 0; 1924 pipe_write_skipped = 0;
1925
1926 ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
1916 1927
1917#if EV_SIGNAL_ENABLE 1928#if EV_SIGNAL_ENABLE
1918 if (sig_pending) 1929 if (sig_pending)
1919 { 1930 {
1920 sig_pending = 0; 1931 sig_pending = 0;
1932
1933 ECB_MEMORY_FENCE_RELEASE;
1921 1934
1922 for (i = EV_NSIG - 1; i--; ) 1935 for (i = EV_NSIG - 1; i--; )
1923 if (expect_false (signals [i].pending)) 1936 if (expect_false (signals [i].pending))
1924 ev_feed_signal_event (EV_A_ i + 1); 1937 ev_feed_signal_event (EV_A_ i + 1);
1925 } 1938 }
… …
1927 1940
1928#if EV_ASYNC_ENABLE 1941#if EV_ASYNC_ENABLE
1929 if (async_pending) 1942 if (async_pending)
1930 { 1943 {
1931 async_pending = 0; 1944 async_pending = 0;
1945
1946 ECB_MEMORY_FENCE_RELEASE;
1932 1947
1933 for (i = asynccnt; i--; ) 1948 for (i = asynccnt; i--; )
1934 if (asyncs [i]->sent) 1949 if (asyncs [i]->sent)
1935 { 1950 {
1936 asyncs [i]->sent = 0; 1951 asyncs [i]->sent = 0;
… …
2319 } 2334 }
2320} 2335}
2321 2336
2322/* free up a loop structure */ 2337/* free up a loop structure */
2323void ecb_cold 2338void ecb_cold
2324ev_loop_destroy (EV_P) EV_THROW 2339ev_loop_destroy (EV_P)
2325{ 2340{
2326 int i; 2341 int i;
2327 2342
2328#if EV_MULTIPLICITY 2343#if EV_MULTIPLICITY
2329 /* mimic free (0) */ 2344 /* mimic free (0) */
… …
2545void ecb_cold 2560void ecb_cold
2546ev_verify (EV_P) EV_THROW 2561ev_verify (EV_P) EV_THROW
2547{ 2562{
2548#if EV_VERIFY 2563#if EV_VERIFY
2549 int i; 2564 int i;
2550 WL w; 2565 WL w, w2;
2551 2566
2552 assert (activecnt >= -1); 2567 assert (activecnt >= -1);
2553 2568
2554 assert (fdchangemax >= fdchangecnt); 2569 assert (fdchangemax >= fdchangecnt);
2555 for (i = 0; i < fdchangecnt; ++i) 2570 for (i = 0; i < fdchangecnt; ++i)
2556 assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0)); 2571 assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0));
2557 2572
2558 assert (anfdmax >= 0); 2573 assert (anfdmax >= 0);
2559 for (i = 0; i < anfdmax; ++i) 2574 for (i = 0; i < anfdmax; ++i)
2575 {
2576 int j = 0;
2577
2560 for (w = anfds [i].head; w; w = w->next) 2578 for (w = w2 = anfds [i].head; w; w = w->next)
2561 { 2579 {
2562 verify_watcher (EV_A_ (W)w); 2580 verify_watcher (EV_A_ (W)w);
2581
2582 if (j++ & 1)
2583 {
2584 assert (("libev: io watcher list contains a loop", w != w2));
2585 w2 = w2->next;
2586 }
2587
2563 assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1)); 2588 assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1));
2564 assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i)); 2589 assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
2565 } 2590 }
2591 }
2566 2592
2567 assert (timermax >= timercnt); 2593 assert (timermax >= timercnt);
2568 verify_heap (EV_A_ timers, timercnt); 2594 verify_heap (EV_A_ timers, timercnt);
2569 2595
2570#if EV_PERIODIC_ENABLE 2596#if EV_PERIODIC_ENABLE
… …
2677} 2703}
2678 2704
2679void noinline 2705void noinline
2680ev_invoke_pending (EV_P) 2706ev_invoke_pending (EV_P)
2681{ 2707{
2682 int pri; 2708 for (pendingpri = NUMPRI; pendingpri--; ) /* pendingpri is modified during the loop */
2683
2684 for (pri = NUMPRI; pri--; )
2685 while (pendingcnt [pri]) 2709 while (pendingcnt [pendingpri])
2686 { 2710 {
2687 ANPENDING *p = pendings [pri] + --pendingcnt [pri]; 2711 ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2688 2712
2689 p->w->pending = 0; 2713 p->w->pending = 0;
2690 EV_CB_INVOKE (p->w, p->events); 2714 EV_CB_INVOKE (p->w, p->events);
2691 EV_FREQUENT_CHECK; 2715 EV_FREQUENT_CHECK;
2692 } 2716 }
… …
3241 EV_FREQUENT_CHECK; 3265 EV_FREQUENT_CHECK;
3242 3266
3243 ev_start (EV_A_ (W)w, 1); 3267 ev_start (EV_A_ (W)w, 1);
3244 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 3268 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
3245 wlist_add (&anfds[fd].head, (WL)w); 3269 wlist_add (&anfds[fd].head, (WL)w);
3270
3271 /* common bug, apparently */
3272 assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3246 3273
3247 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY); 3274 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
3248 w->events &= ~EV__IOFDSET; 3275 w->events &= ~EV__IOFDSET;
3249 3276
3250 EV_FREQUENT_CHECK; 3277 EV_FREQUENT_CHECK;

Diff Legend

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