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

Comparing AnyEvent/README (file contents):
Revision 1.42 by root, Mon Jun 29 21:00:32 2009 UTC vs.
Revision 1.51 by root, Sun Aug 9 16:05:11 2009 UTC

1NAME 1NAME
2 AnyEvent - provide framework for multiple event loops 2 AnyEvent - the DBI of event loop programming
3 3
4 EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported 4 EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async,
5 event loops. 5 Qt and POE are various supported event loops/environments.
6 6
7SYNOPSIS 7SYNOPSIS
8 use AnyEvent; 8 use AnyEvent;
9 9
10 # file descriptor readable 10 # file descriptor readable
… …
37 37
38INTRODUCTION/TUTORIAL 38INTRODUCTION/TUTORIAL
39 This manpage is mainly a reference manual. If you are interested in a 39 This manpage is mainly a reference manual. If you are interested in a
40 tutorial or some gentle introduction, have a look at the AnyEvent::Intro 40 tutorial or some gentle introduction, have a look at the AnyEvent::Intro
41 manpage. 41 manpage.
42
43SUPPORT
44 There is a mailinglist for discussing all things AnyEvent, and an IRC
45 channel, too.
46
47 See the AnyEvent project page at the Schmorpforge Ta-Sa Software
48 Repository, at <http://anyevent.schmorp.de>, for more info.
42 49
43WHY YOU SHOULD USE THIS MODULE (OR NOT) 50WHY YOU SHOULD USE THIS MODULE (OR NOT)
44 Glib, POE, IO::Async, Event... CPAN offers event models by the dozen 51 Glib, POE, IO::Async, Event... CPAN offers event models by the dozen
45 nowadays. So what is different about AnyEvent? 52 nowadays. So what is different about AnyEvent?
46 53
… …
166 Note that "my $w; $w =" combination. This is necessary because in Perl, 173 Note that "my $w; $w =" combination. This is necessary because in Perl,
167 my variables are only visible after the statement in which they are 174 my variables are only visible after the statement in which they are
168 declared. 175 declared.
169 176
170 I/O WATCHERS 177 I/O WATCHERS
178 $w = AnyEvent->io (
179 fh => <filehandle_or_fileno>,
180 poll => <"r" or "w">,
181 cb => <callback>,
182 );
183
171 You can create an I/O watcher by calling the "AnyEvent->io" method with 184 You can create an I/O watcher by calling the "AnyEvent->io" method with
172 the following mandatory key-value pairs as arguments: 185 the following mandatory key-value pairs as arguments:
173 186
174 "fh" is the Perl *file handle* (*not* file descriptor) to watch for 187 "fh" is the Perl *file handle* (or a naked file descriptor) to watch for
175 events (AnyEvent might or might not keep a reference to this file 188 events (AnyEvent might or might not keep a reference to this file
176 handle). Note that only file handles pointing to things for which 189 handle). Note that only file handles pointing to things for which
177 non-blocking operation makes sense are allowed. This includes sockets, 190 non-blocking operation makes sense are allowed. This includes sockets,
178 most character devices, pipes, fifos and so on, but not for example 191 most character devices, pipes, fifos and so on, but not for example
179 files or block devices. 192 files or block devices.
… …
203 warn "read: $input\n"; 216 warn "read: $input\n";
204 undef $w; 217 undef $w;
205 }); 218 });
206 219
207 TIME WATCHERS 220 TIME WATCHERS
221 $w = AnyEvent->timer (after => <seconds>, cb => <callback>);
222
223 $w = AnyEvent->timer (
224 after => <fractional_seconds>,
225 interval => <fractional_seconds>,
226 cb => <callback>,
227 );
228
208 You can create a time watcher by calling the "AnyEvent->timer" method 229 You can create a time watcher by calling the "AnyEvent->timer" method
209 with the following mandatory arguments: 230 with the following mandatory arguments:
210 231
211 "after" specifies after how many seconds (fractional values are 232 "after" specifies after how many seconds (fractional values are
212 supported) the callback should be invoked. "cb" is the callback to 233 supported) the callback should be invoked. "cb" is the callback to
… …
336 the event loop's idea of "current time". 357 the event loop's idea of "current time".
337 358
338 Note that updating the time *might* cause some events to be handled. 359 Note that updating the time *might* cause some events to be handled.
339 360
340 SIGNAL WATCHERS 361 SIGNAL WATCHERS
362 $w = AnyEvent->signal (signal => <uppercase_signal_name>, cb => <callback>);
363
341 You can watch for signals using a signal watcher, "signal" is the signal 364 You can watch for signals using a signal watcher, "signal" is the signal
342 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl 365 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl
343 callback to be invoked whenever a signal occurs. 366 callback to be invoked whenever a signal occurs.
344 367
345 Although the callback might get passed parameters, their value and 368 Although the callback might get passed parameters, their value and
… …
350 invocation, and callback invocation will be synchronous. Synchronous 373 invocation, and callback invocation will be synchronous. Synchronous
351 means that it might take a while until the signal gets handled by the 374 means that it might take a while until the signal gets handled by the
352 process, but it is guaranteed not to interrupt any other callbacks. 375 process, but it is guaranteed not to interrupt any other callbacks.
353 376
354 The main advantage of using these watchers is that you can share a 377 The main advantage of using these watchers is that you can share a
355 signal between multiple watchers. 378 signal between multiple watchers, and AnyEvent will ensure that signals
379 will not interrupt your program at bad times.
356 380
357 This watcher might use %SIG, so programs overwriting those signals 381 This watcher might use %SIG (depending on the event loop used), so
358 directly will likely not work correctly. 382 programs overwriting those signals directly will likely not work
383 correctly.
359 384
360 Example: exit on SIGINT 385 Example: exit on SIGINT
361 386
362 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 }); 387 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
363 388
389 Signal Races, Delays and Workarounds
390 Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
391 callbacks to signals in a generic way, which is a pity, as you cannot do
392 race-free signal handling in perl, requiring C libraries for this.
393 AnyEvent will try to do it's best, which means in some cases, signals
394 will be delayed. The maximum time a signal might be delayed is specified
395 in $AnyEvent::MAX_SIGNAL_LATENCY (default: 10 seconds). This variable
396 can be changed only before the first signal watcher is created, and
397 should be left alone otherwise. This variable determines how often
398 AnyEvent polls for signals (in case a wake-up was missed). Higher values
399 will cause fewer spurious wake-ups, which is better for power and CPU
400 saving.
401
402 All these problems can be avoided by installing the optional
403 Async::Interrupt module, which works with most event loops. It will not
404 work with inherently broken event loops such as Event or Event::Lib (and
405 not with POE currently, as POE does it's own workaround with one-second
406 latency). For those, you just have to suffer the delays.
407
364 CHILD PROCESS WATCHERS 408 CHILD PROCESS WATCHERS
409 $w = AnyEvent->child (pid => <process id>, cb => <callback>);
410
365 You can also watch on a child process exit and catch its exit status. 411 You can also watch on a child process exit and catch its exit status.
366 412
367 The child process is specified by the "pid" argument (if set to 0, it 413 The child process is specified by the "pid" argument (one some backends,
368 watches for any child process exit). The watcher will triggered only 414 using 0 watches for any child process exit, on others this will croak).
369 when the child process has finished and an exit status is available, not 415 The watcher will be triggered only when the child process has finished
370 on any trace events (stopped/continued). 416 and an exit status is available, not on any trace events
417 (stopped/continued).
371 418
372 The callback will be called with the pid and exit status (as returned by 419 The callback will be called with the pid and exit status (as returned by
373 waitpid), so unlike other watcher types, you *can* rely on child watcher 420 waitpid), so unlike other watcher types, you *can* rely on child watcher
374 callback arguments. 421 callback arguments.
375 422
… …
390 of when you start the watcher. 437 of when you start the watcher.
391 438
392 This means you cannot create a child watcher as the very first thing in 439 This means you cannot create a child watcher as the very first thing in
393 an AnyEvent program, you *have* to create at least one watcher before 440 an AnyEvent program, you *have* to create at least one watcher before
394 you "fork" the child (alternatively, you can call "AnyEvent::detect"). 441 you "fork" the child (alternatively, you can call "AnyEvent::detect").
442
443 As most event loops do not support waiting for child events, they will
444 be emulated by AnyEvent in most cases, in which the latency and race
445 problems mentioned in the description of signal watchers apply.
395 446
396 Example: fork a process and wait for it 447 Example: fork a process and wait for it
397 448
398 my $done = AnyEvent->condvar; 449 my $done = AnyEvent->condvar;
399 450
… …
410 461
411 # do something else, then wait for process exit 462 # do something else, then wait for process exit
412 $done->recv; 463 $done->recv;
413 464
414 IDLE WATCHERS 465 IDLE WATCHERS
466 $w = AnyEvent->idle (cb => <callback>);
467
415 Sometimes there is a need to do something, but it is not so important to 468 Sometimes there is a need to do something, but it is not so important to
416 do it instantly, but only when there is nothing better to do. This 469 do it instantly, but only when there is nothing better to do. This
417 "nothing better to do" is usually defined to be "no other events need 470 "nothing better to do" is usually defined to be "no other events need
418 attention by the event loop". 471 attention by the event loop".
419 472
… …
444 } 497 }
445 }); 498 });
446 }); 499 });
447 500
448 CONDITION VARIABLES 501 CONDITION VARIABLES
502 $cv = AnyEvent->condvar;
503
504 $cv->send (<list>);
505 my @res = $cv->recv;
506
449 If you are familiar with some event loops you will know that all of them 507 If you are familiar with some event loops you will know that all of them
450 require you to run some blocking "loop", "run" or similar function that 508 require you to run some blocking "loop", "run" or similar function that
451 will actively watch for new events and call your callbacks. 509 will actively watch for new events and call your callbacks.
452 510
453 AnyEvent is different, it expects somebody else to run the event loop 511 AnyEvent is slightly different: it expects somebody else to run the
454 and will only block when necessary (usually when told by the user). 512 event loop and will only block when necessary (usually when told by the
513 user).
455 514
456 The instrument to do that is called a "condition variable", so called 515 The instrument to do that is called a "condition variable", so called
457 because they represent a condition that must become true. 516 because they represent a condition that must become true.
458 517
518 Now is probably a good time to look at the examples further below.
519
459 Condition variables can be created by calling the "AnyEvent->condvar" 520 Condition variables can be created by calling the "AnyEvent->condvar"
460 method, usually without arguments. The only argument pair allowed is 521 method, usually without arguments. The only argument pair allowed is
461
462 "cb", which specifies a callback to be called when the condition 522 "cb", which specifies a callback to be called when the condition
463 variable becomes true, with the condition variable as the first argument 523 variable becomes true, with the condition variable as the first argument
464 (but not the results). 524 (but not the results).
465 525
466 After creation, the condition variable is "false" until it becomes 526 After creation, the condition variable is "false" until it becomes
… …
471 Condition variables are similar to callbacks, except that you can 531 Condition variables are similar to callbacks, except that you can
472 optionally wait for them. They can also be called merge points - points 532 optionally wait for them. They can also be called merge points - points
473 in time where multiple outstanding events have been processed. And yet 533 in time where multiple outstanding events have been processed. And yet
474 another way to call them is transactions - each condition variable can 534 another way to call them is transactions - each condition variable can
475 be used to represent a transaction, which finishes at some point and 535 be used to represent a transaction, which finishes at some point and
476 delivers a result. 536 delivers a result. And yet some people know them as "futures" - a
537 promise to compute/deliver something that you can wait for.
477 538
478 Condition variables are very useful to signal that something has 539 Condition variables are very useful to signal that something has
479 finished, for example, if you write a module that does asynchronous http 540 finished, for example, if you write a module that does asynchronous http
480 requests, then a condition variable would be the ideal candidate to 541 requests, then a condition variable would be the ideal candidate to
481 signal the availability of results. The user can either act when the 542 signal the availability of results. The user can either act when the
… …
515 after => 1, 576 after => 1,
516 cb => sub { $result_ready->send }, 577 cb => sub { $result_ready->send },
517 ); 578 );
518 579
519 # this "blocks" (while handling events) till the callback 580 # this "blocks" (while handling events) till the callback
520 # calls send 581 # calls -<send
521 $result_ready->recv; 582 $result_ready->recv;
522 583
523 Example: wait for a timer, but take advantage of the fact that condition 584 Example: wait for a timer, but take advantage of the fact that condition
524 variables are also code references. 585 variables are also callable directly.
525 586
526 my $done = AnyEvent->condvar; 587 my $done = AnyEvent->condvar;
527 my $delay = AnyEvent->timer (after => 5, cb => $done); 588 my $delay = AnyEvent->timer (after => 5, cb => $done);
528 $done->recv; 589 $done->recv;
529 590
… …
535 596
536 ... 597 ...
537 598
538 my @info = $couchdb->info->recv; 599 my @info = $couchdb->info->recv;
539 600
540 And this is how you would just ste a callback to be called whenever the 601 And this is how you would just set a callback to be called whenever the
541 results are available: 602 results are available:
542 603
543 $couchdb->info->cb (sub { 604 $couchdb->info->cb (sub {
544 my @info = $_[0]->recv; 605 my @info = $_[0]->recv;
545 }); 606 });
… …
560 621
561 Any arguments passed to the "send" call will be returned by all 622 Any arguments passed to the "send" call will be returned by all
562 future "->recv" calls. 623 future "->recv" calls.
563 624
564 Condition variables are overloaded so one can call them directly (as 625 Condition variables are overloaded so one can call them directly (as
565 a code reference). Calling them directly is the same as calling 626 if they were a code reference). Calling them directly is the same as
566 "send". Note, however, that many C-based event loops do not handle 627 calling "send".
567 overloading, so as tempting as it may be, passing a condition
568 variable instead of a callback does not work. Both the pure perl and
569 EV loops support overloading, however, as well as all functions that
570 use perl to invoke a callback (as in AnyEvent::Socket and
571 AnyEvent::DNS for example).
572 628
573 $cv->croak ($error) 629 $cv->croak ($error)
574 Similar to send, but causes all call's to "->recv" to invoke 630 Similar to send, but causes all call's to "->recv" to invoke
575 "Carp::croak" with the given error message/object/scalar. 631 "Carp::croak" with the given error message/object/scalar.
576 632
577 This can be used to signal any errors to the condition variable 633 This can be used to signal any errors to the condition variable
578 user/consumer. 634 user/consumer. Doing it this way instead of calling "croak" directly
635 delays the error detetcion, but has the overwhelmign advantage that
636 it diagnoses the error at the place where the result is expected,
637 and not deep in some event clalback without connection to the actual
638 code causing the problem.
579 639
580 $cv->begin ([group callback]) 640 $cv->begin ([group callback])
581 $cv->end 641 $cv->end
582 These two methods can be used to combine many transactions/events 642 These two methods can be used to combine many transactions/events
583 into one. For example, a function that pings many hosts in parallel 643 into one. For example, a function that pings many hosts in parallel
… …
671 function will call "croak". 731 function will call "croak".
672 732
673 In list context, all parameters passed to "send" will be returned, 733 In list context, all parameters passed to "send" will be returned,
674 in scalar context only the first one will be returned. 734 in scalar context only the first one will be returned.
675 735
736 Note that doing a blocking wait in a callback is not supported by
737 any event loop, that is, recursive invocation of a blocking "->recv"
738 is not allowed, and the "recv" call will "croak" if such a condition
739 is detected. This condition can be slightly loosened by using
740 Coro::AnyEvent, which allows you to do a blocking "->recv" from any
741 thread that doesn't run the event loop itself.
742
676 Not all event models support a blocking wait - some die in that case 743 Not all event models support a blocking wait - some die in that case
677 (programs might want to do that to stay interactive), so *if you are 744 (programs might want to do that to stay interactive), so *if you are
678 using this from a module, never require a blocking wait*, but let 745 using this from a module, never require a blocking wait*. Instead,
679 the caller decide whether the call will block or not (for example, 746 let the caller decide whether the call will block or not (for
680 by coupling condition variables with some kind of request results 747 example, by coupling condition variables with some kind of request
681 and supporting callbacks so the caller knows that getting the result 748 results and supporting callbacks so the caller knows that getting
682 will not block, while still supporting blocking waits if the caller 749 the result will not block, while still supporting blocking waits if
683 so desires). 750 the caller so desires).
684
685 Another reason *never* to "->recv" in a module is that you cannot
686 sensibly have two "->recv"'s in parallel, as that would require
687 multiple interpreters or coroutines/threads, none of which
688 "AnyEvent" can supply.
689
690 The Coro module, however, *can* and *does* supply coroutines and, in
691 fact, Coro::AnyEvent replaces AnyEvent's condvars by coroutine-safe
692 versions and also integrates coroutines into AnyEvent, making
693 blocking "->recv" calls perfectly safe as long as they are done from
694 another coroutine (one that doesn't run the event loop).
695 751
696 You can ensure that "-recv" never blocks by setting a callback and 752 You can ensure that "-recv" never blocks by setting a callback and
697 only calling "->recv" from within that callback (or at a later 753 only calling "->recv" from within that callback (or at a later
698 time). This will work even when the event loop does not support 754 time). This will work even when the event loop does not support
699 blocking waits otherwise. 755 blocking waits otherwise.
… …
704 760
705 $cb = $cv->cb ($cb->($cv)) 761 $cb = $cv->cb ($cb->($cv))
706 This is a mutator function that returns the callback set and 762 This is a mutator function that returns the callback set and
707 optionally replaces it before doing so. 763 optionally replaces it before doing so.
708 764
709 The callback will be called when the condition becomes "true", i.e. 765 The callback will be called when the condition becomes (or already
710 when "send" or "croak" are called, with the only argument being the 766 was) "true", i.e. when "send" or "croak" are called (or were
711 condition variable itself. Calling "recv" inside the callback or at 767 called), with the only argument being the condition variable itself.
768 Calling "recv" inside the callback or at any later time is
712 any later time is guaranteed not to block. 769 guaranteed not to block.
770
771SUPPORTED EVENT LOOPS/BACKENDS
772 The available backend classes are (every class has its own manpage):
773
774 Backends that are autoprobed when no other event loop can be found.
775 EV is the preferred backend when no other event loop seems to be in
776 use. If EV is not installed, then AnyEvent will fall back to its own
777 pure-perl implementation, which is available everywhere as it comes
778 with AnyEvent itself.
779
780 AnyEvent::Impl::EV based on EV (interface to libev, best choice).
781 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
782
783 Backends that are transparently being picked up when they are used.
784 These will be used when they are currently loaded when the first
785 watcher is created, in which case it is assumed that the application
786 is using them. This means that AnyEvent will automatically pick the
787 right backend when the main program loads an event module before
788 anything starts to create watchers. Nothing special needs to be done
789 by the main program.
790
791 AnyEvent::Impl::Event based on Event, very stable, few glitches.
792 AnyEvent::Impl::Glib based on Glib, slow but very stable.
793 AnyEvent::Impl::Tk based on Tk, very broken.
794 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
795 AnyEvent::Impl::POE based on POE, very slow, some limitations.
796 AnyEvent::Impl::Irssi used when running within irssi.
797
798 Backends with special needs.
799 Qt requires the Qt::Application to be instantiated first, but will
800 otherwise be picked up automatically. As long as the main program
801 instantiates the application before any AnyEvent watchers are
802 created, everything should just work.
803
804 AnyEvent::Impl::Qt based on Qt.
805
806 Support for IO::Async can only be partial, as it is too broken and
807 architecturally limited to even support the AnyEvent API. It also is
808 the only event loop that needs the loop to be set explicitly, so it
809 can only be used by a main program knowing about AnyEvent. See
810 AnyEvent::Impl::Async for the gory details.
811
812 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed.
813
814 Event loops that are indirectly supported via other backends.
815 Some event loops can be supported via other modules:
816
817 There is no direct support for WxWidgets (Wx) or Prima.
818
819 WxWidgets has no support for watching file handles. However, you can
820 use WxWidgets through the POE adaptor, as POE has a Wx backend that
821 simply polls 20 times per second, which was considered to be too
822 horrible to even consider for AnyEvent.
823
824 Prima is not supported as nobody seems to be using it, but it has a
825 POE backend, so it can be supported through POE.
826
827 AnyEvent knows about both Prima and Wx, however, and will try to
828 load POE when detecting them, in the hope that POE will pick them
829 up, in which case everything will be automatic.
713 830
714GLOBAL VARIABLES AND FUNCTIONS 831GLOBAL VARIABLES AND FUNCTIONS
832 These are not normally required to use AnyEvent, but can be useful to
833 write AnyEvent extension modules.
834
715 $AnyEvent::MODEL 835 $AnyEvent::MODEL
716 Contains "undef" until the first watcher is being created. Then it 836 Contains "undef" until the first watcher is being created, before
837 the backend has been autodetected.
838
717 contains the event model that is being used, which is the name of 839 Afterwards it contains the event model that is being used, which is
718 the Perl class implementing the model. This class is usually one of 840 the name of the Perl class implementing the model. This class is
719 the "AnyEvent::Impl:xxx" modules, but can be any other class in the 841 usually one of the "AnyEvent::Impl:xxx" modules, but can be any
720 case AnyEvent has been extended at runtime (e.g. in *rxvt-unicode*). 842 other class in the case AnyEvent has been extended at runtime (e.g.
721 843 in *rxvt-unicode* it will be "urxvt::anyevent").
722 The known classes so far are:
723
724 AnyEvent::Impl::EV based on EV (an interface to libev, best choice).
725 AnyEvent::Impl::Event based on Event, second best choice.
726 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
727 AnyEvent::Impl::Glib based on Glib, third-best choice.
728 AnyEvent::Impl::Tk based on Tk, very bad choice.
729 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
730 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
731 AnyEvent::Impl::POE based on POE, not generic enough for full support.
732
733 # warning, support for IO::Async is only partial, as it is too broken
734 # and limited toe ven support the AnyEvent API. See AnyEvent::Impl::Async.
735 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed (see its docs).
736
737 There is no support for WxWidgets, as WxWidgets has no support for
738 watching file handles. However, you can use WxWidgets through the
739 POE Adaptor, as POE has a Wx backend that simply polls 20 times per
740 second, which was considered to be too horrible to even consider for
741 AnyEvent. Likewise, other POE backends can be used by AnyEvent by
742 using it's adaptor.
743
744 AnyEvent knows about Prima and Wx and will try to use POE when
745 autodetecting them.
746 844
747 AnyEvent::detect 845 AnyEvent::detect
748 Returns $AnyEvent::MODEL, forcing autodetection of the event model 846 Returns $AnyEvent::MODEL, forcing autodetection of the event model
749 if necessary. You should only call this function right before you 847 if necessary. You should only call this function right before you
750 would have created an AnyEvent watcher anyway, that is, as late as 848 would have created an AnyEvent watcher anyway, that is, as late as
751 possible at runtime. 849 possible at runtime, and not e.g. while initialising of your module.
850
851 If you need to do some initialisation before AnyEvent watchers are
852 created, use "post_detect".
752 853
753 $guard = AnyEvent::post_detect { BLOCK } 854 $guard = AnyEvent::post_detect { BLOCK }
754 Arranges for the code block to be executed as soon as the event 855 Arranges for the code block to be executed as soon as the event
755 model is autodetected (or immediately if this has already happened). 856 model is autodetected (or immediately if this has already happened).
756 857
858 The block will be executed *after* the actual backend has been
859 detected ($AnyEvent::MODEL is set), but *before* any watchers have
860 been created, so it is possible to e.g. patch @AnyEvent::ISA or do
861 other initialisations - see the sources of AnyEvent::Strict or
862 AnyEvent::AIO to see how this is used.
863
864 The most common usage is to create some global watchers, without
865 forcing event module detection too early, for example, AnyEvent::AIO
866 creates and installs the global IO::AIO watcher in a "post_detect"
867 block to avoid autodetecting the event module at load time.
868
757 If called in scalar or list context, then it creates and returns an 869 If called in scalar or list context, then it creates and returns an
758 object that automatically removes the callback again when it is 870 object that automatically removes the callback again when it is
871 destroyed (or "undef" when the hook was immediately executed). See
759 destroyed. See Coro::BDB for a case where this is useful. 872 AnyEvent::AIO for a case where this is useful.
873
874 Example: Create a watcher for the IO::AIO module and store it in
875 $WATCHER. Only do so after the event loop is initialised, though.
876
877 our WATCHER;
878
879 my $guard = AnyEvent::post_detect {
880 $WATCHER = AnyEvent->io (fh => IO::AIO::poll_fileno, poll => 'r', cb => \&IO::AIO::poll_cb);
881 };
882
883 # the ||= is important in case post_detect immediately runs the block,
884 # as to not clobber the newly-created watcher. assigning both watcher and
885 # post_detect guard to the same variable has the advantage of users being
886 # able to just C<undef $WATCHER> if the watcher causes them grief.
887
888 $WATCHER ||= $guard;
760 889
761 @AnyEvent::post_detect 890 @AnyEvent::post_detect
762 If there are any code references in this array (you can "push" to it 891 If there are any code references in this array (you can "push" to it
763 before or after loading AnyEvent), then they will called directly 892 before or after loading AnyEvent), then they will called directly
764 after the event loop has been chosen. 893 after the event loop has been chosen.
765 894
766 You should check $AnyEvent::MODEL before adding to this array, 895 You should check $AnyEvent::MODEL before adding to this array,
767 though: if it contains a true value then the event loop has already 896 though: if it is defined then the event loop has already been
768 been detected, and the array will be ignored. 897 detected, and the array will be ignored.
769 898
770 Best use "AnyEvent::post_detect { BLOCK }" instead. 899 Best use "AnyEvent::post_detect { BLOCK }" when your application
900 allows it,as it takes care of these details.
901
902 This variable is mainly useful for modules that can do something
903 useful when AnyEvent is used and thus want to know when it is
904 initialised, but do not need to even load it by default. This array
905 provides the means to hook into AnyEvent passively, without loading
906 it.
771 907
772WHAT TO DO IN A MODULE 908WHAT TO DO IN A MODULE
773 As a module author, you should "use AnyEvent" and call AnyEvent methods 909 As a module author, you should "use AnyEvent" and call AnyEvent methods
774 freely, but you should not load a specific event module or rely on it. 910 freely, but you should not load a specific event module or rely on it.
775 911
… …
826 variable somewhere, waiting for it, and sending it when the program 962 variable somewhere, waiting for it, and sending it when the program
827 should exit cleanly. 963 should exit cleanly.
828 964
829OTHER MODULES 965OTHER MODULES
830 The following is a non-exhaustive list of additional modules that use 966 The following is a non-exhaustive list of additional modules that use
831 AnyEvent and can therefore be mixed easily with other AnyEvent modules 967 AnyEvent as a client and can therefore be mixed easily with other
832 in the same program. Some of the modules come with AnyEvent, some are 968 AnyEvent modules and other event loops in the same program. Some of the
833 available via CPAN. 969 modules come with AnyEvent, most are available via CPAN.
834 970
835 AnyEvent::Util 971 AnyEvent::Util
836 Contains various utility functions that replace often-used but 972 Contains various utility functions that replace often-used but
837 blocking functions such as "inet_aton" by event-/callback-based 973 blocking functions such as "inet_aton" by event-/callback-based
838 versions. 974 versions.
… …
844 more. 980 more.
845 981
846 AnyEvent::Handle 982 AnyEvent::Handle
847 Provide read and write buffers, manages watchers for reads and 983 Provide read and write buffers, manages watchers for reads and
848 writes, supports raw and formatted I/O, I/O queued and fully 984 writes, supports raw and formatted I/O, I/O queued and fully
849 transparent and non-blocking SSL/TLS. 985 transparent and non-blocking SSL/TLS (via AnyEvent::TLS.
850 986
851 AnyEvent::DNS 987 AnyEvent::DNS
852 Provides rich asynchronous DNS resolver capabilities. 988 Provides rich asynchronous DNS resolver capabilities.
853 989
854 AnyEvent::HTTP 990 AnyEvent::HTTP
… …
875 1011
876 AnyEvent::GPSD 1012 AnyEvent::GPSD
877 A non-blocking interface to gpsd, a daemon delivering GPS 1013 A non-blocking interface to gpsd, a daemon delivering GPS
878 information. 1014 information.
879 1015
1016 AnyEvent::IRC
1017 AnyEvent based IRC client module family (replacing the older
1018 Net::IRC3).
1019
1020 AnyEvent::XMPP
1021 AnyEvent based XMPP (Jabber protocol) module family (replacing the
1022 older Net::XMPP2>.
1023
880 AnyEvent::IGS 1024 AnyEvent::IGS
881 A non-blocking interface to the Internet Go Server protocol (used by 1025 A non-blocking interface to the Internet Go Server protocol (used by
882 App::IGS). 1026 App::IGS).
883 1027
884 AnyEvent::IRC
885 AnyEvent based IRC client module family (replacing the older
886 Net::IRC3).
887
888 Net::XMPP2
889 AnyEvent based XMPP (Jabber protocol) module family.
890
891 Net::FCP 1028 Net::FCP
892 AnyEvent-based implementation of the Freenet Client Protocol, 1029 AnyEvent-based implementation of the Freenet Client Protocol,
893 birthplace of AnyEvent. 1030 birthplace of AnyEvent.
894 1031
895 Event::ExecFlow 1032 Event::ExecFlow
896 High level API for event-based execution flow control. 1033 High level API for event-based execution flow control.
897 1034
898 Coro 1035 Coro
899 Has special support for AnyEvent via Coro::AnyEvent. 1036 Has special support for AnyEvent via Coro::AnyEvent.
900 1037
901 IO::Lambda 1038SIMPLIFIED AE API
902 The lambda approach to I/O - don't ask, look there. Can use 1039 Starting with version 5.0, AnyEvent officially supports a second, much
903 AnyEvent. 1040 simpler, API that is designed to reduce the calling, typing and memory
1041 overhead.
1042
1043 See the AE manpage for details.
904 1044
905ERROR AND EXCEPTION HANDLING 1045ERROR AND EXCEPTION HANDLING
906 In general, AnyEvent does not do any error handling - it relies on the 1046 In general, AnyEvent does not do any error handling - it relies on the
907 caller to do that if required. The AnyEvent::Strict module (see also the 1047 caller to do that if required. The AnyEvent::Strict module (see also the
908 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict 1048 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict
… …
936 by "PERL_ANYEVENT_MODEL". 1076 by "PERL_ANYEVENT_MODEL".
937 1077
938 When set to 2 or higher, cause AnyEvent to report to STDERR which 1078 When set to 2 or higher, cause AnyEvent to report to STDERR which
939 event model it chooses. 1079 event model it chooses.
940 1080
1081 When set to 8 or higher, then AnyEvent will report extra information
1082 on which optional modules it loads and how it implements certain
1083 features.
1084
941 "PERL_ANYEVENT_STRICT" 1085 "PERL_ANYEVENT_STRICT"
942 AnyEvent does not do much argument checking by default, as thorough 1086 AnyEvent does not do much argument checking by default, as thorough
943 argument checking is very costly. Setting this variable to a true 1087 argument checking is very costly. Setting this variable to a true
944 value will cause AnyEvent to load "AnyEvent::Strict" and then to 1088 value will cause AnyEvent to load "AnyEvent::Strict" and then to
945 thoroughly check the arguments passed to most method calls. If it 1089 thoroughly check the arguments passed to most method calls. If it
946 finds any problems, it will croak. 1090 finds any problems, it will croak.
947 1091
948 In other words, enables "strict" mode. 1092 In other words, enables "strict" mode.
949 1093
950 Unlike "use strict", it is definitely recommended to keep it off in 1094 Unlike "use strict" (or it's modern cousin, "use common::sense", it
951 production. Keeping "PERL_ANYEVENT_STRICT=1" in your environment 1095 is definitely recommended to keep it off in production. Keeping
1096 "PERL_ANYEVENT_STRICT=1" in your environment while developing
952 while developing programs can be very useful, however. 1097 programs can be very useful, however.
953 1098
954 "PERL_ANYEVENT_MODEL" 1099 "PERL_ANYEVENT_MODEL"
955 This can be used to specify the event model to be used by AnyEvent, 1100 This can be used to specify the event model to be used by AnyEvent,
956 before auto detection and -probing kicks in. It must be a string 1101 before auto detection and -probing kicks in. It must be a string
957 consisting entirely of ASCII letters. The string "AnyEvent::Impl::" 1102 consisting entirely of ASCII letters. The string "AnyEvent::Impl::"
… …
998 EDNS0 in its DNS requests. 1143 EDNS0 in its DNS requests.
999 1144
1000 "PERL_ANYEVENT_MAX_FORKS" 1145 "PERL_ANYEVENT_MAX_FORKS"
1001 The maximum number of child processes that 1146 The maximum number of child processes that
1002 "AnyEvent::Util::fork_call" will create in parallel. 1147 "AnyEvent::Util::fork_call" will create in parallel.
1148
1149 "PERL_ANYEVENT_MAX_OUTSTANDING_DNS"
1150 The default value for the "max_outstanding" parameter for the
1151 default DNS resolver - this is the maximum number of parallel DNS
1152 requests that are sent to the DNS server.
1153
1154 "PERL_ANYEVENT_RESOLV_CONF"
1155 The file to use instead of /etc/resolv.conf (or OS-specific
1156 configuration) in the default resolver. When set to the empty
1157 string, no default config will be used.
1158
1159 "PERL_ANYEVENT_CA_FILE", "PERL_ANYEVENT_CA_PATH".
1160 When neither "ca_file" nor "ca_path" was specified during
1161 AnyEvent::TLS context creation, and either of these environment
1162 variables exist, they will be used to specify CA certificate
1163 locations instead of a system-dependent default.
1164
1165 "PERL_ANYEVENT_AVOID_GUARD" and "PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT"
1166 When these are set to 1, then the respective modules are not loaded.
1167 Mostly good for testing AnyEvent itself.
1003 1168
1004SUPPLYING YOUR OWN EVENT MODEL INTERFACE 1169SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1005 This is an advanced topic that you do not normally need to use AnyEvent 1170 This is an advanced topic that you do not normally need to use AnyEvent
1006 in a module. This section is only of use to event loop authors who want 1171 in a module. This section is only of use to event loop authors who want
1007 to provide AnyEvent compatibility. 1172 to provide AnyEvent compatibility.
… …
1208 through AnyEvent. The benchmark creates a lot of timers (with a zero 1373 through AnyEvent. The benchmark creates a lot of timers (with a zero
1209 timeout) and I/O watchers (watching STDOUT, a pty, to become writable, 1374 timeout) and I/O watchers (watching STDOUT, a pty, to become writable,
1210 which it is), lets them fire exactly once and destroys them again. 1375 which it is), lets them fire exactly once and destroys them again.
1211 1376
1212 Source code for this benchmark is found as eg/bench in the AnyEvent 1377 Source code for this benchmark is found as eg/bench in the AnyEvent
1213 distribution. 1378 distribution. It uses the AE interface, which makes a real difference
1379 for the EV and Perl backends only.
1214 1380
1215 Explanation of the columns 1381 Explanation of the columns
1216 *watcher* is the number of event watchers created/destroyed. Since 1382 *watcher* is the number of event watchers created/destroyed. Since
1217 different event models feature vastly different performances, each event 1383 different event models feature vastly different performances, each event
1218 loop was given a number of watchers so that overall runtime is 1384 loop was given a number of watchers so that overall runtime is
… …
1237 *destroy* is the time, in microseconds, that it takes to destroy a 1403 *destroy* is the time, in microseconds, that it takes to destroy a
1238 single watcher. 1404 single watcher.
1239 1405
1240 Results 1406 Results
1241 name watchers bytes create invoke destroy comment 1407 name watchers bytes create invoke destroy comment
1242 EV/EV 400000 224 0.47 0.35 0.27 EV native interface 1408 EV/EV 100000 223 0.47 0.43 0.27 EV native interface
1243 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers 1409 EV/Any 100000 223 0.48 0.42 0.26 EV + AnyEvent watchers
1244 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal 1410 Coro::EV/Any 100000 223 0.47 0.42 0.26 coroutines + Coro::Signal
1245 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation 1411 Perl/Any 100000 431 2.70 0.74 0.92 pure perl implementation
1246 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 1412 Event/Event 16000 516 31.16 31.84 0.82 Event native interface
1247 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 1413 Event/Any 16000 1203 42.61 34.79 1.80 Event + AnyEvent watchers
1248 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll 1414 IOAsync/Any 16000 1911 41.92 27.45 16.81 via IO::Async::Loop::IO_Poll
1249 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll 1415 IOAsync/Any 16000 1726 40.69 26.37 15.25 via IO::Async::Loop::Epoll
1250 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 1416 Glib/Any 16000 1118 89.00 12.57 51.17 quadratic behaviour
1251 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 1417 Tk/Any 2000 1346 20.96 10.75 8.00 SEGV with >> 2000 watchers
1252 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 1418 POE/Any 2000 6951 108.97 795.32 14.24 via POE::Loop::Event
1253 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select 1419 POE/Any 2000 6648 94.79 774.40 575.51 via POE::Loop::Select
1254 1420
1255 Discussion 1421 Discussion
1256 The benchmark does *not* measure scalability of the event loop very 1422 The benchmark does *not* measure scalability of the event loop very
1257 well. For example, a select-based event loop (such as the pure perl one) 1423 well. For example, a select-based event loop (such as the pure perl one)
1258 can never compete with an event loop that uses epoll when the number of 1424 can never compete with an event loop that uses epoll when the number of
… …
1269 benchmark machine, handling an event takes roughly 1600 CPU cycles with 1435 benchmark machine, handling an event takes roughly 1600 CPU cycles with
1270 EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 1436 EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000
1271 CPU cycles with POE. 1437 CPU cycles with POE.
1272 1438
1273 "EV" is the sole leader regarding speed and memory use, which are both 1439 "EV" is the sole leader regarding speed and memory use, which are both
1274 maximal/minimal, respectively. Even when going through AnyEvent, it uses 1440 maximal/minimal, respectively. When using the AE API there is zero
1441 overhead (when going through the AnyEvent API create is about 5-6 times
1442 slower, with other times being equal, so still uses far less memory than
1275 far less memory than any other event loop and is still faster than Event 1443 any other event loop and is still faster than Event natively).
1276 natively.
1277 1444
1278 The pure perl implementation is hit in a few sweet spots (both the 1445 The pure perl implementation is hit in a few sweet spots (both the
1279 constant timeout and the use of a single fd hit optimisations in the 1446 constant timeout and the use of a single fd hit optimisations in the
1280 perl interpreter and the backend itself). Nevertheless this shows that 1447 perl interpreter and the backend itself). Nevertheless this shows that
1281 it adds very little overhead in itself. Like any select-based backend 1448 it adds very little overhead in itself. Like any select-based backend
… …
1351 In this benchmark, we use 10000 socket pairs (20000 sockets), of which 1518 In this benchmark, we use 10000 socket pairs (20000 sockets), of which
1352 100 (1%) are active. This mirrors the activity of large servers with 1519 100 (1%) are active. This mirrors the activity of large servers with
1353 many connections, most of which are idle at any one point in time. 1520 many connections, most of which are idle at any one point in time.
1354 1521
1355 Source code for this benchmark is found as eg/bench2 in the AnyEvent 1522 Source code for this benchmark is found as eg/bench2 in the AnyEvent
1356 distribution. 1523 distribution. It uses the AE interface, which makes a real difference
1524 for the EV and Perl backends only.
1357 1525
1358 Explanation of the columns 1526 Explanation of the columns
1359 *sockets* is the number of sockets, and twice the number of "servers" 1527 *sockets* is the number of sockets, and twice the number of "servers"
1360 (as each server has a read and write socket end). 1528 (as each server has a read and write socket end).
1361 1529
… …
1367 forwarding it to another server. This includes deleting the old timeout 1535 forwarding it to another server. This includes deleting the old timeout
1368 and creating a new one that moves the timeout into the future. 1536 and creating a new one that moves the timeout into the future.
1369 1537
1370 Results 1538 Results
1371 name sockets create request 1539 name sockets create request
1372 EV 20000 69.01 11.16 1540 EV 20000 62.66 7.99
1373 Perl 20000 73.32 35.87 1541 Perl 20000 68.32 32.64
1374 IOAsync 20000 157.00 98.14 epoll 1542 IOAsync 20000 174.06 101.15 epoll
1375 IOAsync 20000 159.31 616.06 poll 1543 IOAsync 20000 174.67 610.84 poll
1376 Event 20000 212.62 257.32 1544 Event 20000 202.69 242.91
1377 Glib 20000 651.16 1896.30 1545 Glib 20000 557.01 1689.52
1378 POE 20000 349.67 12317.24 uses POE::Loop::Event 1546 POE 20000 341.54 12086.32 uses POE::Loop::Event
1379 1547
1380 Discussion 1548 Discussion
1381 This benchmark *does* measure scalability and overall performance of the 1549 This benchmark *does* measure scalability and overall performance of the
1382 particular event loop. 1550 particular event loop.
1383 1551
… …
1512 SIGCHLD 1680 SIGCHLD
1513 A handler for "SIGCHLD" is installed by AnyEvent's child watcher 1681 A handler for "SIGCHLD" is installed by AnyEvent's child watcher
1514 emulation for event loops that do not support them natively. Also, 1682 emulation for event loops that do not support them natively. Also,
1515 some event loops install a similar handler. 1683 some event loops install a similar handler.
1516 1684
1517 If, when AnyEvent is loaded, SIGCHLD is set to IGNORE, then AnyEvent 1685 Additionally, when AnyEvent is loaded and SIGCHLD is set to IGNORE,
1518 will reset it to default, to avoid losing child exit statuses. 1686 then AnyEvent will reset it to default, to avoid losing child exit
1687 statuses.
1519 1688
1520 SIGPIPE 1689 SIGPIPE
1521 A no-op handler is installed for "SIGPIPE" when $SIG{PIPE} is 1690 A no-op handler is installed for "SIGPIPE" when $SIG{PIPE} is
1522 "undef" when AnyEvent gets loaded. 1691 "undef" when AnyEvent gets loaded.
1523 1692
… …
1531 it is that this way, the handler will be restored to defaults on 1700 it is that this way, the handler will be restored to defaults on
1532 exec. 1701 exec.
1533 1702
1534 Feel free to install your own handler, or reset it to defaults. 1703 Feel free to install your own handler, or reset it to defaults.
1535 1704
1705RECOMMENDED/OPTIONAL MODULES
1706 One of AnyEvent's main goals is to be 100% Pure-Perl(tm): only perl (and
1707 it's built-in modules) are required to use it.
1708
1709 That does not mean that AnyEvent won't take advantage of some additional
1710 modules if they are installed.
1711
1712 This section epxlains which additional modules will be used, and how
1713 they affect AnyEvent's operetion.
1714
1715 Async::Interrupt
1716 This slightly arcane module is used to implement fast signal
1717 handling: To my knowledge, there is no way to do completely
1718 race-free and quick signal handling in pure perl. To ensure that
1719 signals still get delivered, AnyEvent will start an interval timer
1720 to wake up perl (and catch the signals) with some delay (default is
1721 10 seconds, look for $AnyEvent::MAX_SIGNAL_LATENCY).
1722
1723 If this module is available, then it will be used to implement
1724 signal catching, which means that signals will not be delayed, and
1725 the event loop will not be interrupted regularly, which is more
1726 efficient (And good for battery life on laptops).
1727
1728 This affects not just the pure-perl event loop, but also other event
1729 loops that have no signal handling on their own (e.g. Glib, Tk, Qt).
1730
1731 Some event loops (POE, Event, Event::Lib) offer signal watchers
1732 natively, and either employ their own workarounds (POE) or use
1733 AnyEvent's workaround (using $AnyEvent::MAX_SIGNAL_LATENCY).
1734 Installing Async::Interrupt does nothing for those backends.
1735
1736 EV This module isn't really "optional", as it is simply one of the
1737 backend event loops that AnyEvent can use. However, it is simply the
1738 best event loop available in terms of features, speed and stability:
1739 It supports the AnyEvent API optimally, implements all the watcher
1740 types in XS, does automatic timer adjustments even when no monotonic
1741 clock is available, can take avdantage of advanced kernel interfaces
1742 such as "epoll" and "kqueue", and is the fastest backend *by far*.
1743 You can even embed Glib/Gtk2 in it (or vice versa, see EV::Glib and
1744 Glib::EV).
1745
1746 Guard
1747 The guard module, when used, will be used to implement
1748 "AnyEvent::Util::guard". This speeds up guards considerably (and
1749 uses a lot less memory), but otherwise doesn't affect guard
1750 operation much. It is purely used for performance.
1751
1752 JSON and JSON::XS
1753 This module is required when you want to read or write JSON data via
1754 AnyEvent::Handle. It is also written in pure-perl, but can take
1755 advantage of the ultra-high-speed JSON::XS module when it is
1756 installed.
1757
1758 In fact, AnyEvent::Handle will use JSON::XS by default if it is
1759 installed.
1760
1761 Net::SSLeay
1762 Implementing TLS/SSL in Perl is certainly interesting, but not very
1763 worthwhile: If this module is installed, then AnyEvent::Handle (with
1764 the help of AnyEvent::TLS), gains the ability to do TLS/SSL.
1765
1766 Time::HiRes
1767 This module is part of perl since release 5.008. It will be used
1768 when the chosen event library does not come with a timing source on
1769 it's own. The pure-perl event loop (AnyEvent::Impl::Perl) will
1770 additionally use it to try to use a monotonic clock for timing
1771 stability.
1772
1536FORK 1773FORK
1537 Most event libraries are not fork-safe. The ones who are usually are 1774 Most event libraries are not fork-safe. The ones who are usually are
1538 because they rely on inefficient but fork-safe "select" or "poll" calls. 1775 because they rely on inefficient but fork-safe "select" or "poll" calls.
1539 Only EV is fully fork-aware. 1776 Only EV is fully fork-aware.
1540 1777
1541 If you have to fork, you must either do so *before* creating your first 1778 If you have to fork, you must either do so *before* creating your first
1542 watcher OR you must not use AnyEvent at all in the child. 1779 watcher OR you must not use AnyEvent at all in the child OR you must do
1780 something completely out of the scope of AnyEvent.
1543 1781
1544SECURITY CONSIDERATIONS 1782SECURITY CONSIDERATIONS
1545 AnyEvent can be forced to load any event model via 1783 AnyEvent can be forced to load any event model via
1546 $ENV{PERL_ANYEVENT_MODEL}. While this cannot (to my knowledge) be used 1784 $ENV{PERL_ANYEVENT_MODEL}. While this cannot (to my knowledge) be used
1547 to execute arbitrary code or directly gain access, it can easily be used 1785 to execute arbitrary code or directly gain access, it can easily be used
… …
1578 Event modules: EV, EV::Glib, Glib::EV, Event, Glib::Event, Glib, Tk, 1816 Event modules: EV, EV::Glib, Glib::EV, Event, Glib::Event, Glib, Tk,
1579 Event::Lib, Qt, POE. 1817 Event::Lib, Qt, POE.
1580 1818
1581 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event, 1819 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event,
1582 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl, 1820 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl,
1583 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE. 1821 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE,
1822 AnyEvent::Impl::IOAsync, Anyevent::Impl::Irssi.
1584 1823
1585 Non-blocking file handles, sockets, TCP clients and servers: 1824 Non-blocking file handles, sockets, TCP clients and servers:
1586 AnyEvent::Handle, AnyEvent::Socket. 1825 AnyEvent::Handle, AnyEvent::Socket, AnyEvent::TLS.
1587 1826
1588 Asynchronous DNS: AnyEvent::DNS. 1827 Asynchronous DNS: AnyEvent::DNS.
1589 1828
1590 Coroutine support: Coro, Coro::AnyEvent, Coro::EV, Coro::Event, 1829 Coroutine support: Coro, Coro::AnyEvent, Coro::EV, Coro::Event,
1591 1830
1592 Nontrivial usage examples: Net::FCP, Net::XMPP2, AnyEvent::DNS. 1831 Nontrivial usage examples: AnyEvent::GPSD, AnyEvent::XMPP,
1832 AnyEvent::HTTP.
1593 1833
1594AUTHOR 1834AUTHOR
1595 Marc Lehmann <schmorp@schmorp.de> 1835 Marc Lehmann <schmorp@schmorp.de>
1596 http://home.schmorp.de/ 1836 http://home.schmorp.de/
1597 1837

Diff Legend

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