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

Comparing AnyEvent/README (file contents):
Revision 1.46 by root, Sat Jul 18 05:19:09 2009 UTC vs.
Revision 1.51 by root, Sun Aug 9 16:05:11 2009 UTC

1NAME 1NAME
2 AnyEvent - provide framework for multiple event loops 2 AnyEvent - the DBI of event loop programming
3 3
4 EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported 4 EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async,
5 event loops. 5 Qt and POE are various supported event loops/environments.
6 6
7SYNOPSIS 7SYNOPSIS
8 use AnyEvent; 8 use AnyEvent;
9 9
10 # file descriptor readable 10 # file descriptor readable
… …
37 37
38INTRODUCTION/TUTORIAL 38INTRODUCTION/TUTORIAL
39 This manpage is mainly a reference manual. If you are interested in a 39 This manpage is mainly a reference manual. If you are interested in a
40 tutorial or some gentle introduction, have a look at the AnyEvent::Intro 40 tutorial or some gentle introduction, have a look at the AnyEvent::Intro
41 manpage. 41 manpage.
42
43SUPPORT
44 There is a mailinglist for discussing all things AnyEvent, and an IRC
45 channel, too.
46
47 See the AnyEvent project page at the Schmorpforge Ta-Sa Software
48 Repository, at <http://anyevent.schmorp.de>, for more info.
42 49
43WHY YOU SHOULD USE THIS MODULE (OR NOT) 50WHY YOU SHOULD USE THIS MODULE (OR NOT)
44 Glib, POE, IO::Async, Event... CPAN offers event models by the dozen 51 Glib, POE, IO::Async, Event... CPAN offers event models by the dozen
45 nowadays. So what is different about AnyEvent? 52 nowadays. So what is different about AnyEvent?
46 53
… …
166 Note that "my $w; $w =" combination. This is necessary because in Perl, 173 Note that "my $w; $w =" combination. This is necessary because in Perl,
167 my variables are only visible after the statement in which they are 174 my variables are only visible after the statement in which they are
168 declared. 175 declared.
169 176
170 I/O WATCHERS 177 I/O WATCHERS
178 $w = AnyEvent->io (
179 fh => <filehandle_or_fileno>,
180 poll => <"r" or "w">,
181 cb => <callback>,
182 );
183
171 You can create an I/O watcher by calling the "AnyEvent->io" method with 184 You can create an I/O watcher by calling the "AnyEvent->io" method with
172 the following mandatory key-value pairs as arguments: 185 the following mandatory key-value pairs as arguments:
173 186
174 "fh" is the Perl *file handle* (or a naked file descriptor) to watch for 187 "fh" is the Perl *file handle* (or a naked file descriptor) to watch for
175 events (AnyEvent might or might not keep a reference to this file 188 events (AnyEvent might or might not keep a reference to this file
… …
203 warn "read: $input\n"; 216 warn "read: $input\n";
204 undef $w; 217 undef $w;
205 }); 218 });
206 219
207 TIME WATCHERS 220 TIME WATCHERS
221 $w = AnyEvent->timer (after => <seconds>, cb => <callback>);
222
223 $w = AnyEvent->timer (
224 after => <fractional_seconds>,
225 interval => <fractional_seconds>,
226 cb => <callback>,
227 );
228
208 You can create a time watcher by calling the "AnyEvent->timer" method 229 You can create a time watcher by calling the "AnyEvent->timer" method
209 with the following mandatory arguments: 230 with the following mandatory arguments:
210 231
211 "after" specifies after how many seconds (fractional values are 232 "after" specifies after how many seconds (fractional values are
212 supported) the callback should be invoked. "cb" is the callback to 233 supported) the callback should be invoked. "cb" is the callback to
… …
336 the event loop's idea of "current time". 357 the event loop's idea of "current time".
337 358
338 Note that updating the time *might* cause some events to be handled. 359 Note that updating the time *might* cause some events to be handled.
339 360
340 SIGNAL WATCHERS 361 SIGNAL WATCHERS
362 $w = AnyEvent->signal (signal => <uppercase_signal_name>, cb => <callback>);
363
341 You can watch for signals using a signal watcher, "signal" is the signal 364 You can watch for signals using a signal watcher, "signal" is the signal
342 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl 365 *name* in uppercase and without any "SIG" prefix, "cb" is the Perl
343 callback to be invoked whenever a signal occurs. 366 callback to be invoked whenever a signal occurs.
344 367
345 Although the callback might get passed parameters, their value and 368 Although the callback might get passed parameters, their value and
… …
357 380
358 This watcher might use %SIG (depending on the event loop used), so 381 This watcher might use %SIG (depending on the event loop used), so
359 programs overwriting those signals directly will likely not work 382 programs overwriting those signals directly will likely not work
360 correctly. 383 correctly.
361 384
385 Example: exit on SIGINT
386
387 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
388
389 Signal Races, Delays and Workarounds
362 Also note that many event loops (e.g. Glib, Tk, Qt, IO::Async) do not 390 Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
363 support attaching callbacks to signals, which is a pity, as you cannot 391 callbacks to signals in a generic way, which is a pity, as you cannot do
364 do race-free signal handling in perl. AnyEvent will try to do it's best, 392 race-free signal handling in perl, requiring C libraries for this.
365 but in some cases, signals will be delayed. The maximum time a signal 393 AnyEvent will try to do it's best, which means in some cases, signals
366 might be delayed is specified in $AnyEvent::MAX_SIGNAL_LATENCY (default: 394 will be delayed. The maximum time a signal might be delayed is specified
367 10 seconds). This variable can be changed only before the first signal 395 in $AnyEvent::MAX_SIGNAL_LATENCY (default: 10 seconds). This variable
368 watcher is created, and should be left alone otherwise. Higher values 396 can be changed only before the first signal watcher is created, and
397 should be left alone otherwise. This variable determines how often
398 AnyEvent polls for signals (in case a wake-up was missed). Higher values
369 will cause fewer spurious wake-ups, which is better for power and CPU 399 will cause fewer spurious wake-ups, which is better for power and CPU
400 saving.
401
370 saving. All these problems can be avoided by installing the optional 402 All these problems can be avoided by installing the optional
371 Async::Interrupt module. 403 Async::Interrupt module, which works with most event loops. It will not
372 404 work with inherently broken event loops such as Event or Event::Lib (and
373 Example: exit on SIGINT 405 not with POE currently, as POE does it's own workaround with one-second
374 406 latency). For those, you just have to suffer the delays.
375 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
376 407
377 CHILD PROCESS WATCHERS 408 CHILD PROCESS WATCHERS
409 $w = AnyEvent->child (pid => <process id>, cb => <callback>);
410
378 You can also watch on a child process exit and catch its exit status. 411 You can also watch on a child process exit and catch its exit status.
379 412
380 The child process is specified by the "pid" argument (if set to 0, it 413 The child process is specified by the "pid" argument (one some backends,
381 watches for any child process exit). The watcher will triggered only 414 using 0 watches for any child process exit, on others this will croak).
382 when the child process has finished and an exit status is available, not 415 The watcher will be triggered only when the child process has finished
383 on any trace events (stopped/continued). 416 and an exit status is available, not on any trace events
417 (stopped/continued).
384 418
385 The callback will be called with the pid and exit status (as returned by 419 The callback will be called with the pid and exit status (as returned by
386 waitpid), so unlike other watcher types, you *can* rely on child watcher 420 waitpid), so unlike other watcher types, you *can* rely on child watcher
387 callback arguments. 421 callback arguments.
388 422
… …
427 461
428 # do something else, then wait for process exit 462 # do something else, then wait for process exit
429 $done->recv; 463 $done->recv;
430 464
431 IDLE WATCHERS 465 IDLE WATCHERS
466 $w = AnyEvent->idle (cb => <callback>);
467
432 Sometimes there is a need to do something, but it is not so important to 468 Sometimes there is a need to do something, but it is not so important to
433 do it instantly, but only when there is nothing better to do. This 469 do it instantly, but only when there is nothing better to do. This
434 "nothing better to do" is usually defined to be "no other events need 470 "nothing better to do" is usually defined to be "no other events need
435 attention by the event loop". 471 attention by the event loop".
436 472
… …
461 } 497 }
462 }); 498 });
463 }); 499 });
464 500
465 CONDITION VARIABLES 501 CONDITION VARIABLES
502 $cv = AnyEvent->condvar;
503
504 $cv->send (<list>);
505 my @res = $cv->recv;
506
466 If you are familiar with some event loops you will know that all of them 507 If you are familiar with some event loops you will know that all of them
467 require you to run some blocking "loop", "run" or similar function that 508 require you to run some blocking "loop", "run" or similar function that
468 will actively watch for new events and call your callbacks. 509 will actively watch for new events and call your callbacks.
469 510
470 AnyEvent is slightly different: it expects somebody else to run the 511 AnyEvent is slightly different: it expects somebody else to run the
… …
490 Condition variables are similar to callbacks, except that you can 531 Condition variables are similar to callbacks, except that you can
491 optionally wait for them. They can also be called merge points - points 532 optionally wait for them. They can also be called merge points - points
492 in time where multiple outstanding events have been processed. And yet 533 in time where multiple outstanding events have been processed. And yet
493 another way to call them is transactions - each condition variable can 534 another way to call them is transactions - each condition variable can
494 be used to represent a transaction, which finishes at some point and 535 be used to represent a transaction, which finishes at some point and
495 delivers a result. 536 delivers a result. And yet some people know them as "futures" - a
537 promise to compute/deliver something that you can wait for.
496 538
497 Condition variables are very useful to signal that something has 539 Condition variables are very useful to signal that something has
498 finished, for example, if you write a module that does asynchronous http 540 finished, for example, if you write a module that does asynchronous http
499 requests, then a condition variable would be the ideal candidate to 541 requests, then a condition variable would be the ideal candidate to
500 signal the availability of results. The user can either act when the 542 signal the availability of results. The user can either act when the
… …
718 760
719 $cb = $cv->cb ($cb->($cv)) 761 $cb = $cv->cb ($cb->($cv))
720 This is a mutator function that returns the callback set and 762 This is a mutator function that returns the callback set and
721 optionally replaces it before doing so. 763 optionally replaces it before doing so.
722 764
723 The callback will be called when the condition becomes "true", i.e. 765 The callback will be called when the condition becomes (or already
724 when "send" or "croak" are called, with the only argument being the 766 was) "true", i.e. when "send" or "croak" are called (or were
725 condition variable itself. Calling "recv" inside the callback or at 767 called), with the only argument being the condition variable itself.
768 Calling "recv" inside the callback or at any later time is
726 any later time is guaranteed not to block. 769 guaranteed not to block.
727 770
728SUPPORTED EVENT LOOPS/BACKENDS 771SUPPORTED EVENT LOOPS/BACKENDS
729 The available backend classes are (every class has its own manpage): 772 The available backend classes are (every class has its own manpage):
730 773
731 Backends that are autoprobed when no other event loop can be found. 774 Backends that are autoprobed when no other event loop can be found.
732 EV is the preferred backend when no other event loop seems to be in 775 EV is the preferred backend when no other event loop seems to be in
733 use. If EV is not installed, then AnyEvent will try Event, and, 776 use. If EV is not installed, then AnyEvent will fall back to its own
734 failing that, will fall back to its own pure-perl implementation, 777 pure-perl implementation, which is available everywhere as it comes
735 which is available everywhere as it comes with AnyEvent itself. 778 with AnyEvent itself.
736 779
737 AnyEvent::Impl::EV based on EV (interface to libev, best choice). 780 AnyEvent::Impl::EV based on EV (interface to libev, best choice).
738 AnyEvent::Impl::Event based on Event, very stable, few glitches.
739 AnyEvent::Impl::Perl pure-perl implementation, fast and portable. 781 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
740 782
741 Backends that are transparently being picked up when they are used. 783 Backends that are transparently being picked up when they are used.
742 These will be used when they are currently loaded when the first 784 These will be used when they are currently loaded when the first
743 watcher is created, in which case it is assumed that the application 785 watcher is created, in which case it is assumed that the application
744 is using them. This means that AnyEvent will automatically pick the 786 is using them. This means that AnyEvent will automatically pick the
745 right backend when the main program loads an event module before 787 right backend when the main program loads an event module before
746 anything starts to create watchers. Nothing special needs to be done 788 anything starts to create watchers. Nothing special needs to be done
747 by the main program. 789 by the main program.
748 790
791 AnyEvent::Impl::Event based on Event, very stable, few glitches.
749 AnyEvent::Impl::Glib based on Glib, slow but very stable. 792 AnyEvent::Impl::Glib based on Glib, slow but very stable.
750 AnyEvent::Impl::Tk based on Tk, very broken. 793 AnyEvent::Impl::Tk based on Tk, very broken.
751 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 794 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
752 AnyEvent::Impl::POE based on POE, very slow, some limitations. 795 AnyEvent::Impl::POE based on POE, very slow, some limitations.
796 AnyEvent::Impl::Irssi used when running within irssi.
753 797
754 Backends with special needs. 798 Backends with special needs.
755 Qt requires the Qt::Application to be instantiated first, but will 799 Qt requires the Qt::Application to be instantiated first, but will
756 otherwise be picked up automatically. As long as the main program 800 otherwise be picked up automatically. As long as the main program
757 instantiates the application before any AnyEvent watchers are 801 instantiates the application before any AnyEvent watchers are
… …
822 creates and installs the global IO::AIO watcher in a "post_detect" 866 creates and installs the global IO::AIO watcher in a "post_detect"
823 block to avoid autodetecting the event module at load time. 867 block to avoid autodetecting the event module at load time.
824 868
825 If called in scalar or list context, then it creates and returns an 869 If called in scalar or list context, then it creates and returns an
826 object that automatically removes the callback again when it is 870 object that automatically removes the callback again when it is
871 destroyed (or "undef" when the hook was immediately executed). See
827 destroyed. See Coro::BDB for a case where this is useful. 872 AnyEvent::AIO for a case where this is useful.
873
874 Example: Create a watcher for the IO::AIO module and store it in
875 $WATCHER. Only do so after the event loop is initialised, though.
876
877 our WATCHER;
878
879 my $guard = AnyEvent::post_detect {
880 $WATCHER = AnyEvent->io (fh => IO::AIO::poll_fileno, poll => 'r', cb => \&IO::AIO::poll_cb);
881 };
882
883 # the ||= is important in case post_detect immediately runs the block,
884 # as to not clobber the newly-created watcher. assigning both watcher and
885 # post_detect guard to the same variable has the advantage of users being
886 # able to just C<undef $WATCHER> if the watcher causes them grief.
887
888 $WATCHER ||= $guard;
828 889
829 @AnyEvent::post_detect 890 @AnyEvent::post_detect
830 If there are any code references in this array (you can "push" to it 891 If there are any code references in this array (you can "push" to it
831 before or after loading AnyEvent), then they will called directly 892 before or after loading AnyEvent), then they will called directly
832 after the event loop has been chosen. 893 after the event loop has been chosen.
… …
971 Event::ExecFlow 1032 Event::ExecFlow
972 High level API for event-based execution flow control. 1033 High level API for event-based execution flow control.
973 1034
974 Coro 1035 Coro
975 Has special support for AnyEvent via Coro::AnyEvent. 1036 Has special support for AnyEvent via Coro::AnyEvent.
1037
1038SIMPLIFIED AE API
1039 Starting with version 5.0, AnyEvent officially supports a second, much
1040 simpler, API that is designed to reduce the calling, typing and memory
1041 overhead.
1042
1043 See the AE manpage for details.
976 1044
977ERROR AND EXCEPTION HANDLING 1045ERROR AND EXCEPTION HANDLING
978 In general, AnyEvent does not do any error handling - it relies on the 1046 In general, AnyEvent does not do any error handling - it relies on the
979 caller to do that if required. The AnyEvent::Strict module (see also the 1047 caller to do that if required. The AnyEvent::Strict module (see also the
980 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict 1048 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict
… …
1305 through AnyEvent. The benchmark creates a lot of timers (with a zero 1373 through AnyEvent. The benchmark creates a lot of timers (with a zero
1306 timeout) and I/O watchers (watching STDOUT, a pty, to become writable, 1374 timeout) and I/O watchers (watching STDOUT, a pty, to become writable,
1307 which it is), lets them fire exactly once and destroys them again. 1375 which it is), lets them fire exactly once and destroys them again.
1308 1376
1309 Source code for this benchmark is found as eg/bench in the AnyEvent 1377 Source code for this benchmark is found as eg/bench in the AnyEvent
1310 distribution. 1378 distribution. It uses the AE interface, which makes a real difference
1379 for the EV and Perl backends only.
1311 1380
1312 Explanation of the columns 1381 Explanation of the columns
1313 *watcher* is the number of event watchers created/destroyed. Since 1382 *watcher* is the number of event watchers created/destroyed. Since
1314 different event models feature vastly different performances, each event 1383 different event models feature vastly different performances, each event
1315 loop was given a number of watchers so that overall runtime is 1384 loop was given a number of watchers so that overall runtime is
… …
1334 *destroy* is the time, in microseconds, that it takes to destroy a 1403 *destroy* is the time, in microseconds, that it takes to destroy a
1335 single watcher. 1404 single watcher.
1336 1405
1337 Results 1406 Results
1338 name watchers bytes create invoke destroy comment 1407 name watchers bytes create invoke destroy comment
1339 EV/EV 400000 224 0.47 0.35 0.27 EV native interface 1408 EV/EV 100000 223 0.47 0.43 0.27 EV native interface
1340 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers 1409 EV/Any 100000 223 0.48 0.42 0.26 EV + AnyEvent watchers
1341 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal 1410 Coro::EV/Any 100000 223 0.47 0.42 0.26 coroutines + Coro::Signal
1342 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation 1411 Perl/Any 100000 431 2.70 0.74 0.92 pure perl implementation
1343 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 1412 Event/Event 16000 516 31.16 31.84 0.82 Event native interface
1344 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 1413 Event/Any 16000 1203 42.61 34.79 1.80 Event + AnyEvent watchers
1345 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll 1414 IOAsync/Any 16000 1911 41.92 27.45 16.81 via IO::Async::Loop::IO_Poll
1346 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll 1415 IOAsync/Any 16000 1726 40.69 26.37 15.25 via IO::Async::Loop::Epoll
1347 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 1416 Glib/Any 16000 1118 89.00 12.57 51.17 quadratic behaviour
1348 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 1417 Tk/Any 2000 1346 20.96 10.75 8.00 SEGV with >> 2000 watchers
1349 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 1418 POE/Any 2000 6951 108.97 795.32 14.24 via POE::Loop::Event
1350 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select 1419 POE/Any 2000 6648 94.79 774.40 575.51 via POE::Loop::Select
1351 1420
1352 Discussion 1421 Discussion
1353 The benchmark does *not* measure scalability of the event loop very 1422 The benchmark does *not* measure scalability of the event loop very
1354 well. For example, a select-based event loop (such as the pure perl one) 1423 well. For example, a select-based event loop (such as the pure perl one)
1355 can never compete with an event loop that uses epoll when the number of 1424 can never compete with an event loop that uses epoll when the number of
… …
1366 benchmark machine, handling an event takes roughly 1600 CPU cycles with 1435 benchmark machine, handling an event takes roughly 1600 CPU cycles with
1367 EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 1436 EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000
1368 CPU cycles with POE. 1437 CPU cycles with POE.
1369 1438
1370 "EV" is the sole leader regarding speed and memory use, which are both 1439 "EV" is the sole leader regarding speed and memory use, which are both
1371 maximal/minimal, respectively. Even when going through AnyEvent, it uses 1440 maximal/minimal, respectively. When using the AE API there is zero
1441 overhead (when going through the AnyEvent API create is about 5-6 times
1442 slower, with other times being equal, so still uses far less memory than
1372 far less memory than any other event loop and is still faster than Event 1443 any other event loop and is still faster than Event natively).
1373 natively.
1374 1444
1375 The pure perl implementation is hit in a few sweet spots (both the 1445 The pure perl implementation is hit in a few sweet spots (both the
1376 constant timeout and the use of a single fd hit optimisations in the 1446 constant timeout and the use of a single fd hit optimisations in the
1377 perl interpreter and the backend itself). Nevertheless this shows that 1447 perl interpreter and the backend itself). Nevertheless this shows that
1378 it adds very little overhead in itself. Like any select-based backend 1448 it adds very little overhead in itself. Like any select-based backend
… …
1448 In this benchmark, we use 10000 socket pairs (20000 sockets), of which 1518 In this benchmark, we use 10000 socket pairs (20000 sockets), of which
1449 100 (1%) are active. This mirrors the activity of large servers with 1519 100 (1%) are active. This mirrors the activity of large servers with
1450 many connections, most of which are idle at any one point in time. 1520 many connections, most of which are idle at any one point in time.
1451 1521
1452 Source code for this benchmark is found as eg/bench2 in the AnyEvent 1522 Source code for this benchmark is found as eg/bench2 in the AnyEvent
1453 distribution. 1523 distribution. It uses the AE interface, which makes a real difference
1524 for the EV and Perl backends only.
1454 1525
1455 Explanation of the columns 1526 Explanation of the columns
1456 *sockets* is the number of sockets, and twice the number of "servers" 1527 *sockets* is the number of sockets, and twice the number of "servers"
1457 (as each server has a read and write socket end). 1528 (as each server has a read and write socket end).
1458 1529
… …
1464 forwarding it to another server. This includes deleting the old timeout 1535 forwarding it to another server. This includes deleting the old timeout
1465 and creating a new one that moves the timeout into the future. 1536 and creating a new one that moves the timeout into the future.
1466 1537
1467 Results 1538 Results
1468 name sockets create request 1539 name sockets create request
1469 EV 20000 69.01 11.16 1540 EV 20000 62.66 7.99
1470 Perl 20000 73.32 35.87 1541 Perl 20000 68.32 32.64
1471 IOAsync 20000 157.00 98.14 epoll 1542 IOAsync 20000 174.06 101.15 epoll
1472 IOAsync 20000 159.31 616.06 poll 1543 IOAsync 20000 174.67 610.84 poll
1473 Event 20000 212.62 257.32 1544 Event 20000 202.69 242.91
1474 Glib 20000 651.16 1896.30 1545 Glib 20000 557.01 1689.52
1475 POE 20000 349.67 12317.24 uses POE::Loop::Event 1546 POE 20000 341.54 12086.32 uses POE::Loop::Event
1476 1547
1477 Discussion 1548 Discussion
1478 This benchmark *does* measure scalability and overall performance of the 1549 This benchmark *does* measure scalability and overall performance of the
1479 particular event loop. 1550 particular event loop.
1480 1551
… …
1644 Async::Interrupt 1715 Async::Interrupt
1645 This slightly arcane module is used to implement fast signal 1716 This slightly arcane module is used to implement fast signal
1646 handling: To my knowledge, there is no way to do completely 1717 handling: To my knowledge, there is no way to do completely
1647 race-free and quick signal handling in pure perl. To ensure that 1718 race-free and quick signal handling in pure perl. To ensure that
1648 signals still get delivered, AnyEvent will start an interval timer 1719 signals still get delivered, AnyEvent will start an interval timer
1649 to wake up perl (and catch the signals) with soemd elay (default is 1720 to wake up perl (and catch the signals) with some delay (default is
1650 10 seconds, look for $AnyEvent::MAX_SIGNAL_LATENCY). 1721 10 seconds, look for $AnyEvent::MAX_SIGNAL_LATENCY).
1651 1722
1652 If this module is available, then it will be used to implement 1723 If this module is available, then it will be used to implement
1653 signal catching, which means that signals will not be delayed, and 1724 signal catching, which means that signals will not be delayed, and
1654 the event loop will not be interrupted regularly, which is more 1725 the event loop will not be interrupted regularly, which is more
1655 efficient (And good for battery life on laptops). 1726 efficient (And good for battery life on laptops).
1656 1727
1657 This affects not just the pure-perl event loop, but also other event 1728 This affects not just the pure-perl event loop, but also other event
1658 loops that have no signal handling on their own (e.g. Glib, Tk, Qt). 1729 loops that have no signal handling on their own (e.g. Glib, Tk, Qt).
1730
1731 Some event loops (POE, Event, Event::Lib) offer signal watchers
1732 natively, and either employ their own workarounds (POE) or use
1733 AnyEvent's workaround (using $AnyEvent::MAX_SIGNAL_LATENCY).
1734 Installing Async::Interrupt does nothing for those backends.
1659 1735
1660 EV This module isn't really "optional", as it is simply one of the 1736 EV This module isn't really "optional", as it is simply one of the
1661 backend event loops that AnyEvent can use. However, it is simply the 1737 backend event loops that AnyEvent can use. However, it is simply the
1662 best event loop available in terms of features, speed and stability: 1738 best event loop available in terms of features, speed and stability:
1663 It supports the AnyEvent API optimally, implements all the watcher 1739 It supports the AnyEvent API optimally, implements all the watcher
… …
1674 operation much. It is purely used for performance. 1750 operation much. It is purely used for performance.
1675 1751
1676 JSON and JSON::XS 1752 JSON and JSON::XS
1677 This module is required when you want to read or write JSON data via 1753 This module is required when you want to read or write JSON data via
1678 AnyEvent::Handle. It is also written in pure-perl, but can take 1754 AnyEvent::Handle. It is also written in pure-perl, but can take
1679 advantage of the ulta-high-speed JSON::XS module when it is 1755 advantage of the ultra-high-speed JSON::XS module when it is
1680 installed. 1756 installed.
1681 1757
1682 In fact, AnyEvent::Handle will use JSON::XS by default if it is 1758 In fact, AnyEvent::Handle will use JSON::XS by default if it is
1683 installed. 1759 installed.
1684 1760
… …
1741 Event::Lib, Qt, POE. 1817 Event::Lib, Qt, POE.
1742 1818
1743 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event, 1819 Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event,
1744 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl, 1820 AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl,
1745 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE, 1821 AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE,
1746 AnyEvent::Impl::IOAsync. 1822 AnyEvent::Impl::IOAsync, Anyevent::Impl::Irssi.
1747 1823
1748 Non-blocking file handles, sockets, TCP clients and servers: 1824 Non-blocking file handles, sockets, TCP clients and servers:
1749 AnyEvent::Handle, AnyEvent::Socket, AnyEvent::TLS. 1825 AnyEvent::Handle, AnyEvent::Socket, AnyEvent::TLS.
1750 1826
1751 Asynchronous DNS: AnyEvent::DNS. 1827 Asynchronous DNS: AnyEvent::DNS.

Diff Legend

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