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

Comparing AnyEvent/README (file contents):
Revision 1.29 by root, Tue Jul 29 10:20:33 2008 UTC vs.
Revision 1.44 by root, Fri Jul 10 22:35:27 2009 UTC

1NAME 1NAME
2 AnyEvent - provide framework for multiple event loops 2 AnyEvent - provide framework for multiple event loops
3 3
4 EV, Event, Glib, Tk, Perl, Event::Lib, Qt, POE - various supported event 4 EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
5 loops 5 event loops.
6 6
7SYNOPSIS 7SYNOPSIS
8 use AnyEvent; 8 use AnyEvent;
9 9
10 # file descriptor readable
10 my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub { ... }); 11 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
11 12
13 # one-shot or repeating timers
12 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 14 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
13 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 15 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
14 16
15 print AnyEvent->now; # prints current event loop time 17 print AnyEvent->now; # prints current event loop time
16 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time. 18 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
17 19
20 # POSIX signal
18 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... }); 21 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
19 22
23 # child process exit
20 my $w = AnyEvent->child (pid => $pid, cb => sub { 24 my $w = AnyEvent->child (pid => $pid, cb => sub {
21 my ($pid, $status) = @_; 25 my ($pid, $status) = @_;
22 ... 26 ...
23 }); 27 });
28
29 # called when event loop idle (if applicable)
30 my $w = AnyEvent->idle (cb => sub { ... });
24 31
25 my $w = AnyEvent->condvar; # stores whether a condition was flagged 32 my $w = AnyEvent->condvar; # stores whether a condition was flagged
26 $w->send; # wake up current and all future recv's 33 $w->send; # wake up current and all future recv's
27 $w->recv; # enters "main loop" till $condvar gets ->send 34 $w->recv; # enters "main loop" till $condvar gets ->send
28 # use a condvar in callback mode: 35 # use a condvar in callback mode:
… …
132 These watchers are normal Perl objects with normal Perl lifetime. After 139 These watchers are normal Perl objects with normal Perl lifetime. After
133 creating a watcher it will immediately "watch" for events and invoke the 140 creating a watcher it will immediately "watch" for events and invoke the
134 callback when the event occurs (of course, only when the event model is 141 callback when the event occurs (of course, only when the event model is
135 in control). 142 in control).
136 143
144 Note that callbacks must not permanently change global variables
145 potentially in use by the event loop (such as $_ or $[) and that
146 callbacks must not "die". The former is good programming practise in
147 Perl and the latter stems from the fact that exception handling differs
148 widely between event loops.
149
137 To disable the watcher you have to destroy it (e.g. by setting the 150 To disable the watcher you have to destroy it (e.g. by setting the
138 variable you store it in to "undef" or otherwise deleting all references 151 variable you store it in to "undef" or otherwise deleting all references
139 to it). 152 to it).
140 153
141 All watchers are created by calling a method on the "AnyEvent" class. 154 All watchers are created by calling a method on the "AnyEvent" class.
… …
156 169
157 I/O WATCHERS 170 I/O WATCHERS
158 You can create an I/O watcher by calling the "AnyEvent->io" method with 171 You can create an I/O watcher by calling the "AnyEvent->io" method with
159 the following mandatory key-value pairs as arguments: 172 the following mandatory key-value pairs as arguments:
160 173
161 "fh" the Perl *file handle* (*not* file descriptor) to watch for events 174 "fh" is the Perl *file handle* (or a naked file descriptor) to watch for
162 (AnyEvent might or might not keep a reference to this file handle). 175 events (AnyEvent might or might not keep a reference to this file
176 handle). Note that only file handles pointing to things for which
177 non-blocking operation makes sense are allowed. This includes sockets,
178 most character devices, pipes, fifos and so on, but not for example
179 files or block devices.
180
163 "poll" must be a string that is either "r" or "w", which creates a 181 "poll" must be a string that is either "r" or "w", which creates a
164 watcher waiting for "r"eadable or "w"ritable events, respectively. "cb" 182 watcher waiting for "r"eadable or "w"ritable events, respectively.
183
165 is the callback to invoke each time the file handle becomes ready. 184 "cb" is the callback to invoke each time the file handle becomes ready.
166 185
167 Although the callback might get passed parameters, their value and 186 Although the callback might get passed parameters, their value and
168 presence is undefined and you cannot rely on them. Portable AnyEvent 187 presence is undefined and you cannot rely on them. Portable AnyEvent
169 callbacks cannot use arguments passed to I/O watcher callbacks. 188 callbacks cannot use arguments passed to I/O watcher callbacks.
170 189
… …
302 In either case, if you care (and in most cases, you don't), then you 321 In either case, if you care (and in most cases, you don't), then you
303 can get whatever behaviour you want with any event loop, by taking 322 can get whatever behaviour you want with any event loop, by taking
304 the difference between "AnyEvent->time" and "AnyEvent->now" into 323 the difference between "AnyEvent->time" and "AnyEvent->now" into
305 account. 324 account.
306 325
326 AnyEvent->now_update
327 Some event loops (such as EV or AnyEvent::Impl::Perl) cache the
328 current time for each loop iteration (see the discussion of
329 AnyEvent->now, above).
330
331 When a callback runs for a long time (or when the process sleeps),
332 then this "current" time will differ substantially from the real
333 time, which might affect timers and time-outs.
334
335 When this is the case, you can call this method, which will update
336 the event loop's idea of "current time".
337
338 Note that updating the time *might* cause some events to be handled.
339
307 SIGNAL WATCHERS 340 SIGNAL WATCHERS
308 You can watch for signals using a signal watcher, "signal" is the signal 341 You can watch for signals using a signal watcher, "signal" is the signal
309 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl 342 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl
310 callback to be invoked whenever a signal occurs. 343 callback to be invoked whenever a signal occurs.
311 344
… …
330 363
331 CHILD PROCESS WATCHERS 364 CHILD PROCESS WATCHERS
332 You can also watch on a child process exit and catch its exit status. 365 You can also watch on a child process exit and catch its exit status.
333 366
334 The child process is specified by the "pid" argument (if set to 0, it 367 The child process is specified by the "pid" argument (if set to 0, it
335 watches for any child process exit). The watcher will trigger as often 368 watches for any child process exit). The watcher will triggered only
336 as status change for the child are received. This works by installing a 369 when the child process has finished and an exit status is available, not
337 signal handler for "SIGCHLD". The callback will be called with the pid 370 on any trace events (stopped/continued).
338 and exit status (as returned by waitpid), so unlike other watcher types, 371
339 you *can* rely on child watcher callback arguments. 372 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
374 callback arguments.
375
376 This watcher type works by installing a signal handler for "SIGCHLD",
377 and since it cannot be shared, nothing else should use SIGCHLD or reap
378 random child processes (waiting for specific child processes, e.g.
379 inside "system", is just fine).
340 380
341 There is a slight catch to child watchers, however: you usually start 381 There is a slight catch to child watchers, however: you usually start
342 them *after* the child process was created, and this means the process 382 them *after* the child process was created, and this means the process
343 could have exited already (and no SIGCHLD will be sent anymore). 383 could have exited already (and no SIGCHLD will be sent anymore).
344 384
345 Not all event models handle this correctly (POE doesn't), but even for 385 Not all event models handle this correctly (neither POE nor IO::Async
386 do, see their AnyEvent::Impl manpages for details), but even for event
346 event models that *do* handle this correctly, they usually need to be 387 models that *do* handle this correctly, they usually need to be loaded
347 loaded before the process exits (i.e. before you fork in the first 388 before the process exits (i.e. before you fork in the first place).
348 place). 389 AnyEvent's pure perl event loop handles all cases correctly regardless
390 of when you start the watcher.
349 391
350 This means you cannot create a child watcher as the very first thing in 392 This means you cannot create a child watcher as the very first thing in
351 an AnyEvent program, you *have* to create at least one watcher before 393 an AnyEvent program, you *have* to create at least one watcher before
352 you "fork" the child (alternatively, you can call "AnyEvent::detect"). 394 you "fork" the child (alternatively, you can call "AnyEvent::detect").
353 395
354 Example: fork a process and wait for it 396 Example: fork a process and wait for it
355 397
356 my $done = AnyEvent->condvar; 398 my $done = AnyEvent->condvar;
357 399
358 my $pid = fork or exit 5; 400 my $pid = fork or exit 5;
359 401
360 my $w = AnyEvent->child ( 402 my $w = AnyEvent->child (
361 pid => $pid, 403 pid => $pid,
362 cb => sub { 404 cb => sub {
363 my ($pid, $status) = @_; 405 my ($pid, $status) = @_;
364 warn "pid $pid exited with status $status"; 406 warn "pid $pid exited with status $status";
365 $done->send; 407 $done->send;
366 }, 408 },
367 ); 409 );
368 410
369 # do something else, then wait for process exit 411 # do something else, then wait for process exit
370 $done->recv; 412 $done->recv;
413
414 IDLE WATCHERS
415 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
417 "nothing better to do" is usually defined to be "no other events need
418 attention by the event loop".
419
420 Idle watchers ideally get invoked when the event loop has nothing better
421 to do, just before it would block the process to wait for new events.
422 Instead of blocking, the idle watcher is invoked.
423
424 Most event loops unfortunately do not really support idle watchers (only
425 EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
426 will simply call the callback "from time to time".
427
428 Example: read lines from STDIN, but only process them when the program
429 is otherwise idle:
430
431 my @lines; # read data
432 my $idle_w;
433 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
434 push @lines, scalar <STDIN>;
435
436 # start an idle watcher, if not already done
437 $idle_w ||= AnyEvent->idle (cb => sub {
438 # handle only one line, when there are lines left
439 if (my $line = shift @lines) {
440 print "handled when idle: $line";
441 } else {
442 # otherwise disable the idle watcher again
443 undef $idle_w;
444 }
445 });
446 });
371 447
372 CONDITION VARIABLES 448 CONDITION VARIABLES
373 If you are familiar with some event loops you will know that all of them 449 If you are familiar with some event loops you will know that all of them
374 require you to run some blocking "loop", "run" or similar function that 450 require you to run some blocking "loop", "run" or similar function that
375 will actively watch for new events and call your callbacks. 451 will actively watch for new events and call your callbacks.
… …
501 This can be used to signal any errors to the condition variable 577 This can be used to signal any errors to the condition variable
502 user/consumer. 578 user/consumer.
503 579
504 $cv->begin ([group callback]) 580 $cv->begin ([group callback])
505 $cv->end 581 $cv->end
506 These two methods are EXPERIMENTAL and MIGHT CHANGE.
507
508 These two methods can be used to combine many transactions/events 582 These two methods can be used to combine many transactions/events
509 into one. For example, a function that pings many hosts in parallel 583 into one. For example, a function that pings many hosts in parallel
510 might want to use a condition variable for the whole process. 584 might want to use a condition variable for the whole process.
511 585
512 Every call to "->begin" will increment a counter, and every call to 586 Every call to "->begin" will increment a counter, and every call to
513 "->end" will decrement it. If the counter reaches 0 in "->end", the 587 "->end" will decrement it. If the counter reaches 0 in "->end", the
514 (last) callback passed to "begin" will be executed. That callback is 588 (last) callback passed to "begin" will be executed. That callback is
515 *supposed* to call "->send", but that is not required. If no 589 *supposed* to call "->send", but that is not required. If no
516 callback was set, "send" will be called without any arguments. 590 callback was set, "send" will be called without any arguments.
517 591
518 Let's clarify this with the ping example: 592 You can think of "$cv->send" giving you an OR condition (one call
593 sends), while "$cv->begin" and "$cv->end" giving you an AND
594 condition (all "begin" calls must be "end"'ed before the condvar
595 sends).
596
597 Let's start with a simple example: you have two I/O watchers (for
598 example, STDOUT and STDERR for a program), and you want to wait for
599 both streams to close before activating a condvar:
600
601 my $cv = AnyEvent->condvar;
602
603 $cv->begin; # first watcher
604 my $w1 = AnyEvent->io (fh => $fh1, cb => sub {
605 defined sysread $fh1, my $buf, 4096
606 or $cv->end;
607 });
608
609 $cv->begin; # second watcher
610 my $w2 = AnyEvent->io (fh => $fh2, cb => sub {
611 defined sysread $fh2, my $buf, 4096
612 or $cv->end;
613 });
614
615 $cv->recv;
616
617 This works because for every event source (EOF on file handle),
618 there is one call to "begin", so the condvar waits for all calls to
619 "end" before sending.
620
621 The ping example mentioned above is slightly more complicated, as
622 the there are results to be passwd back, and the number of tasks
623 that are begung can potentially be zero:
519 624
520 my $cv = AnyEvent->condvar; 625 my $cv = AnyEvent->condvar;
521 626
522 my %result; 627 my %result;
523 $cv->begin (sub { $cv->send (\%result) }); 628 $cv->begin (sub { $cv->send (\%result) });
… …
543 the loop, which serves two important purposes: first, it sets the 648 the loop, which serves two important purposes: first, it sets the
544 callback to be called once the counter reaches 0, and second, it 649 callback to be called once the counter reaches 0, and second, it
545 ensures that "send" is called even when "no" hosts are being pinged 650 ensures that "send" is called even when "no" hosts are being pinged
546 (the loop doesn't execute once). 651 (the loop doesn't execute once).
547 652
548 This is the general pattern when you "fan out" into multiple 653 This is the general pattern when you "fan out" into multiple (but
549 subrequests: use an outer "begin"/"end" pair to set the callback and 654 potentially none) subrequests: use an outer "begin"/"end" pair to
550 ensure "end" is called at least once, and then, for each subrequest 655 set the callback and ensure "end" is called at least once, and then,
551 you start, call "begin" and for each subrequest you finish, call 656 for each subrequest you start, call "begin" and for each subrequest
552 "end". 657 you finish, call "end".
553 658
554 METHODS FOR CONSUMERS 659 METHODS FOR CONSUMERS
555 These methods should only be used by the consuming side, i.e. the code 660 These methods should only be used by the consuming side, i.e. the code
556 awaits the condition. 661 awaits the condition.
557 662
… …
604 The callback will be called when the condition becomes "true", i.e. 709 The callback will be called when the condition becomes "true", i.e.
605 when "send" or "croak" are called, with the only argument being the 710 when "send" or "croak" are called, with the only argument being the
606 condition variable itself. Calling "recv" inside the callback or at 711 condition variable itself. Calling "recv" inside the callback or at
607 any later time is guaranteed not to block. 712 any later time is guaranteed not to block.
608 713
714SUPPORTED EVENT LOOPS/BACKENDS
715 The available backend classes are (every class has its own manpage):
716
717 Backends that are autoprobed when no other event loop can be found.
718 EV is the preferred backend when no other event loop seems to be in
719 use. If EV is not installed, then AnyEvent will try Event, and,
720 failing that, will fall back to its own pure-perl implementation,
721 which is available everywhere as it comes with AnyEvent itself.
722
723 AnyEvent::Impl::EV based on EV (interface to libev, best choice).
724 AnyEvent::Impl::Event based on Event, very stable, few glitches.
725 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
726
727 Backends that are transparently being picked up when they are used.
728 These will be used when they are currently loaded when the first
729 watcher is created, in which case it is assumed that the application
730 is using them. This means that AnyEvent will automatically pick the
731 right backend when the main program loads an event module before
732 anything starts to create watchers. Nothing special needs to be done
733 by the main program.
734
735 AnyEvent::Impl::Glib based on Glib, slow but very stable.
736 AnyEvent::Impl::Tk based on Tk, very broken.
737 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
738 AnyEvent::Impl::POE based on POE, very slow, some limitations.
739
740 Backends with special needs.
741 Qt requires the Qt::Application to be instantiated first, but will
742 otherwise be picked up automatically. As long as the main program
743 instantiates the application before any AnyEvent watchers are
744 created, everything should just work.
745
746 AnyEvent::Impl::Qt based on Qt.
747
748 Support for IO::Async can only be partial, as it is too broken and
749 architecturally limited to even support the AnyEvent API. It also is
750 the only event loop that needs the loop to be set explicitly, so it
751 can only be used by a main program knowing about AnyEvent. See
752 AnyEvent::Impl::Async for the gory details.
753
754 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed.
755
756 Event loops that are indirectly supported via other backends.
757 Some event loops can be supported via other modules:
758
759 There is no direct support for WxWidgets (Wx) or Prima.
760
761 WxWidgets has no support for watching file handles. However, you can
762 use WxWidgets through the POE adaptor, as POE has a Wx backend that
763 simply polls 20 times per second, which was considered to be too
764 horrible to even consider for AnyEvent.
765
766 Prima is not supported as nobody seems to be using it, but it has a
767 POE backend, so it can be supported through POE.
768
769 AnyEvent knows about both Prima and Wx, however, and will try to
770 load POE when detecting them, in the hope that POE will pick them
771 up, in which case everything will be automatic.
772
609GLOBAL VARIABLES AND FUNCTIONS 773GLOBAL VARIABLES AND FUNCTIONS
774 These are not normally required to use AnyEvent, but can be useful to
775 write AnyEvent extension modules.
776
610 $AnyEvent::MODEL 777 $AnyEvent::MODEL
611 Contains "undef" until the first watcher is being created. Then it 778 Contains "undef" until the first watcher is being created, before
779 the backend has been autodetected.
780
612 contains the event model that is being used, which is the name of 781 Afterwards it contains the event model that is being used, which is
613 the Perl class implementing the model. This class is usually one of 782 the name of the Perl class implementing the model. This class is
614 the "AnyEvent::Impl:xxx" modules, but can be any other class in the 783 usually one of the "AnyEvent::Impl:xxx" modules, but can be any
615 case AnyEvent has been extended at runtime (e.g. in *rxvt-unicode*). 784 other class in the case AnyEvent has been extended at runtime (e.g.
616 785 in *rxvt-unicode* it will be "urxvt::anyevent").
617 The known classes so far are:
618
619 AnyEvent::Impl::EV based on EV (an interface to libev, best choice).
620 AnyEvent::Impl::Event based on Event, second best choice.
621 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
622 AnyEvent::Impl::Glib based on Glib, third-best choice.
623 AnyEvent::Impl::Tk based on Tk, very bad choice.
624 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
625 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
626 AnyEvent::Impl::POE based on POE, not generic enough for full support.
627
628 There is no support for WxWidgets, as WxWidgets has no support for
629 watching file handles. However, you can use WxWidgets through the
630 POE Adaptor, as POE has a Wx backend that simply polls 20 times per
631 second, which was considered to be too horrible to even consider for
632 AnyEvent. Likewise, other POE backends can be used by AnyEvent by
633 using it's adaptor.
634
635 AnyEvent knows about Prima and Wx and will try to use POE when
636 autodetecting them.
637 786
638 AnyEvent::detect 787 AnyEvent::detect
639 Returns $AnyEvent::MODEL, forcing autodetection of the event model 788 Returns $AnyEvent::MODEL, forcing autodetection of the event model
640 if necessary. You should only call this function right before you 789 if necessary. You should only call this function right before you
641 would have created an AnyEvent watcher anyway, that is, as late as 790 would have created an AnyEvent watcher anyway, that is, as late as
642 possible at runtime. 791 possible at runtime, and not e.g. while initialising of your module.
792
793 If you need to do some initialisation before AnyEvent watchers are
794 created, use "post_detect".
643 795
644 $guard = AnyEvent::post_detect { BLOCK } 796 $guard = AnyEvent::post_detect { BLOCK }
645 Arranges for the code block to be executed as soon as the event 797 Arranges for the code block to be executed as soon as the event
646 model is autodetected (or immediately if this has already happened). 798 model is autodetected (or immediately if this has already happened).
799
800 The block will be executed *after* the actual backend has been
801 detected ($AnyEvent::MODEL is set), but *before* any watchers have
802 been created, so it is possible to e.g. patch @AnyEvent::ISA or do
803 other initialisations - see the sources of AnyEvent::Strict or
804 AnyEvent::AIO to see how this is used.
805
806 The most common usage is to create some global watchers, without
807 forcing event module detection too early, for example, AnyEvent::AIO
808 creates and installs the global IO::AIO watcher in a "post_detect"
809 block to avoid autodetecting the event module at load time.
647 810
648 If called in scalar or list context, then it creates and returns an 811 If called in scalar or list context, then it creates and returns an
649 object that automatically removes the callback again when it is 812 object that automatically removes the callback again when it is
650 destroyed. See Coro::BDB for a case where this is useful. 813 destroyed. See Coro::BDB for a case where this is useful.
651 814
… …
653 If there are any code references in this array (you can "push" to it 816 If there are any code references in this array (you can "push" to it
654 before or after loading AnyEvent), then they will called directly 817 before or after loading AnyEvent), then they will called directly
655 after the event loop has been chosen. 818 after the event loop has been chosen.
656 819
657 You should check $AnyEvent::MODEL before adding to this array, 820 You should check $AnyEvent::MODEL before adding to this array,
658 though: if it contains a true value then the event loop has already 821 though: if it is defined then the event loop has already been
659 been detected, and the array will be ignored. 822 detected, and the array will be ignored.
660 823
661 Best use "AnyEvent::post_detect { BLOCK }" instead. 824 Best use "AnyEvent::post_detect { BLOCK }" when your application
825 allows it,as it takes care of these details.
826
827 This variable is mainly useful for modules that can do something
828 useful when AnyEvent is used and thus want to know when it is
829 initialised, but do not need to even load it by default. This array
830 provides the means to hook into AnyEvent passively, without loading
831 it.
662 832
663WHAT TO DO IN A MODULE 833WHAT TO DO IN A MODULE
664 As a module author, you should "use AnyEvent" and call AnyEvent methods 834 As a module author, you should "use AnyEvent" and call AnyEvent methods
665 freely, but you should not load a specific event module or rely on it. 835 freely, but you should not load a specific event module or rely on it.
666 836
… …
717 variable somewhere, waiting for it, and sending it when the program 887 variable somewhere, waiting for it, and sending it when the program
718 should exit cleanly. 888 should exit cleanly.
719 889
720OTHER MODULES 890OTHER MODULES
721 The following is a non-exhaustive list of additional modules that use 891 The following is a non-exhaustive list of additional modules that use
722 AnyEvent and can therefore be mixed easily with other AnyEvent modules 892 AnyEvent as a client and can therefore be mixed easily with other
723 in the same program. Some of the modules come with AnyEvent, some are 893 AnyEvent modules and other event loops in the same program. Some of the
724 available via CPAN. 894 modules come with AnyEvent, most are available via CPAN.
725 895
726 AnyEvent::Util 896 AnyEvent::Util
727 Contains various utility functions that replace often-used but 897 Contains various utility functions that replace often-used but
728 blocking functions such as "inet_aton" by event-/callback-based 898 blocking functions such as "inet_aton" by event-/callback-based
729 versions. 899 versions.
… …
735 more. 905 more.
736 906
737 AnyEvent::Handle 907 AnyEvent::Handle
738 Provide read and write buffers, manages watchers for reads and 908 Provide read and write buffers, manages watchers for reads and
739 writes, supports raw and formatted I/O, I/O queued and fully 909 writes, supports raw and formatted I/O, I/O queued and fully
740 transparent and non-blocking SSL/TLS. 910 transparent and non-blocking SSL/TLS (via AnyEvent::TLS.
741 911
742 AnyEvent::DNS 912 AnyEvent::DNS
743 Provides rich asynchronous DNS resolver capabilities. 913 Provides rich asynchronous DNS resolver capabilities.
744 914
745 AnyEvent::HTTP 915 AnyEvent::HTTP
… …
766 936
767 AnyEvent::GPSD 937 AnyEvent::GPSD
768 A non-blocking interface to gpsd, a daemon delivering GPS 938 A non-blocking interface to gpsd, a daemon delivering GPS
769 information. 939 information.
770 940
941 AnyEvent::IRC
942 AnyEvent based IRC client module family (replacing the older
943 Net::IRC3).
944
945 AnyEvent::XMPP
946 AnyEvent based XMPP (Jabber protocol) module family (replacing the
947 older Net::XMPP2>.
948
771 AnyEvent::IGS 949 AnyEvent::IGS
772 A non-blocking interface to the Internet Go Server protocol (used by 950 A non-blocking interface to the Internet Go Server protocol (used by
773 App::IGS). 951 App::IGS).
774 952
775 Net::IRC3
776 AnyEvent based IRC client module family.
777
778 Net::XMPP2
779 AnyEvent based XMPP (Jabber protocol) module family.
780
781 Net::FCP 953 Net::FCP
782 AnyEvent-based implementation of the Freenet Client Protocol, 954 AnyEvent-based implementation of the Freenet Client Protocol,
783 birthplace of AnyEvent. 955 birthplace of AnyEvent.
784 956
785 Event::ExecFlow 957 Event::ExecFlow
786 High level API for event-based execution flow control. 958 High level API for event-based execution flow control.
787 959
788 Coro 960 Coro
789 Has special support for AnyEvent via Coro::AnyEvent. 961 Has special support for AnyEvent via Coro::AnyEvent.
790 962
791 IO::Lambda 963ERROR AND EXCEPTION HANDLING
792 The lambda approach to I/O - don't ask, look there. Can use 964 In general, AnyEvent does not do any error handling - it relies on the
793 AnyEvent. 965 caller to do that if required. The AnyEvent::Strict module (see also the
966 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict
967 checking of all AnyEvent methods, however, which is highly useful during
968 development.
794 969
795SUPPLYING YOUR OWN EVENT MODEL INTERFACE 970 As for exception handling (i.e. runtime errors and exceptions thrown
796 This is an advanced topic that you do not normally need to use AnyEvent 971 while executing a callback), this is not only highly event-loop
797 in a module. This section is only of use to event loop authors who want 972 specific, but also not in any way wrapped by this module, as this is the
798 to provide AnyEvent compatibility. 973 job of the main program.
799 974
800 If you need to support another event library which isn't directly 975 The pure perl event loop simply re-throws the exception (usually within
801 supported by AnyEvent, you can supply your own interface to it by 976 "condvar->recv"), the Event and EV modules call "$Event/EV::DIED->()",
802 pushing, before the first watcher gets created, the package name of the 977 Glib uses "install_exception_handler" and so on.
803 event module and the package name of the interface to use onto
804 @AnyEvent::REGISTRY. You can do that before and even without loading
805 AnyEvent, so it is reasonably cheap.
806
807 Example:
808
809 push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::];
810
811 This tells AnyEvent to (literally) use the "urxvt::anyevent::"
812 package/class when it finds the "urxvt" package/module is already
813 loaded.
814
815 When AnyEvent is loaded and asked to find a suitable event model, it
816 will first check for the presence of urxvt by trying to "use" the
817 "urxvt::anyevent" module.
818
819 The class should provide implementations for all watcher types. See
820 AnyEvent::Impl::EV (source code), AnyEvent::Impl::Glib (Source code) and
821 so on for actual examples. Use "perldoc -m AnyEvent::Impl::Glib" to see
822 the sources.
823
824 If you don't provide "signal" and "child" watchers than AnyEvent will
825 provide suitable (hopefully) replacements.
826
827 The above example isn't fictitious, the *rxvt-unicode* (a.k.a. urxvt)
828 terminal emulator uses the above line as-is. An interface isn't included
829 in AnyEvent because it doesn't make sense outside the embedded
830 interpreter inside *rxvt-unicode*, and it is updated and maintained as
831 part of the *rxvt-unicode* distribution.
832
833 *rxvt-unicode* also cheats a bit by not providing blocking access to
834 condition variables: code blocking while waiting for a condition will
835 "die". This still works with most modules/usages, and blocking calls
836 must not be done in an interactive application, so it makes sense.
837 978
838ENVIRONMENT VARIABLES 979ENVIRONMENT VARIABLES
839 The following environment variables are used by this module: 980 The following environment variables are used by this module or its
981 submodules.
982
983 Note that AnyEvent will remove *all* environment variables starting with
984 "PERL_ANYEVENT_" from %ENV when it is loaded while taint mode is
985 enabled.
840 986
841 "PERL_ANYEVENT_VERBOSE" 987 "PERL_ANYEVENT_VERBOSE"
842 By default, AnyEvent will be completely silent except in fatal 988 By default, AnyEvent will be completely silent except in fatal
843 conditions. You can set this environment variable to make AnyEvent 989 conditions. You can set this environment variable to make AnyEvent
844 more talkative. 990 more talkative.
… …
853 "PERL_ANYEVENT_STRICT" 999 "PERL_ANYEVENT_STRICT"
854 AnyEvent does not do much argument checking by default, as thorough 1000 AnyEvent does not do much argument checking by default, as thorough
855 argument checking is very costly. Setting this variable to a true 1001 argument checking is very costly. Setting this variable to a true
856 value will cause AnyEvent to load "AnyEvent::Strict" and then to 1002 value will cause AnyEvent to load "AnyEvent::Strict" and then to
857 thoroughly check the arguments passed to most method calls. If it 1003 thoroughly check the arguments passed to most method calls. If it
858 finds any problems it will croak. 1004 finds any problems, it will croak.
859 1005
860 In other words, enables "strict" mode. 1006 In other words, enables "strict" mode.
861 1007
862 Unlike "use strict" it is definitely recommended ot keep it off in 1008 Unlike "use strict", it is definitely recommended to keep it off in
863 production. 1009 production. Keeping "PERL_ANYEVENT_STRICT=1" in your environment
1010 while developing programs can be very useful, however.
864 1011
865 "PERL_ANYEVENT_MODEL" 1012 "PERL_ANYEVENT_MODEL"
866 This can be used to specify the event model to be used by AnyEvent, 1013 This can be used to specify the event model to be used by AnyEvent,
867 before auto detection and -probing kicks in. It must be a string 1014 before auto detection and -probing kicks in. It must be a string
868 consisting entirely of ASCII letters. The string "AnyEvent::Impl::" 1015 consisting entirely of ASCII letters. The string "AnyEvent::Impl::"
… …
887 mentioned will be used, and preference will be given to protocols 1034 mentioned will be used, and preference will be given to protocols
888 mentioned earlier in the list. 1035 mentioned earlier in the list.
889 1036
890 This variable can effectively be used for denial-of-service attacks 1037 This variable can effectively be used for denial-of-service attacks
891 against local programs (e.g. when setuid), although the impact is 1038 against local programs (e.g. when setuid), although the impact is
892 likely small, as the program has to handle connection errors 1039 likely small, as the program has to handle conenction and other
893 already- 1040 failures anyways.
894 1041
895 Examples: "PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6" - prefer IPv4 over 1042 Examples: "PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6" - prefer IPv4 over
896 IPv6, but support both and try to use both. 1043 IPv6, but support both and try to use both.
897 "PERL_ANYEVENT_PROTOCOLS=ipv4" - only support IPv4, never try to 1044 "PERL_ANYEVENT_PROTOCOLS=ipv4" - only support IPv4, never try to
898 resolve or contact IPv6 addresses. 1045 resolve or contact IPv6 addresses.
… …
909 EDNS0 in its DNS requests. 1056 EDNS0 in its DNS requests.
910 1057
911 "PERL_ANYEVENT_MAX_FORKS" 1058 "PERL_ANYEVENT_MAX_FORKS"
912 The maximum number of child processes that 1059 The maximum number of child processes that
913 "AnyEvent::Util::fork_call" will create in parallel. 1060 "AnyEvent::Util::fork_call" will create in parallel.
1061
1062 "PERL_ANYEVENT_MAX_OUTSTANDING_DNS"
1063 The default value for the "max_outstanding" parameter for the
1064 default DNS resolver - this is the maximum number of parallel DNS
1065 requests that are sent to the DNS server.
1066
1067 "PERL_ANYEVENT_RESOLV_CONF"
1068 The file to use instead of /etc/resolv.conf (or OS-specific
1069 configuration) in the default resolver. When set to the empty
1070 string, no default config will be used.
1071
1072 "PERL_ANYEVENT_CA_FILE", "PERL_ANYEVENT_CA_PATH".
1073 When neither "ca_file" nor "ca_path" was specified during
1074 AnyEvent::TLS context creation, and either of these environment
1075 variables exist, they will be used to specify CA certificate
1076 locations instead of a system-dependent default.
1077
1078SUPPLYING YOUR OWN EVENT MODEL INTERFACE
1079 This is an advanced topic that you do not normally need to use AnyEvent
1080 in a module. This section is only of use to event loop authors who want
1081 to provide AnyEvent compatibility.
1082
1083 If you need to support another event library which isn't directly
1084 supported by AnyEvent, you can supply your own interface to it by
1085 pushing, before the first watcher gets created, the package name of the
1086 event module and the package name of the interface to use onto
1087 @AnyEvent::REGISTRY. You can do that before and even without loading
1088 AnyEvent, so it is reasonably cheap.
1089
1090 Example:
1091
1092 push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::];
1093
1094 This tells AnyEvent to (literally) use the "urxvt::anyevent::"
1095 package/class when it finds the "urxvt" package/module is already
1096 loaded.
1097
1098 When AnyEvent is loaded and asked to find a suitable event model, it
1099 will first check for the presence of urxvt by trying to "use" the
1100 "urxvt::anyevent" module.
1101
1102 The class should provide implementations for all watcher types. See
1103 AnyEvent::Impl::EV (source code), AnyEvent::Impl::Glib (Source code) and
1104 so on for actual examples. Use "perldoc -m AnyEvent::Impl::Glib" to see
1105 the sources.
1106
1107 If you don't provide "signal" and "child" watchers than AnyEvent will
1108 provide suitable (hopefully) replacements.
1109
1110 The above example isn't fictitious, the *rxvt-unicode* (a.k.a. urxvt)
1111 terminal emulator uses the above line as-is. An interface isn't included
1112 in AnyEvent because it doesn't make sense outside the embedded
1113 interpreter inside *rxvt-unicode*, and it is updated and maintained as
1114 part of the *rxvt-unicode* distribution.
1115
1116 *rxvt-unicode* also cheats a bit by not providing blocking access to
1117 condition variables: code blocking while waiting for a condition will
1118 "die". This still works with most modules/usages, and blocking calls
1119 must not be done in an interactive application, so it makes sense.
914 1120
915EXAMPLE PROGRAM 1121EXAMPLE PROGRAM
916 The following program uses an I/O watcher to read data from STDIN, a 1122 The following program uses an I/O watcher to read data from STDIN, a
917 timer to display a message once per second, and a condition variable to 1123 timer to display a message once per second, and a condition variable to
918 quit the program when the user enters quit: 1124 quit the program when the user enters quit:
… …
1105 *destroy* is the time, in microseconds, that it takes to destroy a 1311 *destroy* is the time, in microseconds, that it takes to destroy a
1106 single watcher. 1312 single watcher.
1107 1313
1108 Results 1314 Results
1109 name watchers bytes create invoke destroy comment 1315 name watchers bytes create invoke destroy comment
1110 EV/EV 400000 244 0.56 0.46 0.31 EV native interface 1316 EV/EV 400000 224 0.47 0.35 0.27 EV native interface
1111 EV/Any 100000 244 2.50 0.46 0.29 EV + AnyEvent watchers 1317 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers
1112 CoroEV/Any 100000 244 2.49 0.44 0.29 coroutines + Coro::Signal 1318 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal
1113 Perl/Any 100000 513 4.92 0.87 1.12 pure perl implementation 1319 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation
1114 Event/Event 16000 516 31.88 31.30 0.85 Event native interface 1320 Event/Event 16000 517 32.20 31.80 0.81 Event native interface
1115 Event/Any 16000 590 35.75 31.42 1.08 Event + AnyEvent watchers 1321 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers
1322 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll
1323 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll
1116 Glib/Any 16000 1357 98.22 12.41 54.00 quadratic behaviour 1324 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour
1117 Tk/Any 2000 1860 26.97 67.98 14.00 SEGV with >> 2000 watchers 1325 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers
1118 POE/Event 2000 6644 108.64 736.02 14.73 via POE::Loop::Event 1326 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event
1119 POE/Select 2000 6343 94.13 809.12 565.96 via POE::Loop::Select 1327 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select
1120 1328
1121 Discussion 1329 Discussion
1122 The benchmark does *not* measure scalability of the event loop very 1330 The benchmark does *not* measure scalability of the event loop very
1123 well. For example, a select-based event loop (such as the pure perl one) 1331 well. For example, a select-based event loop (such as the pure perl one)
1124 can never compete with an event loop that uses epoll when the number of 1332 can never compete with an event loop that uses epoll when the number of
… …
1149 few of them active), of course, but this was not subject of this 1357 few of them active), of course, but this was not subject of this
1150 benchmark. 1358 benchmark.
1151 1359
1152 The "Event" module has a relatively high setup and callback invocation 1360 The "Event" module has a relatively high setup and callback invocation
1153 cost, but overall scores in on the third place. 1361 cost, but overall scores in on the third place.
1362
1363 "IO::Async" performs admirably well, about on par with "Event", even
1364 when using its pure perl backend.
1154 1365
1155 "Glib"'s memory usage is quite a bit higher, but it features a faster 1366 "Glib"'s memory usage is quite a bit higher, but it features a faster
1156 callback invocation and overall ends up in the same class as "Event". 1367 callback invocation and overall ends up in the same class as "Event".
1157 However, Glib scales extremely badly, doubling the number of watchers 1368 However, Glib scales extremely badly, doubling the number of watchers
1158 increases the processing time by more than a factor of four, making it 1369 increases the processing time by more than a factor of four, making it
… …
1229 single "request", that is, reading the token from the pipe and 1440 single "request", that is, reading the token from the pipe and
1230 forwarding it to another server. This includes deleting the old timeout 1441 forwarding it to another server. This includes deleting the old timeout
1231 and creating a new one that moves the timeout into the future. 1442 and creating a new one that moves the timeout into the future.
1232 1443
1233 Results 1444 Results
1234 name sockets create request 1445 name sockets create request
1235 EV 20000 69.01 11.16 1446 EV 20000 69.01 11.16
1236 Perl 20000 73.32 35.87 1447 Perl 20000 73.32 35.87
1448 IOAsync 20000 157.00 98.14 epoll
1449 IOAsync 20000 159.31 616.06 poll
1237 Event 20000 212.62 257.32 1450 Event 20000 212.62 257.32
1238 Glib 20000 651.16 1896.30 1451 Glib 20000 651.16 1896.30
1239 POE 20000 349.67 12317.24 uses POE::Loop::Event 1452 POE 20000 349.67 12317.24 uses POE::Loop::Event
1240 1453
1241 Discussion 1454 Discussion
1242 This benchmark *does* measure scalability and overall performance of the 1455 This benchmark *does* measure scalability and overall performance of the
1243 particular event loop. 1456 particular event loop.
1244 1457
1245 EV is again fastest. Since it is using epoll on my system, the setup 1458 EV is again fastest. Since it is using epoll on my system, the setup
1246 time is relatively high, though. 1459 time is relatively high, though.
1247 1460
1248 Perl surprisingly comes second. It is much faster than the C-based event 1461 Perl surprisingly comes second. It is much faster than the C-based event
1249 loops Event and Glib. 1462 loops Event and Glib.
1463
1464 IO::Async performs very well when using its epoll backend, and still
1465 quite good compared to Glib when using its pure perl backend.
1250 1466
1251 Event suffers from high setup time as well (look at its code and you 1467 Event suffers from high setup time as well (look at its code and you
1252 will understand why). Callback invocation also has a high overhead 1468 will understand why). Callback invocation also has a high overhead
1253 compared to the "$_->() for .."-style loop that the Perl event loop 1469 compared to the "$_->() for .."-style loop that the Perl event loop
1254 uses. Event uses select or poll in basically all documented 1470 uses. Event uses select or poll in basically all documented
… …
1305 1521
1306 Summary 1522 Summary
1307 * C-based event loops perform very well with small number of watchers, 1523 * C-based event loops perform very well with small number of watchers,
1308 as the management overhead dominates. 1524 as the management overhead dominates.
1309 1525
1526 THE IO::Lambda BENCHMARK
1527 Recently I was told about the benchmark in the IO::Lambda manpage, which
1528 could be misinterpreted to make AnyEvent look bad. In fact, the
1529 benchmark simply compares IO::Lambda with POE, and IO::Lambda looks
1530 better (which shouldn't come as a surprise to anybody). As such, the
1531 benchmark is fine, and mostly shows that the AnyEvent backend from
1532 IO::Lambda isn't very optimal. But how would AnyEvent compare when used
1533 without the extra baggage? To explore this, I wrote the equivalent
1534 benchmark for AnyEvent.
1535
1536 The benchmark itself creates an echo-server, and then, for 500 times,
1537 connects to the echo server, sends a line, waits for the reply, and then
1538 creates the next connection. This is a rather bad benchmark, as it
1539 doesn't test the efficiency of the framework or much non-blocking I/O,
1540 but it is a benchmark nevertheless.
1541
1542 name runtime
1543 Lambda/select 0.330 sec
1544 + optimized 0.122 sec
1545 Lambda/AnyEvent 0.327 sec
1546 + optimized 0.138 sec
1547 Raw sockets/select 0.077 sec
1548 POE/select, components 0.662 sec
1549 POE/select, raw sockets 0.226 sec
1550 POE/select, optimized 0.404 sec
1551
1552 AnyEvent/select/nb 0.085 sec
1553 AnyEvent/EV/nb 0.068 sec
1554 +state machine 0.134 sec
1555
1556 The benchmark is also a bit unfair (my fault): the IO::Lambda/POE
1557 benchmarks actually make blocking connects and use 100% blocking I/O,
1558 defeating the purpose of an event-based solution. All of the newly
1559 written AnyEvent benchmarks use 100% non-blocking connects (using
1560 AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
1561 resolver), so AnyEvent is at a disadvantage here, as non-blocking
1562 connects generally require a lot more bookkeeping and event handling
1563 than blocking connects (which involve a single syscall only).
1564
1565 The last AnyEvent benchmark additionally uses AnyEvent::Handle, which
1566 offers similar expressive power as POE and IO::Lambda, using
1567 conventional Perl syntax. This means that both the echo server and the
1568 client are 100% non-blocking, further placing it at a disadvantage.
1569
1570 As you can see, the AnyEvent + EV combination even beats the
1571 hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
1572 backend easily beats IO::Lambda and POE.
1573
1574 And even the 100% non-blocking version written using the high-level (and
1575 slow :) AnyEvent::Handle abstraction beats both POE and IO::Lambda by a
1576 large margin, even though it does all of DNS, tcp-connect and socket I/O
1577 in a non-blocking way.
1578
1579 The two AnyEvent benchmarks programs can be found as eg/ae0.pl and
1580 eg/ae2.pl in the AnyEvent distribution, the remaining benchmarks are
1581 part of the IO::lambda distribution and were used without any changes.
1582
1583SIGNALS
1584 AnyEvent currently installs handlers for these signals:
1585
1586 SIGCHLD
1587 A handler for "SIGCHLD" is installed by AnyEvent's child watcher
1588 emulation for event loops that do not support them natively. Also,
1589 some event loops install a similar handler.
1590
1591 Additionally, when AnyEvent is loaded and SIGCHLD is set to IGNORE,
1592 then AnyEvent will reset it to default, to avoid losing child exit
1593 statuses.
1594
1595 SIGPIPE
1596 A no-op handler is installed for "SIGPIPE" when $SIG{PIPE} is
1597 "undef" when AnyEvent gets loaded.
1598
1599 The rationale for this is that AnyEvent users usually do not really
1600 depend on SIGPIPE delivery (which is purely an optimisation for
1601 shell use, or badly-written programs), but "SIGPIPE" can cause
1602 spurious and rare program exits as a lot of people do not expect
1603 "SIGPIPE" when writing to some random socket.
1604
1605 The rationale for installing a no-op handler as opposed to ignoring
1606 it is that this way, the handler will be restored to defaults on
1607 exec.
1608
1609 Feel free to install your own handler, or reset it to defaults.
1610
1310FORK 1611FORK
1311 Most event libraries are not fork-safe. The ones who are usually are 1612 Most event libraries are not fork-safe. The ones who are usually are
1312 because they rely on inefficient but fork-safe "select" or "poll" calls. 1613 because they rely on inefficient but fork-safe "select" or "poll" calls.
1313 Only EV is fully fork-aware. 1614 Only EV is fully fork-aware.
1314 1615
… …
1325 1626
1326 You can make AnyEvent completely ignore this variable by deleting it 1627 You can make AnyEvent completely ignore this variable by deleting it
1327 before the first watcher gets created, e.g. with a "BEGIN" block: 1628 before the first watcher gets created, e.g. with a "BEGIN" block:
1328 1629
1329 BEGIN { delete $ENV{PERL_ANYEVENT_MODEL} } 1630 BEGIN { delete $ENV{PERL_ANYEVENT_MODEL} }
1330 1631
1331 use AnyEvent; 1632 use AnyEvent;
1332 1633
1333 Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 1634 Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1334 be used to probe what backend is used and gain other information (which 1635 be used to probe what backend is used and gain other information (which
1335 is probably even less useful to an attacker than PERL_ANYEVENT_MODEL), 1636 is probably even less useful to an attacker than PERL_ANYEVENT_MODEL),
1336 and $ENV{PERL_ANYEGENT_STRICT}. 1637 and $ENV{PERL_ANYEVENT_STRICT}.
1638
1639 Note that AnyEvent will remove *all* environment variables starting with
1640 "PERL_ANYEVENT_" from %ENV when it is loaded while taint mode is
1641 enabled.
1337 1642
1338BUGS 1643BUGS
1339 Perl 5.8 has numerous memleaks that sometimes hit this module and are 1644 Perl 5.8 has numerous memleaks that sometimes hit this module and are
1340 hard to work around. If you suffer from memleaks, first upgrade to Perl 1645 hard to work around. If you suffer from memleaks, first upgrade to Perl
1341 5.10 and check wether the leaks still show up. (Perl 5.10.0 has other 1646 5.10 and check wether the leaks still show up. (Perl 5.10.0 has other
1342 annoying mamleaks, such as leaking on "map" and "grep" but it is usually 1647 annoying memleaks, such as leaking on "map" and "grep" but it is usually
1343 not as pronounced). 1648 not as pronounced).
1344 1649
1345SEE ALSO 1650SEE ALSO
1346 Utility functions: AnyEvent::Util. 1651 Utility functions: AnyEvent::Util.
1347 1652
1348 Event modules: EV, EV::Glib, Glib::EV, Event, Glib::Event, Glib, Tk, 1653 Event modules: EV, EV::Glib, Glib::EV, Event, Glib::Event, Glib, Tk,
1349 Event::Lib, Qt, POE. 1654 Event::Lib, Qt, POE.
1350 1655
1351 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event, 1656 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event,
1352 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl, 1657 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl,
1353 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE. 1658 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE,
1659 AnyEvent::Impl::IOAsync.
1354 1660
1355 Non-blocking file handles, sockets, TCP clients and servers: 1661 Non-blocking file handles, sockets, TCP clients and servers:
1356 AnyEvent::Handle, AnyEvent::Socket. 1662 AnyEvent::Handle, AnyEvent::Socket, AnyEvent::TLS.
1357 1663
1358 Asynchronous DNS: AnyEvent::DNS. 1664 Asynchronous DNS: AnyEvent::DNS.
1359 1665
1360 Coroutine support: Coro, Coro::AnyEvent, Coro::EV, Coro::Event, 1666 Coroutine support: Coro, Coro::AnyEvent, Coro::EV, Coro::Event,
1361 1667
1362 Nontrivial usage examples: Net::FCP, Net::XMPP2, AnyEvent::DNS. 1668 Nontrivial usage examples: AnyEvent::GPSD, AnyEvent::XMPP,
1669 AnyEvent::HTTP.
1363 1670
1364AUTHOR 1671AUTHOR
1365 Marc Lehmann <schmorp@schmorp.de> 1672 Marc Lehmann <schmorp@schmorp.de>
1366 http://home.schmorp.de/ 1673 http://home.schmorp.de/
1367 1674

Diff Legend

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