1
0
mirror of https://github.com/danog/parallel.git synced 2024-12-12 09:09:35 +01:00
parallel/lib/Context/Parallel.php

394 lines
12 KiB
PHP
Raw Normal View History

2019-02-13 21:19:01 +01:00
<?php
namespace Amp\Parallel\Context;
use Amp\Loop;
use Amp\Parallel\Sync\ChannelledSocket;
2019-05-01 20:30:57 +02:00
use Amp\Parallel\Sync\ExitFailure;
2019-02-13 21:19:01 +01:00
use Amp\Parallel\Sync\ExitResult;
2019-05-01 20:30:57 +02:00
use Amp\Parallel\Sync\ExitSuccess;
use Amp\Parallel\Sync\SerializationException;
2019-02-13 21:19:01 +01:00
use Amp\Parallel\Sync\SynchronizationError;
use Amp\Promise;
use parallel\Runtime;
use function Amp\call;
/**
* Implements an execution context using native threads provided by the parallel extension.
2019-02-13 21:19:01 +01:00
*/
final class Parallel implements Context
{
const EXIT_CHECK_FREQUENCY = 250;
2019-02-13 21:19:01 +01:00
const KEY_LENGTH = 32;
/** @var string|null */
private static $autoloadPath;
/** @var int Next thread ID. */
private static $nextId = 1;
2019-02-13 21:19:01 +01:00
/** @var Internal\ProcessHub */
private $hub;
/** @var int|null */
private $id;
/** @var Runtime|null */
2019-02-13 21:19:01 +01:00
private $runtime;
/** @var ChannelledSocket|null A channel for communicating with the parallel thread. */
private $channel;
2019-02-13 21:19:01 +01:00
/** @var string Script path. */
2019-02-13 21:19:01 +01:00
private $script;
/** @var string[] */
private $args = [];
2019-02-13 21:19:01 +01:00
/** @var int */
private $oid = 0;
/** @var bool */
private $killed = false;
2019-02-13 21:19:01 +01:00
/**
* Checks if threading is enabled.
*
* @return bool True if threading is enabled, otherwise false.
*/
public static function isSupported(): bool
{
return \extension_loaded('parallel');
}
/**
* Creates and starts a new thread.
*
* @param string|array $script Path to PHP script or array with first element as path and following elements options
* to the PHP script (e.g.: ['bin/worker', 'Option1Value', 'Option2Value'].
2019-02-13 21:19:01 +01:00
* @param mixed ...$args Additional arguments to pass to the given callable.
*
* @return Promise<Thread> The thread object that was spawned.
*/
public static function run($script): Promise
2019-02-13 21:19:01 +01:00
{
$thread = new self($script);
2019-02-13 21:19:01 +01:00
return call(function () use ($thread) {
yield $thread->start();
return $thread;
});
}
/**
* @param string|array $script Path to PHP script or array with first element as path and following elements options
* to the PHP script (e.g.: ['bin/worker', 'Option1Value', 'Option2Value'].
2019-02-13 21:19:01 +01:00
*
* @throws \Error Thrown if the pthreads extension is not available.
*/
public function __construct($script)
2019-02-13 21:19:01 +01:00
{
if (!self::isSupported()) {
throw new \Error("The parallel extension is required to create parallel threads.");
}
$this->hub = Loop::getState(self::class);
if (!$this->hub instanceof Internal\ParallelHub) {
$this->hub = new Internal\ParallelHub;
Loop::setState(self::class, $this->hub);
}
if (\is_array($script)) {
$this->script = (string) \array_shift($script);
$this->args = \array_values(\array_map("strval", $script));
} else {
$this->script = (string) $script;
}
2019-02-13 21:19:01 +01:00
if (self::$autoloadPath === null) {
$paths = [
\dirname(__DIR__, 2) . \DIRECTORY_SEPARATOR . "vendor" . \DIRECTORY_SEPARATOR . "autoload.php",
\dirname(__DIR__, 4) . \DIRECTORY_SEPARATOR . "autoload.php",
];
foreach ($paths as $path) {
if (\file_exists($path)) {
self::$autoloadPath = $path;
break;
}
}
if (self::$autoloadPath === null) {
throw new \Error("Could not locate autoload.php");
}
}
}
/**
* Returns the thread to the condition before starting. The new thread can be started and run independently of the
* first thread.
*/
public function __clone()
{
$this->runtime = null;
$this->channel = null;
$this->id = null;
2019-02-13 21:19:01 +01:00
$this->oid = 0;
$this->killed = false;
2019-02-13 21:19:01 +01:00
}
/**
* Kills the thread if it is still running.
*
* @throws \Amp\Parallel\Context\ContextException
*/
public function __destruct()
{
if (\getmypid() === $this->oid) {
$this->kill();
}
}
/**
* Checks if the context is running.
*
* @return bool True if the context is running, otherwise false.
*/
public function isRunning(): bool
{
return $this->channel !== null;
2019-02-13 21:19:01 +01:00
}
/**
* Spawns the thread and begins the thread's execution.
*
* @return Promise<int> Resolved once the thread has started.
2019-02-13 21:19:01 +01:00
*
* @throws \Amp\Parallel\Context\StatusError If the thread has already been started.
* @throws \Amp\Parallel\Context\ContextException If starting the thread was unsuccessful.
*/
public function start(): Promise
{
if ($this->oid !== 0) {
throw new StatusError('The thread has already been started.');
}
$this->oid = \getmypid();
$this->runtime = new Runtime(self::$autoloadPath);
$this->id = self::$nextId++;
2019-02-13 21:19:01 +01:00
$future = $this->runtime->run(static function (int $id, string $uri, string $key, string $path, array $argv): int {
// @codeCoverageIgnoreStart
// Only executed in thread.
2019-02-13 21:19:01 +01:00
\define("AMP_CONTEXT", "parallel");
\define("AMP_CONTEXT_ID", $id);
2019-02-13 21:19:01 +01:00
if (!$socket = \stream_socket_client($uri, $errno, $errstr, 5, \STREAM_CLIENT_CONNECT)) {
\trigger_error("Could not connect to IPC socket", E_USER_ERROR);
return 1;
}
$channel = new ChannelledSocket($socket, $socket);
try {
Promise\wait($channel->send($key));
2019-02-13 21:19:01 +01:00
} catch (\Throwable $exception) {
\trigger_error("Could not send key to parent", E_USER_ERROR);
return 1;
}
try {
2019-05-01 20:30:57 +02:00
Loop::unreference(Loop::repeat(self::EXIT_CHECK_FREQUENCY, function () {
// Timer to give the chance for the PHP VM to be interrupted by Runtime::kill(), since system calls such as
// select() will not be interrupted.
}));
try {
if (!\is_file($path)) {
throw new \Error(\sprintf("No script found at '%s' (be sure to provide the full path to the script)", $path));
}
$argc = \array_unshift($argv, $path);
try {
// Protect current scope by requiring script within another function.
$callable = (function () use ($argc, $argv): callable { // Using $argc so it is available to the required script.
return require $argv[0];
})->bindTo(null, null)();
2019-05-01 20:30:57 +02:00
} catch (\TypeError $exception) {
throw new \Error(\sprintf("Script '%s' did not return a callable function", $path), 0, $exception);
} catch (\ParseError $exception) {
throw new \Error(\sprintf("Script '%s' contains a parse error", $path), 0, $exception);
}
$result = new ExitSuccess(Promise\wait(call($callable, $channel)));
} catch (\Throwable $exception) {
$result = new ExitFailure($exception);
}
Promise\wait(call(function () use ($channel, $result) {
try {
yield $channel->send($result);
} catch (SerializationException $exception) {
// Serializing the result failed. Send the reason why.
yield $channel->send(new ExitFailure($exception));
}
}));
} catch (\Throwable $exception) {
\trigger_error("Could not send result to parent; be sure to shutdown the child before ending the parent", E_USER_ERROR);
return 1;
} finally {
$channel->close();
}
return 0;
// @codeCoverageIgnoreEnd
2019-02-13 21:19:01 +01:00
}, [
$this->id,
2019-02-13 21:19:01 +01:00
$this->hub->getUri(),
$this->hub->generateKey($this->id, self::KEY_LENGTH),
2019-02-13 21:19:01 +01:00
$this->script,
$this->args
2019-02-13 21:19:01 +01:00
]);
return call(function () use ($future) {
2019-02-13 21:19:01 +01:00
try {
2019-03-08 18:12:10 +01:00
$this->channel = yield $this->hub->accept($this->id);
$this->hub->add($this->id, $this->channel, $future);
2019-02-13 21:19:01 +01:00
} catch (\Throwable $exception) {
$this->kill();
2019-02-13 21:19:01 +01:00
throw new ContextException("Starting the parallel runtime failed", 0, $exception);
}
if ($this->killed) {
$this->kill();
}
return $this->id;
2019-02-13 21:19:01 +01:00
});
}
/**
* Immediately kills the context.
*/
public function kill()
{
$this->killed = true;
if ($this->runtime !== null) {
try {
$this->runtime->kill();
} finally {
$this->close();
}
}
2019-02-13 21:19:01 +01:00
}
/**
* Closes channel and socket if still open.
*/
private function close()
{
$this->runtime = null;
if ($this->channel !== null) {
$this->channel->close();
2019-02-13 21:19:01 +01:00
}
$this->channel = null;
2019-03-08 18:12:10 +01:00
$this->hub->remove($this->id);
2019-02-13 21:19:01 +01:00
}
/**
* Gets a promise that resolves when the context ends and joins with the
* parent context.
*
* @return \Amp\Promise<mixed>
*
* @throws StatusError Thrown if the context has not been started.
* @throws SynchronizationError Thrown if an exit status object is not received.
* @throws ContextException If the context stops responding.
*/
public function join(): Promise
{
if ($this->channel === null) {
2019-02-13 21:19:01 +01:00
throw new StatusError('The thread has not been started or has already finished.');
}
return call(function () {
try {
$response = yield $this->channel->receive();
$this->close();
2019-02-13 21:19:01 +01:00
} catch (\Throwable $exception) {
$this->kill();
throw new ContextException("Failed to receive result from thread", 0, $exception);
}
if (!$response instanceof ExitResult) {
$this->kill();
throw new SynchronizationError('Did not receive an exit result from thread.');
2019-02-13 21:19:01 +01:00
}
return $response->getResult();
});
}
/**
* {@inheritdoc}
*/
public function receive(): Promise
{
if ($this->channel === null) {
2019-02-13 21:19:01 +01:00
throw new StatusError('The process has not been started.');
}
return call(function () {
$data = yield $this->channel->receive();
2019-02-13 21:19:01 +01:00
if ($data instanceof ExitResult) {
$data = $data->getResult();
throw new SynchronizationError(\sprintf(
'Thread process unexpectedly exited with result of type: %s',
\is_object($data) ? \get_class($data) : \gettype($data)
));
}
return $data;
});
}
/**
* {@inheritdoc}
*/
public function send($data): Promise
{
if ($this->channel === null) {
2019-02-13 21:19:01 +01:00
throw new StatusError('The thread has not been started or has already finished.');
}
if ($data instanceof ExitResult) {
throw new \Error('Cannot send exit result objects.');
}
return $this->channel->send($data);
2019-02-13 21:19:01 +01:00
}
/**
* Returns the ID of the thread. This ID will be unique to this process.
*
* @return int
*
* @throws \Amp\Process\StatusError
*/
public function getId(): int
{
if ($this->id === null) {
throw new StatusError('The thread has not been started');
}
return $this->id;
}
2019-02-13 21:19:01 +01:00
}