NAME
   Parallel::Runner - An object to manage running things in parallel
   processes.

DESCRIPTION
   There are several other modules to do this, you probably want one of
   them. This module exists as a super specialised parallel task manager.
   You create the object with a proces limit and callbacks for what to do
   while waiting for a free process slot, as well as a callback for what a
   process shoudl do just before exiting.

   You must explicetly call $runner->finish() when you are done. If the
   runner is destroyed before it's children are finished a warning will be
   generated and your child processes will be killed, by force if
   necessary.

   If you specify a maximum of 1 then no forking will occur, and run() will
   block until the coderef returns. You can force a fork by providing a
   boolean true value as the second argument to run(), this will force the
   runner to fork before running the coderef, however run() will still
   block until it the child exits.

SYNOPSYS
       #!/usr/bin/perl
       use strict;
       use warnings;
       use Parallel::Runner;

       my $runner = Parallel::Runner->new(4);
       $runner->run( sub { ... } );
       $runner->run( sub { ... } );
       $runner->run( sub { ... } );
       $runner->run( sub { ... } );

       # This will block until one of the previous 4 finishes
       $runner->run( sub { ... } );

       # Do not forget this.
       $runner->finish;

CONSTRUCTOR
   $runner = $class->new( $max, $accessor => $value, ... );
       Create a new instance of Parallel::Runner. $accessor can be anything
       listed under the ACCESSORS section. $max should be the maximum
       number of processes allowed, defaults to 1.

ACCESSORS
   These are simple accessors, provididng an argument sets the accessor to
   that argument, no argument it simply returns the current value.

   $val = $runner->data_callback( \&callback )
       If this is specified than IPC will be automatically enabled, and the
       final return from each process will be passed into this handler in
       the main process. Due to the way IPC works only strings/numerical
       data is passed, if you need to pass a ref you will need to serialize
       it yourself before returning it, followed by deserializing it in
       your callback.

       Example:

           # Place to put the accumulated data
           my @accum_data;

           # Create the runner with a callback that pushes the data onto our array.
           $runner = $CLASS->new( 2,
               data_callback => sub {
                   my ($data) = @_;
                   push @accum_data => $data;
               },
           );

           # 4 processes that return data
           $runner->run( sub { return "foo" });
           $runner->run( sub { return "bar" });
           $runner->run( sub { return "baz" });
           $runner->run( sub { return "bat" });
           $runner->finish;

           # Verify the data (order is not predictable)
           is_deeply(
               [ sort @accum_data ],
               [ sort qw/foo bar baz bat/ ],
               "Got all data returned by subprocesses"
           );

   $val = $runner->exit_callback( \&callback )
       Codref to call just before a child exits (called within child)

   $val = $runner->iteration_delay( $float );
       How long to wait per iterate if nothing has changed.

   $val = $runner->iteration_callback( $newval )
       Coderef to call multiple times in a loop while run() is blocking
       waiting for a process slot.

   $val = $runner->reap_callback( $newval )
       Codref to call whenever a pid is reaped using waitpid. The callback
       sub will be passed 3 values The first is the exit status of the
       child process. The second is the pid of the child process. The third
       used to be the return of waitpid, but this is depricated as Child is
       now used and throws an exception when waitpid is not what it should
       be. The third is simply the pid of the child process again. The
       final argument is the child process object itself.

           $runner->reap_callback( sub {
               my ( $status, $pid, $pid_again, $proc ) = @_;

               # Status as returned from system, so 0 is good, 1+ is bad.
               die "Child $pid did not exit 0"
                   if $status;
           });

   @children = $runner->children( @append )
       Returns a list of Child::Link::Proc objects.

   $val = $runner->pid()
       pid of the parent process

   $val = $runner->max( $newval )
       Maximum number of children

OBJECT METHODS
   run( $code )
   run( $code, $force_fork )
       Run the specified code in a child process. Blocks if no free slots
       are available. Force fork can be used to force a fork when max is 1,
       however it will still block until the child exits.

   finish()
   finish( $timeout )
   finish( $timeout, $timeoutcallback )
       Wait for all children to finish, then clean up after them. If a
       timeout is specified it will return after the timeout regardless of
       wether or not children have all exited. If there is a timeout call
       back then that code will be run upon timeout just before the method
       returns.

       NOTE: DO NOT LET YOUR RUNNER BE DESTROYED BEFORE FINISH COMPLETES
       WITHOUT A TIMEOUT.

       the runner will kill all children, possibly with force if your
       runner is destroyed with children still running, or not waited on.

   killall( $sig )
       Send all children the specified kill signal.

   DESTROY()
       Automagically called when the object is destroyed. If called while
       children are running it will forcefully clean up after you as
       follows:

       1) Sends an ugly warning.

       2) Will first give all your children 1 second to complete.

       Windows) Strawberry fails with processes, so on windows DESTROY will
       wait as long as needed, possibly forever.

       3) Sends kill signal 15 to all children then waits up to 4 seconds.

       4) Sends kill signal 9 to any remaining children then waits up to 10
       seconds

       5) Gives up and returns

FENNEC PROJECT
   This module is part of the Fennec project. See Fennec for more details.
   Fennec is a project to develop an extendable and powerful testing
   framework. Together the tools that make up the Fennec framework provide
   a potent testing environment.

   The tools provided by Fennec are also useful on their own. Sometimes a
   tool created for Fennec is useful outside the greator framework. Such
   tools are turned into their own projects. This is one such project.

   Fennec - The core framework
     The primary Fennec project that ties them all together.

AUTHORS
   Chad Granum [email protected]

COPYRIGHT
   Copyright (C) 2010 Chad Granum

   Parallel-Runner is free software; Standard perl licence.

   Parallel-Runner is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the license for
   more details.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.