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

Comparing libev/ev.c (file contents):
Revision 1.281 by root, Mon Mar 16 21:15:06 2009 UTC vs.
Revision 1.287 by root, Mon Apr 20 19:45:58 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)
… …
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
… …
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 1901static void noinline
1902timers_reschedule (EV_P_ ev_tstamp adjust)
1903{
1904 int i;
1905
1906 for (i = 0; i < timercnt; ++i)
1907 {
1908 ANHE *he = timers + i + HEAP0;
1909 ANHE_w (*he)->at += adjust;
1910 ANHE_at_cache (*he);
1911 }
1912}
1913
1914inline_speed void
1872time_update (EV_P_ ev_tstamp max_block) 1915time_update (EV_P_ ev_tstamp max_block)
1873{ 1916{
1874 int i; 1917 int i;
1875 1918
1876#if EV_USE_MONOTONIC 1919#if EV_USE_MONOTONIC
… …
1909 ev_rt_now = ev_time (); 1952 ev_rt_now = ev_time ();
1910 mn_now = get_clock (); 1953 mn_now = get_clock ();
1911 now_floor = mn_now; 1954 now_floor = mn_now;
1912 } 1955 }
1913 1956
1957 /* no timer adjustment, as the monotonic clock doesn't jump */
1958 /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1914# if EV_PERIODIC_ENABLE 1959# if EV_PERIODIC_ENABLE
1915 periodics_reschedule (EV_A); 1960 periodics_reschedule (EV_A);
1916# endif 1961# endif
1917 /* no timer adjustment, as the monotonic clock doesn't jump */
1918 /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1919 } 1962 }
1920 else 1963 else
1921#endif 1964#endif
1922 { 1965 {
1923 ev_rt_now = ev_time (); 1966 ev_rt_now = ev_time ();
1924 1967
1925 if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP)) 1968 if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
1926 { 1969 {
1970 /* adjust timers. this is easy, as the offset is the same for all of them */
1971 timers_reschedule (EV_A_ ev_rt_now - mn_now);
1927#if EV_PERIODIC_ENABLE 1972#if EV_PERIODIC_ENABLE
1928 periodics_reschedule (EV_A); 1973 periodics_reschedule (EV_A);
1929#endif 1974#endif
1930 /* adjust timers. this is easy, as the offset is the same for all of them */
1931 for (i = 0; i < timercnt; ++i)
1932 {
1933 ANHE *he = timers + i + HEAP0;
1934 ANHE_w (*he)->at += ev_rt_now - mn_now;
1935 ANHE_at_cache (*he);
1936 }
1937 } 1975 }
1938 1976
1939 mn_now = ev_rt_now; 1977 mn_now = ev_rt_now;
1940 } 1978 }
1941}
1942
1943void
1944ev_ref (EV_P)
1945{
1946 ++activecnt;
1947}
1948
1949void
1950ev_unref (EV_P)
1951{
1952 --activecnt;
1953}
1954
1955void
1956ev_now_update (EV_P)
1957{
1958 time_update (EV_A_ 1e100);
1959} 1979}
1960 1980
1961static int loop_done; 1981static int loop_done;
1962 1982
1963void 1983void
… …
1997 { 2017 {
1998 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); 2018 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1999 call_pending (EV_A); 2019 call_pending (EV_A);
2000 } 2020 }
2001 2021
2002 if (expect_false (!activecnt))
2003 break;
2004
2005 /* we might have forked, so reify kernel state if necessary */ 2022 /* we might have forked, so reify kernel state if necessary */
2006 if (expect_false (postfork)) 2023 if (expect_false (postfork))
2007 loop_fork (EV_A); 2024 loop_fork (EV_A);
2008 2025
2009 /* update fd-related kernel structures */ 2026 /* update fd-related kernel structures */
… …
2088ev_unloop (EV_P_ int how) 2105ev_unloop (EV_P_ int how)
2089{ 2106{
2090 loop_done = how; 2107 loop_done = how;
2091} 2108}
2092 2109
2110void
2111ev_ref (EV_P)
2112{
2113 ++activecnt;
2114}
2115
2116void
2117ev_unref (EV_P)
2118{
2119 --activecnt;
2120}
2121
2122void
2123ev_now_update (EV_P)
2124{
2125 time_update (EV_A_ 1e100);
2126}
2127
2128void
2129ev_suspend (EV_P)
2130{
2131 ev_now_update (EV_A);
2132}
2133
2134void
2135ev_resume (EV_P)
2136{
2137 ev_tstamp mn_prev = mn_now;
2138
2139 ev_now_update (EV_A);
2140 timers_reschedule (EV_A_ mn_now - mn_prev);
2141#if EV_PERIODIC_ENABLE
2142 periodics_reschedule (EV_A);
2143#endif
2144}
2145
2093/*****************************************************************************/ 2146/*****************************************************************************/
2094 2147
2095void inline_size 2148inline_size void
2096wlist_add (WL *head, WL elem) 2149wlist_add (WL *head, WL elem)
2097{ 2150{
2098 elem->next = *head; 2151 elem->next = *head;
2099 *head = elem; 2152 *head = elem;
2100} 2153}
2101 2154
2102void inline_size 2155inline_size void
2103wlist_del (WL *head, WL elem) 2156wlist_del (WL *head, WL elem)
2104{ 2157{
2105 while (*head) 2158 while (*head)
2106 { 2159 {
2107 if (*head == elem) 2160 if (*head == elem)
… …
2112 2165
2113 head = &(*head)->next; 2166 head = &(*head)->next;
2114 } 2167 }
2115} 2168}
2116 2169
2117void inline_speed 2170inline_speed void
2118clear_pending (EV_P_ W w) 2171clear_pending (EV_P_ W w)
2119{ 2172{
2120 if (w->pending) 2173 if (w->pending)
2121 { 2174 {
2122 pendings [ABSPRI (w)][w->pending - 1].w = 0; 2175 pendings [ABSPRI (w)][w->pending - 1].w = 0;
… …
2139 } 2192 }
2140 else 2193 else
2141 return 0; 2194 return 0;
2142} 2195}
2143 2196
2144void inline_size 2197inline_size void
2145pri_adjust (EV_P_ W w) 2198pri_adjust (EV_P_ W w)
2146{ 2199{
2147 int pri = w->priority; 2200 int pri = w->priority;
2148 pri = pri < EV_MINPRI ? EV_MINPRI : pri; 2201 pri = pri < EV_MINPRI ? EV_MINPRI : pri;
2149 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri; 2202 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
2150 w->priority = pri; 2203 w->priority = pri;
2151} 2204}
2152 2205
2153void inline_speed 2206inline_speed void
2154ev_start (EV_P_ W w, int active) 2207ev_start (EV_P_ W w, int active)
2155{ 2208{
2156 pri_adjust (EV_A_ w); 2209 pri_adjust (EV_A_ w);
2157 w->active = active; 2210 w->active = active;
2158 ev_ref (EV_A); 2211 ev_ref (EV_A);
2159} 2212}
2160 2213
2161void inline_size 2214inline_size void
2162ev_stop (EV_P_ W w) 2215ev_stop (EV_P_ W w)
2163{ 2216{
2164 ev_unref (EV_A); 2217 ev_unref (EV_A);
2165 w->active = 0; 2218 w->active = 0;
2166} 2219}
… …
2591 2644
2592 for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len) 2645 for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)
2593 infy_wd (EV_A_ ev->wd, ev->wd, ev); 2646 infy_wd (EV_A_ ev->wd, ev->wd, ev);
2594} 2647}
2595 2648
2596void inline_size 2649inline_size void
2597check_2625 (EV_P) 2650check_2625 (EV_P)
2598{ 2651{
2599 /* kernels < 2.6.25 are borked 2652 /* kernels < 2.6.25 are borked
2600 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html 2653 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2601 */ 2654 */
… …
2614 return; 2667 return;
2615 2668
2616 fs_2625 = 1; 2669 fs_2625 = 1;
2617} 2670}
2618 2671
2619void inline_size 2672inline_size void
2620infy_init (EV_P) 2673infy_init (EV_P)
2621{ 2674{
2622 if (fs_fd != -2) 2675 if (fs_fd != -2)
2623 return; 2676 return;
2624 2677
… …
2634 ev_set_priority (&fs_w, EV_MAXPRI); 2687 ev_set_priority (&fs_w, EV_MAXPRI);
2635 ev_io_start (EV_A_ &fs_w); 2688 ev_io_start (EV_A_ &fs_w);
2636 } 2689 }
2637} 2690}
2638 2691
2639void inline_size 2692inline_size void
2640infy_fork (EV_P) 2693infy_fork (EV_P)
2641{ 2694{
2642 int slot; 2695 int slot;
2643 2696
2644 if (fs_fd < 0) 2697 if (fs_fd < 0)
… …
3146 ev_timer_set (&once->to, timeout, 0.); 3199 ev_timer_set (&once->to, timeout, 0.);
3147 ev_timer_start (EV_A_ &once->to); 3200 ev_timer_start (EV_A_ &once->to);
3148 } 3201 }
3149} 3202}
3150 3203
3204/*****************************************************************************/
3205
3206#if 0
3207void
3208ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w))
3209{
3210 int i, j;
3211 ev_watcher_list *wl, *wn;
3212
3213 if (types & (EV_IO | EV_EMBED))
3214 for (i = 0; i < anfdmax; ++i)
3215 for (wl = anfds [i].head; wl; )
3216 {
3217 wn = wl->next;
3218
3219#if EV_EMBED_ENABLE
3220 if (ev_cb ((ev_io *)wl) == embed_io_cb)
3221 {
3222 if (types & EV_EMBED)
3223 cb (EV_A_ EV_EMBED, ((char *)wl) - offsetof (struct ev_embed, io));
3224 }
3225 else
3226#endif
3227#if EV_USE_INOTIFY
3228 if (ev_cb ((ev_io *)wl) == infy_cb)
3229 ;
3230 else
3231#endif
3232 if ((ev_io *)wl != &pipeev)
3233 if (types & EV_IO)
3234 cb (EV_A_ EV_IO, wl);
3235
3236 wl = wn;
3237 }
3238
3239 if (types & (EV_TIMER | EV_STAT))
3240 for (i = timercnt + HEAP0; i-- > HEAP0; )
3241#if EV_STAT_ENABLE
3242 /*TODO: timer is not always active*/
3243 if (ev_cb ((ev_timer *)ANHE_w (timers [i])) == stat_timer_cb)
3244 {
3245 if (types & EV_STAT)
3246 cb (EV_A_ EV_STAT, ((char *)ANHE_w (timers [i])) - offsetof (struct ev_stat, timer));
3247 }
3248 else
3249#endif
3250 if (types & EV_TIMER)
3251 cb (EV_A_ EV_TIMER, ANHE_w (timers [i]));
3252
3253#if EV_PERIODIC_ENABLE
3254 if (types & EV_PERIODIC)
3255 for (i = periodiccnt + HEAP0; i-- > HEAP0; )
3256 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
3257#endif
3258
3259#if EV_IDLE_ENABLE
3260 if (types & EV_IDLE)
3261 for (j = NUMPRI; i--; )
3262 for (i = idlecnt [j]; i--; )
3263 cb (EV_A_ EV_IDLE, idles [j][i]);
3264#endif
3265
3266#if EV_FORK_ENABLE
3267 if (types & EV_FORK)
3268 for (i = forkcnt; i--; )
3269 if (ev_cb (forks [i]) != embed_fork_cb)
3270 cb (EV_A_ EV_FORK, forks [i]);
3271#endif
3272
3273#if EV_ASYNC_ENABLE
3274 if (types & EV_ASYNC)
3275 for (i = asynccnt; i--; )
3276 cb (EV_A_ EV_ASYNC, asyncs [i]);
3277#endif
3278
3279 if (types & EV_PREPARE)
3280 for (i = preparecnt; i--; )
3281#if EV_EMBED_ENABLE
3282 if (ev_cb (prepares [i]) != embed_prepare_cb)
3283#endif
3284 cb (EV_A_ EV_PREPARE, prepares [i]);
3285
3286 if (types & EV_CHECK)
3287 for (i = checkcnt; i--; )
3288 cb (EV_A_ EV_CHECK, checks [i]);
3289
3290 if (types & EV_SIGNAL)
3291 for (i = 0; i < signalmax; ++i)
3292 for (wl = signals [i].head; wl; )
3293 {
3294 wn = wl->next;
3295 cb (EV_A_ EV_SIGNAL, wl);
3296 wl = wn;
3297 }
3298
3299 if (types & EV_CHILD)
3300 for (i = EV_PID_HASHSIZE; i--; )
3301 for (wl = childs [i]; wl; )
3302 {
3303 wn = wl->next;
3304 cb (EV_A_ EV_CHILD, wl);
3305 wl = wn;
3306 }
3307/* EV_STAT 0x00001000 /* stat data changed */
3308/* EV_EMBED 0x00010000 /* embedded event loop needs sweep */
3309}
3310#endif
3311
3151#if EV_MULTIPLICITY 3312#if EV_MULTIPLICITY
3152 #include "ev_wrap.h" 3313 #include "ev_wrap.h"
3153#endif 3314#endif
3154 3315
3155#ifdef __cplusplus 3316#ifdef __cplusplus

Diff Legend

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