ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.70 by root, Fri Apr 25 07:25:44 2008 UTC vs.
Revision 1.86 by root, Fri Apr 25 14:01:48 2008 UTC

… …
80module. 80module.
81 81
82During the first call of any watcher-creation method, the module tries 82During the first call of any watcher-creation method, the module tries
83to detect the currently loaded event loop by probing whether one of the 83to detect the currently loaded event loop by probing whether one of the
84following modules is already loaded: L<Coro::EV>, L<Coro::Event>, L<EV>, 84following modules is already loaded: L<Coro::EV>, L<Coro::Event>, L<EV>,
85L<Event>, L<Glib>, L<Tk>, L<AnyEvent::Impl::Perl>, L<Event::Lib>, L<Qt>, 85L<Event>, L<Glib>, L<AnyEvent::Impl::Perl>, L<Tk>, L<Event::Lib>, L<Qt>,
86L<POE>. The first one found is used. If none are found, the module tries 86L<POE>. The first one found is used. If none are found, the module tries
87to load these modules (excluding Event::Lib, Qt and POE as the pure perl 87to load these modules (excluding Tk, Event::Lib, Qt and POE as the pure perl
88adaptor should always succeed) in the order given. The first one that can 88adaptor should always succeed) in the order given. The first one that can
89be successfully loaded will be used. If, after this, still none could be 89be successfully loaded will be used. If, after this, still none could be
90found, AnyEvent will fall back to a pure-perl event loop, which is not 90found, AnyEvent will fall back to a pure-perl event loop, which is not
91very efficient, but should work everywhere. 91very efficient, but should work everywhere.
92 92
… …
136 136
137Note that C<my $w; $w => combination. This is necessary because in Perl, 137Note that C<my $w; $w => combination. This is necessary because in Perl,
138my variables are only visible after the statement in which they are 138my variables are only visible after the statement in which they are
139declared. 139declared.
140 140
141=head2 IO WATCHERS 141=head2 I/O WATCHERS
142 142
143You can create an I/O watcher by calling the C<< AnyEvent->io >> method 143You can create an I/O watcher by calling the C<< AnyEvent->io >> method
144with the following mandatory key-value pairs as arguments: 144with the following mandatory key-value pairs as arguments:
145 145
146C<fh> the Perl I<file handle> (I<not> file descriptor) to watch for 146C<fh> the Perl I<file handle> (I<not> file descriptor) to watch
147events. C<poll> must be a string that is either C<r> or C<w>, which 147for events. C<poll> must be a string that is either C<r> or C<w>,
148creates a watcher waiting for "r"eadable or "w"ritable events, 148which creates a watcher waiting for "r"eadable or "w"ritable events,
149respectively. C<cb> is the callback to invoke each time the file handle 149respectively. C<cb> is the callback to invoke each time the file handle
150becomes ready. 150becomes ready.
151 151
152As long as the I/O watcher exists it will keep the file descriptor or a 152Although the callback might get passed parameters, their value and
153copy of it alive/open. 153presence is undefined and you cannot rely on them. Portable AnyEvent
154callbacks cannot use arguments passed to I/O watcher callbacks.
154 155
156The I/O watcher might use the underlying file descriptor or a copy of it.
155It is not allowed to close a file handle as long as any watcher is active 157You must not close a file handle as long as any watcher is active on the
156on the underlying file descriptor. 158underlying file descriptor.
157 159
158Some event loops issue spurious readyness notifications, so you should 160Some event loops issue spurious readyness notifications, so you should
159always use non-blocking calls when reading/writing from/to your file 161always use non-blocking calls when reading/writing from/to your file
160handles. 162handles.
161 163
… …
172 174
173You can create a time watcher by calling the C<< AnyEvent->timer >> 175You can create a time watcher by calling the C<< AnyEvent->timer >>
174method with the following mandatory arguments: 176method with the following mandatory arguments:
175 177
176C<after> specifies after how many seconds (fractional values are 178C<after> specifies after how many seconds (fractional values are
177supported) should the timer activate. C<cb> the callback to invoke in that 179supported) the callback should be invoked. C<cb> is the callback to invoke
178case. 180in that case.
181
182Although the callback might get passed parameters, their value and
183presence is undefined and you cannot rely on them. Portable AnyEvent
184callbacks cannot use arguments passed to time watcher callbacks.
179 185
180The timer callback will be invoked at most once: if you want a repeating 186The timer callback will be invoked at most once: if you want a repeating
181timer you have to create a new watcher (this is a limitation by both Tk 187timer you have to create a new watcher (this is a limitation by both Tk
182and Glib). 188and Glib).
183 189
… …
228 234
229You can watch for signals using a signal watcher, C<signal> is the signal 235You can watch for signals using a signal watcher, C<signal> is the signal
230I<name> without any C<SIG> prefix, C<cb> is the Perl callback to 236I<name> without any C<SIG> prefix, C<cb> is the Perl callback to
231be invoked whenever a signal occurs. 237be invoked whenever a signal occurs.
232 238
239Although the callback might get passed parameters, their value and
240presence is undefined and you cannot rely on them. Portable AnyEvent
241callbacks cannot use arguments passed to signal watcher callbacks.
242
233Multiple signal occurances can be clumped together into one callback 243Multiple signal occurances can be clumped together into one callback
234invocation, and callback invocation will be synchronous. synchronous means 244invocation, and callback invocation will be synchronous. synchronous means
235that it might take a while until the signal gets handled by the process, 245that it might take a while until the signal gets handled by the process,
236but it is guarenteed not to interrupt any other callbacks. 246but it is guarenteed not to interrupt any other callbacks.
237 247
… …
251 261
252The child process is specified by the C<pid> argument (if set to C<0>, it 262The child process is specified by the C<pid> argument (if set to C<0>, it
253watches for any child process exit). The watcher will trigger as often 263watches for any child process exit). The watcher will trigger as often
254as status change for the child are received. This works by installing a 264as status change for the child are received. This works by installing a
255signal handler for C<SIGCHLD>. The callback will be called with the pid 265signal handler for C<SIGCHLD>. The callback will be called with the pid
256and exit status (as returned by waitpid). 266and exit status (as returned by waitpid), so unlike other watcher types,
267you I<can> rely on child watcher callback arguments.
257 268
258Example: wait for pid 1333 269There is a slight catch to child watchers, however: you usually start them
270I<after> the child process was created, and this means the process could
271have exited already (and no SIGCHLD will be sent anymore).
272
273Not all event models handle this correctly (POE doesn't), but even for
274event models that I<do> handle this correctly, they usually need to be
275loaded before the process exits (i.e. before you fork in the first place).
276
277This means you cannot create a child watcher as the very first thing in an
278AnyEvent program, you I<have> to create at least one watcher before you
279C<fork> the child (alternatively, you can call C<AnyEvent::detect>).
280
281Example: fork a process and wait for it
282
283 my $done = AnyEvent->condvar;
284
285 AnyEvent::detect; # force event module to be initialised
286
287 my $pid = fork or exit 5;
259 288
260 my $w = AnyEvent->child ( 289 my $w = AnyEvent->child (
261 pid => 1333, 290 pid => $pid,
262 cb => sub { 291 cb => sub {
263 my ($pid, $status) = @_; 292 my ($pid, $status) = @_;
264 warn "pid $pid exited with status $status"; 293 warn "pid $pid exited with status $status";
294 $done->broadcast;
265 }, 295 },
266 ); 296 );
297
298 # do something else, then wait for process exit
299 $done->wait;
267 300
268=head2 CONDITION VARIABLES 301=head2 CONDITION VARIABLES
269 302
270Condition variables can be created by calling the C<< AnyEvent->condvar >> 303Condition variables can be created by calling the C<< AnyEvent->condvar >>
271method without any arguments. 304method without any arguments.
… …
359 AnyEvent::Impl::CoroEV based on Coro::EV, best choice. 392 AnyEvent::Impl::CoroEV based on Coro::EV, best choice.
360 AnyEvent::Impl::CoroEvent based on Coro::Event, second best choice. 393 AnyEvent::Impl::CoroEvent based on Coro::Event, second best choice.
361 AnyEvent::Impl::EV based on EV (an interface to libev, best choice). 394 AnyEvent::Impl::EV based on EV (an interface to libev, best choice).
362 AnyEvent::Impl::Event based on Event, second best choice. 395 AnyEvent::Impl::Event based on Event, second best choice.
363 AnyEvent::Impl::Glib based on Glib, third-best choice. 396 AnyEvent::Impl::Glib based on Glib, third-best choice.
397 AnyEvent::Impl::Perl pure-perl implementation, inefficient but portable.
364 AnyEvent::Impl::Tk based on Tk, very bad choice. 398 AnyEvent::Impl::Tk based on Tk, very bad choice.
365 AnyEvent::Impl::Perl pure-perl implementation, inefficient but portable.
366 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs). 399 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
367 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 400 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
368 AnyEvent::Impl::POE based on POE, not generic enough for full support. 401 AnyEvent::Impl::POE based on POE, not generic enough for full support.
369 402
370There is no support for WxWidgets, as WxWidgets has no support for 403There is no support for WxWidgets, as WxWidgets has no support for
… …
706 739
707=back 740=back
708 741
709=head1 EXAMPLE PROGRAM 742=head1 EXAMPLE PROGRAM
710 743
711The following program uses an IO watcher to read data from STDIN, a timer 744The following program uses an I/O watcher to read data from STDIN, a timer
712to display a message once per second, and a condition variable to quit the 745to display a message once per second, and a condition variable to quit the
713program when the user enters quit: 746program when the user enters quit:
714 747
715 use AnyEvent; 748 use AnyEvent;
716 749
… …
864 897
865 898
866=head1 BENCHMARK 899=head1 BENCHMARK
867 900
868To give you an idea of the performance and overheads that AnyEvent adds 901To give you an idea of the performance and overheads that AnyEvent adds
902over the event loops themselves (and to give you an impression of the
869over the event loops directly, here is a benchmark of various supported 903speed of various event loops), here is a benchmark of various supported
870event models natively and with anyevent. The benchmark creates a lot of 904event models natively and with anyevent. The benchmark creates a lot of
871timers (with a zero timeout) and io watchers (watching STDOUT, a pty, to 905timers (with a zero timeout) and I/O watchers (watching STDOUT, a pty, to
872become writable, which it is), lets them fire exactly once and destroys 906become writable, which it is), lets them fire exactly once and destroys
873them again. 907them again.
908
909Rewriting the benchmark to use many different sockets instead of using
910the same filehandle for all I/O watchers results in a much longer runtime
911(socket creation is expensive), but qualitatively the same figures, so it
912was not used.
874 913
875=head2 Explanation of the columns 914=head2 Explanation of the columns
876 915
877I<watcher> is the number of event watchers created/destroyed. Since 916I<watcher> is the number of event watchers created/destroyed. Since
878different event models feature vastly different performances, each event 917different event models feature vastly different performances, each event
… …
893I<invoke> is the time, in microseconds, used to invoke a simple 932I<invoke> is the time, in microseconds, used to invoke a simple
894callback. The callback simply counts down a Perl variable and after it was 933callback. The callback simply counts down a Perl variable and after it was
895invoked "watcher" times, it would C<< ->broadcast >> a condvar once to 934invoked "watcher" times, it would C<< ->broadcast >> a condvar once to
896signal the end of this phase. 935signal the end of this phase.
897 936
898I<destroy> is the time, in microseconds, that it takes destroy a single 937I<destroy> is the time, in microseconds, that it takes to destroy a single
899watcher. 938watcher.
900 939
901=head2 Results 940=head2 Results
902 941
903 name watcher bytes create invoke destroy comment 942 name watchers bytes create invoke destroy comment
904 EV/EV 400000 244 0.56 0.46 0.31 EV native interface 943 EV/EV 400000 244 0.56 0.46 0.31 EV native interface
905 EV/Any 100000 610 3.52 0.91 0.75 EV + AnyEvent watchers 944 EV/Any 100000 244 2.50 0.46 0.29 EV + AnyEvent watchers
906 CoroEV/Any 100000 610 3.49 0.92 0.75 coroutines + Coro::Signal 945 CoroEV/Any 100000 244 2.49 0.44 0.29 coroutines + Coro::Signal
907 Perl/Any 16000 654 4.64 1.22 0.77 pure perl implementation 946 Perl/Any 100000 513 4.92 0.87 1.12 pure perl implementation
908 Event/Event 16000 523 28.05 21.38 0.86 Event native interface 947 Event/Event 16000 516 31.88 31.30 0.85 Event native interface
909 Event/Any 16000 943 34.43 20.48 1.39 Event + AnyEvent watchers 948 Event/Any 16000 936 39.17 33.63 1.43 Event + AnyEvent watchers
910 Glib/Any 16000 1357 96.99 12.55 55.51 quadratic behaviour 949 Glib/Any 16000 1357 98.22 12.41 54.00 quadratic behaviour
911 Tk/Any 2000 1855 27.01 66.61 14.03 SEGV with >> 2000 watchers 950 Tk/Any 2000 1860 26.97 67.98 14.00 SEGV with >> 2000 watchers
912 POE/Event 2000 6644 108.15 768.19 14.33 via POE::Loop::Event 951 POE/Event 2000 6644 108.64 736.02 14.73 via POE::Loop::Event
913 POE/Select 2000 6343 94.69 807.65 562.69 via POE::Loop::Select 952 POE/Select 2000 6343 94.13 809.12 565.96 via POE::Loop::Select
914 953
915=head2 Discussion 954=head2 Discussion
916 955
917The benchmark does I<not> measure scalability of the event loop very 956The benchmark does I<not> measure scalability of the event loop very
918well. For example, a select-based event loop (such as the pure perl one) 957well. For example, a select-based event loop (such as the pure perl one)
919can never compete with an event loop that uses epoll when the number of 958can never compete with an event loop that uses epoll when the number of
920file descriptors grows high. In this benchmark, only a single filehandle 959file descriptors grows high. In this benchmark, all events become ready at
921is used (although some of the AnyEvent adaptors dup() its file descriptor 960the same time, so select/poll-based implementations get an unnatural speed
922to worka round bugs). 961boost.
923 962
924C<EV> is the sole leader regarding speed and memory use, which are both 963C<EV> is the sole leader regarding speed and memory use, which are both
925maximal/minimal, respectively. Even when going through AnyEvent, there is 964maximal/minimal, respectively. Even when going through AnyEvent, it uses
926only one event loop that uses less memory (the C<Event> module natively), and 965far less memory than any other event loop and is still faster than Event
927no faster event model, not event C<Event> natively. 966natively.
928 967
929The pure perl implementation is hit in a few sweet spots (both the 968The pure perl implementation is hit in a few sweet spots (both the
930zero timeout and the use of a single fd hit optimisations in the perl 969constant timeout and the use of a single fd hit optimisations in the perl
931interpreter and the backend itself). Nevertheless tis shows that it 970interpreter and the backend itself). Nevertheless this shows that it
932adds very little overhead in itself. Like any select-based backend its 971adds very little overhead in itself. Like any select-based backend its
933performance becomes really bad with lots of file descriptors, of course, 972performance becomes really bad with lots of file descriptors (and few of
934but this was not subjetc of this benchmark. 973them active), of course, but this was not subject of this benchmark.
935 974
936The C<Event> module has a relatively high setup and callback invocation cost, 975The C<Event> module has a relatively high setup and callback invocation cost,
937but overall scores on the third place. 976but overall scores on the third place.
938 977
939C<Glib>'s memory usage is quite a bit bit higher, features a faster 978C<Glib>'s memory usage is quite a bit bit higher, but it features a
940callback invocation and overall lands in the same class as C<Event>. 979faster callback invocation and overall ends up in the same class as
980C<Event>. However, Glib scales extremely badly, doubling the number of
981watchers increases the processing time by more than a factor of four,
982making it completely unusable when using larger numbers of watchers
983(note that only a single file descriptor was used in the benchmark, so
984inefficiencies of C<poll> do not account for this).
941 985
942The C<Tk> adaptor works relatively well, the fact that it crashes with 986The C<Tk> adaptor works relatively well. The fact that it crashes with
943more than 2000 watchers is a big setback, however, as correctness takes 987more than 2000 watchers is a big setback, however, as correctness takes
944precedence over speed. Nevertheless, its performance is surprising, as the 988precedence over speed. Nevertheless, its performance is surprising, as the
945file descriptor is dup()ed for each watcher. This shows that the dup() 989file descriptor is dup()ed for each watcher. This shows that the dup()
946employed by some adaptors is not a big performance issue (it does incur a 990employed by some adaptors is not a big performance issue (it does incur a
947hidden memory cost inside the kernel, though). 991hidden memory cost inside the kernel, though, that is not reflected in the
992figures above).
948 993
949C<POE>, regardless of backend (wether using its pure perl select-based 994C<POE>, regardless of underlying event loop (whether using its pure perl
950backend or the Event backend) shows abysmal performance and memory 995select-based backend or the Event module) shows abysmal performance and
951usage: Watchers use almost 30 times as much memory as EV watchers, and 10 996memory usage: Watchers use almost 30 times as much memory as EV watchers,
952times as much memory as both Event or EV via AnyEvent. Watcher invocation 997and 10 times as much memory as both Event or EV via AnyEvent. Watcher
953is almost 700 times slower as with AnyEvent's pure perl implementation. 998invocation is almost 900 times slower than with AnyEvent's pure perl
999implementation. The design of the POE adaptor class in AnyEvent can not
1000really account for this, as session creation overhead is small compared
1001to execution of the state machine, which is coded pretty optimally within
1002L<AnyEvent::Impl::POE>. POE simply seems to be abysmally slow.
954 1003
1004=head2 Summary
1005
955Summary: using EV through AnyEvent is faster than any other event 1006Using EV through AnyEvent is faster than any other event loop, but most
956loop. The overhead AnyEvent adds can be very small, and you should avoid 1007event loops have acceptable performance with or without AnyEvent.
957POE like the plague if you want performance or reasonable memory usage. 1008
1009The overhead AnyEvent adds is usually much smaller than the overhead of
1010the actual event loop, only with extremely fast event loops such as the EV
1011adds AnyEvent significant overhead.
1012
1013And you should simply avoid POE like the plague if you want performance or
1014reasonable memory usage.
958 1015
959 1016
960=head1 FORK 1017=head1 FORK
961 1018
962Most event libraries are not fork-safe. The ones who are usually are 1019Most event libraries are not fork-safe. The ones who are usually are

Diff Legend

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