ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-Fork/Fork.pm
(Generate patch)

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.42 by root, Mon Apr 8 05:44:23 2013 UTC vs.
Revision 1.49 by root, Fri Apr 19 12:56:53 2013 UTC

… …
34This module only creates processes and lets you pass file handles and 34This module only creates processes and lets you pass file handles and
35strings to it, and run perl code. It does not implement any kind of RPC - 35strings to it, and run perl code. It does not implement any kind of RPC -
36there is no back channel from the process back to you, and there is no RPC 36there is no back channel from the process back to you, and there is no RPC
37or message passing going on. 37or message passing going on.
38 38
39If you need some form of RPC, you can either implement it yourself 39If you need some form of RPC, you could use the L<AnyEvent::Fork::RPC>
40in whatever way you like, use some message-passing module such 40companion module, which adds simple RPC/job queueing to a process created
41as L<AnyEvent::MP>, some pipe such as L<AnyEvent::ZeroMQ>, use 41by this module.
42L<AnyEvent::Handle> on both sides to send e.g. JSON or Storable messages, 42
43and so on. 43Or you can implement it yourself in whatever way you like, use some
44message-passing module such as L<AnyEvent::MP>, some pipe such as
45L<AnyEvent::ZeroMQ>, use L<AnyEvent::Handle> on both sides to send
46e.g. JSON or Storable messages, and so on.
44 47
45=head2 COMPARISON TO OTHER MODULES 48=head2 COMPARISON TO OTHER MODULES
46 49
47There is an abundance of modules on CPAN that do "something fork", such as 50There is an abundance of modules on CPAN that do "something fork", such as
48L<Parallel::ForkManager>, L<AnyEvent::ForkManager>, L<AnyEvent::Worker> 51L<Parallel::ForkManager>, L<AnyEvent::ForkManager>, L<AnyEvent::Worker>
… …
221 } 224 }
222 } 225 }
223 226
224=head2 use AnyEvent::Fork as a faster fork+exec 227=head2 use AnyEvent::Fork as a faster fork+exec
225 228
226This runs C</bin/echo hi>, with stdandard output redirected to /tmp/log 229This runs C</bin/echo hi>, with standard output redirected to F</tmp/log>
227and standard error redirected to the communications socket. It is usually 230and standard error redirected to the communications socket. It is usually
228faster than fork+exec, but still lets you prepare the environment. 231faster than fork+exec, but still lets you prepare the environment.
229 232
230 open my $output, ">/tmp/log" or die "$!"; 233 open my $output, ">/tmp/log" or die "$!";
231 234
… …
251 254
252=head1 CONCEPTS 255=head1 CONCEPTS
253 256
254This module can create new processes either by executing a new perl 257This module can create new processes either by executing a new perl
255process, or by forking from an existing "template" process. 258process, or by forking from an existing "template" process.
259
260All these processes are called "child processes" (whether they are direct
261children or not), while the process that manages them is called the
262"parent process".
256 263
257Each such process comes with its own file handle that can be used to 264Each such process comes with its own file handle that can be used to
258communicate with it (it's actually a socket - one end in the new process, 265communicate with it (it's actually a socket - one end in the new process,
259one end in the main process), and among the things you can do in it are 266one end in the main process), and among the things you can do in it are
260load modules, fork new processes, send file handles to it, and execute 267load modules, fork new processes, send file handles to it, and execute
… …
370use AnyEvent; 377use AnyEvent;
371use AnyEvent::Util (); 378use AnyEvent::Util ();
372 379
373use IO::FDPass; 380use IO::FDPass;
374 381
375our $VERSION = 0.6; 382our $VERSION = 0.7;
376
377=over 4
378
379=back
380
381=cut
382 383
383# the early fork template process 384# the early fork template process
384our $EARLY; 385our $EARLY;
385 386
386# the empty template process 387# the empty template process
… …
447 448
448 # everything written 449 # everything written
449 undef $self->[WW]; 450 undef $self->[WW];
450 451
451 # invoke run callback, if any 452 # invoke run callback, if any
453 if ($self->[CB]) {
452 $self->[CB]->($self->[FH]) if $self->[CB]; 454 $self->[CB]->($self->[FH]);
455 @$self = ();
456 }
453 }; 457 };
454 458
455 () # make sure we don't leak the watcher 459 () # make sure we don't leak the watcher
456} 460}
457 461
… …
598 $_[0][PID] 602 $_[0][PID]
599} 603}
600 604
601=item $proc = $proc->eval ($perlcode, @args) 605=item $proc = $proc->eval ($perlcode, @args)
602 606
603Evaluates the given C<$perlcode> as ... perl code, while setting C<@_> to 607Evaluates the given C<$perlcode> as ... Perl code, while setting C<@_> to
604the strings specified by C<@args>, in the "main" package. 608the strings specified by C<@args>, in the "main" package.
605 609
606This call is meant to do any custom initialisation that might be required 610This call is meant to do any custom initialisation that might be required
607(for example, the C<require> method uses it). It's not supposed to be used 611(for example, the C<require> method uses it). It's not supposed to be used
608to completely take over the process, use C<run> for that. 612to completely take over the process, use C<run> for that.
… …
770 774
771 $self->[CB] = $cb; 775 $self->[CB] = $cb;
772 $self->_cmd (r => $func); 776 $self->_cmd (r => $func);
773} 777}
774 778
779=item $proc->to_fh ($cb->($fh))
780
781Flushes all commands out to the process and then calls the callback with
782the communications socket.
783
784The process object becomes unusable on return from this function - any
785further method calls result in undefined behaviour.
786
787The point of this method is to give you a file handle thta you cna pass
788to another process. In that other process, you can call C<new_from_fh
789AnyEvent::Fork::RPC> to create a new C<AnyEvent::Fork> object from it,
790thereby effectively passing a fork object to another process.
791
792=cut
793
794sub to_fh {
795 my ($self, $cb) = @_;
796
797 $self->[CB] = $cb;
798
799 unless ($self->[WW]) {
800 $self->[CB]->($self->[FH]);
801 @$self = ();
802 }
803}
804
805=item new_from_fh AnyEvent::Fork $fh
806
807Takes a file handle originally rceeived by the C<to_fh> method and creates
808a new C<AnyEvent:Fork> object. The child process itself will not change in
809any way, i.e. it will keep all the modifications done to it before calling
810C<to_fh>.
811
812The new object is very much like the original object, except that the
813C<pid> method will return C<undef> even if the process is a direct child.
814
815=cut
816
817sub new_from_fh {
818 my ($class, $fh) = @_;
819
820 $class->_new ($fh)
821}
822
775=back 823=back
776 824
777=head1 PERFORMANCE 825=head1 PERFORMANCE
778 826
779Now for some unscientific benchmark numbers (all done on an amd64 827Now for some unscientific benchmark numbers (all done on an amd64
… …
787 835
788 2079 new processes per second, using manual socketpair + fork 836 2079 new processes per second, using manual socketpair + fork
789 837
790Then I did the same thing, but instead of calling fork, I called 838Then I did the same thing, but instead of calling fork, I called
791AnyEvent::Fork->new->run ("CORE::exit") and then again waited for the 839AnyEvent::Fork->new->run ("CORE::exit") and then again waited for the
792socket form the child to close on exit. This does the same thing as manual 840socket from the child to close on exit. This does the same thing as manual
793socket pair + fork, except that what is forked is the template process 841socket pair + fork, except that what is forked is the template process
794(2440kB), and the socket needs to be passed to the server at the other end 842(2440kB), and the socket needs to be passed to the server at the other end
795of the socket first. 843of the socket first.
796 844
797 2307 new processes per second, using AnyEvent::Fork->new 845 2307 new processes per second, using AnyEvent::Fork->new
… …
804So how can C<< AnyEvent->new >> be faster than a standard fork, even 852So how can C<< AnyEvent->new >> be faster than a standard fork, even
805though it uses the same operations, but adds a lot of overhead? 853though it uses the same operations, but adds a lot of overhead?
806 854
807The difference is simply the process size: forking the 5MB process takes 855The difference is simply the process size: forking the 5MB process takes
808so much longer than forking the 2.5MB template process that the extra 856so much longer than forking the 2.5MB template process that the extra
809overhead introduced is canceled out. 857overhead is canceled out.
810 858
811If the benchmark process grows, the normal fork becomes even slower: 859If the benchmark process grows, the normal fork becomes even slower:
812 860
813 1340 new processes, manual fork of a 20MB process 861 1340 new processes, manual fork of a 20MB process
814 731 new processes, manual fork of a 200MB process 862 731 new processes, manual fork of a 200MB process
… …
874initialising them, for example, by calling C<init Gtk2> manually. 922initialising them, for example, by calling C<init Gtk2> manually.
875 923
876=item exiting calls object destructors 924=item exiting calls object destructors
877 925
878This only applies to users of L<AnyEvent::Fork:Early> and 926This only applies to users of L<AnyEvent::Fork:Early> and
879L<AnyEvent::Fork::Template>, or when initialiasing code creates objects 927L<AnyEvent::Fork::Template>, or when initialising code creates objects
880that reference external resources. 928that reference external resources.
881 929
882When a process created by AnyEvent::Fork exits, it might do so by calling 930When a process created by AnyEvent::Fork exits, it might do so by calling
883exit, or simply letting perl reach the end of the program. At which point 931exit, or simply letting perl reach the end of the program. At which point
884Perl runs all destructors. 932Perl runs all destructors.
… …
904to make it so, mostly due to the bloody broken perl that nobody seems to 952to make it so, mostly due to the bloody broken perl that nobody seems to
905care about. The fork emulation is a bad joke - I have yet to see something 953care about. The fork emulation is a bad joke - I have yet to see something
906useful that you can do with it without running into memory corruption 954useful that you can do with it without running into memory corruption
907issues or other braindamage. Hrrrr. 955issues or other braindamage. Hrrrr.
908 956
957Since fork is endlessly broken on win32 perls (it doesn't even remotely
958work within it's documented limits) and quite obviously it's not getting
959improved any time soon, the best way to proceed on windows would be to
960always use C<new_exec> and thus never rely on perl's fork "emulation".
961
909Cygwin perl is not supported at the moment due to some hilarious 962Cygwin perl is not supported at the moment due to some hilarious
910shortcomings of its API - see L<IO::FDPoll> for more details. 963shortcomings of its API - see L<IO::FDPoll> for more details. If you never
964use C<send_fh> and always use C<new_exec> to create processes, it should
965work though.
911 966
912=head1 SEE ALSO 967=head1 SEE ALSO
913 968
914L<AnyEvent::Fork::Early> (to avoid executing a perl interpreter), 969L<AnyEvent::Fork::Early>, to avoid executing a perl interpreter at all
970(part of this distribution).
971
915L<AnyEvent::Fork::Template> (to create a process by forking the main 972L<AnyEvent::Fork::Template>, to create a process by forking the main
916program at a convenient time). 973program at a convenient time (part of this distribution).
917 974
918=head1 AUTHOR 975L<AnyEvent::Fork::RPC>, for simple RPC to child processes (on CPAN).
976
977=head1 AUTHOR AND CONTACT INFORMATION
919 978
920 Marc Lehmann <schmorp@schmorp.de> 979 Marc Lehmann <schmorp@schmorp.de>
921 http://home.schmorp.de/ 980 http://software.schmorp.de/pkg/AnyEvent-Fork
922 981
923=cut 982=cut
924 983
9251 9841
926 985

Diff Legend

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