NAME

Parallel::PreForkManager - A manager for pre-forked child worker processes

DESCRIPTION

Once upon a time, there were X modules on CPAN for managing worker processes, none of the ones I looked at worked in quite the way I wanted, so now there are X+1.

Easy management of child worker processes.

This module manages a pool of child worker processes, these work through a list of jobs returning the results to the parent process.

Each child can be made to exit and respawn after a set number of jobs, and can call back to methods in the parent process if required.

Methods can be defined for child setup and teardown.

SYNOPSIS

use Parallel::PreForkManager;
use English qw( -no_match_vars );

my $Worker = Parallel::PreForkManager->new({
    'ChildHandler'      => \&WorkHandler,
    'ParentCallback'    => \&CallbackHandler,
    'ProgressCallback'  => {
        'Log' => \&LogCallback,
    },
    'ChildSetupHook'    => \&ChildSetupHook,
    'ChildTeardownHook' => \&ChildTeardownHook,
    'ChildCount'        => 10,
    'JobsPerChild'      => 10,
});

for ( my $i=0;$i<300;$i++ ) {
    $Worker->AddJob({ 'Value' => $i });
}

$Worker->RunJobs();

sub ChildSetupHook {
    my ( $Self ) = @_;
    return;
}

sub ChildTeardownHook {
    my ( $Self ) = @_;
    return;
}

sub LogCallback {
    my ( $Self, $Data ) = @_;
    print "$PID LogCallback: $Data\n";
    return;
}

sub WorkHandler {
    my ( $Self, $Thing ) = @_;
    my $Val = $Thing->{'Value'};
    $Self->ProgressCallback( 'Log', "WORKER $PID - $Val" );
    return { 'Data' => "Printed $Val in $PID" };
}

sub CallbackHandler {
    my ( $Self, $Result ) = @_;
    my $Foo = $Result->{ 'Data' };
    print "Child returned $Foo to Parent\n";
    return;
};

CONSTRUCTOR

• new( $Args )

    my $Worker = Parellel::PreForkManager->new({
        'ChildHandler'     => \&WorkHandler,
        'ParentCallback'   => \&CallbackHandler,
        'ProgressCallback' => {
            'Log' => \&LogCallback,
        },
        'ChildCount'       => 10,
        'JobsPerChild'     => 10,
    });
  

  • ChildHandler

    The method which will do the work in the child.

  • ParentCallback

    An optional method called in the parent process with the results from each child process.

  • ProgressCallback

    An optional hashref of named methods which child processes may call back to the parent process and run.

  • ChildCount

    Number of child processes to spawn/maintain, default 10.

  • JobsPerChild

    The number of jobs a child process may run before it is respawned.

  • Timeout

    Time limit in seconds for a child process run.

  • WaitComplete

    Wait for all children to complete before returning? Defaults to 1.

    Call the WaitComplete() method to wait for children manually.

  • ChildSetupHook

    Method which runs in the child when it is spawned.

  • ChildTeardownHook

    Method which runs in the child when it is reaped.

PUBLIC METHODS

• AddJob( $Job )

  Adds a job to the job queue. A job is a reference (usually a hashref) which is passed to the child worker process for processing.

• RunJobs

  Start the children and run the jobs.

• GetResult

  Called in the parent callback, get a full results dataset from the child.

• WaitComplete

  Run in the parent process, waits for all children to complete.

• ProgressCallback

USER DEFINED METHODS

• ChildHandler( $Job )

  Passed to the constructor in the ChildHandler element. This method runs in each child to process the job queue. Its return value is optionally passed back to the parent via the defined ParentCallback method.

• ParentCallback( $Data )

  Passed to the constructor in the ParentCallback element. This method runs in the parent after each job completion in the child. The $Data is passed back from the completed child to the parent.

• ProgressCallback( $Data )

  Passed to the constructor in a named element in the ProgressCallback hashred element. These methods run in the parent, and are called from a running child by using the ProgressCallback method and given method name from within the child. The child may pass data back to the parent, and the results of the parent call are passed back to the running child.

  The parent is blocked from doing any scheduling work while this callback is running.

  This should only be used for short running tasks which need to run in the parent process.

INTERNAL METHODS

• StartChildren

  Start the right number of child processes.

• StartChild

  Start a single child process.

• Child

  Child process main processing loop.

• Receive

  IPC Receive.

• Send

  IPC Send.

JSON

Note: All communication between the parent and a child are serialised using JSON.pm, please be aware of the data type restrictions of JSON serialisation.

DEPENDENCIES

Carp
IO::Handle
IO::Select
JSON
English

BUGS

Please report bugs via the github tracker.

https://github.com/marcbradshaw/Parallel-PreForkManager/issues

REFERENCE

Obligatory XKCD reference.

https://xkcd.com/927/

AUTHORS

Marc Bradshaw, [email protected]

COPYRIGHT

Copyright (c) 2018, Marc Bradshaw.

CREDITS

Originally based on code from Parallel::Fork::BossWorker by Jeff Rodriguez, [email protected] (c) 2007 and Tim Wilde, [email protected] (c) 2011

LICENCE

This library is free software; you may redistribute it and/or modify it under the same terms as Perl itself.