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

Comparing AnyEvent/README (file contents):
Revision 1.28 by root, Sat Jul 12 20:45:27 2008 UTC vs.
Revision 1.38 by root, Sun Apr 26 18:12:53 2009 UTC

… …
5 loops 5 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 { ... });
12
13 # one-shot or repeating timers
14 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
15 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
16
17 print AnyEvent->now; # prints current event loop time
18 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
19
20 # POSIX signal
21 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
22
23 # child process exit
24 my $w = AnyEvent->child (pid => $pid, cb => sub {
25 my ($pid, $status) = @_;
11 ... 26 ...
12 }); 27 });
13 28
14 my $w = AnyEvent->timer (after => $seconds, cb => sub { 29 # called when event loop idle (if applicable)
15 ... 30 my $w = AnyEvent->idle (cb => sub { ... });
16 });
17 31
18 my $w = AnyEvent->condvar; # stores whether a condition was flagged 32 my $w = AnyEvent->condvar; # stores whether a condition was flagged
19 $w->send; # wake up current and all future recv's 33 $w->send; # wake up current and all future recv's
20 $w->recv; # enters "main loop" till $condvar gets ->send 34 $w->recv; # enters "main loop" till $condvar gets ->send
35 # use a condvar in callback mode:
36 $w->cb (sub { $_[0]->recv });
21 37
22INTRODUCTION/TUTORIAL 38INTRODUCTION/TUTORIAL
23 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
24 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
25 manpage. 41 manpage.
… …
123 These watchers are normal Perl objects with normal Perl lifetime. After 139 These watchers are normal Perl objects with normal Perl lifetime. After
124 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
125 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
126 in control). 142 in control).
127 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
128 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
129 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
130 to it). 152 to it).
131 153
132 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.
… …
147 169
148 I/O WATCHERS 170 I/O WATCHERS
149 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
150 the following mandatory key-value pairs as arguments: 172 the following mandatory key-value pairs as arguments:
151 173
152 "fh" the Perl *file handle* (*not* file descriptor) to watch for events 174 "fh" is the Perl *file handle* (*not* file descriptor) to watch for
153 (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
154 "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
155 watcher waiting for "r"eadable or "w"ritable events, respectively. "cb" 182 watcher waiting for "r"eadable or "w"ritable events, respectively.
183
156 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.
157 185
158 Although the callback might get passed parameters, their value and 186 Although the callback might get passed parameters, their value and
159 presence is undefined and you cannot rely on them. Portable AnyEvent 187 presence is undefined and you cannot rely on them. Portable AnyEvent
160 callbacks cannot use arguments passed to I/O watcher callbacks. 188 callbacks cannot use arguments passed to I/O watcher callbacks.
161 189
… …
293 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
294 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
295 the difference between "AnyEvent->time" and "AnyEvent->now" into 323 the difference between "AnyEvent->time" and "AnyEvent->now" into
296 account. 324 account.
297 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
298 SIGNAL WATCHERS 340 SIGNAL WATCHERS
299 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
300 *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
301 callback to be invoked whenever a signal occurs. 343 callback to be invoked whenever a signal occurs.
302 344
… …
321 363
322 CHILD PROCESS WATCHERS 364 CHILD PROCESS WATCHERS
323 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.
324 366
325 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
326 watches for any child process exit). The watcher will trigger as often 368 watches for any child process exit). The watcher will triggered only
327 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
328 signal handler for "SIGCHLD". The callback will be called with the pid 370 on any trace events (stopped/continued).
329 and exit status (as returned by waitpid), so unlike other watcher types, 371
330 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).
331 380
332 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
333 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
334 could have exited already (and no SIGCHLD will be sent anymore). 383 could have exited already (and no SIGCHLD will be sent anymore).
335 384
… …
358 ); 407 );
359 408
360 # do something else, then wait for process exit 409 # do something else, then wait for process exit
361 $done->recv; 410 $done->recv;
362 411
412 IDLE WATCHERS
413 Sometimes there is a need to do something, but it is not so important to
414 do it instantly, but only when there is nothing better to do. This
415 "nothing better to do" is usually defined to be "no other events need
416 attention by the event loop".
417
418 Idle watchers ideally get invoked when the event loop has nothing better
419 to do, just before it would block the process to wait for new events.
420 Instead of blocking, the idle watcher is invoked.
421
422 Most event loops unfortunately do not really support idle watchers (only
423 EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
424 will simply call the callback "from time to time".
425
426 Example: read lines from STDIN, but only process them when the program
427 is otherwise idle:
428
429 my @lines; # read data
430 my $idle_w;
431 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
432 push @lines, scalar <STDIN>;
433
434 # start an idle watcher, if not already done
435 $idle_w ||= AnyEvent->idle (cb => sub {
436 # handle only one line, when there are lines left
437 if (my $line = shift @lines) {
438 print "handled when idle: $line";
439 } else {
440 # otherwise disable the idle watcher again
441 undef $idle_w;
442 }
443 });
444 });
445
363 CONDITION VARIABLES 446 CONDITION VARIABLES
364 If you are familiar with some event loops you will know that all of them 447 If you are familiar with some event loops you will know that all of them
365 require you to run some blocking "loop", "run" or similar function that 448 require you to run some blocking "loop", "run" or similar function that
366 will actively watch for new events and call your callbacks. 449 will actively watch for new events and call your callbacks.
367 450
… …
371 The instrument to do that is called a "condition variable", so called 454 The instrument to do that is called a "condition variable", so called
372 because they represent a condition that must become true. 455 because they represent a condition that must become true.
373 456
374 Condition variables can be created by calling the "AnyEvent->condvar" 457 Condition variables can be created by calling the "AnyEvent->condvar"
375 method, usually without arguments. The only argument pair allowed is 458 method, usually without arguments. The only argument pair allowed is
459
376 "cb", which specifies a callback to be called when the condition 460 "cb", which specifies a callback to be called when the condition
377 variable becomes true. 461 variable becomes true, with the condition variable as the first argument
462 (but not the results).
378 463
379 After creation, the condition variable is "false" until it becomes 464 After creation, the condition variable is "false" until it becomes
380 "true" by calling the "send" method (or calling the condition variable 465 "true" by calling the "send" method (or calling the condition variable
381 as if it were a callback, read about the caveats in the description for 466 as if it were a callback, read about the caveats in the description for
382 the "->send" method). 467 the "->send" method).
… …
438 523
439 my $done = AnyEvent->condvar; 524 my $done = AnyEvent->condvar;
440 my $delay = AnyEvent->timer (after => 5, cb => $done); 525 my $delay = AnyEvent->timer (after => 5, cb => $done);
441 $done->recv; 526 $done->recv;
442 527
528 Example: Imagine an API that returns a condvar and doesn't support
529 callbacks. This is how you make a synchronous call, for example from the
530 main program:
531
532 use AnyEvent::CouchDB;
533
534 ...
535
536 my @info = $couchdb->info->recv;
537
538 And this is how you would just ste a callback to be called whenever the
539 results are available:
540
541 $couchdb->info->cb (sub {
542 my @info = $_[0]->recv;
543 });
544
443 METHODS FOR PRODUCERS 545 METHODS FOR PRODUCERS
444 These methods should only be used by the producing side, i.e. the 546 These methods should only be used by the producing side, i.e. the
445 code/module that eventually sends the signal. Note that it is also the 547 code/module that eventually sends the signal. Note that it is also the
446 producer side which creates the condvar in most cases, but it isn't 548 producer side which creates the condvar in most cases, but it isn't
447 uncommon for the consumer to create it as well. 549 uncommon for the consumer to create it as well.
… …
567 669
568 $bool = $cv->ready 670 $bool = $cv->ready
569 Returns true when the condition is "true", i.e. whether "send" or 671 Returns true when the condition is "true", i.e. whether "send" or
570 "croak" have been called. 672 "croak" have been called.
571 673
572 $cb = $cv->cb ([new callback]) 674 $cb = $cv->cb ($cb->($cv))
573 This is a mutator function that returns the callback set and 675 This is a mutator function that returns the callback set and
574 optionally replaces it before doing so. 676 optionally replaces it before doing so.
575 677
576 The callback will be called when the condition becomes "true", i.e. 678 The callback will be called when the condition becomes "true", i.e.
577 when "send" or "croak" are called, with the only argument being the 679 when "send" or "croak" are called, with the only argument being the
… …
742 844
743 AnyEvent::IGS 845 AnyEvent::IGS
744 A non-blocking interface to the Internet Go Server protocol (used by 846 A non-blocking interface to the Internet Go Server protocol (used by
745 App::IGS). 847 App::IGS).
746 848
849 AnyEvent::IRC
850 AnyEvent based IRC client module family (replacing the older
747 Net::IRC3 851 Net::IRC3).
748 AnyEvent based IRC client module family.
749 852
750 Net::XMPP2 853 Net::XMPP2
751 AnyEvent based XMPP (Jabber protocol) module family. 854 AnyEvent based XMPP (Jabber protocol) module family.
752 855
753 Net::FCP 856 Net::FCP
… …
762 865
763 IO::Lambda 866 IO::Lambda
764 The lambda approach to I/O - don't ask, look there. Can use 867 The lambda approach to I/O - don't ask, look there. Can use
765 AnyEvent. 868 AnyEvent.
766 869
767SUPPLYING YOUR OWN EVENT MODEL INTERFACE 870ERROR AND EXCEPTION HANDLING
768 This is an advanced topic that you do not normally need to use AnyEvent 871 In general, AnyEvent does not do any error handling - it relies on the
769 in a module. This section is only of use to event loop authors who want 872 caller to do that if required. The AnyEvent::Strict module (see also the
770 to provide AnyEvent compatibility. 873 "PERL_ANYEVENT_STRICT" environment variable, below) provides strict
874 checking of all AnyEvent methods, however, which is highly useful during
875 development.
771 876
772 If you need to support another event library which isn't directly 877 As for exception handling (i.e. runtime errors and exceptions thrown
773 supported by AnyEvent, you can supply your own interface to it by 878 while executing a callback), this is not only highly event-loop
774 pushing, before the first watcher gets created, the package name of the 879 specific, but also not in any way wrapped by this module, as this is the
775 event module and the package name of the interface to use onto 880 job of the main program.
776 @AnyEvent::REGISTRY. You can do that before and even without loading
777 AnyEvent, so it is reasonably cheap.
778 881
779 Example: 882 The pure perl event loop simply re-throws the exception (usually within
780 883 "condvar->recv"), the Event and EV modules call "$Event/EV::DIED->()",
781 push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::]; 884 Glib uses "install_exception_handler" and so on.
782
783 This tells AnyEvent to (literally) use the "urxvt::anyevent::"
784 package/class when it finds the "urxvt" package/module is already
785 loaded.
786
787 When AnyEvent is loaded and asked to find a suitable event model, it
788 will first check for the presence of urxvt by trying to "use" the
789 "urxvt::anyevent" module.
790
791 The class should provide implementations for all watcher types. See
792 AnyEvent::Impl::EV (source code), AnyEvent::Impl::Glib (Source code) and
793 so on for actual examples. Use "perldoc -m AnyEvent::Impl::Glib" to see
794 the sources.
795
796 If you don't provide "signal" and "child" watchers than AnyEvent will
797 provide suitable (hopefully) replacements.
798
799 The above example isn't fictitious, the *rxvt-unicode* (a.k.a. urxvt)
800 terminal emulator uses the above line as-is. An interface isn't included
801 in AnyEvent because it doesn't make sense outside the embedded
802 interpreter inside *rxvt-unicode*, and it is updated and maintained as
803 part of the *rxvt-unicode* distribution.
804
805 *rxvt-unicode* also cheats a bit by not providing blocking access to
806 condition variables: code blocking while waiting for a condition will
807 "die". This still works with most modules/usages, and blocking calls
808 must not be done in an interactive application, so it makes sense.
809 885
810ENVIRONMENT VARIABLES 886ENVIRONMENT VARIABLES
811 The following environment variables are used by this module: 887 The following environment variables are used by this module or its
888 submodules:
812 889
813 "PERL_ANYEVENT_VERBOSE" 890 "PERL_ANYEVENT_VERBOSE"
814 By default, AnyEvent will be completely silent except in fatal 891 By default, AnyEvent will be completely silent except in fatal
815 conditions. You can set this environment variable to make AnyEvent 892 conditions. You can set this environment variable to make AnyEvent
816 more talkative. 893 more talkative.
… …
829 thoroughly check the arguments passed to most method calls. If it 906 thoroughly check the arguments passed to most method calls. If it
830 finds any problems it will croak. 907 finds any problems it will croak.
831 908
832 In other words, enables "strict" mode. 909 In other words, enables "strict" mode.
833 910
834 Unlike "use strict" it is definitely recommended ot keep it off in 911 Unlike "use strict", it is definitely recommended ot keep it off in
835 production. 912 production. Keeping "PERL_ANYEVENT_STRICT=1" in your environment
913 while developing programs can be very useful, however.
836 914
837 "PERL_ANYEVENT_MODEL" 915 "PERL_ANYEVENT_MODEL"
838 This can be used to specify the event model to be used by AnyEvent, 916 This can be used to specify the event model to be used by AnyEvent,
839 before auto detection and -probing kicks in. It must be a string 917 before auto detection and -probing kicks in. It must be a string
840 consisting entirely of ASCII letters. The string "AnyEvent::Impl::" 918 consisting entirely of ASCII letters. The string "AnyEvent::Impl::"
… …
859 mentioned will be used, and preference will be given to protocols 937 mentioned will be used, and preference will be given to protocols
860 mentioned earlier in the list. 938 mentioned earlier in the list.
861 939
862 This variable can effectively be used for denial-of-service attacks 940 This variable can effectively be used for denial-of-service attacks
863 against local programs (e.g. when setuid), although the impact is 941 against local programs (e.g. when setuid), although the impact is
864 likely small, as the program has to handle connection errors 942 likely small, as the program has to handle conenction and other
865 already- 943 failures anyways.
866 944
867 Examples: "PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6" - prefer IPv4 over 945 Examples: "PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6" - prefer IPv4 over
868 IPv6, but support both and try to use both. 946 IPv6, but support both and try to use both.
869 "PERL_ANYEVENT_PROTOCOLS=ipv4" - only support IPv4, never try to 947 "PERL_ANYEVENT_PROTOCOLS=ipv4" - only support IPv4, never try to
870 resolve or contact IPv6 addresses. 948 resolve or contact IPv6 addresses.
… …
881 EDNS0 in its DNS requests. 959 EDNS0 in its DNS requests.
882 960
883 "PERL_ANYEVENT_MAX_FORKS" 961 "PERL_ANYEVENT_MAX_FORKS"
884 The maximum number of child processes that 962 The maximum number of child processes that
885 "AnyEvent::Util::fork_call" will create in parallel. 963 "AnyEvent::Util::fork_call" will create in parallel.
964
965SUPPLYING YOUR OWN EVENT MODEL INTERFACE
966 This is an advanced topic that you do not normally need to use AnyEvent
967 in a module. This section is only of use to event loop authors who want
968 to provide AnyEvent compatibility.
969
970 If you need to support another event library which isn't directly
971 supported by AnyEvent, you can supply your own interface to it by
972 pushing, before the first watcher gets created, the package name of the
973 event module and the package name of the interface to use onto
974 @AnyEvent::REGISTRY. You can do that before and even without loading
975 AnyEvent, so it is reasonably cheap.
976
977 Example:
978
979 push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::];
980
981 This tells AnyEvent to (literally) use the "urxvt::anyevent::"
982 package/class when it finds the "urxvt" package/module is already
983 loaded.
984
985 When AnyEvent is loaded and asked to find a suitable event model, it
986 will first check for the presence of urxvt by trying to "use" the
987 "urxvt::anyevent" module.
988
989 The class should provide implementations for all watcher types. See
990 AnyEvent::Impl::EV (source code), AnyEvent::Impl::Glib (Source code) and
991 so on for actual examples. Use "perldoc -m AnyEvent::Impl::Glib" to see
992 the sources.
993
994 If you don't provide "signal" and "child" watchers than AnyEvent will
995 provide suitable (hopefully) replacements.
996
997 The above example isn't fictitious, the *rxvt-unicode* (a.k.a. urxvt)
998 terminal emulator uses the above line as-is. An interface isn't included
999 in AnyEvent because it doesn't make sense outside the embedded
1000 interpreter inside *rxvt-unicode*, and it is updated and maintained as
1001 part of the *rxvt-unicode* distribution.
1002
1003 *rxvt-unicode* also cheats a bit by not providing blocking access to
1004 condition variables: code blocking while waiting for a condition will
1005 "die". This still works with most modules/usages, and blocking calls
1006 must not be done in an interactive application, so it makes sense.
886 1007
887EXAMPLE PROGRAM 1008EXAMPLE PROGRAM
888 The following program uses an I/O watcher to read data from STDIN, a 1009 The following program uses an I/O watcher to read data from STDIN, a
889 timer to display a message once per second, and a condition variable to 1010 timer to display a message once per second, and a condition variable to
890 quit the program when the user enters quit: 1011 quit the program when the user enters quit:
… …
1077 *destroy* is the time, in microseconds, that it takes to destroy a 1198 *destroy* is the time, in microseconds, that it takes to destroy a
1078 single watcher. 1199 single watcher.
1079 1200
1080 Results 1201 Results
1081 name watchers bytes create invoke destroy comment 1202 name watchers bytes create invoke destroy comment
1082 EV/EV 400000 244 0.56 0.46 0.31 EV native interface 1203 EV/EV 400000 224 0.47 0.35 0.27 EV native interface
1083 EV/Any 100000 244 2.50 0.46 0.29 EV + AnyEvent watchers 1204 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers
1084 CoroEV/Any 100000 244 2.49 0.44 0.29 coroutines + Coro::Signal 1205 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal
1085 Perl/Any 100000 513 4.92 0.87 1.12 pure perl implementation 1206 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation
1086 Event/Event 16000 516 31.88 31.30 0.85 Event native interface 1207 Event/Event 16000 517 32.20 31.80 0.81 Event native interface
1087 Event/Any 16000 590 35.75 31.42 1.08 Event + AnyEvent watchers 1208 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers
1088 Glib/Any 16000 1357 98.22 12.41 54.00 quadratic behaviour 1209 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour
1089 Tk/Any 2000 1860 26.97 67.98 14.00 SEGV with >> 2000 watchers 1210 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers
1090 POE/Event 2000 6644 108.64 736.02 14.73 via POE::Loop::Event 1211 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event
1091 POE/Select 2000 6343 94.13 809.12 565.96 via POE::Loop::Select 1212 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select
1092 1213
1093 Discussion 1214 Discussion
1094 The benchmark does *not* measure scalability of the event loop very 1215 The benchmark does *not* measure scalability of the event loop very
1095 well. For example, a select-based event loop (such as the pure perl one) 1216 well. For example, a select-based event loop (such as the pure perl one)
1096 can never compete with an event loop that uses epoll when the number of 1217 can never compete with an event loop that uses epoll when the number of
… …
1277 1398
1278 Summary 1399 Summary
1279 * C-based event loops perform very well with small number of watchers, 1400 * C-based event loops perform very well with small number of watchers,
1280 as the management overhead dominates. 1401 as the management overhead dominates.
1281 1402
1403SIGNALS
1404 AnyEvent currently installs handlers for these signals:
1405
1406 SIGCHLD
1407 A handler for "SIGCHLD" is installed by AnyEvent's child watcher
1408 emulation for event loops that do not support them natively. Also,
1409 some event loops install a similar handler.
1410
1411 SIGPIPE
1412 A no-op handler is installed for "SIGPIPE" when $SIG{PIPE} is
1413 "undef" when AnyEvent gets loaded.
1414
1415 The rationale for this is that AnyEvent users usually do not really
1416 depend on SIGPIPE delivery (which is purely an optimisation for
1417 shell use, or badly-written programs), but "SIGPIPE" can cause
1418 spurious and rare program exits as a lot of people do not expect
1419 "SIGPIPE" when writing to some random socket.
1420
1421 The rationale for installing a no-op handler as opposed to ignoring
1422 it is that this way, the handler will be restored to defaults on
1423 exec.
1424
1425 Feel free to install your own handler, or reset it to defaults.
1426
1282FORK 1427FORK
1283 Most event libraries are not fork-safe. The ones who are usually are 1428 Most event libraries are not fork-safe. The ones who are usually are
1284 because they rely on inefficient but fork-safe "select" or "poll" calls. 1429 because they rely on inefficient but fork-safe "select" or "poll" calls.
1285 Only EV is fully fork-aware. 1430 Only EV is fully fork-aware.
1286 1431
… …
1309 1454
1310BUGS 1455BUGS
1311 Perl 5.8 has numerous memleaks that sometimes hit this module and are 1456 Perl 5.8 has numerous memleaks that sometimes hit this module and are
1312 hard to work around. If you suffer from memleaks, first upgrade to Perl 1457 hard to work around. If you suffer from memleaks, first upgrade to Perl
1313 5.10 and check wether the leaks still show up. (Perl 5.10.0 has other 1458 5.10 and check wether the leaks still show up. (Perl 5.10.0 has other
1314 annoying mamleaks, such as leaking on "map" and "grep" but it is usually 1459 annoying memleaks, such as leaking on "map" and "grep" but it is usually
1315 not as pronounced). 1460 not as pronounced).
1316 1461
1317SEE ALSO 1462SEE ALSO
1318 Utility functions: AnyEvent::Util. 1463 Utility functions: AnyEvent::Util.
1319 1464

Diff Legend

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