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

Comparing libev/ev.c (file contents):
Revision 1.143 by root, Tue Nov 27 07:27:10 2007 UTC vs.
Revision 1.146 by root, Tue Nov 27 09:17:51 2007 UTC

198# define inline_speed static inline 198# define inline_speed static inline
199# endif 199# endif
200#else 200#else
201# define expect(expr,value) (expr) 201# define expect(expr,value) (expr)
202# define inline_speed static 202# define inline_speed static
203# define inline_minimal static 203# define inline_size static
204# define noinline 204# define noinline
205#endif 205#endif
206 206
207#define expect_false(expr) expect ((expr) != 0, 0) 207#define expect_false(expr) expect ((expr) != 0, 0)
208#define expect_true(expr) expect ((expr) != 0, 1) 208#define expect_true(expr) expect ((expr) != 0, 1)
1558 ev_periodic_stop (EV_A_ w); 1558 ev_periodic_stop (EV_A_ w);
1559 ev_periodic_start (EV_A_ w); 1559 ev_periodic_start (EV_A_ w);
1560} 1560}
1561#endif 1561#endif
1562 1562
1563void
1564ev_idle_start (EV_P_ ev_idle *w)
1565{
1566 if (expect_false (ev_is_active (w)))
1567 return;
1568
1569 ev_start (EV_A_ (W)w, ++idlecnt);
1570 array_needsize (ev_idle *, idles, idlemax, idlecnt, EMPTY2);
1571 idles [idlecnt - 1] = w;
1572}
1573
1574void
1575ev_idle_stop (EV_P_ ev_idle *w)
1576{
1577 ev_clear_pending (EV_A_ (W)w);
1578 if (expect_false (!ev_is_active (w)))
1579 return;
1580
1581 {
1582 int active = ((W)w)->active;
1583 idles [active - 1] = idles [--idlecnt];
1584 ((W)idles [active - 1])->active = active;
1585 }
1586
1587 ev_stop (EV_A_ (W)w);
1588}
1589
1590void
1591ev_prepare_start (EV_P_ ev_prepare *w)
1592{
1593 if (expect_false (ev_is_active (w)))
1594 return;
1595
1596 ev_start (EV_A_ (W)w, ++preparecnt);
1597 array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
1598 prepares [preparecnt - 1] = w;
1599}
1600
1601void
1602ev_prepare_stop (EV_P_ ev_prepare *w)
1603{
1604 ev_clear_pending (EV_A_ (W)w);
1605 if (expect_false (!ev_is_active (w)))
1606 return;
1607
1608 {
1609 int active = ((W)w)->active;
1610 prepares [active - 1] = prepares [--preparecnt];
1611 ((W)prepares [active - 1])->active = active;
1612 }
1613
1614 ev_stop (EV_A_ (W)w);
1615}
1616
1617void
1618ev_check_start (EV_P_ ev_check *w)
1619{
1620 if (expect_false (ev_is_active (w)))
1621 return;
1622
1623 ev_start (EV_A_ (W)w, ++checkcnt);
1624 array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
1625 checks [checkcnt - 1] = w;
1626}
1627
1628void
1629ev_check_stop (EV_P_ ev_check *w)
1630{
1631 ev_clear_pending (EV_A_ (W)w);
1632 if (expect_false (!ev_is_active (w)))
1633 return;
1634
1635 {
1636 int active = ((W)w)->active;
1637 checks [active - 1] = checks [--checkcnt];
1638 ((W)checks [active - 1])->active = active;
1639 }
1640
1641 ev_stop (EV_A_ (W)w);
1642}
1643
1644#ifndef SA_RESTART 1563#ifndef SA_RESTART
1645# define SA_RESTART 0 1564# define SA_RESTART 0
1646#endif 1565#endif
1647 1566
1648void 1567void
1710 1629
1711 wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w); 1630 wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1712 ev_stop (EV_A_ (W)w); 1631 ev_stop (EV_A_ (W)w);
1713} 1632}
1714 1633
1634#if EV_STAT_ENABLE
1635
1636# ifdef _WIN32
1637# undef lstat
1638# define lstat(a,b) _stati64 (a,b)
1639# endif
1640
1641#define DEF_STAT_INTERVAL 5.0074891
1642#define MIN_STAT_INTERVAL 0.1074891
1643
1644void
1645ev_stat_stat (EV_P_ ev_stat *w)
1646{
1647 if (lstat (w->path, &w->attr) < 0)
1648 w->attr.st_nlink = 0;
1649 else if (!w->attr.st_nlink)
1650 w->attr.st_nlink = 1;
1651}
1652
1653static void
1654stat_timer_cb (EV_P_ ev_timer *w_, int revents)
1655{
1656 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
1657
1658 /* we copy this here each the time so that */
1659 /* prev has the old value when the callback gets invoked */
1660 w->prev = w->attr;
1661 ev_stat_stat (EV_A_ w);
1662
1663 if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))
1664 ev_feed_event (EV_A_ w, EV_STAT);
1665}
1666
1667void
1668ev_stat_start (EV_P_ ev_stat *w)
1669{
1670 if (expect_false (ev_is_active (w)))
1671 return;
1672
1673 /* since we use memcmp, we need to clear any padding data etc. */
1674 memset (&w->prev, 0, sizeof (ev_statdata));
1675 memset (&w->attr, 0, sizeof (ev_statdata));
1676
1677 ev_stat_stat (EV_A_ w);
1678
1679 if (w->interval < MIN_STAT_INTERVAL)
1680 w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
1681
1682 ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
1683 ev_set_priority (&w->timer, ev_priority (w));
1684 ev_timer_start (EV_A_ &w->timer);
1685
1686 ev_start (EV_A_ (W)w, 1);
1687}
1688
1689void
1690ev_stat_stop (EV_P_ ev_stat *w)
1691{
1692 ev_clear_pending (EV_A_ (W)w);
1693 if (expect_false (!ev_is_active (w)))
1694 return;
1695
1696 ev_timer_stop (EV_A_ &w->timer);
1697
1698 ev_stop (EV_A_ (W)w);
1699}
1700#endif
1701
1702void
1703ev_idle_start (EV_P_ ev_idle *w)
1704{
1705 if (expect_false (ev_is_active (w)))
1706 return;
1707
1708 ev_start (EV_A_ (W)w, ++idlecnt);
1709 array_needsize (ev_idle *, idles, idlemax, idlecnt, EMPTY2);
1710 idles [idlecnt - 1] = w;
1711}
1712
1713void
1714ev_idle_stop (EV_P_ ev_idle *w)
1715{
1716 ev_clear_pending (EV_A_ (W)w);
1717 if (expect_false (!ev_is_active (w)))
1718 return;
1719
1720 {
1721 int active = ((W)w)->active;
1722 idles [active - 1] = idles [--idlecnt];
1723 ((W)idles [active - 1])->active = active;
1724 }
1725
1726 ev_stop (EV_A_ (W)w);
1727}
1728
1729void
1730ev_prepare_start (EV_P_ ev_prepare *w)
1731{
1732 if (expect_false (ev_is_active (w)))
1733 return;
1734
1735 ev_start (EV_A_ (W)w, ++preparecnt);
1736 array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
1737 prepares [preparecnt - 1] = w;
1738}
1739
1740void
1741ev_prepare_stop (EV_P_ ev_prepare *w)
1742{
1743 ev_clear_pending (EV_A_ (W)w);
1744 if (expect_false (!ev_is_active (w)))
1745 return;
1746
1747 {
1748 int active = ((W)w)->active;
1749 prepares [active - 1] = prepares [--preparecnt];
1750 ((W)prepares [active - 1])->active = active;
1751 }
1752
1753 ev_stop (EV_A_ (W)w);
1754}
1755
1756void
1757ev_check_start (EV_P_ ev_check *w)
1758{
1759 if (expect_false (ev_is_active (w)))
1760 return;
1761
1762 ev_start (EV_A_ (W)w, ++checkcnt);
1763 array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
1764 checks [checkcnt - 1] = w;
1765}
1766
1767void
1768ev_check_stop (EV_P_ ev_check *w)
1769{
1770 ev_clear_pending (EV_A_ (W)w);
1771 if (expect_false (!ev_is_active (w)))
1772 return;
1773
1774 {
1775 int active = ((W)w)->active;
1776 checks [active - 1] = checks [--checkcnt];
1777 ((W)checks [active - 1])->active = active;
1778 }
1779
1780 ev_stop (EV_A_ (W)w);
1781}
1782
1715#if EV_EMBED_ENABLE 1783#if EV_EMBED_ENABLE
1716void noinline 1784void noinline
1717ev_embed_sweep (EV_P_ ev_embed *w) 1785ev_embed_sweep (EV_P_ ev_embed *w)
1718{ 1786{
1719 ev_loop (w->loop, EVLOOP_NONBLOCK); 1787 ev_loop (w->loop, EVLOOP_NONBLOCK);
1759 1827
1760 ev_stop (EV_A_ (W)w); 1828 ev_stop (EV_A_ (W)w);
1761} 1829}
1762#endif 1830#endif
1763 1831
1764#if EV_STAT_ENABLE
1765
1766# ifdef _WIN32
1767# define lstat(a,b) stat(a,b)
1768# endif
1769
1770#define DEF_STAT_INTERVAL 5.0074891
1771#define MIN_STAT_INTERVAL 0.1074891
1772
1773void
1774ev_stat_stat (EV_P_ ev_stat *w)
1775{
1776 if (lstat (w->path, &w->attr) < 0)
1777 w->attr.st_nlink = 0;
1778 else if (!w->attr.st_nlink)
1779 w->attr.st_nlink = 1;
1780}
1781
1782static void
1783stat_timer_cb (EV_P_ ev_timer *w_, int revents)
1784{
1785 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
1786
1787 /* we copy this here each the time so that */
1788 /* prev has the old value when the callback gets invoked */
1789 w->prev = w->attr;
1790 ev_stat_stat (EV_A_ w);
1791
1792 if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))
1793 ev_feed_event (EV_A_ w, EV_STAT);
1794}
1795
1796void
1797ev_stat_start (EV_P_ ev_stat *w)
1798{
1799 if (expect_false (ev_is_active (w)))
1800 return;
1801
1802 /* since we use memcmp, we need to clear any padding data etc. */
1803 memset (&w->prev, 0, sizeof (ev_statdata));
1804 memset (&w->attr, 0, sizeof (ev_statdata));
1805
1806 ev_stat_stat (EV_A_ w);
1807
1808 if (w->interval < MIN_STAT_INTERVAL)
1809 w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
1810
1811 ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
1812 ev_set_priority (&w->timer, ev_priority (w));
1813 ev_timer_start (EV_A_ &w->timer);
1814
1815 ev_start (EV_A_ (W)w, 1);
1816}
1817
1818void
1819ev_stat_stop (EV_P_ ev_stat *w)
1820{
1821 ev_clear_pending (EV_A_ (W)w);
1822 if (expect_false (!ev_is_active (w)))
1823 return;
1824
1825 ev_timer_stop (EV_A_ &w->timer);
1826
1827 ev_stop (EV_A_ (W)w);
1828}
1829#endif
1830
1831/*****************************************************************************/ 1832/*****************************************************************************/
1832 1833
1833struct ev_once 1834struct ev_once
1834{ 1835{
1835 ev_io io; 1836 ev_io io;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines