contrib/DocBlox/Parallel/Manager.php
DocBlox
PHP Version 5
- Author
- Mike van Riel
- Category
- DocBlox
- Copyright
- 2010-2011 Mike van Riel / Naenius (http://www.naenius.com)
- License
- MIT
- Link
- http://docblox-project.org
- Package
- Parallel
\DocBlox_Parallel_Manager
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.
- Parent(s)
- \ArrayObject
- Author
- Mike van Riel
- Category
- DocBlox
- License
- MIT
- Link
- http://docblox-project.org
Properties


boolean
$is_running= 'false'
false
Details- Type
- boolean
Methods


__construct(
array $input
=
array(), int $flags
=
0, string $iterator_class
=
"ArrayIterator"
)
:
void
Tries to autodetect the optimal number of process by counting the number of processors.
Name | Type | Description |
---|---|---|
$input | array | Input for the array object. |
$flags | int | flags for the array object. |
$iterator_class | string | Iterator class for this array object. |


addWorker(
\DocBlox_Parallel_Worker $worker
)
:
\DocBlox_Parallel_Manager
Convenience method to make the addition of workers explicit and allow a fluent interface.
Name | Type | Description |
---|---|---|
$worker | \DocBlox_Parallel_Worker | The worker to add onto the queue. |
Type | Description |
---|---|
\DocBlox_Parallel_Manager |
- Fluent
- This method is part of a fluent interface and will return the same instance


checkRequirements(
)
:
bool
Returns true when all requirements are met.
Type | Description |
---|---|
bool |


execute(
)
:
void
Executes each worker.
This method loops through the list of workers and tries to fork as many times as the ProcessLimit dictates at the same time.


forkAndRun(
\DocBlox_Parallel_Worker $worker, \int[] $processes
)
:
void
Forks the current process and calls the Worker's execute method OR handles the parent process' execution.
This is the really tricky part of the forking mechanism. Here we invoke {@link http://www.php.net/manual/en/function.pcntl-fork.php 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 {@link http://www.php.net/manual/en/function.pcntl-fork.php 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.
Name | Type | Description |
---|---|---|
$worker | \DocBlox_Parallel_Worker | The worker to process. |
$processes | \int[] | &$processes The list of running processes. |
Exception | Description |
---|---|
\RuntimeException | if we are unable to fork. |


getProcessLimit(
)
:
int
Returns the current limit on the amount of processes that can be executed at the same time.
Type | Description |
---|---|
int |


isRunning(
)
:
boolean
Returns whether the manager is executing the workers.
Type | Description |
---|---|
boolean |


offsetSet(
int $index, \DocBlox_Parallel_Worker $newval
)
:
void
Adds a worker to to the queue.
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();
Name | Type | Description |
---|---|---|
$index | int | The key for this worker. |
$newval | \DocBlox_Parallel_Worker | The worker to add onto the queue. |
Exception | Description |
---|---|
\RuntimeException | if this method is invoked while the manager is busy executing tasks. |
\InvalidArgumentException | if the provided element is not of type DocBlox_Parallel_Worker. |


setProcessLimit(
int $process_limit
)
:
\DocBlox_Parallel_Manager
Sets how many processes at most to execute at the same time.
A fluent interface is provided so that you can chain multiple workers in one call.
Name | Type | Description |
---|---|---|
$process_limit | int | The limit, minimum of 1 |
Type | Description |
---|---|
\DocBlox_Parallel_Manager |
- Fluent
- This method is part of a fluent interface and will return the same instance
- See
- \DocBlox_Parallel_Manager::addWorker()


startExecution(
)
:
\int[]
Notifies manager that execution has started, checks requirements and returns array for child processes.
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.
Type | Description |
---|---|
\int[] |


stopExecution(
\int[] $processes
)
:
void
Waits for all processes to have finished and notifies the manager that execution has stopped.
Name | Type | Description |
---|---|---|
$processes | \int[] | &$processes List of running processes. |