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

Comparing libev/ev.c (file contents):
Revision 1.280 by root, Sat Mar 14 04:45:39 2009 UTC vs.
Revision 1.284 by root, Wed Apr 15 17:49:26 2009 UTC

… …
570 struct timeval tv; 570 struct timeval tv;
571 gettimeofday (&tv, 0); 571 gettimeofday (&tv, 0);
572 return tv.tv_sec + tv.tv_usec * 1e-6; 572 return tv.tv_sec + tv.tv_usec * 1e-6;
573} 573}
574 574
575ev_tstamp inline_size 575inline_size ev_tstamp
576get_clock (void) 576get_clock (void)
577{ 577{
578#if EV_USE_MONOTONIC 578#if EV_USE_MONOTONIC
579 if (expect_true (have_monotonic)) 579 if (expect_true (have_monotonic))
580 { 580 {
… …
625 625
626/*****************************************************************************/ 626/*****************************************************************************/
627 627
628#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */ 628#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
629 629
630int inline_size 630inline_size int
631array_nextsize (int elem, int cur, int cnt) 631array_nextsize (int elem, int cur, int cnt)
632{ 632{
633 int ncur = cur + 1; 633 int ncur = cur + 1;
634 634
635 do 635 do
… …
697 pendings [pri][w_->pending - 1].w = w_; 697 pendings [pri][w_->pending - 1].w = w_;
698 pendings [pri][w_->pending - 1].events = revents; 698 pendings [pri][w_->pending - 1].events = revents;
699 } 699 }
700} 700}
701 701
702void inline_speed 702inline_speed void
703feed_reverse (EV_P_ W w)
704{
705 array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);
706 rfeeds [rfeedcnt++] = w;
707}
708
709inline_size void
710feed_reverse_done (EV_P_ int revents)
711{
712 do
713 ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);
714 while (rfeedcnt);
715}
716
717inline_speed void
703queue_events (EV_P_ W *events, int eventcnt, int type) 718queue_events (EV_P_ W *events, int eventcnt, int type)
704{ 719{
705 int i; 720 int i;
706 721
707 for (i = 0; i < eventcnt; ++i) 722 for (i = 0; i < eventcnt; ++i)
708 ev_feed_event (EV_A_ events [i], type); 723 ev_feed_event (EV_A_ events [i], type);
709} 724}
710 725
711/*****************************************************************************/ 726/*****************************************************************************/
712 727
713void inline_speed 728inline_speed void
714fd_event (EV_P_ int fd, int revents) 729fd_event (EV_P_ int fd, int revents)
715{ 730{
716 ANFD *anfd = anfds + fd; 731 ANFD *anfd = anfds + fd;
717 ev_io *w; 732 ev_io *w;
718 733
… …
730{ 745{
731 if (fd >= 0 && fd < anfdmax) 746 if (fd >= 0 && fd < anfdmax)
732 fd_event (EV_A_ fd, revents); 747 fd_event (EV_A_ fd, revents);
733} 748}
734 749
735void inline_size 750inline_size void
736fd_reify (EV_P) 751fd_reify (EV_P)
737{ 752{
738 int i; 753 int i;
739 754
740 for (i = 0; i < fdchangecnt; ++i) 755 for (i = 0; i < fdchangecnt; ++i)
… …
766 unsigned char o_reify = anfd->reify; 781 unsigned char o_reify = anfd->reify;
767 782
768 anfd->reify = 0; 783 anfd->reify = 0;
769 anfd->events = events; 784 anfd->events = events;
770 785
771 if (o_events != events || o_reify & EV_IOFDSET) 786 if (o_events != events || o_reify & EV__IOFDSET)
772 backend_modify (EV_A_ fd, o_events, events); 787 backend_modify (EV_A_ fd, o_events, events);
773 } 788 }
774 } 789 }
775 790
776 fdchangecnt = 0; 791 fdchangecnt = 0;
777} 792}
778 793
779void inline_size 794inline_size void
780fd_change (EV_P_ int fd, int flags) 795fd_change (EV_P_ int fd, int flags)
781{ 796{
782 unsigned char reify = anfds [fd].reify; 797 unsigned char reify = anfds [fd].reify;
783 anfds [fd].reify |= flags; 798 anfds [fd].reify |= flags;
784 799
… …
788 array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2); 803 array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
789 fdchanges [fdchangecnt - 1] = fd; 804 fdchanges [fdchangecnt - 1] = fd;
790 } 805 }
791} 806}
792 807
793void inline_speed 808inline_speed void
794fd_kill (EV_P_ int fd) 809fd_kill (EV_P_ int fd)
795{ 810{
796 ev_io *w; 811 ev_io *w;
797 812
798 while ((w = (ev_io *)anfds [fd].head)) 813 while ((w = (ev_io *)anfds [fd].head))
… …
800 ev_io_stop (EV_A_ w); 815 ev_io_stop (EV_A_ w);
801 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE); 816 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
802 } 817 }
803} 818}
804 819
805int inline_size 820inline_size int
806fd_valid (int fd) 821fd_valid (int fd)
807{ 822{
808#ifdef _WIN32 823#ifdef _WIN32
809 return _get_osfhandle (fd) != -1; 824 return _get_osfhandle (fd) != -1;
810#else 825#else
… …
847 for (fd = 0; fd < anfdmax; ++fd) 862 for (fd = 0; fd < anfdmax; ++fd)
848 if (anfds [fd].events) 863 if (anfds [fd].events)
849 { 864 {
850 anfds [fd].events = 0; 865 anfds [fd].events = 0;
851 anfds [fd].emask = 0; 866 anfds [fd].emask = 0;
852 fd_change (EV_A_ fd, EV_IOFDSET | 1); 867 fd_change (EV_A_ fd, EV__IOFDSET | 1);
853 } 868 }
854} 869}
855 870
856/*****************************************************************************/ 871/*****************************************************************************/
857 872
… …
873#define HEAP0 (DHEAP - 1) /* index of first element in heap */ 888#define HEAP0 (DHEAP - 1) /* index of first element in heap */
874#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0) 889#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
875#define UPHEAP_DONE(p,k) ((p) == (k)) 890#define UPHEAP_DONE(p,k) ((p) == (k))
876 891
877/* away from the root */ 892/* away from the root */
878void inline_speed 893inline_speed void
879downheap (ANHE *heap, int N, int k) 894downheap (ANHE *heap, int N, int k)
880{ 895{
881 ANHE he = heap [k]; 896 ANHE he = heap [k];
882 ANHE *E = heap + N + HEAP0; 897 ANHE *E = heap + N + HEAP0;
883 898
… …
923#define HEAP0 1 938#define HEAP0 1
924#define HPARENT(k) ((k) >> 1) 939#define HPARENT(k) ((k) >> 1)
925#define UPHEAP_DONE(p,k) (!(p)) 940#define UPHEAP_DONE(p,k) (!(p))
926 941
927/* away from the root */ 942/* away from the root */
928void inline_speed 943inline_speed void
929downheap (ANHE *heap, int N, int k) 944downheap (ANHE *heap, int N, int k)
930{ 945{
931 ANHE he = heap [k]; 946 ANHE he = heap [k];
932 947
933 for (;;) 948 for (;;)
… …
953 ev_active (ANHE_w (he)) = k; 968 ev_active (ANHE_w (he)) = k;
954} 969}
955#endif 970#endif
956 971
957/* towards the root */ 972/* towards the root */
958void inline_speed 973inline_speed void
959upheap (ANHE *heap, int k) 974upheap (ANHE *heap, int k)
960{ 975{
961 ANHE he = heap [k]; 976 ANHE he = heap [k];
962 977
963 for (;;) 978 for (;;)
… …
974 989
975 heap [k] = he; 990 heap [k] = he;
976 ev_active (ANHE_w (he)) = k; 991 ev_active (ANHE_w (he)) = k;
977} 992}
978 993
979void inline_size 994inline_size void
980adjustheap (ANHE *heap, int N, int k) 995adjustheap (ANHE *heap, int N, int k)
981{ 996{
982 if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k])) 997 if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))
983 upheap (heap, k); 998 upheap (heap, k);
984 else 999 else
985 downheap (heap, N, k); 1000 downheap (heap, N, k);
986} 1001}
987 1002
988/* rebuild the heap: this function is used only once and executed rarely */ 1003/* rebuild the heap: this function is used only once and executed rarely */
989void inline_size 1004inline_size void
990reheap (ANHE *heap, int N) 1005reheap (ANHE *heap, int N)
991{ 1006{
992 int i; 1007 int i;
993 1008
994 /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */ 1009 /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
… …
1010 1025
1011static EV_ATOMIC_T gotsig; 1026static EV_ATOMIC_T gotsig;
1012 1027
1013/*****************************************************************************/ 1028/*****************************************************************************/
1014 1029
1015void inline_speed 1030inline_speed void
1016fd_intern (int fd) 1031fd_intern (int fd)
1017{ 1032{
1018#ifdef _WIN32 1033#ifdef _WIN32
1019 unsigned long arg = 1; 1034 unsigned long arg = 1;
1020 ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg); 1035 ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
… …
1050 ev_io_start (EV_A_ &pipeev); 1065 ev_io_start (EV_A_ &pipeev);
1051 ev_unref (EV_A); /* watcher should not keep loop alive */ 1066 ev_unref (EV_A); /* watcher should not keep loop alive */
1052 } 1067 }
1053} 1068}
1054 1069
1055void inline_size 1070inline_size void
1056evpipe_write (EV_P_ EV_ATOMIC_T *flag) 1071evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1057{ 1072{
1058 if (!*flag) 1073 if (!*flag)
1059 { 1074 {
1060 int old_errno = errno; /* save errno because write might clobber it */ 1075 int old_errno = errno; /* save errno because write might clobber it */
… …
1164 1179
1165#ifndef WIFCONTINUED 1180#ifndef WIFCONTINUED
1166# define WIFCONTINUED(status) 0 1181# define WIFCONTINUED(status) 0
1167#endif 1182#endif
1168 1183
1169void inline_speed 1184inline_speed void
1170child_reap (EV_P_ int chain, int pid, int status) 1185child_reap (EV_P_ int chain, int pid, int status)
1171{ 1186{
1172 ev_child *w; 1187 ev_child *w;
1173 int traced = WIFSTOPPED (status) || WIFCONTINUED (status); 1188 int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
1174 1189
… …
1452 } 1467 }
1453 1468
1454 ev_free (anfds); anfdmax = 0; 1469 ev_free (anfds); anfdmax = 0;
1455 1470
1456 /* have to use the microsoft-never-gets-it-right macro */ 1471 /* have to use the microsoft-never-gets-it-right macro */
1472 array_free (rfeed, EMPTY);
1457 array_free (fdchange, EMPTY); 1473 array_free (fdchange, EMPTY);
1458 array_free (timer, EMPTY); 1474 array_free (timer, EMPTY);
1459#if EV_PERIODIC_ENABLE 1475#if EV_PERIODIC_ENABLE
1460 array_free (periodic, EMPTY); 1476 array_free (periodic, EMPTY);
1461#endif 1477#endif
… …
1470 1486
1471 backend = 0; 1487 backend = 0;
1472} 1488}
1473 1489
1474#if EV_USE_INOTIFY 1490#if EV_USE_INOTIFY
1475void inline_size infy_fork (EV_P); 1491inline_size void infy_fork (EV_P);
1476#endif 1492#endif
1477 1493
1478void inline_size 1494inline_size void
1479loop_fork (EV_P) 1495loop_fork (EV_P)
1480{ 1496{
1481#if EV_USE_PORT 1497#if EV_USE_PORT
1482 if (backend == EVBACKEND_PORT ) port_fork (EV_A); 1498 if (backend == EVBACKEND_PORT ) port_fork (EV_A);
1483#endif 1499#endif
… …
1720ev_invoke (EV_P_ void *w, int revents) 1736ev_invoke (EV_P_ void *w, int revents)
1721{ 1737{
1722 EV_CB_INVOKE ((W)w, revents); 1738 EV_CB_INVOKE ((W)w, revents);
1723} 1739}
1724 1740
1725void inline_speed 1741inline_speed void
1726call_pending (EV_P) 1742call_pending (EV_P)
1727{ 1743{
1728 int pri; 1744 int pri;
1729 1745
1730 for (pri = NUMPRI; pri--; ) 1746 for (pri = NUMPRI; pri--; )
… …
1742 } 1758 }
1743 } 1759 }
1744} 1760}
1745 1761
1746#if EV_IDLE_ENABLE 1762#if EV_IDLE_ENABLE
1747void inline_size 1763inline_size void
1748idle_reify (EV_P) 1764idle_reify (EV_P)
1749{ 1765{
1750 if (expect_false (idleall)) 1766 if (expect_false (idleall))
1751 { 1767 {
1752 int pri; 1768 int pri;
… …
1764 } 1780 }
1765 } 1781 }
1766} 1782}
1767#endif 1783#endif
1768 1784
1769void inline_size 1785inline_size void
1770timers_reify (EV_P) 1786timers_reify (EV_P)
1771{ 1787{
1772 EV_FREQUENT_CHECK; 1788 EV_FREQUENT_CHECK;
1773 1789
1774 while (timercnt && ANHE_at (timers [HEAP0]) < mn_now) 1790 if (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
1775 { 1791 {
1776 ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]); 1792 do
1777
1778 /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/
1779
1780 /* first reschedule or stop timer */
1781 if (w->repeat)
1782 { 1793 {
1794 ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
1795
1796 /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/
1797
1798 /* first reschedule or stop timer */
1799 if (w->repeat)
1800 {
1783 ev_at (w) += w->repeat; 1801 ev_at (w) += w->repeat;
1784 if (ev_at (w) < mn_now) 1802 if (ev_at (w) < mn_now)
1785 ev_at (w) = mn_now; 1803 ev_at (w) = mn_now;
1786 1804
1787 assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.)); 1805 assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));
1788 1806
1789 ANHE_at_cache (timers [HEAP0]); 1807 ANHE_at_cache (timers [HEAP0]);
1790 downheap (timers, timercnt, HEAP0); 1808 downheap (timers, timercnt, HEAP0);
1809 }
1810 else
1811 ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
1812
1813 EV_FREQUENT_CHECK;
1814 feed_reverse (EV_A_ (W)w);
1791 } 1815 }
1792 else 1816 while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);
1793 ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
1794 1817
1795 EV_FREQUENT_CHECK;
1796 ev_feed_event (EV_A_ (W)w, EV_TIMEOUT); 1818 feed_reverse_done (EV_A_ EV_TIMEOUT);
1797 } 1819 }
1798} 1820}
1799 1821
1800#if EV_PERIODIC_ENABLE 1822#if EV_PERIODIC_ENABLE
1801void inline_size 1823inline_size void
1802periodics_reify (EV_P) 1824periodics_reify (EV_P)
1803{ 1825{
1804 EV_FREQUENT_CHECK; 1826 EV_FREQUENT_CHECK;
1805 1827
1806 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now) 1828 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
1807 { 1829 {
1808 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]); 1830 int feed_count = 0;
1809 1831
1810 /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/ 1832 do
1811
1812 /* first reschedule or stop timer */
1813 if (w->reschedule_cb)
1814 { 1833 {
1834 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
1835
1836 /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
1837
1838 /* first reschedule or stop timer */
1839 if (w->reschedule_cb)
1840 {
1815 ev_at (w) = w->reschedule_cb (w, ev_rt_now); 1841 ev_at (w) = w->reschedule_cb (w, ev_rt_now);
1816 1842
1817 assert (("libev: ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now)); 1843 assert (("libev: ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
1818 1844
1819 ANHE_at_cache (periodics [HEAP0]); 1845 ANHE_at_cache (periodics [HEAP0]);
1820 downheap (periodics, periodiccnt, HEAP0); 1846 downheap (periodics, periodiccnt, HEAP0);
1847 }
1848 else if (w->interval)
1849 {
1850 ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1851 /* if next trigger time is not sufficiently in the future, put it there */
1852 /* this might happen because of floating point inexactness */
1853 if (ev_at (w) - ev_rt_now < TIME_EPSILON)
1854 {
1855 ev_at (w) += w->interval;
1856
1857 /* if interval is unreasonably low we might still have a time in the past */
1858 /* so correct this. this will make the periodic very inexact, but the user */
1859 /* has effectively asked to get triggered more often than possible */
1860 if (ev_at (w) < ev_rt_now)
1861 ev_at (w) = ev_rt_now;
1862 }
1863
1864 ANHE_at_cache (periodics [HEAP0]);
1865 downheap (periodics, periodiccnt, HEAP0);
1866 }
1867 else
1868 ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1869
1870 EV_FREQUENT_CHECK;
1871 feed_reverse (EV_A_ (W)w);
1821 } 1872 }
1822 else if (w->interval) 1873 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now);
1823 {
1824 ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1825 /* if next trigger time is not sufficiently in the future, put it there */
1826 /* this might happen because of floating point inexactness */
1827 if (ev_at (w) - ev_rt_now < TIME_EPSILON)
1828 {
1829 ev_at (w) += w->interval;
1830 1874
1831 /* if interval is unreasonably low we might still have a time in the past */
1832 /* so correct this. this will make the periodic very inexact, but the user */
1833 /* has effectively asked to get triggered more often than possible */
1834 if (ev_at (w) < ev_rt_now)
1835 ev_at (w) = ev_rt_now;
1836 }
1837
1838 ANHE_at_cache (periodics [HEAP0]);
1839 downheap (periodics, periodiccnt, HEAP0);
1840 }
1841 else
1842 ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1843
1844 EV_FREQUENT_CHECK;
1845 ev_feed_event (EV_A_ (W)w, EV_PERIODIC); 1875 feed_reverse_done (EV_A_ EV_PERIODIC);
1846 } 1876 }
1847} 1877}
1848 1878
1849static void noinline 1879static void noinline
1850periodics_reschedule (EV_P) 1880periodics_reschedule (EV_P)
… …
1866 1896
1867 reheap (periodics, periodiccnt); 1897 reheap (periodics, periodiccnt);
1868} 1898}
1869#endif 1899#endif
1870 1900
1871void inline_speed 1901inline_speed void
1872time_update (EV_P_ ev_tstamp max_block) 1902time_update (EV_P_ ev_tstamp max_block)
1873{ 1903{
1874 int i; 1904 int i;
1875 1905
1876#if EV_USE_MONOTONIC 1906#if EV_USE_MONOTONIC
… …
1997 { 2027 {
1998 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); 2028 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1999 call_pending (EV_A); 2029 call_pending (EV_A);
2000 } 2030 }
2001 2031
2002 if (expect_false (!activecnt))
2003 break;
2004
2005 /* we might have forked, so reify kernel state if necessary */ 2032 /* we might have forked, so reify kernel state if necessary */
2006 if (expect_false (postfork)) 2033 if (expect_false (postfork))
2007 loop_fork (EV_A); 2034 loop_fork (EV_A);
2008 2035
2009 /* update fd-related kernel structures */ 2036 /* update fd-related kernel structures */
… …
2016 2043
2017 if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt))) 2044 if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt)))
2018 { 2045 {
2019 /* update time to cancel out callback processing overhead */ 2046 /* update time to cancel out callback processing overhead */
2020 time_update (EV_A_ 1e100); 2047 time_update (EV_A_ 1e100);
2021
2022 waittime = MAX_BLOCKTIME;
2023 2048
2024 if (timercnt) 2049 if (timercnt)
2025 { 2050 {
2026 ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge; 2051 ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge;
2027 if (waittime > to) waittime = to; 2052 if (waittime > to) waittime = to;
… …
2090 loop_done = how; 2115 loop_done = how;
2091} 2116}
2092 2117
2093/*****************************************************************************/ 2118/*****************************************************************************/
2094 2119
2095void inline_size 2120inline_size void
2096wlist_add (WL *head, WL elem) 2121wlist_add (WL *head, WL elem)
2097{ 2122{
2098 elem->next = *head; 2123 elem->next = *head;
2099 *head = elem; 2124 *head = elem;
2100} 2125}
2101 2126
2102void inline_size 2127inline_size void
2103wlist_del (WL *head, WL elem) 2128wlist_del (WL *head, WL elem)
2104{ 2129{
2105 while (*head) 2130 while (*head)
2106 { 2131 {
2107 if (*head == elem) 2132 if (*head == elem)
… …
2112 2137
2113 head = &(*head)->next; 2138 head = &(*head)->next;
2114 } 2139 }
2115} 2140}
2116 2141
2117void inline_speed 2142inline_speed void
2118clear_pending (EV_P_ W w) 2143clear_pending (EV_P_ W w)
2119{ 2144{
2120 if (w->pending) 2145 if (w->pending)
2121 { 2146 {
2122 pendings [ABSPRI (w)][w->pending - 1].w = 0; 2147 pendings [ABSPRI (w)][w->pending - 1].w = 0;
… …
2139 } 2164 }
2140 else 2165 else
2141 return 0; 2166 return 0;
2142} 2167}
2143 2168
2144void inline_size 2169inline_size void
2145pri_adjust (EV_P_ W w) 2170pri_adjust (EV_P_ W w)
2146{ 2171{
2147 int pri = w->priority; 2172 int pri = w->priority;
2148 pri = pri < EV_MINPRI ? EV_MINPRI : pri; 2173 pri = pri < EV_MINPRI ? EV_MINPRI : pri;
2149 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri; 2174 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
2150 w->priority = pri; 2175 w->priority = pri;
2151} 2176}
2152 2177
2153void inline_speed 2178inline_speed void
2154ev_start (EV_P_ W w, int active) 2179ev_start (EV_P_ W w, int active)
2155{ 2180{
2156 pri_adjust (EV_A_ w); 2181 pri_adjust (EV_A_ w);
2157 w->active = active; 2182 w->active = active;
2158 ev_ref (EV_A); 2183 ev_ref (EV_A);
2159} 2184}
2160 2185
2161void inline_size 2186inline_size void
2162ev_stop (EV_P_ W w) 2187ev_stop (EV_P_ W w)
2163{ 2188{
2164 ev_unref (EV_A); 2189 ev_unref (EV_A);
2165 w->active = 0; 2190 w->active = 0;
2166} 2191}
… …
2174 2199
2175 if (expect_false (ev_is_active (w))) 2200 if (expect_false (ev_is_active (w)))
2176 return; 2201 return;
2177 2202
2178 assert (("libev: ev_io_start called with negative fd", fd >= 0)); 2203 assert (("libev: ev_io_start called with negative fd", fd >= 0));
2179 assert (("libev: ev_io start called with illegal event mask", !(w->events & ~(EV_IOFDSET | EV_READ | EV_WRITE)))); 2204 assert (("libev: ev_io start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
2180 2205
2181 EV_FREQUENT_CHECK; 2206 EV_FREQUENT_CHECK;
2182 2207
2183 ev_start (EV_A_ (W)w, 1); 2208 ev_start (EV_A_ (W)w, 1);
2184 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 2209 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
2185 wlist_add (&anfds[fd].head, (WL)w); 2210 wlist_add (&anfds[fd].head, (WL)w);
2186 2211
2187 fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1); 2212 fd_change (EV_A_ fd, w->events & EV__IOFDSET | 1);
2188 w->events &= ~EV_IOFDSET; 2213 w->events &= ~EV__IOFDSET;
2189 2214
2190 EV_FREQUENT_CHECK; 2215 EV_FREQUENT_CHECK;
2191} 2216}
2192 2217
2193void noinline 2218void noinline
… …
2591 2616
2592 for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len) 2617 for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)
2593 infy_wd (EV_A_ ev->wd, ev->wd, ev); 2618 infy_wd (EV_A_ ev->wd, ev->wd, ev);
2594} 2619}
2595 2620
2596void inline_size 2621inline_size void
2597check_2625 (EV_P) 2622check_2625 (EV_P)
2598{ 2623{
2599 /* kernels < 2.6.25 are borked 2624 /* kernels < 2.6.25 are borked
2600 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html 2625 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2601 */ 2626 */
… …
2614 return; 2639 return;
2615 2640
2616 fs_2625 = 1; 2641 fs_2625 = 1;
2617} 2642}
2618 2643
2619void inline_size 2644inline_size void
2620infy_init (EV_P) 2645infy_init (EV_P)
2621{ 2646{
2622 if (fs_fd != -2) 2647 if (fs_fd != -2)
2623 return; 2648 return;
2624 2649
… …
2634 ev_set_priority (&fs_w, EV_MAXPRI); 2659 ev_set_priority (&fs_w, EV_MAXPRI);
2635 ev_io_start (EV_A_ &fs_w); 2660 ev_io_start (EV_A_ &fs_w);
2636 } 2661 }
2637} 2662}
2638 2663
2639void inline_size 2664inline_size void
2640infy_fork (EV_P) 2665infy_fork (EV_P)
2641{ 2666{
2642 int slot; 2667 int slot;
2643 2668
2644 if (fs_fd < 0) 2669 if (fs_fd < 0)
… …
3146 ev_timer_set (&once->to, timeout, 0.); 3171 ev_timer_set (&once->to, timeout, 0.);
3147 ev_timer_start (EV_A_ &once->to); 3172 ev_timer_start (EV_A_ &once->to);
3148 } 3173 }
3149} 3174}
3150 3175
3176/*****************************************************************************/
3177
3178#if 0
3179void
3180ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w))
3181{
3182 int i, j;
3183 ev_watcher_list *wl, *wn;
3184
3185 if (types & (EV_IO | EV_EMBED))
3186 for (i = 0; i < anfdmax; ++i)
3187 for (wl = anfds [i].head; wl; )
3188 {
3189 wn = wl->next;
3190
3191#if EV_EMBED_ENABLE
3192 if (ev_cb ((ev_io *)wl) == embed_io_cb)
3193 {
3194 if (types & EV_EMBED)
3195 cb (EV_A_ EV_EMBED, ((char *)wl) - offsetof (struct ev_embed, io));
3196 }
3197 else
3198#endif
3199#if EV_USE_INOTIFY
3200 if (ev_cb ((ev_io *)wl) == infy_cb)
3201 ;
3202 else
3203#endif
3204 if ((ev_io *)wl != &pipeev)
3205 if (types & EV_IO)
3206 cb (EV_A_ EV_IO, wl);
3207
3208 wl = wn;
3209 }
3210
3211 if (types & (EV_TIMER | EV_STAT))
3212 for (i = timercnt + HEAP0; i-- > HEAP0; )
3213#if EV_STAT_ENABLE
3214 /*TODO: timer is not always active*/
3215 if (ev_cb ((ev_timer *)ANHE_w (timers [i])) == stat_timer_cb)
3216 {
3217 if (types & EV_STAT)
3218 cb (EV_A_ EV_STAT, ((char *)ANHE_w (timers [i])) - offsetof (struct ev_stat, timer));
3219 }
3220 else
3221#endif
3222 if (types & EV_TIMER)
3223 cb (EV_A_ EV_TIMER, ANHE_w (timers [i]));
3224
3225#if EV_PERIODIC_ENABLE
3226 if (types & EV_PERIODIC)
3227 for (i = periodiccnt + HEAP0; i-- > HEAP0; )
3228 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
3229#endif
3230
3231#if EV_IDLE_ENABLE
3232 if (types & EV_IDLE)
3233 for (j = NUMPRI; i--; )
3234 for (i = idlecnt [j]; i--; )
3235 cb (EV_A_ EV_IDLE, idles [j][i]);
3236#endif
3237
3238#if EV_FORK_ENABLE
3239 if (types & EV_FORK)
3240 for (i = forkcnt; i--; )
3241 if (ev_cb (forks [i]) != embed_fork_cb)
3242 cb (EV_A_ EV_FORK, forks [i]);
3243#endif
3244
3245#if EV_ASYNC_ENABLE
3246 if (types & EV_ASYNC)
3247 for (i = asynccnt; i--; )
3248 cb (EV_A_ EV_ASYNC, asyncs [i]);
3249#endif
3250
3251 if (types & EV_PREPARE)
3252 for (i = preparecnt; i--; )
3253#if EV_EMBED_ENABLE
3254 if (ev_cb (prepares [i]) != embed_prepare_cb)
3255#endif
3256 cb (EV_A_ EV_PREPARE, prepares [i]);
3257
3258 if (types & EV_CHECK)
3259 for (i = checkcnt; i--; )
3260 cb (EV_A_ EV_CHECK, checks [i]);
3261
3262 if (types & EV_SIGNAL)
3263 for (i = 0; i < signalmax; ++i)
3264 for (wl = signals [i].head; wl; )
3265 {
3266 wn = wl->next;
3267 cb (EV_A_ EV_SIGNAL, wl);
3268 wl = wn;
3269 }
3270
3271 if (types & EV_CHILD)
3272 for (i = EV_PID_HASHSIZE; i--; )
3273 for (wl = childs [i]; wl; )
3274 {
3275 wn = wl->next;
3276 cb (EV_A_ EV_CHILD, wl);
3277 wl = wn;
3278 }
3279/* EV_STAT 0x00001000 /* stat data changed */
3280/* EV_EMBED 0x00010000 /* embedded event loop needs sweep */
3281}
3282#endif
3283
3151#if EV_MULTIPLICITY 3284#if EV_MULTIPLICITY
3152 #include "ev_wrap.h" 3285 #include "ev_wrap.h"
3153#endif 3286#endif
3154 3287
3155#ifdef __cplusplus 3288#ifdef __cplusplus

Diff Legend

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