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

Comparing libev/ev.pod (file contents):
Revision 1.283 by root, Wed Mar 10 09:18:25 2010 UTC vs.
Revision 1.290 by root, Tue Mar 16 18:03:01 2010 UTC

…		…
567	ev_default_loop (ev_recommended_backends () \| EVBACKEND_KQUEUE);	567	ev_default_loop (ev_recommended_backends () \| EVBACKEND_KQUEUE);
568		568
569	=item struct ev_loop *ev_loop_new (unsigned int flags)	569	=item struct ev_loop *ev_loop_new (unsigned int flags)
570		570
571	Similar to C<ev_default_loop>, but always creates a new event loop that is	571	Similar to C<ev_default_loop>, but always creates a new event loop that is
572	always distinct from the default loop. Unlike the default loop, it cannot	572	always distinct from the default loop.
573	handle signal and child watchers, and attempts to do so will be greeted by
574	undefined behaviour (or a failed assertion if assertions are enabled).
575		573
576	Note that this function I<is> thread-safe, and the recommended way to use	574	Note that this function I<is> thread-safe, and one common way to use
577	libev with threads is indeed to create one loop per thread, and using the	575	libev with threads is indeed to create one loop per thread, and using the
578	default loop in the "main" or "initial" thread.	576	default loop in the "main" or "initial" thread.
579		577
580	Example: Try to create a event loop that uses epoll and nothing else.	578	Example: Try to create a event loop that uses epoll and nothing else.
581		579
…		…
583	if (!epoller)	581	if (!epoller)
584	fatal ("no epoll found here, maybe it hides under your chair");	582	fatal ("no epoll found here, maybe it hides under your chair");
585		583
586	=item ev_default_destroy ()	584	=item ev_default_destroy ()
587		585
588	Destroys the default loop again (frees all memory and kernel state	586	Destroys the default loop (frees all memory and kernel state etc.). None
589	etc.). None of the active event watchers will be stopped in the normal	587	of the active event watchers will be stopped in the normal sense, so
590	sense, so e.g. C<ev_is_active> might still return true. It is your	588	e.g. C<ev_is_active> might still return true. It is your responsibility to
591	responsibility to either stop all watchers cleanly yourself I<before>	589	either stop all watchers cleanly yourself I<before> calling this function,
592	calling this function, or cope with the fact afterwards (which is usually	590	or cope with the fact afterwards (which is usually the easiest thing, you
593	the easiest thing, you can just ignore the watchers and/or C<free ()> them	591	can just ignore the watchers and/or C<free ()> them for example).
594	for example).
595		592
596	Note that certain global state, such as signal state (and installed signal	593	Note that certain global state, such as signal state (and installed signal
597	handlers), will not be freed by this function, and related watchers (such	594	handlers), will not be freed by this function, and related watchers (such
598	as signal and child watchers) would need to be stopped manually.	595	as signal and child watchers) would need to be stopped manually.
599		596
…		…
1032	=item C<EV_WRITE>	1029	=item C<EV_WRITE>
1033		1030
1034	The file descriptor in the C<ev_io> watcher has become readable and/or	1031	The file descriptor in the C<ev_io> watcher has become readable and/or
1035	writable.	1032	writable.
1036		1033
1037	=item C<EV_TIMEOUT>	1034	=item C<EV_TIMER>
1038		1035
1039	The C<ev_timer> watcher has timed out.	1036	The C<ev_timer> watcher has timed out.
1040		1037
1041	=item C<EV_PERIODIC>	1038	=item C<EV_PERIODIC>
1042		1039
…		…
1538		1535
1539	So when you encounter spurious, unexplained daemon exits, make sure you	1536	So when you encounter spurious, unexplained daemon exits, make sure you
1540	ignore SIGPIPE (and maybe make sure you log the exit status of your daemon	1537	ignore SIGPIPE (and maybe make sure you log the exit status of your daemon
1541	somewhere, as that would have given you a big clue).	1538	somewhere, as that would have given you a big clue).
1542		1539
		1540	=head3 The special problem of accept()ing when you can't
		1541
		1542	Many implementations of the POSIX C<accept> function (for example,
		1543	found in port-2004 Linux) have the peculiar behaviour of not removing a
		1544	connection from the pending queue in all error cases.
		1545
		1546	For example, larger servers often run out of file descriptors (because
		1547	of resource limits), causing C<accept> to fail with C<ENFILE> but not
		1548	rejecting the connection, leading to libev signalling readiness on
		1549	the next iteration again (the connection still exists after all), and
		1550	typically causing the program to loop at 100% CPU usage.
		1551
		1552	Unfortunately, the set of errors that cause this issue differs between
		1553	operating systems, there is usually little the app can do to remedy the
		1554	situation, and no known thread-safe method of removing the connection to
		1555	cope with overload is known (to me).
		1556
		1557	One of the easiest ways to handle this situation is to just ignore it
		1558	- when the program encounters an overload, it will just loop until the
		1559	situation is over. While this is a form of busy waiting, no OS offers an
		1560	event-based way to handle this situation, so it's the best one can do.
		1561
		1562	A better way to handle the situation is to log any errors other than
		1563	C<EAGAIN> and C<EWOULDBLOCK>, making sure not to flood the log with such
		1564	messages, and continue as usual, which at least gives the user an idea of
		1565	what could be wrong ("raise the ulimit!"). For extra points one could stop
		1566	the C<ev_io> watcher on the listening fd "for a while", which reduces CPU
		1567	usage.
		1568
		1569	If your program is single-threaded, then you could also keep a dummy file
		1570	descriptor for overload situations (e.g. by opening F</dev/null>), and
		1571	when you run into C<ENFILE> or C<EMFILE>, close it, run C<accept>,
		1572	close that fd, and create a new dummy fd. This will gracefully refuse
		1573	clients under typical overload conditions.
		1574
		1575	The last way to handle it is to simply log the error and C<exit>, as
		1576	is often done with C<malloc> failures, but this results in an easy
		1577	opportunity for a DoS attack.
