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

Comparing libev/ev.c (file contents):
Revision 1.142 by root, Tue Nov 27 06:19:08 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
1770void
1771ev_stat_stat (EV_P_ ev_stat *w)
1772{
1773 if (lstat (w->path, &w->attr) < 0)
1774 w->attr.st_nlink = 0;
1775 else if (!w->attr.st_nlink)
1776 w->attr.st_nlink = 1;
1777}
1778
1779static void
1780stat_timer_cb (EV_P_ ev_timer *w_, int revents)
1781{
1782 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
1783
1784 /* we copy this here each the time so that */
1785 /* prev has the old value when the callback gets invoked */
1786 w->prev = w->attr;
1787 ev_stat_stat (EV_A_ w);
1788
1789 if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))
1790 ev_feed_event (EV_A_ w, EV_STAT);
1791}
1792
1793void
1794ev_stat_start (EV_P_ ev_stat *w)
1795{
1796 if (expect_false (ev_is_active (w)))
1797 return;
1798
1799 /* since we use memcmp, we need to clear any padding data etc. */
1800 memset (&w->prev, 0, sizeof (ev_statdata));
1801 memset (&w->attr, 0, sizeof (ev_statdata));
1802
1803 ev_stat_stat (EV_A_ w);
1804
1805 ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
1806 ev_set_priority (&w->timer, ev_priority (w));
1807 ev_timer_start (EV_A_ &w->timer);
1808
1809 ev_start (EV_A_ (W)w, 1);
1810}
1811
1812void
1813ev_stat_stop (EV_P_ ev_stat *w)
1814{
1815 ev_clear_pending (EV_A_ (W)w);
1816 if (expect_false (!ev_is_active (w)))
1817 return;
1818
1819 ev_timer_stop (EV_A_ &w->timer);
1820
1821 ev_stop (EV_A_ (W)w);
1822}
1823#endif
1824
1825/*****************************************************************************/ 1832/*****************************************************************************/
1826 1833
1827struct ev_once 1834struct ev_once
1828{ 1835{
1829 ev_io io; 1836 ev_io io;

Diff Legend

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