# DocBlox_Parallel_Manager

Extends \ArrayObject

Manager class for Parallel processes.

This class will manage the workers and make sure all processes are executed in parallel and not too many at the same time.

category | DocBlox
package | Parallel
author | Mike van Riel mike.vanriel@naenius.com
license | http://www.opensource.org/licenses/mit-license.php MIT
link | http://docblox-project.org

### Methods

## Tries to autodetect the optimal number of process by counting the number of processors.

    __construct(array $input = array(), integer $flags, string $iterator_class = "ArrayIterator")

### Arguments

#### $input

`array`

Input for the array object.

#### $flags

`integer`

flags for the array object.

#### $iterator_class

`string`

Iterator class for this array object.

## Convenience method to make the addition of workers explicit and allow a fluent interface.

    addWorker(\DocBlox_Parallel_Worker $worker) : self

### Arguments

#### $worker

`\DocBlox_Parallel_Worker`

The worker to add onto the queue.

### Response

`self`

## Returns true when all requirements are met.

    checkRequirements() : boolean

### Response

`boolean`

## Executes each worker.

    execute() : void

This method loops through the list of workers and tries to fork as many times as the ProcessLimit dictates at the same time.

## Forks the current process and calls the Worker's execute method OR handles the parent process' execution.

    forkAndRun(\DocBlox_Parallel_Worker $worker, array &$processes) : void

This is the really tricky part of the forking mechanism. Here we invoke pcntl_fork and either execute the forked process or deal with the parent's process based on in which process we are.

To fully understand what is going on here it is recommended to read the PHP manual page on pcntl_fork and associated articles.

If there are more workers than may be ran simultaneously then this method will wait until a slot becomes available and then starts the next worker.

throws | if we are unable to fork.

### Arguments

#### $worker

`\DocBlox_Parallel_Worker`

The worker to process.

#### $processes

`array`

## Returns the current limit on the amount of processes that can be executed at the same time.

    getProcessLimit() : integer

### Response

`integer`

## Returns whether the manager is executing the workers.

    isRunning() : boolean

### Response

`boolean`

## Adds a worker to the queue.

    offsetSet(integer $index, \DocBlox_Parallel_Worker $newval) : void

This method will prepare a worker to be executed in parallel once the execute method is invoked. A fluent interface is provided so that you can chain multiple workers in one call.

Example:

$cb1 = function () { var_dump('a'); sleep(1); }; $cb2 = function () { var_dump('b'); sleep(1); };

$mgr = new DocBlox_Parallel_Manager(); $mgr->setProcessLimit(2) ->addWorker(new DocBlox_Parallel_Worker($cb1)) ->addWorker(new DocBlox_Parallel_Worker($cb2)) ->execute();

see | \DocBlox_Parallel_Manager::execute()
throws | if this method is invoked while the manager is busy executing tasks. if the provided element is not of type DocBlox_Parallel_Worker.

### Arguments

#### $index

`integer`

The key for this worker.

#### $newval

`\DocBlox_Parallel_Worker`

The worker to add onto the queue.

## Sets how many processes at most to execute at the same time.

    setProcessLimit(integer $process_limit) : self

A fluent interface is provided so that you can chain multiple workers in one call.

see | \DocBlox_Parallel_Manager::addWorker() for an example

### Arguments

#### $process_limit

`integer`

The limit, minimum of 1

### Response

`self`

## Notifies manager that execution has started, checks requirements and returns array for child processes.

    startExecution() : array<mixed,integer>

If forking is not available because library requirements are not met than the list of workers is processed in series and a E_USER_NOTICE is triggered.

### Response

`array<mixed,integer>`

## Waits for all processes to have finished and notifies the manager that execution has stopped.

    stopExecution(array &$processes) : void

### Arguments

#### $processes

`array`

### Properties

## The maximum number of processes to run simultaneously

    process_limit : integer

var | The maximum number of processes to run simultaneously

### Type(s)

`integer`

## Tracks whether this manager is currently executing

    is_running : boolean

var | Tracks whether this manager is currently executing

### Type(s)

`boolean`