[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.166 by root, Sat Dec 8 03:53:36 2007 UTC vs.
Revision 1.176 by root, Tue Dec 11 04:31:55 2007 UTC

…		…
216	# include <sys/inotify.h>	216	# include <sys/inotify.h>
217	#endif	217	#endif
218		218
219	/**/	219	/**/
220		220
		221	/*
		222	* This is used to avoid floating point rounding problems.
		223	* It is added to ev_rt_now when scheduling periodics
		224	* to ensure progress, time-wise, even when rounding
		225	* errors are against us.
		226	* This value is good at least till the year 4000
		227	* and intervals up to 20 years.
		228	* Better solutions welcome.
		229	*/
		230	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
		231
221	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	232	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
222	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	233	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
223	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds */	234	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds, TODO */
224		235
225	#if __GNUC__ >= 3	236	#if __GNUC__ >= 3
226	# define expect(expr,value) __builtin_expect ((expr),(value))	237	# define expect(expr,value) __builtin_expect ((expr),(value))
227	# define inline_size static inline /* inline for codesize */
228	# if EV_MINIMAL
229	# define noinline __attribute__ ((noinline))	238	# define noinline __attribute__ ((noinline))
230	# define inline_speed static noinline
231	# else
232	# define noinline
233	# define inline_speed static inline
234	# endif
235	#else	239	#else
236	# define expect(expr,value) (expr)	240	# define expect(expr,value) (expr)
237	# define inline_speed static
238	# define inline_size static
239	# define noinline	241	# define noinline
		242	# if __STDC_VERSION__ < 199901L
		243	# define inline
		244	# endif
240	#endif	245	#endif
241		246
242	#define expect_false(expr) expect ((expr) != 0, 0)	247	#define expect_false(expr) expect ((expr) != 0, 0)
243	#define expect_true(expr) expect ((expr) != 0, 1)	248	#define expect_true(expr) expect ((expr) != 0, 1)
		249	#define inline_size static inline
		250
		251	#if EV_MINIMAL
		252	# define inline_speed static noinline
		253	#else
		254	# define inline_speed static inline
		255	#endif
244		256
245	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	257	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
246	#define ABSPRI(w) (((W)w)->priority - EV_MINPRI)	258	#define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
247		259
248	#define EMPTY /* required for microsofts broken pseudo-c compiler */	260	#define EMPTY /* required for microsofts broken pseudo-c compiler */
…		…
417	}	429	}
418		430
419	return ncur;	431	return ncur;
420	}	432	}
421		433
422	inline_speed void *	434	static noinline void *
423	array_realloc (int elem, void base, int cur, int cnt)	435	array_realloc (int elem, void base, int cur, int cnt)
424	{	436	{
425	cur = array_nextsize (elem, cur, cnt);	437	cur = array_nextsize (elem, cur, cnt);
426	return ev_realloc (base, elem * *cur);	438	return ev_realloc (base, elem * *cur);
427	}	439	}
…		…
452		464
453	void noinline	465	void noinline
454	ev_feed_event (EV_P_ void *w, int revents)	466	ev_feed_event (EV_P_ void *w, int revents)
455	{	467	{
456	W w_ = (W)w;	468	W w_ = (W)w;
		469	int pri = ABSPRI (w_);
457		470
458	if (expect_false (w_->pending))	471	if (expect_false (w_->pending))
		472	pendings [pri][w_->pending - 1].events \|= revents;
		473	else
459	{	474	{
		475	w_->pending = ++pendingcnt [pri];
		476	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
		477	pendings [pri][w_->pending - 1].w = w_;
460	pendings [ABSPRI (w_)][w_->pending - 1].events \|= revents;	478	pendings [pri][w_->pending - 1].events = revents;
461	return;
462	}	479	}
463
464	w_->pending = ++pendingcnt [ABSPRI (w_)];
465	array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], EMPTY2);
466	pendings [ABSPRI (w_)][w_->pending - 1].w = w_;
467	pendings [ABSPRI (w_)][w_->pending - 1].events = revents;
468	}	480	}
469		481
470	void inline_size	482	void inline_size
471	queue_events (EV_P_ W *events, int eventcnt, int type)	483	queue_events (EV_P_ W *events, int eventcnt, int type)
472	{	484	{
…		…
507	}	519	}
508		520
509	void	521	void
510	ev_feed_fd_event (EV_P_ int fd, int revents)	522	ev_feed_fd_event (EV_P_ int fd, int revents)
511	{	523	{
		524	if (fd >= 0 && fd < anfdmax)
512	fd_event (EV_A_ fd, revents);	525	fd_event (EV_A_ fd, revents);
513	}	526	}
514		527
515	void inline_size	528	void inline_size
516	fd_reify (EV_P)	529	fd_reify (EV_P)
517	{	530	{
…		…
747	for (signum = signalmax; signum--; )	760	for (signum = signalmax; signum--; )
748	if (signals [signum].gotsig)	761	if (signals [signum].gotsig)
749	ev_feed_signal_event (EV_A_ signum + 1);	762	ev_feed_signal_event (EV_A_ signum + 1);
750	}	763	}
751		764
752	void inline_size	765	void inline_speed
753	fd_intern (int fd)	766	fd_intern (int fd)
754	{	767	{
755	#ifdef _WIN32	768	#ifdef _WIN32
756	int arg = 1;	769	int arg = 1;
757	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);	770	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
…		…
1163	postfork = 1;	1176	postfork = 1;
1164	}	1177	}
1165		1178
1166	/*****************************************************************************/	1179	/*****************************************************************************/
1167		1180
		1181	void
		1182	ev_invoke (EV_P_ void *w, int revents)
		1183	{
		1184	EV_CB_INVOKE ((W)w, revents);
		1185	}
		1186