1543		1578
1544	=head3 Watcher-Specific Functions	1579	=head3 Watcher-Specific Functions
1545		1580
1546	=over 4	1581	=over 4
1547		1582
…		…
1726	to the current time (meaning we just have some activity :), then call the	1761	to the current time (meaning we just have some activity :), then call the
1727	callback, which will "do the right thing" and start the timer:	1762	callback, which will "do the right thing" and start the timer:
1728		1763
1729	ev_init (timer, callback);	1764	ev_init (timer, callback);
1730	last_activity = ev_now (loop);	1765	last_activity = ev_now (loop);
1731	callback (loop, timer, EV_TIMEOUT);	1766	callback (loop, timer, EV_TIMER);
1732		1767
1733	And when there is some activity, simply store the current time in	1768	And when there is some activity, simply store the current time in
1734	C<last_activity>, no libev calls at all:	1769	C<last_activity>, no libev calls at all:
1735		1770
1736	last_actiivty = ev_now (loop);	1771	last_actiivty = ev_now (loop);
…		…
3141		3176
3142	If C<timeout> is less than 0, then no timeout watcher will be	3177	If C<timeout> is less than 0, then no timeout watcher will be
3143	started. Otherwise an C<ev_timer> watcher with after = C<timeout> (and	3178	started. Otherwise an C<ev_timer> watcher with after = C<timeout> (and
3144	repeat = 0) will be started. C<0> is a valid timeout.	3179	repeat = 0) will be started. C<0> is a valid timeout.
3145		3180
3146	The callback has the type C<void (cb)(int revents, void arg)> and gets	3181	The callback has the type C<void (cb)(int revents, void arg)> and is
3147	passed an C<revents> set like normal event callbacks (a combination of	3182	passed an C<revents> set like normal event callbacks (a combination of
3148	C<EV_ERROR>, C<EV_READ>, C<EV_WRITE> or C<EV_TIMEOUT>) and the C<arg>	3183	C<EV_ERROR>, C<EV_READ>, C<EV_WRITE> or C<EV_TIMER>) and the C<arg>
3149	value passed to C<ev_once>. Note that it is possible to receive I<both>	3184	value passed to C<ev_once>. Note that it is possible to receive I<both>
3150	a timeout and an io event at the same time - you probably should give io	3185	a timeout and an io event at the same time - you probably should give io
3151	events precedence.	3186	events precedence.
3152		3187
3153	Example: wait up to ten seconds for data to appear on STDIN_FILENO.	3188	Example: wait up to ten seconds for data to appear on STDIN_FILENO.
3154		3189
3155	static void stdin_ready (int revents, void *arg)	3190	static void stdin_ready (int revents, void *arg)
3156	{	3191	{
3157	if (revents & EV_READ)	3192	if (revents & EV_READ)
3158	/* stdin might have data for us, joy! */;	3193	/* stdin might have data for us, joy! */;
3159	else if (revents & EV_TIMEOUT)	3194	else if (revents & EV_TIMER)
3160	/* doh, nothing entered */;	3195	/* doh, nothing entered */;
3161	}	3196	}
3162		3197
3163	ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);	3198	ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
3164		3199
…		…
3846		3881
3847	If undefined or defined to be C<1> (and the platform supports it), then	3882	If undefined or defined to be C<1> (and the platform supports it), then
3848	the respective watcher type is supported. If defined to be C<0>, then it	3883	the respective watcher type is supported. If defined to be C<0>, then it
3849	is not. Disabling watcher types mainly saves codesize.	3884	is not. Disabling watcher types mainly saves codesize.
3850		3885
3851	=item EV_MINIMAL	3886	=item EV_FEATURES
3852		3887
3853	If you need to shave off some kilobytes of code at the expense of some	3888	If you need to shave off some kilobytes of code at the expense of some
3854	speed (but with the full API), define this symbol to C<1>. Currently this	3889	speed (but with the full API), you can define this symbol to request
3855	is used to override some inlining decisions, saves roughly 30% code size	3890	certain subsets of functionality. The default is to enable all features
3856	on amd64. It also selects a much smaller 2-heap for timer management over	3891	that can be enabled on the platform.
3857	the default 4-heap.
3858		3892
3859	You can save even more by disabling watcher types you do not need	3893	A typical way to use this symbol is to define it to C<0> (or to a bitset
3860	and setting C<EV_MAXPRI> == C<EV_MINPRI>. Also, disabling C<assert>	3894	with some broad features you want) and then selectively re-enable
3861	(C<-DNDEBUG>) will usually reduce code size a lot. Disabling inotify,	3895	additional parts you want, for example if you want everything minimal,
3862	eventfd and signalfd will further help, and disabling backends one doesn't	3896	but multiple event loop support, async and child watchers and the poll
3863	need (e.g. poll, epoll, kqueue, ports) will help further.	3897	backend, use this:
3864		3898
3865	Defining C<EV_MINIMAL> to C<2> will additionally reduce the core API to	3899	#define EV_FEATURES 0
3866	provide a bare-bones event library. See C<ev.h> for details on what parts
3867	of the API are still available, and do not complain if this subset changes
3868	over time.
3869
3870	This example set of settings reduces the compiled size of libev from
3871	23.9Kb to 7.7Kb on my GNU/Linux amd64 system (and leaves little
3872	in - there is also an effect on the amount of memory used). With
3873	an intelligent-enough linker (gcc+binutils do this when you use
3874	C<-Wl,--gc-sections -ffunction-sections>) further unused functions might
3875	be left out as well automatically - a binary starting a timer and an I/O
3876	watcher then might come out at only 5Kb.
3877
3878	// tuning and API changes
3879	#define EV_MINIMAL 2
3880	#define EV_MULTIPLICITY 0	3900	#define EV_MULTIPLICITY 1
3881	#define EV_MINPRI 0
3882	#define EV_MAXPRI 0
3883
3884	// OS-specific backends
3885	#define EV_USE_INOTIFY 0
3886	#define EV_USE_EVENTFD 0
3887	#define EV_USE_SIGNALFD 0
3888	#define EV_USE_REALTIME 0
3889	#define EV_USE_MONOTONIC 0
3890	#define EV_USE_CLOCK_SYSCALL 0
3891
3892	// disable all backends except select
3893	#define EV_USE_POLL 0	3901	#define EV_USE_POLL 1
3894	#define EV_USE_PORT 0
3895	#define EV_USE_KQUEUE 0
3896	#define EV_USE_EPOLL 0
3897
3898	// disable all watcher types that cna be disabled
3899	#define EV_STAT_ENABLE 0
3900	#define EV_PERIODIC_ENABLE 0
3901	#define EV_IDLE_ENABLE 0
3902	#define EV_CHECK_ENABLE 0
3903	#define EV_PREPARE_ENABLE 0
3904	#define EV_FORK_ENABLE 0
3905	#define EV_SIGNAL_ENABLE 0
3906	#define EV_CHILD_ENABLE 0	3902	#define EV_CHILD_ENABLE 1
3907	#define EV_ASYNC_ENABLE 0	3903	#define EV_ASYNC_ENABLE 1
3908	#define EV_EMBED_ENABLE 0	3904
		3905	The actual value is a bitset, it can be a combination of the following
		3906	values:
		3907
		3908	=over 4
		3909
		3910	=item C<1> - faster/larger code
		3911
		3912	Use larger code to speed up some operations.
		3913
		3914	Currently this is used to override some inlining decisions (enlarging the roughly
		3915	30% code size on amd64.
		3916
		3917	When optimising for size, use of compiler flags such as C<-Os> with
		3918	gcc recommended, as well as C<-DNDEBUG>, as libev contains a number of
		3919	assertions.
		3920
		3921	=item C<2> - faster/larger data structures
		3922
		3923	Replaces the small 2-heap for timer management by a faster 4-heap, larger
		3924	hash table sizes and so on. This will usually further increase codesize
		3925	and can additionally have an effect on the size of data structures at
		3926	runtime.
		3927
		3928	=item C<4> - full API configuration
		3929
		3930	This enables priorities (sets C<EV_MAXPRI>=2 and C<EV_MINPRI>=-2), and
		3931	enables multiplicity (C<EV_MULTIPLICITY>=1).
		3932
		3933	=item C<8> - full API
		3934
		3935	This enables a lot of the "lesser used" API functions. See C<ev.h> for
		3936	details on which parts of the API are still available without this
		3937	feature, and do not complain if this subset changes over time.
		3938
		3939	=item C<16> - enable all optional watcher types
		3940
		3941	Enables all optional watcher types. If you want to selectively enable
		3942	only some watcher types other than I/O and timers (e.g. prepare,
		3943	embed, async, child...) you can enable them manually by defining
		3944	C<EV_watchertype_ENABLE> to C<1> instead.
		3945
		3946	=item C<32> - enable all backends
		3947
		3948	This enables all backends - without this feature, you need to enable at
		3949	least one backend manually (C<EV_USE_SELECT> is a good choice).
		3950
		3951	=item C<64> - enable OS-specific "helper" APIs
		3952
		3953	Enable inotify, eventfd, signalfd and similar OS-specific helper APIs by
		3954	default.
		3955
		3956	=back
		3957
		3958	Compiling with C<gcc -Os -DEV_STANDALONE -DEV_USE_EPOLL=1 -DEV_FEATURES=0>
		3959	reduces the compiled size of libev from 24.7Kb code/2.8Kb data to 6.5Kb
		3960	code/0.3Kb data on my GNU/Linux amd64 system, while still giving you I/O
		3961	watchers, timers and monotonic clock support.
		3962
		3963	With an intelligent-enough linker (gcc+binutils are intelligent enough
		3964	when you use C<-Wl,--gc-sections -ffunction-sections>) functions unused by
		3965	your program might be left out as well - a binary starting a timer and an
		3966	I/O watcher then might come out at only 5Kb.
3909		3967
3910	=item EV_AVOID_STDIO	3968	=item EV_AVOID_STDIO
3911		3969
3912	If this is set to C<1> at compiletime, then libev will avoid using stdio	3970	If this is set to C<1> at compiletime, then libev will avoid using stdio
3913	functions (printf, scanf, perror etc.). This will increase the codesize	3971	functions (printf, scanf, perror etc.). This will increase the codesize
…		…
3928	statically allocates some 12-24 bytes per signal number.	3986	statically allocates some 12-24 bytes per signal number.
3929		3987
3930	=item EV_PID_HASHSIZE	3988	=item EV_PID_HASHSIZE
3931		3989
3932	C<ev_child> watchers use a small hash table to distribute workload by	3990	C<ev_child> watchers use a small hash table to distribute workload by
3933	pid. The default size is C<16> (or C<1> with C<EV_MINIMAL>), usually more	3991	pid. The default size is C<16> (or C<1> with C<EV_FEATURES> disabled),
3934	than enough. If you need to manage thousands of children you might want to	3992	usually more than enough. If you need to manage thousands of children you
3935	increase this value (I<must> be a power of two).	3993	might want to increase this value (I<must> be a power of two).
3936		3994
3937	=item EV_INOTIFY_HASHSIZE	3995	=item EV_INOTIFY_HASHSIZE
3938		3996
3939	C<ev_stat> watchers use a small hash table to distribute workload by	3997	C<ev_stat> watchers use a small hash table to distribute workload by
3940	inotify watch id. The default size is C<16> (or C<1> with C<EV_MINIMAL>),	3998	inotify watch id. The default size is C<16> (or C<1> with C<EV_FEATURES>
3941	usually more than enough. If you need to manage thousands of C<ev_stat>	3999	disabled), usually more than enough. If you need to manage thousands of
3942	watchers you might want to increase this value (I<must> be a power of	4000	C<ev_stat> watchers you might want to increase this value (I<must> be a
3943	two).	4001	power of two).
3944		4002
3945	=item EV_USE_4HEAP	4003	=item EV_USE_4HEAP
3946		4004
3947	Heaps are not very cache-efficient. To improve the cache-efficiency of the	4005	Heaps are not very cache-efficient. To improve the cache-efficiency of the
3948	timer and periodics heaps, libev uses a 4-heap when this symbol is defined	4006	timer and periodics heaps, libev uses a 4-heap when this symbol is defined
3949	to C<1>. The 4-heap uses more complicated (longer) code but has noticeably	4007	to C<1>. The 4-heap uses more complicated (longer) code but has noticeably
3950	faster performance with many (thousands) of watchers.	4008	faster performance with many (thousands) of watchers.
3951		4009
3952	The default is C<1> unless C<EV_MINIMAL> is set in which case it is C<0>	4010	The default is C<1>, unless C<EV_FEATURES> overrides it, in which case it
3953	(disabled).	4011	will be C<0>.
3954		4012
3955	=item EV_HEAP_CACHE_AT	4013	=item EV_HEAP_CACHE_AT
3956		4014
3957	Heaps are not very cache-efficient. To improve the cache-efficiency of the	4015	Heaps are not very cache-efficient. To improve the cache-efficiency of the
3958	timer and periodics heaps, libev can cache the timestamp (I<at>) within	4016	timer and periodics heaps, libev can cache the timestamp (I<at>) within
3959	the heap structure (selected by defining C<EV_HEAP_CACHE_AT> to C<1>),	4017	the heap structure (selected by defining C<EV_HEAP_CACHE_AT> to C<1>),
3960	which uses 8-12 bytes more per watcher and a few hundred bytes more code,	4018	which uses 8-12 bytes more per watcher and a few hundred bytes more code,
3961	but avoids random read accesses on heap changes. This improves performance	4019	but avoids random read accesses on heap changes. This improves performance
3962	noticeably with many (hundreds) of watchers.	4020	noticeably with many (hundreds) of watchers.
3963		4021
3964	The default is C<1> unless C<EV_MINIMAL> is set in which case it is C<0>	4022	The default is C<1>, unless C<EV_FEATURES> overrides it, in which case it
3965	(disabled).	4023	will be C<0>.
3966		4024
3967	=item EV_VERIFY	4025	=item EV_VERIFY
3968		4026
3969	Controls how much internal verification (see C<ev_loop_verify ()>) will	4027	Controls how much internal verification (see C<ev_loop_verify ()>) will
3970	be done: If set to C<0>, no internal verification code will be compiled	4028	be done: If set to C<0>, no internal verification code will be compiled
…		…
3972	called. If set to C<2>, then the internal verification code will be	4030	called. If set to C<2>, then the internal verification code will be
3973	called once per loop, which can slow down libev. If set to C<3>, then the	4031	called once per loop, which can slow down libev. If set to C<3>, then the
3974	verification code will be called very frequently, which will slow down	4032	verification code will be called very frequently, which will slow down
3975	libev considerably.	4033	libev considerably.
3976		4034
3977	The default is C<1>, unless C<EV_MINIMAL> is set, in which case it will be	4035	The default is C<1>, unless C<EV_FEATURES> overrides it, in which case it
3978	C<0>.	4036	will be C<0>.
3979		4037
3980	=item EV_COMMON	4038	=item EV_COMMON
3981		4039
3982	By default, all watchers have a C<void *data> member. By redefining	4040	By default, all watchers have a C<void *data> member. By redefining
3983	this macro to a something else you can include more and other types of	4041	this macro to a something else you can include more and other types of
…		…
4041	file.	4099	file.
4042		4100
4043	The usage in rxvt-unicode is simpler. It has a F<ev_cpp.h> header file	4101	The usage in rxvt-unicode is simpler. It has a F<ev_cpp.h> header file
4044	that everybody includes and which overrides some configure choices:	4102	that everybody includes and which overrides some configure choices:
4045		4103
4046	#define EV_MINIMAL 1	4104	#define EV_FEATURES 8
4047	#define EV_USE_POLL 0	4105	#define EV_USE_SELECT 1
4048	#define EV_MULTIPLICITY 0
4049	#define EV_PERIODIC_ENABLE 0	4106	#define EV_PREPARE_ENABLE 1
		4107	#define EV_IDLE_ENABLE 1
4050	#define EV_STAT_ENABLE 0	4108	#define EV_SIGNAL_ENABLE 1
4051	#define EV_FORK_ENABLE 0	4109	#define EV_CHILD_ENABLE 1
		4110	#define EV_USE_STDEXCEPT 0
4052	#define EV_CONFIG_H <config.h>	4111	#define EV_CONFIG_H <config.h>
4053	#define EV_MINPRI 0
4054	#define EV_MAXPRI 0
4055		4112
4056	#include "ev++.h"	4113	#include "ev++.h"
4057		4114
4058	And a F<ev_cpp.C> implementation file that contains libev proper and is compiled:	4115	And a F<ev_cpp.C> implementation file that contains libev proper and is compiled:
4059		4116
…		…
4561	involves iterating over all running async watchers or all signal numbers.	4618	involves iterating over all running async watchers or all signal numbers.
4562		4619
4563	=back	4620	=back
4564		4621
4565		4622
		4623	=head1 PORTING FROM 3.X TO 4.X
		4624
		4625	The major version 4 introduced some minor incompatible changes to the API.
		4626
		4627	=over 4
		4628
		4629	=item C<EV_TIMEOUT> replaced by C<EV_TIMER> in C<revents>
		4630
		4631	This is a simple rename - all other watcher types use their name
		4632	as revents flag, and now C<ev_timer> does, too.
		4633
		4634	Both C<EV_TIMER> and C<EV_TIMEOUT> symbols were present in 3.x versions
		4635	and continue to be present for the forseeable future, so this is mostly a
		4636	documentation change.
		4637
		4638	=item C<EV_MINIMAL> mechanism replaced by C<EV_FEATURES>
		4639
		4640	The preprocessor symbol C<EV_MINIMAL> has been replaced by a different
		4641	mechanism, C<EV_FEATURES>. Programs using C<EV_MINIMAL> usually compile
		4642	and work, but the library code will of course be larger.
		4643
		4644	=back
		4645
		4646
4566	=head1 GLOSSARY	4647	=head1 GLOSSARY
4567		4648
4568	=over 4	4649	=over 4
4569		4650
4570	=item active	4651	=item active
…		…
4591	A change of state of some external event, such as data now being available	4672	A change of state of some external event, such as data now being available
4592	for reading on a file descriptor, time having passed or simply not having	4673	for reading on a file descriptor, time having passed or simply not having
4593	any other events happening anymore.	4674	any other events happening anymore.
4594		4675
4595	In libev, events are represented as single bits (such as C<EV_READ> or	4676	In libev, events are represented as single bits (such as C<EV_READ> or
4596	C<EV_TIMEOUT>).	4677	C<EV_TIMER>).
4597		4678
4598	=item event library	4679	=item event library
4599		4680
4600	A software package implementing an event model and loop.	4681	A software package implementing an event model and loop.
4601		4682

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.283 by root, Wed Mar 10 09:18:25 2010 UTC vs. Revision 1.290 by root, Tue Mar 16 18:03:01 2010 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.283 by root, Wed Mar 10 09:18:25 2010 UTC vs.
Revision 1.290 by root, Tue Mar 16 18:03:01 2010 UTC