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.206 by root, Mon Apr 20 14:34:18 2009 UTC vs.
Revision 1.232 by root, Thu Jul 9 01:08:22 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - provide framework for multiple event loops 3AnyEvent - provide framework for multiple event loops
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Qt, POE - various supported event loops 5EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
6event loops.
6 7
7=head1 SYNOPSIS 8=head1 SYNOPSIS
8 9
9 use AnyEvent; 10 use AnyEvent;
10 11
12 # file descriptor readable
11 my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub { ... }); 13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
12 14
15 # one-shot or repeating timers
13 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
14 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
15 18
16 print AnyEvent->now; # prints current event loop time 19 print AnyEvent->now; # prints current event loop time
17 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time. 20 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
18 21
22 # POSIX signal
19 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... }); 23 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
20 24
25 # child process exit
21 my $w = AnyEvent->child (pid => $pid, cb => sub { 26 my $w = AnyEvent->child (pid => $pid, cb => sub {
22 my ($pid, $status) = @_; 27 my ($pid, $status) = @_;
23 ... 28 ...
24 }); 29 });
30
31 # called when event loop idle (if applicable)
32 my $w = AnyEvent->idle (cb => sub { ... });
25 33
26 my $w = AnyEvent->condvar; # stores whether a condition was flagged 34 my $w = AnyEvent->condvar; # stores whether a condition was flagged
27 $w->send; # wake up current and all future recv's 35 $w->send; # wake up current and all future recv's
28 $w->recv; # enters "main loop" till $condvar gets ->send 36 $w->recv; # enters "main loop" till $condvar gets ->send
29 # use a condvar in callback mode: 37 # use a condvar in callback mode:
… …
168=head2 I/O WATCHERS 176=head2 I/O WATCHERS
169 177
170You can create an I/O watcher by calling the C<< AnyEvent->io >> method 178You can create an I/O watcher by calling the C<< AnyEvent->io >> method
171with the following mandatory key-value pairs as arguments: 179with the following mandatory key-value pairs as arguments:
172 180
173C<fh> is the Perl I<file handle> (I<not> file descriptor) to watch 181C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch
174for events (AnyEvent might or might not keep a reference to this file 182for events (AnyEvent might or might not keep a reference to this file
175handle). Note that only file handles pointing to things for which 183handle). Note that only file handles pointing to things for which
176non-blocking operation makes sense are allowed. This includes sockets, 184non-blocking operation makes sense are allowed. This includes sockets,
177most character devices, pipes, fifos and so on, but not for example files 185most character devices, pipes, fifos and so on, but not for example files
178or block devices. 186or block devices.
… …
384 392
385There is a slight catch to child watchers, however: you usually start them 393There is a slight catch to child watchers, however: you usually start them
386I<after> the child process was created, and this means the process could 394I<after> the child process was created, and this means the process could
387have exited already (and no SIGCHLD will be sent anymore). 395have exited already (and no SIGCHLD will be sent anymore).
388 396
389Not all event models handle this correctly (POE doesn't), but even for 397Not all event models handle this correctly (neither POE nor IO::Async do,
398see their AnyEvent::Impl manpages for details), but even for event models
390event models that I<do> handle this correctly, they usually need to be 399that I<do> handle this correctly, they usually need to be loaded before
391loaded before the process exits (i.e. before you fork in the first place). 400the process exits (i.e. before you fork in the first place). AnyEvent's
401pure perl event loop handles all cases correctly regardless of when you
402start the watcher.
392 403
393This means you cannot create a child watcher as the very first thing in an 404This means you cannot create a child watcher as the very first
394AnyEvent program, you I<have> to create at least one watcher before you 405thing in an AnyEvent program, you I<have> to create at least one
395C<fork> the child (alternatively, you can call C<AnyEvent::detect>). 406watcher before you C<fork> the child (alternatively, you can call
407C<AnyEvent::detect>).
396 408
397Example: fork a process and wait for it 409Example: fork a process and wait for it
398 410
399 my $done = AnyEvent->condvar; 411 my $done = AnyEvent->condvar;
400 412
… …
410 ); 422 );
411 423
412 # do something else, then wait for process exit 424 # do something else, then wait for process exit
413 $done->recv; 425 $done->recv;
414 426
427=head2 IDLE WATCHERS
428
429Sometimes there is a need to do something, but it is not so important
430to do it instantly, but only when there is nothing better to do. This
431"nothing better to do" is usually defined to be "no other events need
432attention by the event loop".
433
434Idle watchers ideally get invoked when the event loop has nothing
435better to do, just before it would block the process to wait for new
436events. Instead of blocking, the idle watcher is invoked.
437
438Most event loops unfortunately do not really support idle watchers (only
439EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
440will simply call the callback "from time to time".
441
442Example: read lines from STDIN, but only process them when the
443program is otherwise idle:
444
445 my @lines; # read data
446 my $idle_w;
447 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
448 push @lines, scalar <STDIN>;
449
450 # start an idle watcher, if not already done
451 $idle_w ||= AnyEvent->idle (cb => sub {
452 # handle only one line, when there are lines left
453 if (my $line = shift @lines) {
454 print "handled when idle: $line";
455 } else {
456 # otherwise disable the idle watcher again
457 undef $idle_w;
458 }
459 });
460 });
461
415=head2 CONDITION VARIABLES 462=head2 CONDITION VARIABLES
416 463
417If you are familiar with some event loops you will know that all of them 464If you are familiar with some event loops you will know that all of them
418require you to run some blocking "loop", "run" or similar function that 465require you to run some blocking "loop", "run" or similar function that
419will actively watch for new events and call your callbacks. 466will actively watch for new events and call your callbacks.
… …
552 599
553=item $cv->begin ([group callback]) 600=item $cv->begin ([group callback])
554 601
555=item $cv->end 602=item $cv->end
556 603
557These two methods are EXPERIMENTAL and MIGHT CHANGE.
558
559These two methods can be used to combine many transactions/events into 604These two methods can be used to combine many transactions/events into
560one. For example, a function that pings many hosts in parallel might want 605one. For example, a function that pings many hosts in parallel might want
561to use a condition variable for the whole process. 606to use a condition variable for the whole process.
562 607
563Every call to C<< ->begin >> will increment a counter, and every call to 608Every call to C<< ->begin >> will increment a counter, and every call to
564C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end 609C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end
565>>, the (last) callback passed to C<begin> will be executed. That callback 610>>, the (last) callback passed to C<begin> will be executed. That callback
566is I<supposed> to call C<< ->send >>, but that is not required. If no 611is I<supposed> to call C<< ->send >>, but that is not required. If no
567callback was set, C<send> will be called without any arguments. 612callback was set, C<send> will be called without any arguments.
568 613
569Let's clarify this with the ping example: 614You can think of C<< $cv->send >> giving you an OR condition (one call
615sends), while C<< $cv->begin >> and C<< $cv->end >> giving you an AND
616condition (all C<begin> calls must be C<end>'ed before the condvar sends).
617
618Let's start with a simple example: you have two I/O watchers (for example,
619STDOUT and STDERR for a program), and you want to wait for both streams to
620close before activating a condvar:
621
622 my $cv = AnyEvent->condvar;
623
624 $cv->begin; # first watcher
625 my $w1 = AnyEvent->io (fh => $fh1, cb => sub {
626 defined sysread $fh1, my $buf, 4096
627 or $cv->end;
628 });
629
630 $cv->begin; # second watcher
631 my $w2 = AnyEvent->io (fh => $fh2, cb => sub {
632 defined sysread $fh2, my $buf, 4096
633 or $cv->end;
634 });
635
636 $cv->recv;
637
638This works because for every event source (EOF on file handle), there is
639one call to C<begin>, so the condvar waits for all calls to C<end> before
640sending.
641
642The ping example mentioned above is slightly more complicated, as the
643there are results to be passwd back, and the number of tasks that are
644begung can potentially be zero:
570 645
571 my $cv = AnyEvent->condvar; 646 my $cv = AnyEvent->condvar;
572 647
573 my %result; 648 my %result;
574 $cv->begin (sub { $cv->send (\%result) }); 649 $cv->begin (sub { $cv->send (\%result) });
… …
594loop, which serves two important purposes: first, it sets the callback 669loop, which serves two important purposes: first, it sets the callback
595to be called once the counter reaches C<0>, and second, it ensures that 670to be called once the counter reaches C<0>, and second, it ensures that
596C<send> is called even when C<no> hosts are being pinged (the loop 671C<send> is called even when C<no> hosts are being pinged (the loop
597doesn't execute once). 672doesn't execute once).
598 673
599This is the general pattern when you "fan out" into multiple subrequests: 674This is the general pattern when you "fan out" into multiple (but
600use an outer C<begin>/C<end> pair to set the callback and ensure C<end> 675potentially none) subrequests: use an outer C<begin>/C<end> pair to set
601is called at least once, and then, for each subrequest you start, call 676the callback and ensure C<end> is called at least once, and then, for each
602C<begin> and for each subrequest you finish, call C<end>. 677subrequest you start, call C<begin> and for each subrequest you finish,
678call C<end>.
603 679
604=back 680=back
605 681
606=head3 METHODS FOR CONSUMERS 682=head3 METHODS FOR CONSUMERS
607 683
… …
664variable itself. Calling C<recv> inside the callback or at any later time 740variable itself. Calling C<recv> inside the callback or at any later time
665is guaranteed not to block. 741is guaranteed not to block.
666 742
667=back 743=back
668 744
745=head1 SUPPORTED EVENT LOOPS/BACKENDS
746
747The available backend classes are (every class has its own manpage):
748
749=over 4
750
751=item Backends that are autoprobed when no other event loop can be found.
752
753EV is the preferred backend when no other event loop seems to be in
754use. If EV is not installed, then AnyEvent will try Event, and, failing
755that, will fall back to its own pure-perl implementation, which is
756available everywhere as it comes with AnyEvent itself.
757
758 AnyEvent::Impl::EV based on EV (interface to libev, best choice).
759 AnyEvent::Impl::Event based on Event, very stable, few glitches.
760 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
761
762=item Backends that are transparently being picked up when they are used.
763
764These will be used when they are currently loaded when the first watcher
765is created, in which case it is assumed that the application is using
766them. This means that AnyEvent will automatically pick the right backend
767when the main program loads an event module before anything starts to
768create watchers. Nothing special needs to be done by the main program.
769
770 AnyEvent::Impl::Glib based on Glib, slow but very stable.
771 AnyEvent::Impl::Tk based on Tk, very broken.
772 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
773 AnyEvent::Impl::POE based on POE, very slow, some limitations.
774
775=item Backends with special needs.
776
777Qt requires the Qt::Application to be instantiated first, but will
778otherwise be picked up automatically. As long as the main program
779instantiates the application before any AnyEvent watchers are created,
780everything should just work.
781
782 AnyEvent::Impl::Qt based on Qt.
783
784Support for IO::Async can only be partial, as it is too broken and
785architecturally limited to even support the AnyEvent API. It also
786is the only event loop that needs the loop to be set explicitly, so
787it can only be used by a main program knowing about AnyEvent. See
788L<AnyEvent::Impl::Async> for the gory details.
789
790 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed.
791
792=item Event loops that are indirectly supported via other backends.
793
794Some event loops can be supported via other modules:
795
796There is no direct support for WxWidgets (L<Wx>) or L<Prima>.
797
798B<WxWidgets> has no support for watching file handles. However, you can
799use WxWidgets through the POE adaptor, as POE has a Wx backend that simply
800polls 20 times per second, which was considered to be too horrible to even
801consider for AnyEvent.
802
803B<Prima> is not supported as nobody seems to be using it, but it has a POE
804backend, so it can be supported through POE.
805
806AnyEvent knows about both L<Prima> and L<Wx>, however, and will try to
807load L<POE> when detecting them, in the hope that POE will pick them up,
808in which case everything will be automatic.
809
810=back
811
669=head1 GLOBAL VARIABLES AND FUNCTIONS 812=head1 GLOBAL VARIABLES AND FUNCTIONS
670 813
671=over 4 814=over 4
672 815
673=item $AnyEvent::MODEL 816=item $AnyEvent::MODEL
… …
675Contains C<undef> until the first watcher is being created. Then it 818Contains C<undef> until the first watcher is being created. Then it
676contains the event model that is being used, which is the name of the 819contains the event model that is being used, which is the name of the
677Perl class implementing the model. This class is usually one of the 820Perl class implementing the model. This class is usually one of the
678C<AnyEvent::Impl:xxx> modules, but can be any other class in the case 821C<AnyEvent::Impl:xxx> modules, but can be any other class in the case
679AnyEvent has been extended at runtime (e.g. in I<rxvt-unicode>). 822AnyEvent has been extended at runtime (e.g. in I<rxvt-unicode>).
680
681The known classes so far are:
682
683 AnyEvent::Impl::EV based on EV (an interface to libev, best choice).
684 AnyEvent::Impl::Event based on Event, second best choice.
685 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
686 AnyEvent::Impl::Glib based on Glib, third-best choice.
687 AnyEvent::Impl::Tk based on Tk, very bad choice.
688 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
689 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
690 AnyEvent::Impl::POE based on POE, not generic enough for full support.
691
692There is no support for WxWidgets, as WxWidgets has no support for
693watching file handles. However, you can use WxWidgets through the
694POE Adaptor, as POE has a Wx backend that simply polls 20 times per
695second, which was considered to be too horrible to even consider for
696AnyEvent. Likewise, other POE backends can be used by AnyEvent by using
697it's adaptor.
698
699AnyEvent knows about L<Prima> and L<Wx> and will try to use L<POE> when
700autodetecting them.
701 823
702=item AnyEvent::detect 824=item AnyEvent::detect
703 825
704Returns C<$AnyEvent::MODEL>, forcing autodetection of the event model 826Returns C<$AnyEvent::MODEL>, forcing autodetection of the event model
705if necessary. You should only call this function right before you would 827if necessary. You should only call this function right before you would
… …
788 910
789 911
790=head1 OTHER MODULES 912=head1 OTHER MODULES
791 913
792The following is a non-exhaustive list of additional modules that use 914The following is a non-exhaustive list of additional modules that use
793AnyEvent and can therefore be mixed easily with other AnyEvent modules 915AnyEvent as a client and can therefore be mixed easily with other AnyEvent
794in the same program. Some of the modules come with AnyEvent, some are 916modules and other event loops in the same program. Some of the modules
795available via CPAN. 917come with AnyEvent, most are available via CPAN.
796 918
797=over 4 919=over 4
798 920
799=item L<AnyEvent::Util> 921=item L<AnyEvent::Util>
800 922
… …
809 931
810=item L<AnyEvent::Handle> 932=item L<AnyEvent::Handle>
811 933
812Provide read and write buffers, manages watchers for reads and writes, 934Provide read and write buffers, manages watchers for reads and writes,
813supports raw and formatted I/O, I/O queued and fully transparent and 935supports raw and formatted I/O, I/O queued and fully transparent and
814non-blocking SSL/TLS. 936non-blocking SSL/TLS (via L<AnyEvent::TLS>.
815 937
816=item L<AnyEvent::DNS> 938=item L<AnyEvent::DNS>
817 939
818Provides rich asynchronous DNS resolver capabilities. 940Provides rich asynchronous DNS resolver capabilities.
819 941
… …
847 969
848=item L<AnyEvent::GPSD> 970=item L<AnyEvent::GPSD>
849 971
850A non-blocking interface to gpsd, a daemon delivering GPS information. 972A non-blocking interface to gpsd, a daemon delivering GPS information.
851 973
974=item L<AnyEvent::IRC>
975
976AnyEvent based IRC client module family (replacing the older Net::IRC3).
977
978=item L<AnyEvent::XMPP>
979
980AnyEvent based XMPP (Jabber protocol) module family (replacing the older
981Net::XMPP2>.
982
852=item L<AnyEvent::IGS> 983=item L<AnyEvent::IGS>
853 984
854A non-blocking interface to the Internet Go Server protocol (used by 985A non-blocking interface to the Internet Go Server protocol (used by
855L<App::IGS>). 986L<App::IGS>).
856 987
857=item L<AnyEvent::IRC>
858
859AnyEvent based IRC client module family (replacing the older Net::IRC3).
860
861=item L<Net::XMPP2>
862
863AnyEvent based XMPP (Jabber protocol) module family.
864
865=item L<Net::FCP> 988=item L<Net::FCP>
866 989
867AnyEvent-based implementation of the Freenet Client Protocol, birthplace 990AnyEvent-based implementation of the Freenet Client Protocol, birthplace
868of AnyEvent. 991of AnyEvent.
869 992
… …
873 996
874=item L<Coro> 997=item L<Coro>
875 998
876Has special support for AnyEvent via L<Coro::AnyEvent>. 999Has special support for AnyEvent via L<Coro::AnyEvent>.
877 1000
878=item L<IO::Lambda>
879
880The lambda approach to I/O - don't ask, look there. Can use AnyEvent.
881
882=back 1001=back
883 1002
884=cut 1003=cut
885 1004
886package AnyEvent; 1005package AnyEvent;
… …
888no warnings; 1007no warnings;
889use strict qw(vars subs); 1008use strict qw(vars subs);
890 1009
891use Carp; 1010use Carp;
892 1011
893our $VERSION = 4.352; 1012our $VERSION = 4.801;
894our $MODEL; 1013our $MODEL;
895 1014
896our $AUTOLOAD; 1015our $AUTOLOAD;
897our @ISA; 1016our @ISA;
898 1017
899our @REGISTRY; 1018our @REGISTRY;
900 1019
901our $WIN32; 1020our $WIN32;
902 1021
903BEGIN { 1022BEGIN {
904 my $win32 = ! ! ($^O =~ /mswin32/i); 1023 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";
905 eval "sub WIN32(){ $win32 }"; 1024 eval "sub TAINT(){ " . (${^TAINT}*1) . " }";
1025
1026 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1027 if ${^TAINT};
906} 1028}
907 1029
908our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1030our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
909 1031
910our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 1032our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
… …
921 [Event:: => AnyEvent::Impl::Event::], 1043 [Event:: => AnyEvent::Impl::Event::],
922 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl::], 1044 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl::],
923 # everything below here will not be autoprobed 1045 # everything below here will not be autoprobed
924 # as the pureperl backend should work everywhere 1046 # as the pureperl backend should work everywhere
925 # and is usually faster 1047 # and is usually faster
926 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
927 [Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers 1048 [Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers
928 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1049 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1050 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1051 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
929 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1052 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
930 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
931 [Wx:: => AnyEvent::Impl::POE::], 1053 [Wx:: => AnyEvent::Impl::POE::],
932 [Prima:: => AnyEvent::Impl::POE::], 1054 [Prima:: => AnyEvent::Impl::POE::],
1055 # IO::Async is just too broken - we would need workarounds for its
1056 # byzantine signal and broken child handling, among others.
1057 # IO::Async is rather hard to detect, as it doesn't have any
1058 # obvious default class.
1059# [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
1060# [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
1061# [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
933); 1062);
934 1063
935our %method = map +($_ => 1), 1064our %method = map +($_ => 1),
936 qw(io timer time now now_update signal child condvar one_event DESTROY); 1065 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
937 1066
938our @post_detect; 1067our @post_detect;
939 1068
940sub post_detect(&) { 1069sub post_detect(&) {
941 my ($cb) = @_; 1070 my ($cb) = @_;
… …
946 1 1075 1
947 } else { 1076 } else {
948 push @post_detect, $cb; 1077 push @post_detect, $cb;
949 1078
950 defined wantarray 1079 defined wantarray
951 ? bless \$cb, "AnyEvent::Util::PostDetect" 1080 ? bless \$cb, "AnyEvent::Util::postdetect"
952 : () 1081 : ()
953 } 1082 }
954} 1083}
955 1084
956sub AnyEvent::Util::PostDetect::DESTROY { 1085sub AnyEvent::Util::postdetect::DESTROY {
957 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1086 @post_detect = grep $_ != ${$_[0]}, @post_detect;
958} 1087}
959 1088
960sub detect() { 1089sub detect() {
961 unless ($MODEL) { 1090 unless ($MODEL) {
… …
1029} 1158}
1030 1159
1031# utility function to dup a filehandle. this is used by many backends 1160# utility function to dup a filehandle. this is used by many backends
1032# to support binding more than one watcher per filehandle (they usually 1161# to support binding more than one watcher per filehandle (they usually
1033# allow only one watcher per fd, so we dup it to get a different one). 1162# allow only one watcher per fd, so we dup it to get a different one).
1034sub _dupfh($$$$) { 1163sub _dupfh($$;$$) {
1035 my ($poll, $fh, $r, $w) = @_; 1164 my ($poll, $fh, $r, $w) = @_;
1036 1165
1037 # cygwin requires the fh mode to be matching, unix doesn't 1166 # cygwin requires the fh mode to be matching, unix doesn't
1038 my ($rw, $mode) = $poll eq "r" ? ($r, "<") 1167 my ($rw, $mode) = $poll eq "r" ? ($r, "<") : ($w, ">");
1039 : $poll eq "w" ? ($w, ">")
1040 : Carp::croak "AnyEvent->io requires poll set to either 'r' or 'w'";
1041 1168
1042 open my $fh2, "$mode&" . fileno $fh 1169 open my $fh2, "$mode&", $fh
1043 or die "cannot dup() filehandle: $!,"; 1170 or die "AnyEvent->io: cannot dup() filehandle in mode '$poll': $!,";
1044 1171
1045 # we assume CLOEXEC is already set by perl in all important cases 1172 # we assume CLOEXEC is already set by perl in all important cases
1046 1173
1047 ($fh2, $rw) 1174 ($fh2, $rw)
1048} 1175}
… …
1050package AnyEvent::Base; 1177package AnyEvent::Base;
1051 1178
1052# default implementations for many methods 1179# default implementations for many methods
1053 1180
1054BEGIN { 1181BEGIN {
1055 if (eval "use Time::HiRes (); time (); 1") { 1182 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1056 *_time = \&Time::HiRes::time; 1183 *_time = \&Time::HiRes::time;
1057 # if (eval "use POSIX (); (POSIX::times())... 1184 # if (eval "use POSIX (); (POSIX::times())...
1058 } else { 1185 } else {
1059 *_time = sub { time }; # epic fail 1186 *_time = sub { time }; # epic fail
1060 } 1187 }
… …
1065sub now_update { } 1192sub now_update { }
1066 1193
1067# default implementation for ->condvar 1194# default implementation for ->condvar
1068 1195
1069sub condvar { 1196sub condvar {
1070 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1197 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1071} 1198}
1072 1199
1073# default implementation for ->signal 1200# default implementation for ->signal
1074 1201
1075our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1202our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
… …
1099 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case 1226 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1100 } else { 1227 } else {
1101 pipe $SIGPIPE_R, $SIGPIPE_W; 1228 pipe $SIGPIPE_R, $SIGPIPE_W;
1102 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1229 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1103 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1230 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1231
1232 # not strictly required, as $^F is normally 2, but let's make sure...
1233 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1234 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1104 } 1235 }
1105 1236
1106 $SIGPIPE_R 1237 $SIGPIPE_R
1107 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1238 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1108
1109 # not strictly required, as $^F is normally 2, but let's make sure...
1110 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1111 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1112 1239
1113 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec); 1240 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1114 } 1241 }
1115 1242
1116 my $signal = uc $arg{signal} 1243 my $signal = uc $arg{signal}
… …
1121 local $!; 1248 local $!;
1122 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1249 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1123 undef $SIG_EV{$signal}; 1250 undef $SIG_EV{$signal};
1124 }; 1251 };
1125 1252
1126 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1253 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1127} 1254}
1128 1255
1129sub AnyEvent::Base::Signal::DESTROY { 1256sub AnyEvent::Base::signal::DESTROY {
1130 my ($signal, $cb) = @{$_[0]}; 1257 my ($signal, $cb) = @{$_[0]};
1131 1258
1132 delete $SIG_CB{$signal}{$cb}; 1259 delete $SIG_CB{$signal}{$cb};
1133 1260
1261 # delete doesn't work with older perls - they then
1262 # print weird messages, or just unconditionally exit
1263 # instead of getting the default action.
1134 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1264 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1135} 1265}
1136 1266
1137# default implementation for ->child 1267# default implementation for ->child
1138 1268
1139our %PID_CB; 1269our %PID_CB;
1140our $CHLD_W; 1270our $CHLD_W;
1141our $CHLD_DELAY_W; 1271our $CHLD_DELAY_W;
1142our $PID_IDLE;
1143our $WNOHANG; 1272our $WNOHANG;
1144 1273
1145sub _child_wait { 1274sub _sigchld {
1146 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1275 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1147 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1276 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1148 (values %{ $PID_CB{0} || {} }); 1277 (values %{ $PID_CB{0} || {} });
1149 } 1278 }
1150
1151 undef $PID_IDLE;
1152}
1153
1154sub _sigchld {
1155 # make sure we deliver these changes "synchronous" with the event loop.
1156 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1157 undef $CHLD_DELAY_W;
1158 &_child_wait;
1159 });
1160} 1279}
1161 1280
1162sub child { 1281sub child {
1163 my (undef, %arg) = @_; 1282 my (undef, %arg) = @_;
1164 1283
1165 defined (my $pid = $arg{pid} + 0) 1284 defined (my $pid = $arg{pid} + 0)
1166 or Carp::croak "required option 'pid' is missing"; 1285 or Carp::croak "required option 'pid' is missing";
1167 1286
1168 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1287 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1169 1288
1170 unless ($WNOHANG) {
1171 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1289 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1172 }
1173 1290
1174 unless ($CHLD_W) { 1291 unless ($CHLD_W) {
1175 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1292 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1176 # child could be a zombie already, so make at least one round 1293 # child could be a zombie already, so make at least one round
1177 &_sigchld; 1294 &_sigchld;
1178 } 1295 }
1179 1296
1180 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1297 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1181} 1298}
1182 1299
1183sub AnyEvent::Base::Child::DESTROY { 1300sub AnyEvent::Base::child::DESTROY {
1184 my ($pid, $cb) = @{$_[0]}; 1301 my ($pid, $cb) = @{$_[0]};
1185 1302
1186 delete $PID_CB{$pid}{$cb}; 1303 delete $PID_CB{$pid}{$cb};
1187 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1304 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1188 1305
1189 undef $CHLD_W unless keys %PID_CB; 1306 undef $CHLD_W unless keys %PID_CB;
1307}
1308
1309# idle emulation is done by simply using a timer, regardless
1310# of whether the process is idle or not, and not letting
1311# the callback use more than 50% of the time.
1312sub idle {
1313 my (undef, %arg) = @_;
1314
1315 my ($cb, $w, $rcb) = $arg{cb};
1316
1317 $rcb = sub {
1318 if ($cb) {
1319 $w = _time;
1320 &$cb;
1321 $w = _time - $w;
1322
1323 # never use more then 50% of the time for the idle watcher,
1324 # within some limits
1325 $w = 0.0001 if $w < 0.0001;
1326 $w = 5 if $w > 5;
1327
1328 $w = AnyEvent->timer (after => $w, cb => $rcb);
1329 } else {
1330 # clean up...
1331 undef $w;
1332 undef $rcb;
1333 }
1334 };
1335
1336 $w = AnyEvent->timer (after => 0.05, cb => $rcb);
1337
1338 bless \\$cb, "AnyEvent::Base::idle"
1339}
1340
1341sub AnyEvent::Base::idle::DESTROY {
1342 undef $${$_[0]};
1190} 1343}
1191 1344
1192package AnyEvent::CondVar; 1345package AnyEvent::CondVar;
1193 1346
1194our @ISA = AnyEvent::CondVar::Base::; 1347our @ISA = AnyEvent::CondVar::Base::;
… …
1268so on. 1421so on.
1269 1422
1270=head1 ENVIRONMENT VARIABLES 1423=head1 ENVIRONMENT VARIABLES
1271 1424
1272The following environment variables are used by this module or its 1425The following environment variables are used by this module or its
1273submodules: 1426submodules.
1427
1428Note that AnyEvent will remove I<all> environment variables starting with
1429C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
1430enabled.
1274 1431
1275=over 4 1432=over 4
1276 1433
1277=item C<PERL_ANYEVENT_VERBOSE> 1434=item C<PERL_ANYEVENT_VERBOSE>
1278 1435
… …
1290=item C<PERL_ANYEVENT_STRICT> 1447=item C<PERL_ANYEVENT_STRICT>
1291 1448
1292AnyEvent does not do much argument checking by default, as thorough 1449AnyEvent does not do much argument checking by default, as thorough
1293argument checking is very costly. Setting this variable to a true value 1450argument checking is very costly. Setting this variable to a true value
1294will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly 1451will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
1295check the arguments passed to most method calls. If it finds any problems 1452check the arguments passed to most method calls. If it finds any problems,
1296it will croak. 1453it will croak.
1297 1454
1298In other words, enables "strict" mode. 1455In other words, enables "strict" mode.
1299 1456
1300Unlike C<use strict>, it is definitely recommended ot keep it off in 1457Unlike C<use strict>, it is definitely recommended to keep it off in
1301production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while 1458production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while
1302developing programs can be very useful, however. 1459developing programs can be very useful, however.
1303 1460
1304=item C<PERL_ANYEVENT_MODEL> 1461=item C<PERL_ANYEVENT_MODEL>
1305 1462
… …
1350 1507
1351=item C<PERL_ANYEVENT_MAX_FORKS> 1508=item C<PERL_ANYEVENT_MAX_FORKS>
1352 1509
1353The maximum number of child processes that C<AnyEvent::Util::fork_call> 1510The maximum number of child processes that C<AnyEvent::Util::fork_call>
1354will create in parallel. 1511will create in parallel.
1512
1513=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
1514
1515The default value for the C<max_outstanding> parameter for the default DNS
1516resolver - this is the maximum number of parallel DNS requests that are
1517sent to the DNS server.
1518
1519=item C<PERL_ANYEVENT_RESOLV_CONF>
1520
1521The file to use instead of F</etc/resolv.conf> (or OS-specific
1522configuration) in the default resolver. When set to the empty string, no
1523default config will be used.
1524
1525=item C<PERL_ANYEVENT_CA_FILE>, C<PERL_ANYEVENT_CA_PATH>.
1526
1527When neither C<ca_file> nor C<ca_path> was specified during
1528L<AnyEvent::TLS> context creation, and either of these environment
1529variables exist, they will be used to specify CA certificate locations
1530instead of a system-dependent default.
1355 1531
1356=back 1532=back
1357 1533
1358=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE 1534=head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1359 1535
… …
1604 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers 1780 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers
1605 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal 1781 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal
1606 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation 1782 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation
1607 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 1783 Event/Event 16000 517 32.20 31.80 0.81 Event native interface
1608 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 1784 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers
1785 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll
1786 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll
1609 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 1787 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour
1610 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 1788 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers
1611 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 1789 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event
1612 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select 1790 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select
1613 1791
… …
1642performance becomes really bad with lots of file descriptors (and few of 1820performance becomes really bad with lots of file descriptors (and few of
1643them active), of course, but this was not subject of this benchmark. 1821them active), of course, but this was not subject of this benchmark.
1644 1822
1645The C<Event> module has a relatively high setup and callback invocation 1823The C<Event> module has a relatively high setup and callback invocation
1646cost, but overall scores in on the third place. 1824cost, but overall scores in on the third place.
1825
1826C<IO::Async> performs admirably well, about on par with C<Event>, even
1827when using its pure perl backend.
1647 1828
1648C<Glib>'s memory usage is quite a bit higher, but it features a 1829C<Glib>'s memory usage is quite a bit higher, but it features a
1649faster callback invocation and overall ends up in the same class as 1830faster callback invocation and overall ends up in the same class as
1650C<Event>. However, Glib scales extremely badly, doubling the number of 1831C<Event>. However, Glib scales extremely badly, doubling the number of
1651watchers increases the processing time by more than a factor of four, 1832watchers increases the processing time by more than a factor of four,
… …
1729it to another server. This includes deleting the old timeout and creating 1910it to another server. This includes deleting the old timeout and creating
1730a new one that moves the timeout into the future. 1911a new one that moves the timeout into the future.
1731 1912
1732=head3 Results 1913=head3 Results
1733 1914
1734 name sockets create request 1915 name sockets create request
1735 EV 20000 69.01 11.16 1916 EV 20000 69.01 11.16
1736 Perl 20000 73.32 35.87 1917 Perl 20000 73.32 35.87
1918 IOAsync 20000 157.00 98.14 epoll
1919 IOAsync 20000 159.31 616.06 poll
1737 Event 20000 212.62 257.32 1920 Event 20000 212.62 257.32
1738 Glib 20000 651.16 1896.30 1921 Glib 20000 651.16 1896.30
1739 POE 20000 349.67 12317.24 uses POE::Loop::Event 1922 POE 20000 349.67 12317.24 uses POE::Loop::Event
1740 1923
1741=head3 Discussion 1924=head3 Discussion
1742 1925
1743This benchmark I<does> measure scalability and overall performance of the 1926This benchmark I<does> measure scalability and overall performance of the
1744particular event loop. 1927particular event loop.
… …
1746EV is again fastest. Since it is using epoll on my system, the setup time 1929EV is again fastest. Since it is using epoll on my system, the setup time
1747is relatively high, though. 1930is relatively high, though.
1748 1931
1749Perl surprisingly comes second. It is much faster than the C-based event 1932Perl surprisingly comes second. It is much faster than the C-based event
1750loops Event and Glib. 1933loops Event and Glib.
1934
1935IO::Async performs very well when using its epoll backend, and still quite
1936good compared to Glib when using its pure perl backend.
1751 1937
1752Event suffers from high setup time as well (look at its code and you will 1938Event suffers from high setup time as well (look at its code and you will
1753understand why). Callback invocation also has a high overhead compared to 1939understand why). Callback invocation also has a high overhead compared to
1754the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event 1940the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event
1755uses select or poll in basically all documented configurations. 1941uses select or poll in basically all documented configurations.
… …
1818=item * C-based event loops perform very well with small number of 2004=item * C-based event loops perform very well with small number of
1819watchers, as the management overhead dominates. 2005watchers, as the management overhead dominates.
1820 2006
1821=back 2007=back
1822 2008
2009=head2 THE IO::Lambda BENCHMARK
2010
2011Recently I was told about the benchmark in the IO::Lambda manpage, which
2012could be misinterpreted to make AnyEvent look bad. In fact, the benchmark
2013simply compares IO::Lambda with POE, and IO::Lambda looks better (which
2014shouldn't come as a surprise to anybody). As such, the benchmark is
2015fine, and mostly shows that the AnyEvent backend from IO::Lambda isn't
2016very optimal. But how would AnyEvent compare when used without the extra
2017baggage? To explore this, I wrote the equivalent benchmark for AnyEvent.
2018
2019The benchmark itself creates an echo-server, and then, for 500 times,
2020connects to the echo server, sends a line, waits for the reply, and then
2021creates the next connection. This is a rather bad benchmark, as it doesn't
2022test the efficiency of the framework or much non-blocking I/O, but it is a
2023benchmark nevertheless.
2024
2025 name runtime
2026 Lambda/select 0.330 sec
2027 + optimized 0.122 sec
2028 Lambda/AnyEvent 0.327 sec
2029 + optimized 0.138 sec
2030 Raw sockets/select 0.077 sec
2031 POE/select, components 0.662 sec
2032 POE/select, raw sockets 0.226 sec
2033 POE/select, optimized 0.404 sec
2034
2035 AnyEvent/select/nb 0.085 sec
2036 AnyEvent/EV/nb 0.068 sec
2037 +state machine 0.134 sec
2038
2039The benchmark is also a bit unfair (my fault): the IO::Lambda/POE
2040benchmarks actually make blocking connects and use 100% blocking I/O,
2041defeating the purpose of an event-based solution. All of the newly
2042written AnyEvent benchmarks use 100% non-blocking connects (using
2043AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
2044resolver), so AnyEvent is at a disadvantage here, as non-blocking connects
2045generally require a lot more bookkeeping and event handling than blocking
2046connects (which involve a single syscall only).
2047
2048The last AnyEvent benchmark additionally uses L<AnyEvent::Handle>, which
2049offers similar expressive power as POE and IO::Lambda, using conventional
2050Perl syntax. This means that both the echo server and the client are 100%
2051non-blocking, further placing it at a disadvantage.
2052
2053As you can see, the AnyEvent + EV combination even beats the
2054hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
2055backend easily beats IO::Lambda and POE.
2056
2057And even the 100% non-blocking version written using the high-level (and
2058slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a
2059large margin, even though it does all of DNS, tcp-connect and socket I/O
2060in a non-blocking way.
2061
2062The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and
2063F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
2064part of the IO::lambda distribution and were used without any changes.
2065
1823 2066
1824=head1 SIGNALS 2067=head1 SIGNALS
1825 2068
1826AnyEvent currently installs handlers for these signals: 2069AnyEvent currently installs handlers for these signals:
1827 2070
… …
1830=item SIGCHLD 2073=item SIGCHLD
1831 2074
1832A handler for C<SIGCHLD> is installed by AnyEvent's child watcher 2075A handler for C<SIGCHLD> is installed by AnyEvent's child watcher
1833emulation for event loops that do not support them natively. Also, some 2076emulation for event loops that do not support them natively. Also, some
1834event loops install a similar handler. 2077event loops install a similar handler.
2078
2079If, when AnyEvent is loaded, SIGCHLD is set to IGNORE, then AnyEvent will
2080reset it to default, to avoid losing child exit statuses.
1835 2081
1836=item SIGPIPE 2082=item SIGPIPE
1837 2083
1838A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef> 2084A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef>
1839when AnyEvent gets loaded. 2085when AnyEvent gets loaded.
… …
1851 2097
1852=back 2098=back
1853 2099
1854=cut 2100=cut
1855 2101
2102undef $SIG{CHLD}
2103 if $SIG{CHLD} eq 'IGNORE';
2104
1856$SIG{PIPE} = sub { } 2105$SIG{PIPE} = sub { }
1857 unless defined $SIG{PIPE}; 2106 unless defined $SIG{PIPE};
1858
1859 2107
1860=head1 FORK 2108=head1 FORK
1861 2109
1862Most event libraries are not fork-safe. The ones who are usually are 2110Most event libraries are not fork-safe. The ones who are usually are
1863because they rely on inefficient but fork-safe C<select> or C<poll> 2111because they rely on inefficient but fork-safe C<select> or C<poll>
… …
1884 use AnyEvent; 2132 use AnyEvent;
1885 2133
1886Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2134Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1887be used to probe what backend is used and gain other information (which is 2135be used to probe what backend is used and gain other information (which is
1888probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2136probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1889$ENV{PERL_ANYEGENT_STRICT}. 2137$ENV{PERL_ANYEVENT_STRICT}.
2138
2139Note that AnyEvent will remove I<all> environment variables starting with
2140C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
2141enabled.
1890 2142
1891 2143
1892=head1 BUGS 2144=head1 BUGS
1893 2145
1894Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 2146Perl 5.8 has numerous memleaks that sometimes hit this module and are hard
… …
1906L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>. 2158L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>.
1907 2159
1908Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>, 2160Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
1909L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>, 2161L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
1910L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>, 2162L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
1911L<AnyEvent::Impl::POE>. 2163L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>.
1912 2164
1913Non-blocking file handles, sockets, TCP clients and 2165Non-blocking file handles, sockets, TCP clients and
1914servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>. 2166servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
1915 2167
1916Asynchronous DNS: L<AnyEvent::DNS>. 2168Asynchronous DNS: L<AnyEvent::DNS>.
1917 2169
1918Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>, 2170Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>,
2171L<Coro::Event>,
1919 2172
1920Nontrivial usage examples: L<Net::FCP>, L<Net::XMPP2>, L<AnyEvent::DNS>. 2173Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::XMPP>,
2174L<AnyEvent::HTTP>.
1921 2175
1922 2176
1923=head1 AUTHOR 2177=head1 AUTHOR
1924 2178
1925 Marc Lehmann <schmorp@schmorp.de> 2179 Marc Lehmann <schmorp@schmorp.de>

Diff Legend

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