1168	void inline_speed	1187	void inline_speed
1169	call_pending (EV_P)	1188	call_pending (EV_P)
1170	{	1189	{
1171	int pri;	1190	int pri;
1172		1191
…		…
1223	/assert (("inactive timer on periodic heap detected", ev_is_active (w)));/	1242	/assert (("inactive timer on periodic heap detected", ev_is_active (w)));/
1224		1243
1225	/* first reschedule or stop timer */	1244	/* first reschedule or stop timer */
1226	if (w->reschedule_cb)	1245	if (w->reschedule_cb)
1227	{	1246	{
1228	((WT)w)->at = w->reschedule_cb (w, ev_rt_now + 0.0001);	1247	((WT)w)->at = w->reschedule_cb (w, ev_rt_now + TIME_EPSILON);
1229	assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));	1248	assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));
1230	downheap ((WT *)periodics, periodiccnt, 0);	1249	downheap ((WT *)periodics, periodiccnt, 0);
1231	}	1250	}
1232	else if (w->interval)	1251	else if (w->interval)
1233	{	1252	{
1234	((WT)w)->at += floor ((ev_rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;	1253	((WT)w)->at = w->offset + floor ((ev_rt_now + TIME_EPSILON - w->offset) / w->interval + 1.) * w->interval;
1235	assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));	1254	assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
1236	downheap ((WT *)periodics, periodiccnt, 0);	1255	downheap ((WT *)periodics, periodiccnt, 0);
1237	}	1256	}
1238	else	1257	else
1239	ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */	1258	ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
…		…
1253	ev_periodic *w = periodics [i];	1272	ev_periodic *w = periodics [i];
1254		1273
1255	if (w->reschedule_cb)	1274	if (w->reschedule_cb)
1256	((WT)w)->at = w->reschedule_cb (w, ev_rt_now);	1275	((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1257	else if (w->interval)	1276	else if (w->interval)
1258	((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;	1277	((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1259	}	1278	}
1260		1279
1261	/* now rebuild the heap */	1280	/* now rebuild the heap */
1262	for (i = periodiccnt >> 1; i--; )	1281	for (i = periodiccnt >> 1; i--; )
1263	downheap ((WT *)periodics, periodiccnt, i);	1282	downheap ((WT *)periodics, periodiccnt, i);
…		…
1406	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	1425	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
1407	call_pending (EV_A);	1426	call_pending (EV_A);
1408	}	1427	}
1409	#endif	1428	#endif
1410		1429
1411	/* queue check watchers (and execute them) */	1430	/* queue prepare watchers (and execute them) */
1412	if (expect_false (preparecnt))	1431	if (expect_false (preparecnt))
1413	{	1432	{
1414	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	1433	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1415	call_pending (EV_A);	1434	call_pending (EV_A);
1416	}	1435	}
…		…
1532	pendings [ABSPRI (w)][w->pending - 1].w = 0;	1551	pendings [ABSPRI (w)][w->pending - 1].w = 0;
1533	w->pending = 0;	1552	w->pending = 0;
1534	}	1553	}
1535	}	1554	}
1536		1555
1537	void	1556	int
1538	ev_clear_pending (EV_P_ void *w, int invoke)	1557	ev_clear_pending (EV_P_ void *w)
1539	{	1558	{
1540	W w_ = (W)w;	1559	W w_ = (W)w;
1541	int pending = w_->pending;	1560	int pending = w_->pending;
1542		1561
1543	if (pending)	1562	if (expect_true (pending))
1544	{	1563	{
1545	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	1564	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
1546
1547	w_->pending = 0;	1565	w_->pending = 0;
1548	p->w = 0;	1566	p->w = 0;
1549		1567	return p->events;
1550	if (invoke)
1551	EV_CB_INVOKE (w_, p->events);
1552	}	1568	}
		1569	else
		1570	return 0;
1553	}	1571	}
1554		1572
1555	void inline_size	1573	void inline_size
1556	pri_adjust (EV_P_ W w)	1574	pri_adjust (EV_P_ W w)
1557	{	1575	{
…		…
1576	w->active = 0;	1594	w->active = 0;
1577	}	1595	}
1578		1596
1579	/*****************************************************************************/	1597	/*****************************************************************************/
1580		1598
1581	void	1599	void noinline
1582	ev_io_start (EV_P_ ev_io *w)	1600	ev_io_start (EV_P_ ev_io *w)
1583	{	1601	{
1584	int fd = w->fd;	1602	int fd = w->fd;
1585		1603
1586	if (expect_false (ev_is_active (w)))	1604	if (expect_false (ev_is_active (w)))
…		…
1593	wlist_add ((WL *)&anfds[fd].head, (WL)w);	1611	wlist_add ((WL *)&anfds[fd].head, (WL)w);
1594		1612
1595	fd_change (EV_A_ fd);	1613	fd_change (EV_A_ fd);
1596	}	1614	}
1597		1615
1598	void	1616	void noinline
1599	ev_io_stop (EV_P_ ev_io *w)	1617	ev_io_stop (EV_P_ ev_io *w)
1600	{	1618	{
1601	clear_pending (EV_A_ (W)w);	1619	clear_pending (EV_A_ (W)w);
1602	if (expect_false (!ev_is_active (w)))	1620	if (expect_false (!ev_is_active (w)))
1603	return;	1621	return;
…		…
1608	ev_stop (EV_A_ (W)w);	1626	ev_stop (EV_A_ (W)w);
1609		1627
1610	fd_change (EV_A_ w->fd);	1628	fd_change (EV_A_ w->fd);
1611	}	1629	}
1612		1630
1613	void	1631	void noinline
1614	ev_timer_start (EV_P_ ev_timer *w)	1632	ev_timer_start (EV_P_ ev_timer *w)
1615	{	1633	{
1616	if (expect_false (ev_is_active (w)))	1634	if (expect_false (ev_is_active (w)))
1617	return;	1635	return;
1618		1636
…		…
1626	upheap ((WT *)timers, timercnt - 1);	1644	upheap ((WT *)timers, timercnt - 1);
1627		1645
1628	/assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));/	1646	/assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));/
1629	}	1647	}
1630		1648
1631	void	1649	void noinline
1632	ev_timer_stop (EV_P_ ev_timer *w)	1650	ev_timer_stop (EV_P_ ev_timer *w)
1633	{	1651	{
1634	clear_pending (EV_A_ (W)w);	1652	clear_pending (EV_A_ (W)w);
1635	if (expect_false (!ev_is_active (w)))	1653	if (expect_false (!ev_is_active (w)))
1636	return;	1654	return;
…		…
1650	((WT)w)->at -= mn_now;	1668	((WT)w)->at -= mn_now;
1651		1669
1652	ev_stop (EV_A_ (W)w);	1670	ev_stop (EV_A_ (W)w);
1653	}	1671	}
1654		1672
1655	void	1673	void noinline
1656	ev_timer_again (EV_P_ ev_timer *w)	1674	ev_timer_again (EV_P_ ev_timer *w)
1657	{	1675	{
1658	if (ev_is_active (w))	1676	if (ev_is_active (w))
1659	{	1677	{
1660	if (w->repeat)	1678	if (w->repeat)
…		…
1671	ev_timer_start (EV_A_ w);	1689	ev_timer_start (EV_A_ w);
1672	}	1690	}
1673	}	1691	}
1674		1692
1675	#if EV_PERIODIC_ENABLE	1693	#if EV_PERIODIC_ENABLE
1676	void	1694	void noinline
1677	ev_periodic_start (EV_P_ ev_periodic *w)	1695	ev_periodic_start (EV_P_ ev_periodic *w)
1678	{	1696	{
1679	if (expect_false (ev_is_active (w)))	1697	if (expect_false (ev_is_active (w)))
1680	return;	1698	return;
1681		1699
…		…
1683	((WT)w)->at = w->reschedule_cb (w, ev_rt_now);	1701	((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1684	else if (w->interval)	1702	else if (w->interval)
1685	{	1703	{
1686	assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));	1704	assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1687	/* this formula differs from the one in periodic_reify because we do not always round up */	1705	/* this formula differs from the one in periodic_reify because we do not always round up */
1688	((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;	1706	((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1689	}	1707	}
		1708	else
		1709	((WT)w)->at = w->offset;
1690		1710
1691	ev_start (EV_A_ (W)w, ++periodiccnt);	1711	ev_start (EV_A_ (W)w, ++periodiccnt);
1692	array_needsize (ev_periodic *, periodics, periodicmax, periodiccnt, EMPTY2);	1712	array_needsize (ev_periodic *, periodics, periodicmax, periodiccnt, EMPTY2);
1693	periodics [periodiccnt - 1] = w;	1713	periodics [periodiccnt - 1] = w;
1694	upheap ((WT *)periodics, periodiccnt - 1);	1714	upheap ((WT *)periodics, periodiccnt - 1);
1695		1715
1696	/assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));/	1716	/assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));/
1697	}	1717	}
1698		1718
1699	void	1719	void noinline
1700	ev_periodic_stop (EV_P_ ev_periodic *w)	1720	ev_periodic_stop (EV_P_ ev_periodic *w)
1701	{	1721	{
1702	clear_pending (EV_A_ (W)w);	1722	clear_pending (EV_A_ (W)w);
1703	if (expect_false (!ev_is_active (w)))	1723	if (expect_false (!ev_is_active (w)))
1704	return;	1724	return;
…		…
1716	}	1736	}
1717		1737
1718	ev_stop (EV_A_ (W)w);	1738	ev_stop (EV_A_ (W)w);
1719	}	1739	}
1720		1740
1721	void	1741	void noinline
1722	ev_periodic_again (EV_P_ ev_periodic *w)	1742	ev_periodic_again (EV_P_ ev_periodic *w)
1723	{	1743	{
1724	/* TODO: use adjustheap and recalculation */	1744	/* TODO: use adjustheap and recalculation */
1725	ev_periodic_stop (EV_A_ w);	1745	ev_periodic_stop (EV_A_ w);
1726	ev_periodic_start (EV_A_ w);	1746	ev_periodic_start (EV_A_ w);
…		…
1729		1749
1730	#ifndef SA_RESTART	1750	#ifndef SA_RESTART
1731	# define SA_RESTART 0	1751	# define SA_RESTART 0
1732	#endif	1752	#endif
1733		1753
1734	void	1754	void noinline
1735	ev_signal_start (EV_P_ ev_signal *w)	1755	ev_signal_start (EV_P_ ev_signal *w)
1736	{	1756	{
1737	#if EV_MULTIPLICITY	1757	#if EV_MULTIPLICITY
1738	assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));	1758	assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));
1739	#endif	1759	#endif
…		…
1758	sigaction (w->signum, &sa, 0);	1778	sigaction (w->signum, &sa, 0);
1759	#endif	1779	#endif
1760	}	1780	}
1761	}	1781	}
1762		1782
1763	void	1783	void noinline
1764	ev_signal_stop (EV_P_ ev_signal *w)	1784	ev_signal_stop (EV_P_ ev_signal *w)
1765	{	1785	{
1766	clear_pending (EV_A_ (W)w);	1786	clear_pending (EV_A_ (W)w);
1767	if (expect_false (!ev_is_active (w)))	1787	if (expect_false (!ev_is_active (w)))
1768	return;	1788	return;

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.166 by root, Sat Dec 8 03:53:36 2007 UTC vs. Revision 1.176 by root, Tue Dec 11 04:31:55 2007 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.166 by root, Sat Dec 8 03:53:36 2007 UTC vs.
Revision 1.176 by root, Tue Dec 11 04:31:55 2007 UTC