package.xml 0000664 0001750 0001750 00000026036 12333375647 010141 0 ustar
pthreads
pecl.php.net
Threading API
A compatible Threading API for PHP5.3+
Joe Watkins
krakjoe
pthreads@pthreads.org
yes
2014-05-10
10:12:55
2.0.6
2.0.6
stable
stable
PHP License
fix build in windows
5.3.0
1.4.0b1
pthreads
pthreads-2.0.6/examples/Benchmark.php 0000664 0001750 0001750 00000001430 12333375647 014507 0 ustar start();
$ts[]=$t;
}
$ts = [];
/* end test */
$ti [] = $max/(microtime(true)-$s);
printf(".");
} while ($it++ < $sample);
printf(" %.3f tps\n", array_sum($ti) / count($ti));
?>
pthreads-2.0.6/examples/CallAnyFunction.php 0000664 0001750 0001750 00000004277 12333375647 015662 0 ustar method = $method;
$this->params = $params;
$this->result = null;
$this->joined = false;
}
/**
* The smallest thread in the world
**/
public function run(){
if (($this->result=call_user_func_array($this->method, $this->params))) {
return true;
} else return false;
}
/**
* Static method to create your threads from functions ...
**/
public static function call($method, $params){
$thread = new Async($method, $params);
if($thread->start()){
return $thread;
} /** else throw Nastyness **/
}
/**
* Do whatever, result stored in $this->result, don't try to join twice
**/
public function __toString(){
if(!$this->joined) {
$this->joined = true;
$this->join();
}
return $this->result;
}
}
/* here's us calling file_get_contents in a thread of it's own */
$future = Async::call("file_get_contents", array("http://www.php.net"));
/* here's us counting the bytes out, note, __toString() magic joined so no need to join explicitly */
printf("Got %d bytes from php.net\n", strlen((string)$future));
/* you can reference again as a string because you cached the result, YOU CANNOT JOIN TWICE */
printf("First 16 chars: %s\n", substr((string)$future, 0, 16));
/* if you have no __toString(): */
/* $response = $future->result; */
/* you could also not use a reference to the thread,
if the threads job was to say, log stats and you do not need to know when or how it returns,
then you could just Async::call at the beginning of the request and by the end it would be finished */
?> pthreads-2.0.6/examples/Fetch.php 0000664 0001750 0001750 00000003320 12333375647 013646 0 ustar sym = 10245;
$this->arr = array(
"1", "2", "3"
);
/*
* objects do work, no preparation needed ...
* read/write objects isn't finalized ..
* so do the dance to make it work ...
*/
$obj = new TestObject();
$obj->val = "testval";
$this->obj = $obj;
/*
* will always work
*/
$this->objs = serialize($this->obj);
/*
* nooooooo
*/
$this->res = fopen("php://stdout", "w");
/*
* tell the waiting process we have created symbols and fetch will succeed
*/
$this->synchronized(function(){
$this->notify();
});
/* wait for the process to be finished with the stream */
$this->synchronized(function(){
$this->wait();
});
}
}
$thread = new Fetching();
$thread->start();
$thread->synchronized(function($me){
$me->wait();
}, $thread);
/*
* we just got notified that there are symbols waiting
*/
foreach(array("sym", "arr", "obj", "objs", "res") as $symbol){
printf("\$thread->%s: ", $symbol);
$fetched = $thread->$symbol;
if ($fetched) {
switch($symbol){
/*
* manual unserialize
*/
case "objs":
var_dump(unserialize($fetched));
break;
default: var_dump($fetched);
}
}
printf("\n");
}
/* notify the thread so it can destroy resource */
$thread->synchronized(function($me){
$me->notify();
}, $thread);
?>
pthreads-2.0.6/examples/KeepAliveSession.php 0000664 0001750 0001750 00000015140 12333375647 016031 0 ustar 5.3 with pthreads enabled.
*
* @author Tim Wagner
* @version 0.1.0
* @link https://github.com/krakjoe/pthreads
*/
class Test extends Thread
{
/**
* Socket resource to read/write from/to.
*
* @var resource
*/
protected $socket;
/**
* Initializes the thread with the socket resource
* necessary for reading/writing.
*
* @param resource $socket The socket resource
* @return void
*/
public function __construct($socket)
{
$this->socket = $socket;
}
/**
* Found on php.net {@link http://pa1.php.net/function.http-parse-headers#111226}, thanks
* to anonymous!
*
* @param string $header The header to parse
* @return array The headers parsed from the passed string
* @see http://pa1.php.net/function.http-parse-headers#111226
*/
public function http_parse_headers($header)
{
$retVal = array();
$fields = explode("\r\n", preg_replace('/\x0D\x0A[\x09\x20]+/', ' ', $header));
foreach( $fields as $field ) {
if (preg_match('/([^:]+): (.+)/m', $field, $match)) {
$match[1] = preg_replace('/(?<=^|[\x09\x20\x2D])./e', 'strtoupper("\0")', strtolower(trim($match[1])));
if( isset($retVal[$match[1]]) ) {
if (!is_array($retVal[$match[1]])) {
$retVal[$match[1]] = array($retVal[$match[1]]);
}
$retVal[$match[1]][] = $match[2];
} else {
$retVal[$match[1]] = trim($match[2]);
}
}
}
return $retVal;
}
/**
* The thread's run() method that runs asynchronously.
*
* @link http://www.php.net/manual/en/thread.run.php
*/
public function run()
{
// initialize the local variables and the socket
$threadId = $this->getThreadId();
$counter = 1;
$connectionOpen = true;
$startTime = time();
$timeout = 5;
$maxRequests = 5;
$client = socket_accept($this->socket);
socket_set_option($client, SOL_SOCKET, SO_RCVTIMEO, array("sec" => $timeout, "usec" => 0));
do {
// we only read headers here, because it's an example
$buffer = '';
while ($buffer .= socket_read($client, 1024)) {
if (false !== strpos($buffer, "\r\n\r\n")) {
break;
}
}
// check if the clients stopped sending data
if ($buffer === '') {
socket_close($client);
$connectionOpen = false;
} else {
// parse the request headers
$requestHeaders = $this->http_parse_headers($buffer);
// simulate $_COOKIE array
$_COOKIE = array();
if (array_key_exists('Cookie', $requestHeaders)) {
$cookies = explode('; ', $requestHeaders['Cookie']);
foreach ($cookies as $cookie) {
list ($key, $value) = explode('=', $cookie);
$_COOKIE[$key] = $value;
}
}
// calculate the number of available requests (after this one)
$availableRequests = $maxRequests - $counter++;
// prepare response headers
$headers = array();
$headers[] = "HTTP/1.1 200 OK";
$headers[] = "Content-Type: text/html";
// start the session if not already done
if (session_status() == PHP_SESSION_NONE) {
session_start();
}
// write data to a REAL PHP session, started with session_start()!
$_SESSION["thread_$threadId"]['availableRequest'] = $availableRequests;
// add a header to create session cookie
$headers[] = "Set-Cookie: " . session_name() . "=" . session_id() . "; Path=/";
// prepare HTML body
$body = 'A Title Generated by thread: ' . $threadId . '
' . var_export($_SESSION, true) . '
';
// prepare header with content-length
$contentLength = strlen($body);
$headers[] = "Content-Length: $contentLength";
// check if this will be the last requests handled by this thread
if ($availableRequests > 0) {
$headers[] = "Connection: keep-alive";
$headers[] = "Keep-Alive: max=$availableRequests, timeout=$timeout, thread={$this->getThreadId()}";
} else {
$headers[] = "Connection: close";
}
// prepare the response head/body
$response = array(
"head" => implode("\r\n", $headers) . "\r\n",
"body" => $body
);
// write the result back to the socket
socket_write($client, implode("\r\n", $response));
// check if this is the last request
if ($availableRequests <= 0) {
// if yes, close the socket and end the do/while
socket_close($client);
$connectionOpen = false;
}
}
} while ($connectionOpen);
}
}
// intialize the threads and the socket
$workers = array();
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_bind($socket, '0.0.0.0', $argv[1]);
socket_listen($socket);
// we start 5 worker threads here
if ($socket) {
$worker = 0;
while (++ $worker < 5) {
$workers[$worker] = new Test($socket);
$workers[$worker]->start(PTHREADS_INHERIT_ALL|PTHREADS_ALLOW_HEADERS);
}
foreach ($workers as $worker) {
$worker->join();
}
} pthreads-2.0.6/examples/Mutexes.php 0000664 0001750 0001750 00000003073 12333375647 014254 0 ustar then 50 threads doing the same thing with no mutex */
class MyWorkerThread extends Thread {
public function __construct($limit, $mutex = null){
$this->limit = $limit;
$this->mutex = $mutex;
}
public function run(){
if($this->mutex)
$locked=Mutex::lock($this->mutex);
printf("%s#%lu:<-", !empty($locked)?"Y":"N", $this->getThreadId());
$i=0;
while($i++<$this->limit){
echo ".";
}
printf("->\n");
if($this->mutex)
Mutex::unlock($this->mutex);
return true;
}
}
$timer = microtime(true);
/* create and lock a mutex */
$mutex = Mutex::create(true);
/* create workers */
$workers = array();
for($i=0;$i<50;$i++){
$workers[$i]=new MyWorkerThread(rand(30, 100), $mutex);
/* they cannot go anywhere, I have the mutex */
$workers[$i]->start();
}
printf("Release the (muzzled) hounds ... :\n");
Mutex::unlock($mutex);
foreach($workers as $i=> $worker)
$workers[$i]->join();
printf("Muzzled: %f seconds\n", microtime(true)-$timer);
/* please remember to destroy mutex and condition variables */
Mutex::destroy($mutex);
$timer = microtime(true);
/* same again, no mutex */
printf("Now no mutex ... :\n");
$workers = array();
for($i=0;$i<50;$i++){
$workers[$i]=new MyWorkerThread(rand(30, 100));
/* they cannot go anywhere, I have the mutex */
$workers[$i]->start();
}
foreach($workers as $worker)
$worker->join();
printf("Dribbling: %f seconds\n", microtime(true)-$timer);
?> pthreads-2.0.6/examples/NewSynchronization.php 0000664 0001750 0001750 00000003446 12333375647 016501 0 ustar synchronized(function($self){
printf("%s(%lu) going to wait ...\n", __CLASS__, $self->getThreadId());
$self->wait();
printf("%s(%lu) woken\n", __CLASS__, $self->getThreadId());
$self->done = true;
}, $this);
/* some more here */
}
}
$test = new Test();
$test->start();
/* notice that I have not "used" $self */
/* this is to show that every parameter passed after the block
is passed directly to the block */
/* you can equally make use of "use" and this functionality for added flexibility */
$test->synchronized(function($self){
printf("Process: synchronized.\n");
if (!$self->done) {
$self->notify();
} else printf("Process: error\n");
}, $test);
?>
pthreads-2.0.6/examples/Notifications.php 0000664 0001750 0001750 00000003404 12333375647 015431 0 ustar isWaiting()) {
/* the process is not yet waiting */
/* in the real world, this would indicate
that the process is still working */
/* in the real world, you might have work to do here */
echo ".";
}
echo "\n";
/* always synchronize before calling notify/wait */
$this->synchronized(function($me){
/* there's no harm in notifying when no one is waiting */
/* better that you notify no one than deadlock in any case */
$me->notify();
}, $this);
}
}
/* construct the new thread */
$t = new ExampleThread();
/* start the new thread */
if ($t->start()) {
printf("\nProcess Working ...\n");
do_some_work(1000);
/* synchronize in order to call wait */
$t->synchronized(function($me){
/*
* note: do not stay synchronized for longer than you must
* this is to reduce contention for the lock
* associated with the threads internal state
*/
printf("\nProcess Waiting ...\n");
$me->wait();
printf("Process Done ...\n");
}, $t);
}
?>
pthreads-2.0.6/examples/ObjectsAsParameters.php 0000664 0001750 0001750 00000006062 12333375647 016524 0 ustar url = $url;
$this->start = 0;
$this->finish = 0;
$this->data = null;
$this->length = 0;
}
public function setStart($start) { $this->start = $start; }
public function setFinish($finish) { $this->finish = $finish; }
public function setData($data) {
$this->data = $data;
$this->length = strlen($this->data);
}
public function getUrl() { return $this->url; }
public function getDuration() { return $this->finish - $this->start; }
public function getLength() { return $this->length; }
public function getData() { return $this->data; }
public function getStart() { return $this->start; }
public function getFinish() { return $this->finish; }
public function run(){
/* this particular object won't run */
}
}
class Request extends Thread {
/*
* You could have more parameters but an object can hold everything ...
*/
public function __construct($response){
$this->response = $response;
}
/*
* Populate the response object for creating context
*/
public function run(){
/*
* NOTE:
* Referencing threaded objects inside a thread:
* If you plan to heavily manipulate any object then retain a reference in the method scope
* Anytime you read and write the object context of a threaded object locking occurs
* Retaining method scope references avoids some locking and allocation
* $response retains the connection to the reference in the thread that created the request
* If you have a threaded member that you only plan to execute ONE time:
* (isWaiting/isRunning for example) then it is acceptable to reference the member via the object context
* Referencing the object context on every call will have no adverse affects ( no leaks/errors )
* The hints above are best practices but not required.
*/
if($this->response->getUrl()){
$this->response->setStart(microtime(true));
$this->response->setData(file_get_contents($this->response->getUrl()));
$this->response->setFinish(microtime(true));
}
}
}
/*
* We can retain the reference to the response object !!
*/
$response = new Response(
sprintf("http://www.google.com/?q=%s", md5(rand()*time()))
);
/*
* Initialize a new threaded request with a response object as the only parameter
*/
$request = new Request($response);
/*
* Tell you all about it ...
*/
printf("Fetching: %s ", $response->getUrl());
if($request->start()){
/* do something during runtime */
while($request->isRunning()) {
echo ".";
usleep(100);
}
/*
you do not need to join:
when a thread returns false for isRunning then your code is no longer being executed
pthreads will cleanup the variable when it goes out of scope like any other variable in php
*/
printf(" got %d bytes in %f seconds\n", $response->getLength(), $response->getDuration());
}
?> pthreads-2.0.6/examples/Objects.php 0000664 0001750 0001750 00000013104 12333375647 014207 0 ustar id = 1;
}
public function addToObject($key, $data) {
$this["{$key}"]=$data;
}
public function fetch($key) {
return $this["{$key}"];
}
/* note that members must be strings */
protected function getUniqueId(){
$id = $this->id++;
if (!$id)
return "unknown";
printf("Returning %d\n", $id);
return "{$id}";
}
public function run(){
/* we won't do anything to keep the example simple */
/*
in the real world this kind of object would be executed:
for example, at the beginning of the request
to retrieve
and at the end
to save
*/
}
}
class MyThread extends Thread {
public $stored;
public $storage;
public $worker;
public function __construct($storage, $worker = null) {
$this->storage = $storage;
$this->worker = $worker;
$this->stored = 0;
}
public function run(){
/* it's possible to reference the stackable directly from the object scope for every call */
/* but this will incur unecessary locking and allocation */
/* if logic requires reuse of a reference then pull it into the method scope */
/* a stackable does NOT need to be written back to the method scope for changes to data to be visible in other contexts */
/* ANY other type of object DOES */
if ($this->storage) {
printf("%s (%lu) STORAGE AVAILABLE\n", __METHOD__, $this->getThreadId());
$this->stored = $this->storage->getUniqueId();
$this->storage->addToObject(
$this->stored,
array(rand()*120)
);
if ($this->worker) {
printf("%s (%lu) WORKER AVAILABLE\n", __METHOD__, $this->getThreadId());
if (!$this->worker->isShutdown()){
$work = new MyWork($this->storage);
$this->worker->stack($work);
print_r($work);
} else printf("%s (%lu) WORKER SHUTDOWN\n", __METHOD__, $this->getThreadId());
} else printf("NO WORKER !!\n");
printf("%s (%lu) STORED %s@%s\n", __METHOD__, $this->getThreadId(), $this->storage->fetch($this->stored), $this->getStorageId());
} else printf("%s (%lu) NO STORAGE\n", __METHOD__, $this->getThreadId());
}
public function getStorageId() {
return $this->stored;
}
}
class GlobalWorker extends Worker {
public function __construct($storage){
$this->storage = $storage;
}
public function run() {
/* setup some connections and whatever */
while(++$o<20)
$a[$o]=rand()*1009;
/* this works, incase anyone cares */
$this["storage"][__CLASS__]=$a;
}
/* some useful methods for stackables to fetch connections and whatever here */
}
class MyWork extends Stackable {
public $stored;
public $thread;
public $storage;
public $tstored;
public function __construct($storage) {
$this->storage = $storage;
$this->tstored = null;
}
public function run(){
/* read once, see above ... */
if (($storage = $this->storage)) {
$this->stored = $storage->getUniqueId();
$storage->addToObject(
$this->stored,
array(rand()*120)
);
/*
* This stackable, being executed by a worker to manipulate a global object, created in another thread ...
* Is now going to create a thread and pass it a reference to the global object
* The thread
created by the stackable
executing in the worker
can reference the same objects
* that all the things I just said can ...
*/
$thread = new MyThread($storage, $this->worker);
if ($thread->start()) {
$thread->join();
$this->tstored = $thread->getStorageId();
/* @NOTE doesnt matter what reference to the stackable is passed to the thread */
}
}
}
public function getStorageId() { return $this->stored; }
public function getThreadStorageId() { return $this->tstored; }
}
/* this object we will pass everywhere we can */
$storage = new GlobalStorage();
/* this might be an SQLWorker, or just general purpose executor */
$worker = new GlobalWorker($storage);
$worker->start();
/* in the real world where you're executing the storage: */
/* $worker->stack($storage); */
/* while(!$storage->isReady()) */
/* $storage->wait(); */
/* random array of work to populate some storage from the worker */
$work = array();
while(++$o<10) {
/* items stacked could be using resources available in worker */
$work[]=new MyWork($storage);
}
foreach($work as $w)
$worker->stack($w);
/*
In this example your application would now be loaded, with access to a runnng background worker
and all the other goodies we just created/initiated/whatever
It's worth noting that now any part of your normal application code can stack to the worker, and reference the global storage
or whatever else you created...
It does not matter what reference you pass around.
*/
/* done with worker, execute everything */
$worker->shutdown();
printf("set by stackables...:\n");
foreach($work as $w)
var_dump($storage->fetch($w->getStorageId()));
printf("set by threads executed by stackables executing in a worker: ...\n");
foreach($work as $w) {
if ($w->getThreadStorageId())
var_dump($storage->fetch($w->getThreadStorageId()));
}
printf("set by the worker (alt syntax):\n");
var_dump($storage->fetch("GlobalWorker"));
/*
@NOTE pretty cool, right ?
*/
?>
pthreads-2.0.6/examples/Pooling.php 0000664 0001750 0001750 00000002331 12333375647 014225 0 ustar logger = $logger;
}
protected $logger;
}
class WebWork extends Stackable {
public function isComplete() {
return $this->complete;
}
public function run() {
$this->worker
->logger
->log("%s executing in Thread #%lu",
__CLASS__, $this->worker->getThreadId());
$this->complete = true;
}
protected $complete;
}
class SafeLog extends Stackable {
protected function log($message, $args = []) {
$args = func_get_args();
if (($message = array_shift($args))) {
echo vsprintf(
"{$message}\n", $args);
}
}
}
$pool = new Pool(8, \WebWorker::class, [new SafeLog()]);
$pool->submit($w=new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->shutdown();
$pool->collect(function($work){
return $work->isComplete();
});
var_dump($pool);
?>
pthreads-2.0.6/examples/Scope.php 0000664 0001750 0001750 00000003671 12333375647 013677 0 ustar getThreadId(), __METHOD__);
}
/*
* This protected method can only be called by one thread at a time
*/
protected function exclusive($arg = null){
printf("IN->%s: %s\n", __METHOD__, microtime(true));
if ($arg)
$result = sprintf("%s: got \"%s\"", __METHOD__, $arg);
else $result = sprintf("%s: got nothing", __METHOD__);
printf("%s: %s\n", __METHOD__, microtime(true));
usleep(1000000);
printf("OUT->%s: %s\n", __METHOD__, microtime(true));
return $result;
}
/*
* Nothing special from here on in ...
*/
public function __construct($data){
$this->data = $data;
$this->mine = strrev($this->data);
}
public function run(){
printf("IN->%s: %s\n", __METHOD__, microtime(true));
printf("%s: %s\n", __METHOD__, $this->exclusive(strrev($this->data)));
printf("%s: %s\n", __METHOD__, microtime(true));
printf("%s: %s\n", __METHOD__, $this->noaccess());
printf("OUT->%s: %s\n", __METHOD__, microtime(true));
}
}
/*
* This comment is not in use.
*/
$thread = new ExampleThread(rand()*10);
$thread->start();
/*
* You can see that this call is blocked until the threading context returns from the method
*/
printf("Process: %s\n", $thread->exclusive());
/*
* Passing an argument on the command line will show you what happens when you call a private method from here
*/
if ($argv[1])
printf("Process: %s\n", $thread->noaccess());
?>
pthreads-2.0.6/examples/SelectiveInheritance.php 0000664 0001750 0001750 00000003465 12333375647 016724 0 ustar
expect:
bool(false)
bool(false)
bool(false)
start(PTHREADS_INHERIT_NONE);
$test->join();
?>
=======================================
expect:
bool(false)
bool(true)
bool(true)
start(PTHREADS_INHERIT_ALL & ~PTHREADS_INHERIT_FUNCTIONS);
$test->join();
?>
=======================================
expect:
bool(false)
bool(false)
bool(true)
start(PTHREADS_INHERIT_INI | PTHREADS_INHERIT_CONSTANTS);
$test->join();
?>
=======================================
expect:
bool(true)
bool(true)
bool(true)
start();
$test->join();
?>
pthreads-2.0.6/examples/SharingResources.php 0000664 0001750 0001750 00000004051 12333375647 016105 0 ustar mysql = $mysql;
$this->mutex = $mutex;
}
public function run(){
if ($this->mutex)
printf("LOCK(%d): %d\n", $this->getThreadId(), Mutex::lock($this->mutex));
if (($result = mysqli_query($this->mysql, "SHOW PROCESSLIST;"))) {
while(($row = mysqli_fetch_assoc($result))) {
print_r($row);
}
}
if ($this->mutex)
printf("UNLOCK(%d): %d\n", $this->getThreadId(), Mutex::unlock($this->mutex));
}
}
$mysql = mysqli_connect("127.0.0.1", "root", "");
if ($mysql) {
$mutex = Mutex::create();
$instances = array(new MyShared($mysql, $mutex), new MyShared($mysql, $mutex), new MyShared($mysql, $mutex));
foreach($instances as $instance)
$instance->start();
foreach($instances as $instance)
$instance->join();
Mutex::destroy($mutex);
}
?>
pthreads-2.0.6/examples/SimpleWebRequest.php 0000664 0001750 0001750 00000001663 12333375647 016065 0 ustar url = $url;
}
public function run(){
if(($url = $this->url)){
/*
* If a large amount of data is being requested, you might want to
* fsockopen and read using usleep in between reads
*/
$this->data = file_get_contents($url);
} else printf("Thread #%lu was not provided a URL\n", $this->getThreadId());
}
}
$t = microtime(true);
$g = new AsyncWebRequest(sprintf("http://www.google.com/?q=%s", rand()*10));
/* starting synchronized */
if($g->start()){
printf("Request took %f seconds to start ", microtime(true)-$t);
while($g->isRunning()){
echo ".";
usleep(100);
}
if ($g->join()){
printf(" and %f seconds to finish receiving %d bytes\n", microtime(true)-$t, strlen($g->data));
} else printf(" and %f seconds to finish, request failed\n", microtime(true)-$t);
}
?>
pthreads-2.0.6/examples/Singleton.php 0000664 0001750 0001750 00000002016 12333375647 014560 0 ustar config = $config;
}
public function run () {
/* execute queries */
if (sql::query("SELECT * FROM mysql.user")) {
printf("...\n");
if (sql::query("SELECT * FROM mysql.user")) {
printf("...\n");
}
}
}
}
if (sql::query("SELECT * FROM mysql.user;")) {
printf("...\n");
if (sql::query("SELECT * FROM mysql.user;")) {
printf("...\n");
}
}
$thread = new UserThread();
$thread->start();
?>
pthreads-2.0.6/examples/SocketServer.php 0000664 0001750 0001750 00000005464 12333375647 015247 0 ustar socket = $socket;
$this->start();
}
public function run(){
$client = $this->socket;
if ($client) {
$header = 0;
while(($chars = socket_read($client, 1024, PHP_NORMAL_READ))) {
$head[$header]=trim($chars);
if ($header>0) {
if (!$head[$header] && !$head[$header-1])
break;
}
$header++;
}
foreach($head as $header) {
if ($header) {
$headers[]=$header;
}
}
$response = array(
"head" => array(
"HTTP/1.0 200 OK",
"Content-Type: text/html"
),
"body" => array()
);
socket_getpeername($client, $address, $port);
$response["body"][]="";
$response["body"][]="";
$response["body"][]="Multithread Sockets PHP ({$address}:{$port}) ";
$response["body"][]="";
$response["body"][]="";
$response["body"][]="";
foreach($headers as $header)
$response["body"][]="{$header}";
$response["body"][]=" ";
$response["body"][]="";
$response["body"][]="";
$response["body"] = implode("\r\n", $response["body"]);
$response["head"][] = sprintf("Content-Length: %d", strlen($response["body"]));
$response["head"] = implode("\r\n", $response["head"]);
socket_write($client, $response["head"]);
socket_write($client, "\r\n\r\n");
socket_write($client, $response["body"]);
socket_close($client);
}
}
}
/* ladies and gentlemen, the world first multi-threaded socket server in PHP :) */
$server = socket_create_listen(13000);
while(($client = socket_accept($server))){
$clients[]=new Client($client);
/* we will serve a few clients and quit, to show that memory is freed and there are no errors on shutdown (hopefully) */
/* in the real world, do something here to ensure clients not running are destroyed */
/* the nature of a socket server is an endless loop,
if you do not do something to explicitly destroy clients you create this may leak */
}
/* that is all */
?>
pthreads-2.0.6/examples/SQLWorker.php 0000664 0001750 0001750 00000004061 12333375647 014451 0 ustar sql = $sql;
}
public function run() {
/** included in 0.0.37 is access to the real worker object for stackables **/
if ($this->worker->isReady()) {
$result = mysql_query($this->sql, $this->worker->getConnection());
if ($result) {
while(($row = mysql_fetch_assoc($result))){
/** $this->rows[]=$row; segfaults */
/** you could array_merge, but the fastest thing to do is what I'm doing here */
/** even when the segfault is fixed this will still be the best thing to do as writing to the object scope will always cause locking */
/** but the method scope isn't shared, just like the global scope **/
$rows[]=$row;
}
mysql_free_result($result);
} else printf("%s got no result\n", __CLASS__);
} else printf("%s not ready\n", $this->worker->getConnection());
$this->rows = $rows;
$this->notify();
}
protected function getResults() { return $this->rows; }
}
class SQLWorker extends Worker {
public $mysql;
public function __construct($host, $user, $pass, $db) {
$this->host = $host;
$this->user = $user;
$this->pass = $pass;
$this->db = $db;
$this->ready = false;
$this->name = null;
}
public function run() {
$this->setName(sprintf("%s (%lu)", __CLASS__, $this->getThreadId()));
if (($this->mysql = mysql_connect($this->host, $this->user, $this->pass))) {
$this->ready = (boolean) mysql_select_db($this->db, $this->mysql);
}
}
public function getConnection(){ return $this->mysql; }
protected function isReady($flag = null) {
if (is_null($flag)) {
return $this->ready;
} else $this->ready = $flag;
}
public function setName($name) { $this->name = $name;}
public function getName() { return $this->name; }
}
if (count($argv) == 6) {
$sql = new SQLWorker($argv[1], $argv[2], $argv[3], $argv[4]);
$sql->start();
$query = new SQLQuery($argv[5]);
$sql->stack($query);
$query->wait();
print_r($query->getResults());
} else printf("usage: {$argv[0]} hostname username password database query\n");
?>
pthreads-2.0.6/examples/StackableArray.php 0000664 0001750 0001750 00000004327 12333375647 015515 0 ustar test = $test;
$this->start();
}
public function run(){
/*
* NOTE
* If your editing of an array is this simple
* then don't protect these instructions
* you will incurr additional unecessary locking
*/
$this->test[]=rand(0, 10);
}
}
/* create the array here for passing */
$s = new StackableArray();
/* set a pointless value */
$s[]="h";
/* show it was set */
print_r($s);
$ts = array();
/* hammer the crap out of the array */
while(@$i++ < $hammers){
$ts[]=new T($s);
}
printf("GOT %d T's\n", count($ts));
/* we want all threads to complete */
foreach($ts as $t)
$t->join();
/* show it was all set without corruption */
print_r($s);
?>
pthreads-2.0.6/examples/Stacking.php 0000664 0001750 0001750 00000005626 12333375647 014373 0 ustar local = $data;
}
public function run() {
/*
* We import the worker here to execute it's methods
*/
if ($this->worker) {
printf("Running %s in %s\n", __CLASS__, $this->worker->getName());
$this->worker->addAttempt();
$this->worker->addData($this->getData());
} else printf("failed to get worker something is wrong ...\n");
print_r($this);
}
protected function getData() { return $this->local; }
}
class ExampleWorker extends Worker {
public function __construct($name) {
$this->setSetup(false);
$this->setName($name);
$this->setData(array());
}
/*
* The run method should just prepare the environment for the work that is coming ...
*/
public function run(){
if (!$this->setup) {
$this->setSetup(true);
$this->setName(sprintf("%s (%lu)", __CLASS__, $this->getThreadId()));
} else printf("%s is being run ... why ??\n", $this->getName());
printf("Setup %s Complete\n", $this->getName());
}
public function setSetup($setup) { $this->setup = $setup; }
public function getName() { return $this->name; }
public function setName($name) { $this->name = $name; }
/*
* About protected methods:
* Even if a public or private method read/writes member data the reads and writes will be safe
* So in this particular example they arent strictly required for the objects to function as intended
* Normally methods will read and manipulate data in a more complicated manner than in this example
* If a method reads and writes thread data it will often be a good idea to protect the method
*/
public function addAttempt() { $this->attempts++; }
public function getAttempts() { return $this->attempts; }
/* this method overwrites thread data */
protected function setData($data) { $this->data = $data; }
/* this method reads and writes thread data */
protected function addData($data) { $this->data = array_merge($this->data, $data); }
/* this method reads data but makes no changes, doesnt usually happen in the real world */
protected function getData() { return $this->data; }
}
$worker = new ExampleWorker("My Worker Thread");
$work = array();
while($i++<10){
$work[$i]=new Work(array(rand()*100));
printf(
"Stacking: %d/%d\n", $i, $worker->stack($work[$i])
);
}
$worker->start();
usleep(10000);
while($i++<20){
$work[$i]=new Work(array(rand()*100));
printf(
"Stacking: %d/%d\n", $i, $worker->stack($work[$i])
);
}
$worker->shutdown();
printf("Result: %d/%d\n", $worker->getAttempts(), $worker->getStacked());
print_r($worker->getData());
?>
pthreads-2.0.6/examples/stub.php 0000664 0001750 0001750 00000045457 12333375647 013613 0 ustar
* @version 2.0.0
*/
/**
* The default inheritance mask used when starting Threads and Workers
*/
define('PTHREADS_INHERIT_ALL', 0x111111);
/**
* Nothing will be inherited by the new context
*/
define('PTHREADS_INHERIT_NONE', 0);
/**
* Determines whether the ini entries are inherited by the new context
*/
define('PTHREADS_INHERIT_INI', 0x1);
/**
* Determines whether the constants are inherited by the new context
*/
define('PTHREADS_INHERIT_CONSTANTS', 0x10);
/**
* Determines whether the class table is inherited by the new context
*/
define('PTHREADS_INHERIT_CLASSES', 0x100);
/**
* Determines whether the function table is inherited by the new context
*/
define('PTHREADS_INHERIT_FUNCTIONS', 0x100);
/**
* Determines whether the included_files table is inherited by the new context
*/
define('PTHREADS_INHERIT_INCLUDES', 0x10000);
/**
* Determines whether the comments are inherited by the new context
*/
define('PTHREADS_INHERIT_COMMENTS', 0x100000);
/**
* Allow output headers from the threads
*/
define('PTHREADS_ALLOW_HEADERS', 0x1000000);
/**
* Allow global inheritance for new threads
*/
define('PTHREADS_ALLOW_GLOBALS', 0x10000000);
/**
* Threaded class
*
* Threaded objects form the basis of pthreads ability to execute user code asynchronously;
* they expose and include synchronization methods and various useful interfaces.
*
* Threaded objects, most importantly, provide implicit safety for the programmer;
* all operations on the object scope are safe.
*
* @link http://www.php.net/manual/en/class.threaded.php
* @since 2.0.0
*/
class Threaded implements Traversable, Countable, ArrayAccess
{
/**
* Fetches a chunk of the objects properties table of the given size
*
* @param int $size The number of items to fetch
*
* @link http://www.php.net/manual/en/threaded.chunk.php
* @return array An array of items from the objects member table
*/
public function chunk($size) {}
/**
* {@inheritdoc}
*/
public function count() {}
/**
* Retrieves terminal error information from the referenced object
*
* @link http://www.php.net/manual/en/threaded.getterminationinfo.php
* @return array|bool array containing the termination conditions of the referenced object
*/
public function getTerminationInfo() {}
/**
* Tell if the referenced object is executing
*
* @link http://www.php.net/manual/en/threaded.isrunning.php
* @return bool A boolean indication of state
*/
public function isRunning() {}
/**
* Tell if the referenced object exited, suffered fatal errors, or threw uncaught exceptions during execution
*
* @link http://www.php.net/manual/en/threaded.isterminated.php
* @return bool A boolean indication of state
*/
public function isTerminated() {}
/**
* Tell if the referenced object is waiting for notification
*
* @link http://www.php.net/manual/en/threaded.iswaiting.php
* @return bool A boolean indication of state
*/
public function isWaiting() {}
/**
* Lock the referenced objects property table
*
* @link http://www.php.net/manual/en/threaded.lock.php
* @return bool A boolean indication of state
*/
public function lock() {}
/**
* Merges data into the current object
*
* @param mixed $from The data to merge
* @param bool $overwrite Overwrite existing keys flag, by default true
*
* @link http://www.php.net/manual/en/threaded.merge.php
* @return bool A boolean indication of success
*/
public function merge($from, $overwrite = true) {}
/**
* Send notification to the referenced object
*
* @link http://www.php.net/manual/en/threaded.notify.php
* @return bool A boolean indication of success
*/
public function notify() {}
/**
* {@inheritdoc}
*/
public function offsetGet($offset) {}
/**
* {@inheritdoc}
*/
public function offsetSet($offset, $value) {}
/**
* {@inheritdoc}
*/
public function offsetExists($offset) {}
/**
* {@inheritdoc}
*/
public function offsetUnset($offset) {}
/**
* Pops an item from the objects property table
*
* @link http://www.php.net/manual/en/threaded.pop.php
* @return mixed The last item from the objects properties table
*/
public function pop() {}
/**
* The programmer should always implement the run method for objects that are intended for execution.
*
* @link http://www.php.net/manual/en/threaded.run.php
* @return void The methods return value, if used, will be ignored
*/
public function run() {}
/**
* Shifts an item from the objects properties table
*
* @link http://www.php.net/manual/en/threaded.shift.php
* @return mixed The first item from the objects properties table
*/
public function shift() {}
/**
* Executes the block while retaining the synchronization lock for the current context.
*
* @param \Closure $function The block of code to execute
* @param mixed $args... Variable length list of arguments to use as function arguments to the block
*
* @link http://www.php.net/manual/en/threaded.synchronized.php
* @return mixed The return value from the block
*/
public function synchronized(\Closure $function, $args = null) {}
/**
* Unlock the referenced objects storage for the calling context
*
* @link http://www.php.net/manual/en/threaded.unlock.php
* @return bool A boolean indication of success
*/
public function unlock() {}
/**
* Waits for notification from the Stackable
*
* @param int $timeout An optional timeout in microseconds
*
* @link http://www.php.net/manual/en/threaded.wait.php
* @return bool A boolean indication of success
*/
public function wait($timeout) {}
}
/**
* Basic thread implementation
*
* An implementation of a Thread should extend this declaration, implementing the run method.
* When the start method of that object is called, the run method code will be executed in separate Thread.
*
* @link http://www.php.net/manual/en/class.thread.php
*/
class Thread extends Threaded
{
/**
* Detaches a thread
*
* @return bool A boolean indication of success
*/
public function detach() {}
/**
* Will return the identity of the Thread that created the referenced Thread
*
* @link http://www.php.net/manual/en/thread.getcreatorid.php
* @return int A numeric identity
*/
public function getCreatorId() {}
/**
* Will return the instance of currently executing thread
*
* @return static
*/
public static function getCurrentThread() {}
/**
* Will return the identity of the currently executing thread
*
* @link http://www.php.net/manual/en/thread.getcurrentthreadid.php
* @return int
*/
public static function getCurrentThreadId() {}
/**
* Will return the identity of the referenced Thread
*
* @link http://www.php.net/manual/en/thread.getthreadid.php
* @return int
*/
public function getThreadId() {}
/**
* Tell if the referenced Thread has been joined by another context
*
* @link http://www.php.net/manual/en/thread.isjoined.php
* @return bool A boolean indication of state
*/
public function isJoined() {}
/**
* Tell if the referenced Thread has been started
*
* @link http://www.php.net/manual/en/thread.isstarted.php
* @return bool A boolean indication of state
*/
public function isStarted() {}
/**
* Causes the calling context to wait for the referenced Thread to finish executing
*
* @link http://www.php.net/manual/en/thread.join.php
* @return bool A boolean indication of state
*/
public function join() {}
/**
* Kills the referenced thread, dangerously !
*
* @link http://www.php.net/manual/en/thread.kill.php
*/
public function kill() {}
/**
* Will start a new Thread to execute the implemented run method
*
* @param int $options An optional mask of inheritance constants, by default PTHREADS_INHERIT_ALL
*
* @link http://www.php.net/manual/en/thread.start.php
* @return bool A boolean indication of success
*/
public function start($options = PTHREADS_INHERIT_ALL) {}
/**
* Will execute the Callable in the global scope
*
* @param Callable $block The code to execute
* @param ... $args Variable length list of arguments to pass to the Callable upon execution
* @link http://www.php.net/manual/en/thread.start.php
* @return bool A boolean indication of success
*/
public static function globally(Callable $block [, $args]) {}
}
/**
* Worker
*
* Worker Threads have a persistent context, as such should be used over Threads in most cases.
*
* When a Worker is started, the run method will be executed, but the Thread will not leave until one
* of the following conditions are met:
* - the Worker goes out of scope (no more references remain)
* - the programmer calls shutdown
* - the script dies
* This means the programmer can reuse the context throughout execution; placing objects on the stack of
* the Worker will cause the Worker to execute the stacked objects run method.
*
* @link http://www.php.net/manual/en/class.worker.php
*/
class Worker extends Thread
{
/**
* Returns the number of threaded tasks waiting to be executed by the referenced Worker
*
* @link http://www.php.net/manual/en/worker.getstacked.php
* @return int An integral value
*/
public function getStacked() {}
/**
* Tell if the referenced Worker has been shutdown
*
* @link http://www.php.net/manual/en/worker.isshutdown.php
* @return bool A boolean indication of state
*/
public function isShutdown() {}
/**
* Tell if a Worker is executing threaded tasks
*
* @link http://www.php.net/manual/en/worker.isworking.php
* @return bool A boolean indication of state
*/
public function isWorking() {}
/**
* Shuts down the Worker after executing all the threaded tasks previously stacked
*
* @link http://www.php.net/manual/en/worker.shutdown.php
* @return bool A boolean indication of success
*/
public function shutdown() {}
/**
* Appends the referenced object to the stack of the referenced Worker
*
* @param Threaded $work Threaded object to be executed by the referenced Worker
*
* @link http://www.php.net/manual/en/worker.stack.php
* @return int The new length of the stack
*/
public function stack(Threaded &$work) {}
/**
* Removes the referenced object ( or all objects if parameter is null ) from stack of the referenced Worker
*
* @param Threaded $work Threaded object previously stacked onto Worker
*
* @link http://www.php.net/manual/en/worker.unstack.php
* @return int The new length of the stack
*/
public function unstack(Threaded &$work = null) {}
}
/**
* Mutex class
*
* The static methods contained in the Mutex class provide direct access to Posix Mutex functionality.
*
* @link http://www.php.net/manual/en/class.mutex.php
*/
class Mutex
{
/**
* Create, and optionally lock a new Mutex for the caller
*
* @param bool $lock Setting lock to true will lock the Mutex for the caller before returning the handle
*
* @link http://www.php.net/manual/en/mutex.create.php
* @return int A newly created and optionally locked Mutex handle
*/
final public static function create($lock = false) {}
/**
* Destroy mutex
*
* Destroying Mutex handles must be carried out explicitly by the programmer when they are
* finished with the Mutex handle.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.destroy.php
* @return bool A boolean indication of success
*/
final public static function destroy($mutex) {}
/**
* Attempt to lock the Mutex for the caller.
*
* An attempt to lock a Mutex owned (locked) by another Thread will result in blocking.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.lock.php
* @return bool A boolean indication of success
*/
final public static function lock($mutex) {}
/**
* Attempt to lock the Mutex for the caller without blocking if the Mutex is owned (locked) by another Thread.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.trylock.php
* @return bool A boolean indication of success
*/
final public static function trylock($mutex) {}
/**
* Release mutex
*
* Attempts to unlock the Mutex for the caller, optionally destroying the Mutex handle.
* The calling thread should own the Mutex at the time of the call.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
* @param bool $destroy When true pthreads will destroy the Mutex after a successful unlock.
*
* @link http://www.php.net/manual/en/mutex.unlock.php
* @return bool A boolean indication of success
*/
final public static function unlock($mutex, $destroy = false) {}
}
/**
* Condition class
*
* The static methods contained in the Cond class provide direct access to Posix Condition Variables.
*
* @link http://www.php.net/manual/en/class.cond.php
*/
class Cond
{
/**
* Broadcast to all Threads blocking on a call to Cond::wait().
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.broadcast.php
* @return bool A boolean indication of success
*/
final public static function broadcast($condition) {}
/**
* Creates a new Condition Variable for the caller.
*
* @link http://www.php.net/manual/en/cond.create.php
* @return int A handle to a Condition Variable
*/
final public static function create() {}
/**
* Destroy a condition
*
* Destroying Condition Variable handles must be carried out explicitly by the programmer when they are
* finished with the Condition Variable.
* No Threads should be blocking on a call to Cond::wait() when the call to Cond::destroy() takes place.
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.destroy.php
* @return bool A boolean indication of success
*/
final public static function destroy($condition) {}
/**
* Signal a Condition
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.signal.php
* @return bool A boolean indication of success
*/
final public static function signal($condition) {}
/**
* Wait for a signal on a Condition Variable, optionally specifying a timeout to limit waiting time.
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
* @param int $mutex A handle returned by a previous call to Mutex::create() and owned (locked) by the caller.
* @param int $timeout An optional timeout, in microseconds
*
* @return bool A boolean indication of success
*/
final public static function wait($condition, $mutex, $timeout = null) {}
}
/**
* Pool class
*
* A Pool is a container for, and controller of, a number of Worker threads, the number of threads can be adjusted
* during execution, additionally the Pool provides an easy mechanism to maintain and collect references in the
* proper way.
*
* @link http://www.php.net/manual/en/class.pool.php
*/
class Pool
{
/**
* The maximum number of Worker threads allowed in this Pool
*
* @var integer
*/
protected $size;
/**
* The name of the Worker class for this Pool
*
* @var string
*/
protected $class;
/**
* The array of Worker threads for this Pool
*
* @var array|Worker[]
*/
protected $workers;
/**
* The array of Stackables submitted to this Pool for execution
*
* @var array|Threaded[]
*/
protected $work;
/**
* The constructor arguments to be passed by this Pool to new Workers upon construction
*
* @var array
*/
protected $ctor;
/**
* The numeric identifier for the last Worker used by this Pool
*
* @var integer
*/
protected $last;
/**
* Construct a new Pool of Workers
*
* @param integer $size The maximum number of Workers this Pool can create
* @param string $class The class for new Workers
* @param array $ctor An array of arguments to be passed to new Workers
*
* @link http://www.php.net/manual/en/pool.__construct.php
*/
public function __construct($size, $class, array $ctor = array()) {}
/**
* Shuts down all Workers, and collect all Stackables, finally destroys the Pool
*
* @link http://www.php.net/manual/en/pool.__destruct.php
*/
public function __destruct() {}
/**
* Collect references to completed tasks
*
* Allows the Pool to collect references determined to be garbage by the given collector
*
* @param callable $collector
*
* @link http://www.php.net/manual/en/pool.collect.php
*/
public function collect(callable $collector) {}
/**
* Resize the Pool
*
* @param integer $size The maximum number of Workers this Pool can create
*
* @link http://www.php.net/manual/en/pool.resize.php
*/
public function resize($size) {}
/**
* Shutdown all Workers in this Pool
*
* @link http://www.php.net/manual/en/pool.shutdown.php
*/
public function shutdown() {}
/**
* Submit the task to the next Worker in the Pool
*
* @param Threaded $task The task for execution
*
* @return int the identifier of the Worker executing the object
*/
public function submit(Threaded $task) {}
/**
* Submit the task to the specific Worker in the Pool
*
* @param int $worker The worker for execution
* @param Threaded $task The task for execution
*
* @return int the identifier of the Worker that accepted the object
*/
public function submitTo($worker, Threaded $task) {}
}
pthreads-2.0.6/tests/binding.phpt 0000664 0001750 0001750 00000001716 12333375647 013746 0 ustar --TEST--
Test pthreads connections
--DESCRIPTION--
This test verifies that variables are bound properly by pthreads
--FILE--
other = $other;
}
public function run(){
$this->done = true;
$this->notify();
}
}
class ThreadTest extends Thread {
public $other;
public $done;
public function setOther($other){
$this->other = $other;
}
public function run(){
$this->done = true;
$this->notify();
}
}
$threads[0]=new ThreadTesting();
$threads[1]=new ThreadTest();
$threads[0]->setOther($threads[1]);
$threads[1]->setOther($threads[0]);
foreach($threads as $thread)
$thread->start();
foreach($threads as $thread) {
$thread->synchronized(function() use($thread){
if (!$thread->done)
var_dump($thread->wait());
else var_dump($thread->done);
});
}
?>
--EXPECT--
bool(true)
bool(true)
pthreads-2.0.6/tests/callstatic-etc.phpt 0000664 0001750 0001750 00000000756 12333375647 015233 0 ustar --TEST--
Testing extended object functionality, magic methods bug #34
--DESCRIPTION--
Test that the fix for bug #34 is a success
--FILE--
start();
?>
--EXPECT--
string(11) "called_func"
array(1) {
[0]=>
string(8) "argument"
}
pthreads-2.0.6/tests/chunk.phpt 0000664 0001750 0001750 00000000733 12333375647 013442 0 ustar --TEST--
Check chunking
--DESCRIPTION--
This test verifies functionality of ::chunk
--FILE--
merge(array_fill(0, 10000, true));
var_dump($s->chunk(10));
?>
--EXPECT--
array(10) {
[0]=>
bool(true)
[1]=>
bool(true)
[2]=>
bool(true)
[3]=>
bool(true)
[4]=>
bool(true)
[5]=>
bool(true)
[6]=>
bool(true)
[7]=>
bool(true)
[8]=>
bool(true)
[9]=>
bool(true)
}
pthreads-2.0.6/tests/complex-statics.phpt 0000664 0001750 0001750 00000002261 12333375647 015447 0 ustar --TEST--
Test complex statics bug #32
--DESCRIPTION--
This test verifies that complex static types are ignored when creating thread contexts, leading to predictable stable behaviour
--FILE--
start();
?>
--EXPECT--
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
pthreads-2.0.6/tests/complex-statics-set-null.phpt 0000664 0001750 0001750 00000002350 12333375647 017207 0 ustar --TEST--
Test NULLing ressources in arrays
--FILE--
start();
?>
--EXPECTF--
file::_get: something1
array(1) {
[%i]=>
resource(5) of type (stream)
}
file::_get: something2
array(1) {
[%i]=>
resource(5) of type (stream)
}
file::_get: something3
array(2) {
[%i]=>
NULL
[%i]=>
resource(2) of type (stream)
}
file::_get: something4
array(2) {
[%i]=>
NULL
[%i]=>
resource(2) of type (stream)
}
pthreads-2.0.6/tests/conditions.phpt 0000664 0001750 0001750 00000001172 12333375647 014501 0 ustar --TEST--
Test conditions
--DESCRIPTION--
This test verifies conditions are working
--FILE--
mutex = $mutex;
$this->condition = $condition;
}
public function run(){
Mutex::lock($this->mutex);
Cond::broadcast($this->condition);
Mutex::unlock($this->mutex);
}
}
$mutex = Mutex::create();
$cond = Cond::create();
Mutex::lock($mutex);
$t = new T($mutex, $cond);
$t->start();
var_dump(Cond::wait($cond, $mutex));
Mutex::unlock($mutex);
Cond::destroy($cond);
Mutex::destroy($mutex);
?>
--EXPECT--
bool(true)
pthreads-2.0.6/tests/constants.phpt 0000664 0001750 0001750 00000000571 12333375647 014346 0 ustar --TEST--
Test constants (bug 19)
--DESCRIPTION--
This test verifies that constant members in declarations made outside of threads are available inside threads without error
--FILE--
start();
?>
--EXPECT--
Y-m-d\TH:i:sO
pthreads-2.0.6/tests/corrupted-resources.phpt 0000664 0001750 0001750 00000001271 12333375647 016347 0 ustar --TEST--
Testing sane handling of resources and objects bug #39
--DESCRIPTION--
Test that resources and objects are not corrupted when written to thread storage
--FILE--
test = $test;
print_r($this->test);
var_dump($this->test);
$stream = fopen("/tmp/test.txt", "w+");
var_dump($stream);
$this->stream = $stream;
stream_set_blocking($this->stream, 0);
var_dump($this->stream);
}
}
$test =new Test();
$test->start();
?>
--EXPECT--
Work Object
(
)
object(Work)#2 (0) {
}
resource(2) of type (stream)
resource(2) of type (stream)
pthreads-2.0.6/tests/counting-members.phpt 0000664 0001750 0001750 00000000454 12333375647 015610 0 ustar --TEST--
Testing member count
--DESCRIPTION--
This test verifies that getting member counts works without effort
--FILE--
--EXPECT--
int(3)
pthreads-2.0.6/tests/detach.phpt 0000664 0001750 0001750 00000000504 12333375647 013556 0 ustar --TEST--
Test detach is successful
--DESCRIPTION--
This test will detach a thread and check the return value
--FILE--
start();
$result = $thread->detach();
var_dump($result);
sleep(1);
?>
--EXPECT--
bool(true)
pthreads-2.0.6/tests/doc-comments.phpt 0000664 0001750 0001750 00000003040 12333375647 014714 0 ustar --TEST--
Test doc comments are copied properly
--DESCRIPTION--
Test that doc comments are copied, no leaking/errors
--FILE--
getDocComment());
$reflect = new ReflectionMethod("T", "run");
var_dump($reflect);
var_dump($reflect->getDocComment());
}
}
$t = new T();
$t->start();
$t->join();
$reflect = new ReflectionClass("T");
var_dump($reflect);
var_dump($reflect->getDocComment());
$reflect = new ReflectionMethod("T", "run");
var_dump($reflect);
var_dump($reflect->getDocComment());
?>
--EXPECT--
object(ReflectionClass)#2 (1) {
["name"]=>
string(1) "T"
}
string(16) "/**
* Comment
*/"
object(ReflectionMethod)#3 (2) {
["name"]=>
string(3) "run"
["class"]=>
string(1) "T"
}
string(102) "/**
* Method comment
* @doc comment
* @package package
* @subpackage subpackage
*/"
object(ReflectionClass)#2 (1) {
["name"]=>
string(1) "T"
}
string(16) "/**
* Comment
*/"
object(ReflectionMethod)#3 (2) {
["name"]=>
string(3) "run"
["class"]=>
string(1) "T"
}
string(102) "/**
* Method comment
* @doc comment
* @package package
* @subpackage subpackage
*/"
pthreads-2.0.6/tests/foreign-private-members.phpt 0000664 0001750 0001750 00000001110 12333375647 017051 0 ustar --TEST--
Testing foreign private member access, magic methods bug #32
--DESCRIPTION--
Test that the fix for bug #32 is a success
--FILE--
test;
}
}
class TEST extends Thread {
public function __construct($my) {
$this->my = $my;
}
public function run(){
printf("TEST: %s\n", $this->my->getTest());
}
}
$my = new MY();
$test = new TEST($my);
$test->start();
--EXPECT--
TEST: Hello World
pthreads-2.0.6/tests/functions.phpt 0000664 0001750 0001750 00000000613 12333375647 014337 0 ustar --TEST--
Test function table inheritance
--DESCRIPTION--
This test verifies that the function table is inherited by pthreads correctly
--FILE--
start();
?>
--EXPECT--
TestFunction
pthreads-2.0.6/tests/global-voodoo.phpt 0000664 0001750 0001750 00000001371 12333375647 015074 0 ustar --TEST--
Test Thread::globally
--SKIPIF--
--DESCRIPTION--
Test globally voodoo
--FILE--
start();
$test->join();
?>
--EXPECTF--
object(Test)#%d (%d) {
}
object(stdClass)#%d (%d) {
}
object(stdClass)#%d (%d) {
}
pthreads-2.0.6/tests/globals.phpt 0000664 0001750 0001750 00000001203 12333375647 013746 0 ustar --TEST--
Test global inheritance
--DESCRIPTION--
Test functionality of globals inheritance
--FILE--
one = "one";
$object->two = "two";
$object->three = "three";
$array = array(1, 2, 3);
$test = new Test();
$test->start(PTHREADS_INHERIT_ALL | PTHREADS_ALLOW_GLOBALS);
$test->join();
?>
--EXPECTF--
object(stdClass)#%d (%d) {
["one"]=>
string(3) "one"
["two"]=>
string(3) "two"
["three"]=>
string(5) "three"
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
pthreads-2.0.6/tests/global-constants.phpt 0000664 0001750 0001750 00000001302 12333375647 015575 0 ustar --TEST--
Test global constants
--DESCRIPTION--
This test verifies that global constants are inherited
--FILE--
SCONST,
"long" => LCONST,
"double" => DCONST,
"null" => NCONST,
"boolean" => BCONST
) as $key => $constant) {
printf("%s:", $key);
var_dump($constant);
}
}
}
$thread = new TestThread();
$thread->start();
?>
--EXPECT--
string:string(8) "mystring"
long:int(10)
double:float(1.19)
null:NULL
boolean:bool(true)
pthreads-2.0.6/tests/gone.phpt 0000664 0001750 0001750 00000001214 12333375647 013255 0 ustar --TEST--
Test objects that have gone away
--DESCRIPTION--
This test verifies that objects that have gone away do not cause segfaults
--FILE--
o = new O();
/* this will disappear */
$this->o["data"] = true;
}
}
$t = new T();
$t->start();
$t->join();
var_dump($t->o);
?>
--EXPECTF--
Fatal error: Uncaught exception 'RuntimeException' with message 'pthreads detected an attempt to connect to a O which has already been destroyed' in %s:%d
Stack trace:
#0 %s(%d): unknown()
#1 {main}
thrown in %s on line %d
pthreads-2.0.6/tests/graceful-fatalities.phpt 0000664 0001750 0001750 00000000572 12333375647 016246 0 ustar --TEST--
Test graceful fatalities
--DESCRIPTION--
This test verifies that fatalities are graceful with regard to state
--FILE--
start();
usleep(100000);
var_dump($test->isRunning());
?>
--EXPECTF--
bool(false)
pthreads-2.0.6/tests/included-files.phpt 0000664 0001750 0001750 00000000747 12333375647 015226 0 ustar --TEST--
Test include/require functions as expected
--DESCRIPTION--
This test verifies that require_once and include are working as expected
--FILE--
start();
?>
--EXPECT--
OK
pthreads-2.0.6/tests/includeme.inc 0000664 0001750 0001750 00000000036 12333375647 014071 0 ustar start();
?>
--EXPECT--
Test::run: :/var/lib/other
pthreads-2.0.6/tests/interface.phpt 0000664 0001750 0001750 00000001113 12333375647 014263 0 ustar --TEST--
Test interface functionality
--DESCRIPTION--
This test verifies that interfaces are handled properly by pthreads
--FILE--
name = $name;
}
public function getName() {
return $this->name;
}
public function run() { printf("%s\n", $this->getName()); }
}
$thread = new TestThread();
$thread->setName("InterfaceTest");
$thread->start();
?>
--EXPECT--
InterfaceTest
pthreads-2.0.6/tests/interfaces.phpt 0000664 0001750 0001750 00000001141 12333375647 014447 0 ustar --TEST--
Testing interfaces inheritance (#124)
--DESCRIPTION--
Test if interfaces are stored in thread
--FILE--
test;
}
}
class TEST extends Thread {
public function __construct() {
}
public function run(){
$MY = new MY();
var_dump(in_array("iMY",get_declared_interfaces()));
var_dump(in_array("iMY",class_implements($MY)));
}
}
$test = new TEST();
$test->start();
?>
--EXPECT--
bool(true)
bool(true)
pthreads-2.0.6/tests/isset-unset.phpt 0000664 0001750 0001750 00000001714 12333375647 014615 0 ustar --TEST--
Testing isset unset
--DESCRIPTION--
This tests that isset and unset are working properly
--FILE--
merge(range(1, 10));
var_dump($storage);
for($i = 0; $i < 10; $i ++) {
var_dump(isset($storage[$i]));
var_dump($storage[$i]);
unset($storage[$i]);
var_dump(isset($storage[$i]));
printf("\n");
}
?>
--EXPECT--
object(Storage)#1 (10) {
["0"]=>
int(1)
["1"]=>
int(2)
["2"]=>
int(3)
["3"]=>
int(4)
["4"]=>
int(5)
["5"]=>
int(6)
["6"]=>
int(7)
["7"]=>
int(8)
["8"]=>
int(9)
["9"]=>
int(10)
}
bool(true)
int(1)
bool(false)
bool(true)
int(2)
bool(false)
bool(true)
int(3)
bool(false)
bool(true)
int(4)
bool(false)
bool(true)
int(5)
bool(false)
bool(true)
int(6)
bool(false)
bool(true)
int(7)
bool(false)
bool(true)
int(8)
bool(false)
bool(true)
int(9)
bool(false)
bool(true)
int(10)
bool(false)
pthreads-2.0.6/tests/killed-info.phpt 0000664 0001750 0001750 00000001010 12333375647 014514 0 ustar --TEST--
Test kill termination info
--DESCRIPTION--
This test verifies that ::kill sets state and error information
--FILE--
start();
$t->kill();
$t->join();
var_dump($t->isTerminated());
var_dump($t->getTerminationInfo());
?>
--EXPECTF--
bool(true)
array(4) {
["scope"]=>
string(10) "TestThread"
["function"]=>
string(3) "run"
["file"]=>
string(%d) "%s"
["line"]=>
int(%d)
}
pthreads-2.0.6/tests/merging-members.phpt 0000664 0001750 0001750 00000001435 12333375647 015412 0 ustar --TEST--
Testing merging members
--DESCRIPTION--
This tests that merging members works as expected
--FILE--
test = "one";
$stores[1]->other = "when";
$stores[1]->test = "two";
$stores[1]->next = 0.01;
$stores[0]->merge($stores[1]);
var_dump($stores[0]);
$stores[0]->test = "one";
$stores[1]->other = "when";
$stores[1]->test = "two";
$stores[1]->next = 0.01;
$stores[0]->merge($stores[1], false);
var_dump($stores[0]);
?>
--EXPECT--
object(Store)#1 (3) {
["test"]=>
string(3) "two"
["other"]=>
string(4) "when"
["next"]=>
float(0.01)
}
object(Store)#1 (3) {
["test"]=>
string(3) "one"
["other"]=>
string(4) "when"
["next"]=>
float(0.01)
}
pthreads-2.0.6/tests/merging-range.phpt 0000664 0001750 0001750 00000000467 12333375647 015060 0 ustar --TEST--
Testing merging members (long keys)
--DESCRIPTION--
This tests that merging ranges works as expected (long keys)
--FILE--
merge(range("0", "3"));
var_dump(count($storage));
?>
--EXPECTF--
int(4)
pthreads-2.0.6/tests/mutex.phpt 0000664 0001750 0001750 00000000443 12333375647 013472 0 ustar --TEST--
Test mutex operations
--DESCRIPTION--
This test will ensures mutex functionality
--FILE--
--EXPECT--
bool(true)
bool(true)
bool(true)
pthreads-2.0.6/tests/norefs.phpt 0000664 0001750 0001750 00000000751 12333375647 013626 0 ustar --TEST--
Test members (typeof object) with no other references
--DESCRIPTION--
This test verifies that members of an object type that have no other references in the engine can be set as members of threaded objects
--FILE--
t = new O();
}
public function run(){}
}
var_dump(new T());
?>
--EXPECT--
object(T)#1 (1) {
["t"]=>
object(O)#2 (0) {
}
}
pthreads-2.0.6/tests/normalize-members.phpt 0000664 0001750 0001750 00000000545 12333375647 015763 0 ustar --TEST--
Testing normalizing members
--DESCRIPTION--
This tests that normalizing members works without effort
--FILE--
--EXPECT--
bool(true)
pthreads-2.0.6/tests/normal-reads.phpt 0000664 0001750 0001750 00000000654 12333375647 014720 0 ustar --TEST--
Test reading object properties without debug info
--DESCRIPTION--
This test verifies that reading properties from the object without var_dump/print_r will work
--FILE--
name = sprintf("%s", __CLASS__);
}
}
$thread = new Test();
$thread->start();
$thread->join();
foreach($thread as $key => $value)
var_dump($value);
?>
--EXPECT--
string(4) "Test"
pthreads-2.0.6/tests/null-member-crash.phpt 0000664 0001750 0001750 00000000457 12333375647 015652 0 ustar --TEST--
Null member crash
--DESCRIPTION--
This test verifies that null members do not crash php
--FILE--
--EXPECTF--
object(Test)#1 (1) {
["0"]=>
string(4) "what"
}
pthreads-2.0.6/tests/oomethods.phpt 0000664 0001750 0001750 00000000712 12333375647 014330 0 ustar --TEST--
Test access to user defined methods in the object context
--DESCRIPTION--
User methods are now imported from your declared class into the thread
--FILE--
value;
}
public function run(){
$this->value = 1;
}
}
$thread = new ThreadTest();
if($thread->start()) {
$thread->join();
var_dump($thread->objectTest());
}
?>
--EXPECT--
int(1) pthreads-2.0.6/tests/pools.phpt 0000664 0001750 0001750 00000004077 12333375647 013473 0 ustar --TEST--
Test pooling
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
logger = $logger;
}
protected $loger;
}
class WebWork extends Threaded {
public function isComplete() {
return $this->complete;
}
public function run() {
$this->worker
->logger
->log("%s executing in Thread #%lu",
__CLASS__, $this->worker->getThreadId());
$this->complete = true;
}
protected $complete;
}
class SafeLog extends Threaded {
protected function log($message, $args = array()) {
$args = func_get_args();
if (($message = array_shift($args))) {
echo vsprintf(
"{$message}\n", $args);
}
}
}
$pool = new Pool(8, 'WebWorker', array(new SafeLog()));
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->submit(new WebWork());
$pool->shutdown();
$pool->collect(function($work){
return $work->isComplete();
});
var_dump($pool);
?>
--EXPECTF--
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
WebWork executing in Thread #%d
object(Pool)#%d (6) {
["size":protected]=>
int(8)
["class":protected]=>
string(9) "WebWorker"
["workers":protected]=>
array(0) {
}
["work":protected]=>
array(0) {
}
["ctor":protected]=>
array(1) {
[0]=>
object(SafeLog)#%d (0) {
}
}
["last":protected]=>
int(6)
}
pthreads-2.0.6/tests/pools-default.phpt 0000664 0001750 0001750 00000001264 12333375647 015110 0 ustar --TEST--
Test pool defaults
--DESCRIPTION--
This test verifies pool defaults
--FILE--
submit(new Work());
$pool->shutdown();
var_dump($pool);
?>
--EXPECTF--
object(Work)#%d (%d) {
["worker"]=>
object(Worker)#%d (%d) {
}
}
object(Pool)#%d (%d) {
["size":protected]=>
int(1)
["class":protected]=>
string(6) "Worker"
["workers":protected]=>
array(0) {
}
["work":protected]=>
array(1) {
[0]=>
object(Work)#%d (%d) {
["worker"]=>
object(Worker)#%d (%d) {
}
}
}
["ctor":protected]=>
NULL
["last":protected]=>
int(1)
}
pthreads-2.0.6/tests/selective-inheritance.phpt 0000664 0001750 0001750 00000001445 12333375647 016605 0 ustar --TEST--
Test selective inheritance
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
start();
$thread->join();
$thread = new TestThread();
$thread->start(PTHREADS_INHERIT_NONE);
$thread->join();
$thread = new TestThread();
$thread->start(PTHREADS_INHERIT_FUNCTIONS | PTHREADS_INHERIT_CLASSES);
$thread->join();
?>
--EXPECT--
bool(true)
bool(true)
bool(true)
bool(false)
bool(false)
bool(false)
bool(true)
bool(false)
bool(true)
pthreads-2.0.6/tests/shift-pop.phpt 0000664 0001750 0001750 00000006662 12333375647 014252 0 ustar --TEST--
Test shift and pop
--DESCRIPTION--
This test verifies that shift and pop functionality are working
--FILE--
shift());
var_dump($s);
$s[] = "next";
var_dump($s);
var_dump($s->pop());
var_dump($s);
while (@$i++<100)
$s[$i]=$i;
var_dump($s);
while (($next = $s->pop())) {
var_dump($next);
}
?>
--EXPECT--
object(S)#1 (1) {
["0"]=>
string(4) "help"
}
string(4) "help"
object(S)#1 (0) {
}
object(S)#1 (1) {
["1"]=>
string(4) "next"
}
string(4) "next"
object(S)#1 (0) {
}
object(S)#1 (100) {
["1"]=>
int(1)
["2"]=>
int(2)
["3"]=>
int(3)
["4"]=>
int(4)
["5"]=>
int(5)
["6"]=>
int(6)
["7"]=>
int(7)
["8"]=>
int(8)
["9"]=>
int(9)
["10"]=>
int(10)
["11"]=>
int(11)
["12"]=>
int(12)
["13"]=>
int(13)
["14"]=>
int(14)
["15"]=>
int(15)
["16"]=>
int(16)
["17"]=>
int(17)
["18"]=>
int(18)
["19"]=>
int(19)
["20"]=>
int(20)
["21"]=>
int(21)
["22"]=>
int(22)
["23"]=>
int(23)
["24"]=>
int(24)
["25"]=>
int(25)
["26"]=>
int(26)
["27"]=>
int(27)
["28"]=>
int(28)
["29"]=>
int(29)
["30"]=>
int(30)
["31"]=>
int(31)
["32"]=>
int(32)
["33"]=>
int(33)
["34"]=>
int(34)
["35"]=>
int(35)
["36"]=>
int(36)
["37"]=>
int(37)
["38"]=>
int(38)
["39"]=>
int(39)
["40"]=>
int(40)
["41"]=>
int(41)
["42"]=>
int(42)
["43"]=>
int(43)
["44"]=>
int(44)
["45"]=>
int(45)
["46"]=>
int(46)
["47"]=>
int(47)
["48"]=>
int(48)
["49"]=>
int(49)
["50"]=>
int(50)
["51"]=>
int(51)
["52"]=>
int(52)
["53"]=>
int(53)
["54"]=>
int(54)
["55"]=>
int(55)
["56"]=>
int(56)
["57"]=>
int(57)
["58"]=>
int(58)
["59"]=>
int(59)
["60"]=>
int(60)
["61"]=>
int(61)
["62"]=>
int(62)
["63"]=>
int(63)
["64"]=>
int(64)
["65"]=>
int(65)
["66"]=>
int(66)
["67"]=>
int(67)
["68"]=>
int(68)
["69"]=>
int(69)
["70"]=>
int(70)
["71"]=>
int(71)
["72"]=>
int(72)
["73"]=>
int(73)
["74"]=>
int(74)
["75"]=>
int(75)
["76"]=>
int(76)
["77"]=>
int(77)
["78"]=>
int(78)
["79"]=>
int(79)
["80"]=>
int(80)
["81"]=>
int(81)
["82"]=>
int(82)
["83"]=>
int(83)
["84"]=>
int(84)
["85"]=>
int(85)
["86"]=>
int(86)
["87"]=>
int(87)
["88"]=>
int(88)
["89"]=>
int(89)
["90"]=>
int(90)
["91"]=>
int(91)
["92"]=>
int(92)
["93"]=>
int(93)
["94"]=>
int(94)
["95"]=>
int(95)
["96"]=>
int(96)
["97"]=>
int(97)
["98"]=>
int(98)
["99"]=>
int(99)
["100"]=>
int(100)
}
int(100)
int(99)
int(98)
int(97)
int(96)
int(95)
int(94)
int(93)
int(92)
int(91)
int(90)
int(89)
int(88)
int(87)
int(86)
int(85)
int(84)
int(83)
int(82)
int(81)
int(80)
int(79)
int(78)
int(77)
int(76)
int(75)
int(74)
int(73)
int(72)
int(71)
int(70)
int(69)
int(68)
int(67)
int(66)
int(65)
int(64)
int(63)
int(62)
int(61)
int(60)
int(59)
int(58)
int(57)
int(56)
int(55)
int(54)
int(53)
int(52)
int(51)
int(50)
int(49)
int(48)
int(47)
int(46)
int(45)
int(44)
int(43)
int(42)
int(41)
int(40)
int(39)
int(38)
int(37)
int(36)
int(35)
int(34)
int(33)
int(32)
int(31)
int(30)
int(29)
int(28)
int(27)
int(26)
int(25)
int(24)
int(23)
int(22)
int(21)
int(20)
int(19)
int(18)
int(17)
int(16)
int(15)
int(14)
int(13)
int(12)
int(11)
int(10)
int(9)
int(8)
int(7)
int(6)
int(5)
int(4)
int(3)
int(2)
int(1)
pthreads-2.0.6/tests/shutdown-handler.phpt 0000664 0001750 0001750 00000000626 12333375647 015621 0 ustar --TEST--
Test shutdown handlers #204
--DESCRIPTION--
Shutdown handlers that were closures were causing segfaults
--FILE--
start();
?>
--EXPECTF--
object(stdClass)#%d (0) {
}
pthreads-2.0.6/tests/stateful-fatalities.phpt 0000664 0001750 0001750 00000000473 12333375647 016305 0 ustar --TEST--
Test stateful fatalities
--DESCRIPTION--
This test verifies that state includes fatalities
--FILE--
start();
$test->join();
var_dump($test->isTerminated());
?>
--EXPECTF--
bool(true)
pthreads-2.0.6/tests/stack-by-reference.phpt 0000664 0001750 0001750 00000001066 12333375647 016003 0 ustar --TEST--
Test stacking by reference ONLY
--DESCRIPTION--
Stacking without a reference is not allowed, so the API should enforce the requirement
--FILE--
start();
$t->stack(new T());
$t->shutdown();
?>
--EXPECTF--
Fatal error: Uncaught exception 'InvalidArgumentException' with message 'Worker::stack expects $work to be a reference' in %s:%d
Stack trace:
#0 %s(%d): Worker->stack(Object(T))
#1 {main}
thrown in %s on line %d
pthreads-2.0.6/tests/stack-by-reference-pass.phpt 0000664 0001750 0001750 00000000601 12333375647 016741 0 ustar --TEST--
Test stacking by reference ONLY (pass)
--DESCRIPTION--
Stacking without a reference is not allowed, so the API should enforce the requirement
--FILE--
start();
$o = new T();
$t->stack($o);
$t->shutdown();
?>
--EXPECT--
OK
pthreads-2.0.6/tests/staticmethods.phpt 0000664 0001750 0001750 00000001001 12333375647 015172 0 ustar --TEST--
Test access to static methods from within user threads
--DESCRIPTION--
Static methods as declared in the users implementation of Thread should now be available for calling in the thread scope
--FILE--
result = self::staticTest();
}
}
$thread = new ThreadTest();
if($thread->start())
if ($thread->join())
var_dump($thread->result);
?>
--EXPECT--
int(1) pthreads-2.0.6/tests/static-resolution.phpt 0000664 0001750 0001750 00000000775 12333375647 016030 0 ustar --TEST--
Test static:: regression
--DESCRIPTION--
Bug #210 shows static:: requires different logic to self::
--FILE--
start();
?>
--EXPECT--
int(123)
int(123)
int(123)
int(123)
pthreads-2.0.6/tests/statics.phpt 0000664 0001750 0001750 00000000641 12333375647 014002 0 ustar --TEST--
Test statics (bug 19)
--DESCRIPTION--
This test verifies that static members in declarations made outside of threads are available inside threads without error
--FILE--
start();
?>
--EXPECT--
string(15) "pthreads rocks!"
pthreads-2.0.6/tests/synchronization.phpt 0000664 0001750 0001750 00000001033 12333375647 015565 0 ustar --TEST--
Test synchronized blocks
--DESCRIPTION--
This test verifies that syncronization is working
--FILE--
synchronized(function($thread){
$thread->data = true;
$thread->notify();
}, $this);
}
}
$t = new T;
$t->start();
$t->synchronized(function($thread){
if (!$thread->data) {
var_dump($thread->wait());
} else var_dump($thread->data);
}, $t);
?>
--EXPECT--
bool(true)
pthreads-2.0.6/tests/thorn-in-side.phpt 0000664 0001750 0001750 00000000761 12333375647 015013 0 ustar --TEST--
Testing thorn in my side hasn't returned
--DESCRIPTION--
This test verifies my nemisis has not returned (bug #48)
--FILE--
var;
}
}
class childClass extends parentClass {
}
class clientThread extends Thread {
public function run() {
$objChild = new childClass();
}
}
$objClientThread = new clientThread();
$objClientThread->start();
--EXPECT--
pthreads-2.0.6/tests/thread.phpt 0000664 0001750 0001750 00000000466 12333375647 013604 0 ustar --TEST--
Test basic threading
--DESCRIPTION--
This test will create and join a simple thread
--FILE--
start())
var_dump($thread->join());
?>
--EXPECT--
bool(true) pthreads-2.0.6/tests/trait-aliases.phpt 0000664 0001750 0001750 00000001013 12333375647 015064 0 ustar --TEST--
Test trait aliases
--SKIPIF--
--DESCRIPTION--
Fix bug #274, trait aliases causing memory errors
--FILE--
fromTrait('blah');
}
}
$t = new myThread();
$t->start();
$t->join();
--EXPECT--
string(9) "fromTrait"
pthreads-2.0.6/tests/unset-defaults.phpt 0000664 0001750 0001750 00000000566 12333375647 015301 0 ustar --TEST--
Test unset defaults [moot: default values are ignored]
--DESCRIPTION--
This test verifies that unset members do not cause a problem in pthreads objects
--FILE--
default);
}
}
$thread = new TestThread();
$thread->start();
?>
--EXPECT--
NULL
pthreads-2.0.6/tests/waiting-timeouts.phpt 0000664 0001750 0001750 00000000701 12333375647 015636 0 ustar --TEST--
Test waiting timeouts
--DESCRIPTION--
This test verifies that reaching at timeout returns the correct value
--FILE--
synchronized(function($thread){
usleep(100000);
}, $this);
}
}
$t = new T;
$t->start();
$t->synchronized(function($thread){
var_dump($thread->wait(100));
}, $t);
?>
--EXPECT--
bool(false)
pthreads-2.0.6/tests/wait.phpt 0000664 0001750 0001750 00000001173 12333375647 013275 0 ustar --TEST--
Test wait/notify
--DESCRIPTION--
This test will verify wait/notify functionality
--FILE--
sent = false;
}
public function run(){
$this->synchronized(function($self){
$self->sent = true;
$self->notify();
}, $this);
}
}
$thread = new ThreadTest();
if($thread->start()) {
$thread->synchronized(function($me){
if (!$me->sent) {
var_dump($me->wait());
} else var_dump($me->sent);
}, $thread);
} else printf("bool(false)\n");
?>
--EXPECT--
bool(true)
pthreads-2.0.6/src/pthreads.h 0000664 0001750 0001750 00000006333 12333375647 013047 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_H
#define HAVE_PTHREADS_H
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include
#ifndef _WIN32
#include
#include
#else
#include
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef HAVE_SPL
#include
#include
#else
extern zend_class_entry *spl_ce_InvalidArgumentException;
extern zend_class_entry *spl_ce_Countable;
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
extern zend_class_entry *pthreads_threaded_entry;
extern zend_class_entry *pthreads_thread_entry;
extern zend_class_entry *pthreads_worker_entry;
extern zend_class_entry *pthreads_mutex_entry;
extern zend_class_entry *pthreads_condition_entry;
#ifndef IS_PTHREADS_CLASS
#define IS_PTHREADS_CLASS(c) \
(instanceof_function(c, pthreads_threaded_entry TSRMLS_CC))
#endif
#ifndef IS_PTHREADS_OBJECT
#define IS_PTHREADS_OBJECT(o) \
(IS_PTHREADS_CLASS(Z_OBJCE_P(o)))
#endif
extern zend_object_handlers pthreads_handlers;
extern zend_object_handlers *zend_handlers;
extern struct _pthreads_globals pthreads_globals;
ZEND_EXTERN_MODULE_GLOBALS(pthreads)
#ifndef PTHREADS_ZG
ZEND_BEGIN_MODULE_GLOBALS(pthreads)
pid_t pid;
int signal;
void *pointer;
HashTable *resolve;
HashTable *resources;
HashTable *functions;
ZEND_END_MODULE_GLOBALS(pthreads)
# define PTHREADS_ZG(v) TSRMG(pthreads_globals_id, zend_pthreads_globals *, v)
# define PTHREADS_PID() PTHREADS_ZG(pid) ? PTHREADS_ZG(pid) : (PTHREADS_ZG(pid)=getpid())
#endif
#endif
pthreads-2.0.6/src/globals.c 0000664 0001750 0001750 00000011677 12333375647 012662 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_GLOBALS
#define HAVE_PTHREADS_GLOBALS
#ifndef HAVE_PTHREADS_GLOBALS_H
# include
#endif
struct _pthreads_globals pthreads_globals;
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef PTHREADS_GTSRMLS_C
# define PTHREADS_GTSRMLS_C (TSRMLS_C) ? TSRMLS_C : (void***) &pthreads_globals
#endif
#ifndef PTHREADS_GLOBAL_LOCK_ARGS
# define PTHREADS_GLOBAL_LOCK_ARGS \
locked, PTHREADS_GTSRMLS_C
#endif
/* {{{ */
void pthreads_global_string_free(void *strkey) {
free((char*)*((char**)strkey));
} /* }}} */
/* {{{ */
void pthreads_global_object_free(void *pData) {
free(*(void**)pData);
} /* }}} */
/* {{{ pthreads_globals_init */
zend_bool pthreads_globals_init(TSRMLS_D){
if (!PTHREADS_G(init)&&!PTHREADS_G(failed)) {
PTHREADS_G(init)=1;
if (!(PTHREADS_G(lock)=pthreads_lock_alloc(PTHREADS_GTSRMLS_C)))
PTHREADS_G(failed)=1;
if (PTHREADS_G(failed)) {
PTHREADS_G(init)=0;
} else {
zend_hash_init(
&PTHREADS_G(strings), 64, NULL, (dtor_func_t) pthreads_global_string_free, 1);
zend_hash_init(
&PTHREADS_G(objects), 64, NULL, (dtor_func_t) pthreads_global_object_free, 1);
}
return PTHREADS_G(init);
} else return 0;
} /* }}} */
/* {{{ pthreads_globals_lock */
zend_bool pthreads_globals_lock(zend_bool *locked TSRMLS_DC){
return pthreads_lock_acquire(PTHREADS_G(lock), PTHREADS_GLOBAL_LOCK_ARGS);
} /* }}} */
/* {{{ pthreads_globals_unlock */
void pthreads_globals_unlock(zend_bool locked TSRMLS_DC) {
pthreads_lock_release(PTHREADS_G(lock), PTHREADS_GLOBAL_LOCK_ARGS);
} /* }}} */
/* {{{ pthreads_global_string */
char *pthreads_global_string(char *strkey, zend_uint keylen, zend_bool lower TSRMLS_DC) {
char **created = NULL;
if (zend_hash_find(&PTHREADS_G(strings), strkey, keylen, (void**)&created) != SUCCESS) {
char *creating = malloc(keylen+1);
if (creating) {
if (lower) {
zend_str_tolower_copy(
creating, strkey, keylen);
} else strcpy(creating, strkey);
zend_hash_update(
&PTHREADS_G(strings), strkey, keylen, (void**)&creating, sizeof(void*), NULL);
return creating;
}
}
return *created;
} /* }}} */
/* {{{ pthreads_globals_object */
void* pthreads_globals_object_alloc(size_t length TSRMLS_DC) {
zend_bool locked = 0;
void *bucket = calloc(1, length);
if (!bucket)
return NULL;
if (pthreads_globals_lock(&locked TSRMLS_CC)) {
zend_hash_index_update(
&PTHREADS_G(objects),
(ulong) bucket, (void**)&bucket, sizeof(void*), NULL);
pthreads_globals_unlock(locked TSRMLS_CC);
}
return bucket;
} /* }}} */
/* {{{ pthreads_globals_validate */
zend_bool pthreads_globals_object_validate(zend_ulong address TSRMLS_DC) {
zend_bool valid = 0;
zend_bool locked = 0;
if (!address)
return valid;
if (pthreads_globals_lock(&locked TSRMLS_CC)) {
valid = zend_hash_index_exists(
&PTHREADS_G(objects), address);
pthreads_globals_unlock(locked TSRMLS_CC);
}
return valid;
} /* }}} */
/* {{{ pthreads_globals_delete */
zend_bool pthreads_globals_object_delete(void *address TSRMLS_DC) {
zend_bool deleted = 0;
zend_bool locked = 0;
if (!address)
return deleted;
if (pthreads_globals_lock(&locked TSRMLS_CC)) {
deleted = zend_hash_index_del(
&PTHREADS_G(objects), (zend_ulong) address);
if (deleted) {
free (address);
}
pthreads_globals_unlock(locked TSRMLS_CC);
}
return deleted;
} /* }}} */
/* {{{ shutdown global structures */
void pthreads_globals_shutdown(TSRMLS_D) {
if (PTHREADS_G(init)) {
PTHREADS_G(init)=0;
PTHREADS_G(failed)=0;
zend_hash_destroy(
&PTHREADS_G(strings));
zend_hash_destroy(
&PTHREADS_G(objects));
pthreads_lock_free(PTHREADS_G(lock) TSRMLS_CC);
}
} /* }}} */
#endif
pthreads-2.0.6/src/globals.h 0000664 0001750 0001750 00000005512 12333375647 012656 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_GLOBALS_H
#define HAVE_PTHREADS_GLOBALS_H
/*
* NOTES
* 1. pthreads cannot use the Zend implementation of globals, it makes for instability - we sometimes require a true global lock
*/
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
/* {{{ pthreads_globals */
struct _pthreads_globals {
/*
* Initialized flag
*/
zend_bool init;
/*
* Failed flag
*/
zend_bool failed;
/*
* Globals Mutex
*/
pthreads_lock lock;
/*
* Global Strings
*/
HashTable strings;
/*
* Global/Default Resource Destructor
*/
dtor_func_t (default_resource_dtor);
/*
* Objects Cache
*/
HashTable objects;
}; /* }}} */
extern struct _pthreads_globals pthreads_globals;
ZEND_EXTERN_MODULE_GLOBALS(pthreads)
/* {{{ PTHREADS_G */
#define PTHREADS_G(v) pthreads_globals.v
/* }}} */
/* {{{ */
zend_bool pthreads_globals_object_delete(void *address TSRMLS_DC); /* }}} */
/* {{{ */
zend_bool pthreads_globals_object_validate(zend_ulong address TSRMLS_DC); /* }}} */
/* {{{ */
void* pthreads_globals_object_alloc(size_t length TSRMLS_DC); /* }}} */
/* {{{ initialize (true) globals */
zend_bool pthreads_globals_init(TSRMLS_D); /* }}} */
/* {{{ acquire global lock */
zend_bool pthreads_globals_lock(zend_bool *locked TSRMLS_DC); /* }}} */
/* {{{ release global lock */
void pthreads_globals_unlock(zend_bool locked TSRMLS_DC); /* }}} */
/* {{{ copy string to globals */
char *pthreads_global_string(char *strkey, zend_uint keylen, zend_bool lower TSRMLS_DC); /* }}} */
/* {{{ shutdown global structures */
void pthreads_globals_shutdown(TSRMLS_D); /* }}} */
#endif /* HAVE_PTHREADS_GLOBAL_H */
pthreads-2.0.6/src/handlers.c 0000664 0001750 0001750 00000034123 12333375647 013026 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_HANDLERS
#define HAVE_PTHREADS_HANDLERS
#ifndef HAVE_PTHREADS_HANDLERS_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
# include
#endif
/* {{{ counts properties of object */
int pthreads_count_properties(PTHREADS_COUNT_PASSTHRU_D) {
return pthreads_store_count(PTHREADS_COUNT_PASSTHRU_C);
} /* }}} */
/* {{{ reads properties from storage for debug only */
HashTable* pthreads_read_debug(PTHREADS_READ_DEBUG_PASSTHRU_D) {
HashTable *table = emalloc(sizeof(HashTable));
zend_hash_init(table, 8, NULL, ZVAL_PTR_DTOR, 0);
*is_temp = 1;
pthreads_store_tohash(
(PTHREADS_FETCH_FROM(object))->store,
table TSRMLS_CC
);
return table;
} /* }}} */
/* {{{ reads properties from storage */
HashTable* pthreads_read_properties(PTHREADS_READ_PROPERTIES_PASSTHRU_D) {
PTHREAD pobject = PTHREADS_FETCH_FROM(object);
if (pobject) {
#if PHP_VERSION_ID > 50399
rebuild_object_properties(&pobject->std);
#endif
{
pthreads_store_tohash(
pobject->store,
pobject->std.properties TSRMLS_CC
);
}
}
return pobject->std.properties;
} /* }}} */
/* {{ reads a property from a thread, wherever it is available */
zval * pthreads_read_property (PTHREADS_READ_PROPERTY_PASSTHRU_D) {
zval *value = NULL, *mstring = NULL;
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (Z_TYPE_P(member) != IS_STRING) {
ALLOC_ZVAL(mstring);
*mstring = *member;
zval_copy_ctor(
mstring
);
INIT_PZVAL(mstring);
zend_try {
convert_to_string(mstring);
} zend_end_try();
member = mstring;
#if PHP_VERSION_ID > 50399
key = NULL;
#endif
}
if (Z_TYPE_P(member)==IS_STRING) {
pthreads_store_read(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &value TSRMLS_CC);
} else {
if (value != NULL) {
value = EG(
uninitialized_zval_ptr
);
Z_ADDREF_P(value);
}
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to use an unsupported key type %s", Z_OBJCE_P(object)->name);
}
if (mstring != NULL) {
zval_ptr_dtor(&mstring);
}
return value;
}
zval* pthreads_read_dimension(PTHREADS_READ_DIMENSION_PASSTHRU_D) { return pthreads_read_property(PTHREADS_READ_DIMENSION_PASSTHRU_C); }
/* }}} */
/* {{{ writes a property to a thread in the appropriate way */
void pthreads_write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_D) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
zval *mstring = NULL;
zend_bool nulled = 0;
zend_bool locked;
if (member == NULL || Z_TYPE_P(member) == IS_NULL) {
/* for anonymous members,
we acquire the lock and increment a counter
we do not store any additional information or perform any lookups */
pthreads_lock_acquire(pthreads->store->lock, &locked TSRMLS_CC);
{
if (member == NULL) {
MAKE_STD_ZVAL(member);
nulled = 1;
}
ZVAL_LONG(member, pthreads->store->next++);
}
pthreads_lock_release(pthreads->store->lock, locked TSRMLS_CC);
}
if (Z_TYPE_P(member) != IS_STRING) {
ALLOC_ZVAL(mstring);
*mstring = *member;
zval_copy_ctor(
mstring
);
INIT_PZVAL(mstring);
zend_try {
convert_to_string(mstring);
} zend_end_try();
if(nulled)
FREE_ZVAL(member);
member = mstring;
#if PHP_VERSION_ID > 50399
key = NULL;
#endif
}
if (Z_TYPE_P(member)==IS_STRING) {
switch(Z_TYPE_P(value)){
case IS_STRING:
case IS_LONG:
case IS_ARRAY:
case IS_OBJECT:
case IS_NULL:
case IS_DOUBLE:
case IS_RESOURCE:
case IS_BOOL: {
if (pthreads_store_write(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &value TSRMLS_CC)!=SUCCESS){
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads failed to write member %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member));
}
} break;
default: {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to use unsupported data for %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member));
}
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to use an unsupported key type %s", Z_OBJCE_P(object)->name);
}
if (mstring != NULL) {
zval_ptr_dtor(&mstring);
}
}
void pthreads_write_dimension(PTHREADS_WRITE_DIMENSION_PASSTHRU_D) { pthreads_write_property(PTHREADS_WRITE_DIMENSION_PASSTHRU_C); }
/* }}} */
/* {{{ check if a thread has a property set, wherever it is available */
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D) {
int isset = 0;
zval *mstring = NULL;
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (Z_TYPE_P(member) != IS_STRING) {
ALLOC_ZVAL(mstring);
*mstring = *member;
zval_copy_ctor(
mstring
);
INIT_PZVAL(mstring);
zend_try {
convert_to_string(mstring);
} zend_end_try();
member = mstring;
#if PHP_VERSION_ID > 50399
key = NULL;
#endif
}
if (Z_TYPE_P(member) == IS_STRING) {
isset = pthreads_store_isset(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member), has_set_exists TSRMLS_CC);
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to use an unsupported key type %s", Z_OBJCE_P(object)->name);
}
if (mstring != NULL) {
zval_ptr_dtor(&mstring);
}
return isset;
}
int pthreads_has_dimension(PTHREADS_HAS_DIMENSION_PASSTHRU_D) { return pthreads_has_property(PTHREADS_HAS_DIMENSION_PASSTHRU_C); }
/* }}} */
/* {{{ unset an object property */
void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_D) {
zval *mstring = NULL;
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (Z_TYPE_P(member) != IS_STRING) {
ALLOC_ZVAL(mstring);
*mstring = *member;
zval_copy_ctor(
mstring
);
INIT_PZVAL(mstring);
zend_try {
convert_to_string(mstring);
} zend_end_try();
member = mstring;
#if PHP_VERSION_ID > 50399
key = NULL;
#endif
}
if (Z_TYPE_P(member) == IS_STRING) {
if (pthreads_store_delete(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member) TSRMLS_CC)!=SUCCESS){
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads failed to delete member %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member));
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to use an unsupported key type %s", Z_OBJCE_P(object)->name);
}
if (mstring != NULL) {
zval_ptr_dtor(&mstring);
}
}
void pthreads_unset_dimension(PTHREADS_UNSET_DIMENSION_PASSTHRU_D) { pthreads_unset_property(PTHREADS_UNSET_DIMENSION_PASSTHRU_C); }
/* }}} */
/* {{{ pthreads_get_method will attempt to apply pthreads specific modifiers */
zend_function * pthreads_get_method(PTHREADS_GET_METHOD_PASSTHRU_D) {
zend_class_entry *scope;
zend_function *call;
zend_function *callable;
char *lcname;
int access = 0;
PTHREAD thread = PTHREADS_FETCH_FROM(*pobject);
if (thread) {
switch((access=pthreads_modifiers_get(thread->modifiers, method TSRMLS_CC))){
case ZEND_ACC_PRIVATE:
case ZEND_ACC_PROTECTED:
scope = Z_OBJCE_PP(pobject);
lcname = (char*) calloc(1, methodl+1);
zend_str_tolower_copy(lcname, method, methodl);
if (zend_hash_find(&scope->function_table, lcname, methodl+1, (void**)&call)==SUCCESS) {
callable = (zend_function*) emalloc(sizeof(zend_function));
callable->type = ZEND_OVERLOADED_FUNCTION;
callable->common.function_name = call->common.function_name;
callable->common.fn_flags = ZEND_ACC_PUBLIC;
callable->common.scope = scope;
callable->common.arg_info = call->common.arg_info;
callable->common.num_args = call->common.num_args;
callable->common.required_num_args = call->common.required_num_args;
#if PHP_VERSION_ID < 50400
callable->common.pass_rest_by_reference = call->common.pass_rest_by_reference;
callable->common.return_reference = call->common.return_reference;
#endif
free(lcname);
return callable;
}
free(lcname);
/* TODO : if not found ? switch to default ? or return some error ? */
default: call = zend_handlers->get_method(PTHREADS_GET_METHOD_PASSTHRU_C);
}
} else call = zend_handlers->get_method(PTHREADS_GET_METHOD_PASSTHRU_C);
return call;
} /* }}} */
/* {{{ pthreads_call_method */
int pthreads_call_method(PTHREADS_CALL_METHOD_PASSTHRU_D) {
zval ***argv = NULL, zmethod, *zresult;
zend_function *call = NULL;
zend_fcall_info info;
zend_fcall_info_cache cache;
zend_class_entry *scope;
int called = -1, argc = ZEND_NUM_ARGS(), access = ZEND_ACC_PUBLIC, mlength = 0;
char *lcname;
zend_bool unprotect;
if (getThis()) {
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
switch((access=pthreads_modifiers_get(thread->modifiers, method TSRMLS_CC))){
case ZEND_ACC_PRIVATE:
case ZEND_ACC_PROTECTED: {
scope = Z_OBJCE_P(getThis());
/*
* Stop invalid private method calls
*/
if (access == ZEND_ACC_PRIVATE && !PTHREADS_IN_THREAD(thread)) {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to call private "
"method %s::%s from outside the threading context",
scope->name, method);
return FAILURE;
}
/*
* Get arguments from stack
*/
if (ZEND_NUM_ARGS())
{
argv = safe_emalloc(sizeof(zval **), argc, 0);
if (argv) {
zend_get_parameters_array_ex(argc, argv);
}
}
mlength = strlen(method);
lcname = calloc(1, mlength+1);
zend_str_tolower_copy(lcname, method, mlength);
if (zend_hash_find(&scope->function_table, lcname, mlength+1, (void**)&call)==SUCCESS) {
if (call) {
/*
* Make protected method call
*/
{
if (access != ZEND_ACC_PROTECTED || pthreads_modifiers_protect(thread->modifiers, method, &unprotect TSRMLS_CC)) {
ZVAL_STRINGL(&zmethod, method, strlen(method), 0);
info.size = sizeof(info);
info.object_ptr = getThis();
info.function_name = &zmethod;
info.retval_ptr_ptr = &zresult;
info.no_separation = 1;
info.symbol_table = NULL;
info.param_count = argc;
info.params = argv;
cache.initialized = 1;
cache.function_handler = call;
cache.calling_scope = EG(scope);
cache.called_scope = scope;
cache.object_ptr = getThis();
if ((called=zend_call_function(&info, &cache TSRMLS_CC))!=SUCCESS) {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while "
"calling %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name, method);
called = FAILURE;
} else {
if (zresult) {
if (!return_value_used) {
zval_ptr_dtor(&zresult);
} else {
ZVAL_ZVAL(return_value, zresult, 1, 1);
}
}
}
if (access == ZEND_ACC_PROTECTED) {
pthreads_modifiers_unprotect(thread->modifiers, method, unprotect TSRMLS_CC);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while "
"calling %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name, method);
called = FAILURE;
}
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while "
"finding %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name, method);
called = FAILURE;
}
}
/*
* Free unstacked arguments
*/
if (argc) {
efree(argv);
}
free(lcname);
return called;
} break;
}
}
}
switch (called) {
case -1:
return zend_handlers->call_method(PTHREADS_CALL_METHOD_PASSTHRU_C);
default: return called;
}
} /* }}} */
/* {{{ pthreads_cast_object */
int pthreads_cast_object(PTHREADS_CAST_PASSTHRU_D) {
switch (type) {
case IS_ARRAY: {
pthreads_store_tohash(
(PTHREADS_FETCH_FROM(from))->store, Z_ARRVAL_P(to) TSRMLS_CC
);
return SUCCESS;
} break;
default:
return FAILURE;
}
return SUCCESS;
} /* }}} */
/* {{{ clone object handler */
zend_object_value pthreads_clone_object(PTHREADS_CLONE_PASSTHRU_D)
{
zend_object_value attach;
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads objects cannot be cloned");
return attach;
} /* }}} */
#endif
pthreads-2.0.6/src/handlers.h 0000664 0001750 0001750 00000016632 12333375647 013040 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
/*
* These handlers provide thread-safe read/write/call/count/cast for pthreads objects
*/
#ifndef HAVE_PTHREADS_HANDLERS_H
#define HAVE_PTHREADS_HANDLERS_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
#define PTHREADS_CAST_PASSTHRU_D zval *from, zval *to, int type TSRMLS_DC
#define PTHREADS_CAST_PASSTHRU_C from, to, type TSRMLS_CC
#define PTHREADS_COUNT_PASSTHRU_D zval *object, long *count TSRMLS_DC
#define PTHREADS_COUNT_PASSTHRU_C object, count TSRMLS_CC
#define PTHREADS_CLONE_PASSTHRU_D zval *object TSRMLS_DC
#define PTHREADS_CLONE_PASSTHRU_C object TSRMLS_CC
/* {{{ these resolve differences in 5.3 and 5.4 object handling API */
#if PHP_VERSION_ID > 50399
# define PTHREADS_READ_DEBUG_PASSTHRU_D zval *object, int *is_temp TSRMLS_DC
# define PTHREADS_READ_DEBUG_PASSTHRU_C object, is_temp TSRMLS_CC
# define PTHREADS_READ_PROPERTIES_PASSTHRU_D zval *object TSRMLS_DC
# define PTHREADS_READ_PROPERTIES_PASSTHRU_C object TSRMLS_CC
# define PTHREADS_READ_PROPERTY_PASSTHRU_D zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_READ_DIMENSION_PASSTHRU_D zval *object, zval *member, int type TSRMLS_DC
# define PTHREADS_READ_PROPERTY_PASSTHRU_C object, member, type, key TSRMLS_CC
# define PTHREADS_READ_DIMENSION_PASSTHRU_C object, member, type, NULL TSRMLS_CC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_D zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_WRITE_DIMENSION_PASSTHRU_D zval *object, zval *member, zval *value TSRMLS_DC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_C object, member, value, key TSRMLS_CC
# define PTHREADS_WRITE_DIMENSION_PASSTHRU_C object, member, value, NULL TSRMLS_CC
# define PTHREADS_HAS_PROPERTY_PASSTHRU_D zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_HAS_DIMENSION_PASSTHRU_D zval *object, zval *member, int has_set_exists TSRMLS_DC
# define PTHREADS_HAS_PROPERTY_PASSTHRU_C object, member, has_set_exists, key TSRMLS_CC
# define PTHREADS_HAS_DIMENSION_PASSTHRU_C object, member, has_set_exists, NULL TSRMLS_CC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_D zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_UNSET_DIMENSION_PASSTHRU_D zval *object, zval *member TSRMLS_DC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_C object, member, key TSRMLS_CC
# define PTHREADS_UNSET_DIMENSION_PASSTHRU_C object, member, NULL TSRMLS_CC
# define PTHREADS_GET_METHOD_PASSTHRU_D zval **pobject, char *method, int methodl, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_GET_METHOD_PASSTHRU_C pobject, method, methodl, key TSRMLS_CC
# define PTHREADS_CALL_METHOD_PASSTHRU_D const char *method, INTERNAL_FUNCTION_PARAMETERS
# define PTHREADS_CALL_METHOD_PASSTHRU_C method, INTERNAL_FUNCTION_PARAM_PASSTHRU
#else
# define PTHREADS_READ_DEBUG_PASSTHRU_D zval *object, int *is_temp TSRMLS_DC
# define PTHREADS_READ_DEBUG_PASSTHRU_C object, is_temp TSRMLS_CC
# define PTHREADS_READ_PROPERTIES_PASSTHRU_D zval *object TSRMLS_DC
# define PTHREADS_READ_PROPERTIES_PASSTHRU_C object TSRMLS_CC
# define PTHREADS_READ_PROPERTY_PASSTHRU_D zval *object, zval *member, int type TSRMLS_DC
# define PTHREADS_READ_DIMENSION_PASSTHRU_D PTHREADS_READ_PROPERTY_PASSTHRU_D
# define PTHREADS_READ_PROPERTY_PASSTHRU_C object, member, type TSRMLS_CC
# define PTHREADS_READ_DIMENSION_PASSTHRU_C PTHREADS_READ_PROPERTY_PASSTHRU_C
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_D zval *object, zval *member, zval *value TSRMLS_DC
# define PTHREADS_WRITE_DIMENSION_PASSTHRU_D PTHREADS_WRITE_PROPERTY_PASSTHRU_D
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_C object, member, value TSRMLS_CC
# define PTHREADS_WRITE_DIMENSION_PASSTHRU_C PTHREADS_WRITE_PROPERTY_PASSTHRU_C
# define PTHREADS_HAS_PROPERTY_PASSTHRU_D zval *object, zval *member, int has_set_exists TSRMLS_DC
# define PTHREADS_HAS_DIMENSION_PASSTHRU_D PTHREADS_HAS_PROPERTY_PASSTHRU_D
# define PTHREADS_HAS_PROPERTY_PASSTHRU_C object, member, has_set_exists TSRMLS_CC
# define PTHREADS_HAS_DIMENSION_PASSTHRU_C PTHREADS_HAS_PROPERTY_PASSTHRU_C
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_D zval *object, zval *member TSRMLS_DC
# define PTHREADS_UNSET_DIMENSION_PASSTHRU_D PTHREADS_UNSET_PROPERTY_PASSTHRU_D
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_C object, member TSRMLS_CC
# define PTHREADS_UNSET_DIMENSION_PASSTHRU_C PTHREADS_UNSET_PROPERTY_PASSTHRU_C
# define PTHREADS_GET_METHOD_PASSTHRU_D zval **pobject, char *method, int methodl TSRMLS_DC
# define PTHREADS_GET_METHOD_PASSTHRU_C pobject, method, methodl TSRMLS_CC
# define PTHREADS_CALL_METHOD_PASSTHRU_D char *method, INTERNAL_FUNCTION_PARAMETERS
# define PTHREADS_CALL_METHOD_PASSTHRU_C method, INTERNAL_FUNCTION_PARAM_PASSTHRU
#endif /* }}} */
/* {{{ read proeprties from storage */
HashTable* pthreads_read_debug(PTHREADS_READ_DEBUG_PASSTHRU_D); /* }}} */
/* {{{ read proeprties from storage */
HashTable* pthreads_read_properties(PTHREADS_READ_PROPERTIES_PASSTHRU_D); /* }}} */
/* {{{ read a property from the referenced thread */
zval * pthreads_read_property(PTHREADS_READ_PROPERTY_PASSTHRU_D);
zval * pthreads_read_dimension(PTHREADS_READ_DIMENSION_PASSTHRU_D); /* }}} */
/* {{{ write a property to the referenced thread */
void pthreads_write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_D);
void pthreads_write_dimension(PTHREADS_WRITE_DIMENSION_PASSTHRU_D); /* }}} */
/* {{{ check if the referenced thread has a specific property */
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D);
int pthreads_has_dimension(PTHREADS_HAS_DIMENSION_PASSTHRU_D); /* }}} */
/* {{{ unset a property in the referenced thread */
void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_D);
void pthreads_unset_dimension(PTHREADS_UNSET_DIMENSION_PASSTHRU_D); /* }}} */
/* {{{ count properties in storage */
int pthreads_count_properties(PTHREADS_COUNT_PASSTHRU_D); /* }}} */
/* {{{ fetch a pthreads friendly method */
zend_function * pthreads_get_method(PTHREADS_GET_METHOD_PASSTHRU_D); /* }}} */
/* {{{ make a pthreads method call */
int pthreads_call_method(PTHREADS_CALL_METHOD_PASSTHRU_D); /* }}} */
/* {{{ cast an object to a normal array helper */
int pthreads_cast_object(PTHREADS_CAST_PASSTHRU_D); /* }}} */
/* {{{ clone object handler */
zend_object_value pthreads_clone_object(PTHREADS_CLONE_PASSTHRU_D); /* }}} */
#endif
pthreads-2.0.6/src/lock.c 0000664 0001750 0001750 00000007437 12333375647 012166 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_LOCK
#define HAVE_PTHREADS_LOCK
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ proto pthreads_lock pthreads_lock_alloc(TSRMLS_D)
shall allocate and initialize a pthreads lock */
pthreads_lock pthreads_lock_alloc(TSRMLS_D) {
pthreads_lock lock = calloc(1, sizeof(*lock));
if (lock) {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
#if defined(PTHREAD_MUTEX_RECURSIVE) || defined(__FreeBSD__)
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#else
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
#endif
/* whatever the default type will do */
if (pthread_mutex_init(&lock->mutex, &attr)==SUCCESS) {
lock->owner = NULL;
lock->locks = 0;
return lock;
}
free(lock);
}
return NULL;
} /* }}} */
/* {{{ proto zend_bool pthreads_lock_acquire(pthreads_lock lock, zend_bool *acquired TSRMLS_DC)
shall attempt to acquire the referenced lock, setting acquired and returning true on success
if the lock is already held by the caller, the lock count is increased, acquired is not set,
and true is still returned ( since the caller still owns the lock, and has the privilege to
carry out whatever action they were acqiuring the lock for ) */
zend_bool pthreads_lock_acquire(pthreads_lock lock, zend_bool *acquired TSRMLS_DC) {
zend_bool locked = 0;
if (lock) {
lock->locks++;
switch (pthread_mutex_lock(&lock->mutex)) {
case SUCCESS:
locked = (((*acquired)=1)==1);
lock->owner = TSRMLS_C;
break;
default: {
locked = (((*acquired)=0)==1);
}
}
} else locked = (((*acquired)=0)==1);
return locked;
} /* }}} */
/* {{{ proto zend_bool pthreads_lock_release(pthreads_lock lock, zend_bool acquired TSRMLS_DC)
acquired should have been set by the accompanying call to pthreads_lock_acquire
if acquired is set true then the lock shall be released, resetting the owner and decremeneting the count
if acquired is set false then the counter shall be decremented without unlocking taking place */
zend_bool pthreads_lock_release(pthreads_lock lock, zend_bool acquired TSRMLS_DC) {
zend_bool released = 1;
if (lock) {
switch (pthread_mutex_unlock(&lock->mutex)) {
case SUCCESS:
released = 1;
lock->locks--;
break;
default: {
released = 0;
}
}
} else released = 0;
return released;
} /* }}} */
/* {{{ proto void pthreads_lock_free(pthreads_lock lock TSRMLS_DC)
shall deinitialize and free the memory associated with the referenced lock */
void pthreads_lock_free(pthreads_lock lock TSRMLS_DC) {
if (lock) {
pthread_mutex_destroy(&lock->mutex);
free(lock);
lock = NULL;
}
} /* }}} */
#endif
pthreads-2.0.6/src/lock.h 0000664 0001750 0001750 00000004066 12333375647 012166 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_LOCK_H
#define HAVE_PTHREADS_LOCK_H
/*
* This API is NOT ready to be exposed to userland.
*
* This header provides pthreads with a recursive locking mechanism that
* will eventually be independant of threading implementation that pthreads
* is using, it will use the default mutex type on the system, but will manage
* the lock count using TSRMLS_C as a reference to the owner
*/
#ifndef HAVE_PTHREADS_H
# include
#endif
typedef struct {
pthread_mutex_t mutex;
void*** owner;
ulong locks;
} *pthreads_lock;
/* {{{ allocate a lock */
pthreads_lock pthreads_lock_alloc(TSRMLS_D); /* }}} */
/* {{{ acquire a lock */
zend_bool pthreads_lock_acquire(pthreads_lock lock, zend_bool *acquired TSRMLS_DC); /* }}} */
/* {{{ release a lock */
zend_bool pthreads_lock_release(pthreads_lock lock, zend_bool acquired TSRMLS_DC); /* }}} */
/* {{{ free a lock */
void pthreads_lock_free(pthreads_lock lock TSRMLS_DC); /* }}} */
#endif
pthreads-2.0.6/src/modifiers.c 0000664 0001750 0001750 00000012141 12333375647 013203 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_MODIFIERS
#define HAVE_PTHREADS_MODIFIERS
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
/* {{{ statics */
static void pthreads_modifiers_modifiers_dtor(void **element);
static void pthreads_modifiers_protection_dtor(void **element); /* }}} */
/* {{{ allocate modifiers */
pthreads_modifiers pthreads_modifiers_alloc(TSRMLS_D) {
pthreads_modifiers modifiers = calloc(1, sizeof(*modifiers));
if (modifiers) {
/*
* Initialize modifiers
*/
zend_hash_init(&modifiers->modified, 32, NULL, (dtor_func_t) pthreads_modifiers_modifiers_dtor, 1);
zend_hash_init(&modifiers->protection, 32, NULL, (dtor_func_t) pthreads_modifiers_protection_dtor, 1);
}
return modifiers;
} /* }}} */
/* {{{ initialize pthreads modifiers using the referenced class entry */
void pthreads_modifiers_init(pthreads_modifiers modifiers, zend_class_entry *entry TSRMLS_DC) {
HashPosition position;
zend_function *method;
for (zend_hash_internal_pointer_reset_ex(&entry->function_table, &position);
zend_hash_get_current_data_ex(&entry->function_table, (void**)&method, &position) == SUCCESS;
zend_hash_move_forward_ex(&entry->function_table, &position)) {
if (method && (method->type != ZEND_INTERNAL_FUNCTION)) {
if (method->common.fn_flags & ZEND_ACC_PRIVATE){
pthreads_modifiers_set(
modifiers,
method->common.function_name,
ZEND_ACC_PRIVATE TSRMLS_CC
);
}
if (method->common.fn_flags & ZEND_ACC_PROTECTED) {
pthreads_modifiers_set(
modifiers,
method->common.function_name,
ZEND_ACC_PROTECTED TSRMLS_CC
);
}
}
}
} /* }}} */
/* {{{ set access modifier for method */
int pthreads_modifiers_set(pthreads_modifiers modifiers, const char *method, zend_uint modify TSRMLS_DC) {
size_t mlength = strlen(method);
if (zend_hash_add(
&modifiers->modified,
method, mlength,
(void**) &modify, sizeof(zend_uint),
NULL
)==SUCCESS) {
pthreads_lock lock = pthreads_lock_alloc(TSRMLS_C);
if (lock) {
return zend_hash_add(
&modifiers->protection,
method, mlength,
(void**) &lock, sizeof(*lock),
NULL
);
}
}
return FAILURE;
} /* }}} */
/* {{{ get access modifier for method */
zend_uint pthreads_modifiers_get(pthreads_modifiers modifiers, const char *method TSRMLS_DC) {
zend_uint *modified;
size_t mlength = strlen(method);
if (zend_hash_find(
&modifiers->modified,
method, mlength,
(void*) &modified
)==SUCCESS) {
return *modified;
}
return 0;
} /* }}} */
/* {{{ protect a method call */
zend_bool pthreads_modifiers_protect(pthreads_modifiers modifiers, const char *method, zend_bool *unprotect TSRMLS_DC) {
pthreads_lock *protection;
size_t mlength = strlen(method);
if (zend_hash_find(&modifiers->protection, method, mlength, (void**)&protection)==SUCCESS) {
return pthreads_lock_acquire(*protection, unprotect TSRMLS_CC);
} else return 0;
} /* }}} */
/* {{{ unprotect a method call */
zend_bool pthreads_modifiers_unprotect(pthreads_modifiers modifiers, const char *method, zend_bool unprotect TSRMLS_DC) {
pthreads_lock *protection;
size_t mlength = strlen(method);
if (zend_hash_find(&modifiers->protection, method, mlength, (void**)&protection)==SUCCESS) {
return pthreads_lock_release(*protection, unprotect TSRMLS_CC);
} else return 0;
} /* }}} */
/* {{{ free modifiers */
void pthreads_modifiers_free(pthreads_modifiers modifiers TSRMLS_DC) {
if (modifiers) {
zend_hash_destroy(&modifiers->modified);
zend_hash_destroy(&modifiers->protection);
free(modifiers);
}
} /* }}} */
/* {{{ destructor callback for modifiers (definition) hash table */
static void pthreads_modifiers_modifiers_dtor(void **element) {
} /* }}} */
/* {{{ destructor callback for modifiers (protection) hash table */
static void pthreads_modifiers_protection_dtor(void **element) {
TSRMLS_FETCH();
pthreads_lock_free((pthreads_lock) (*element) TSRMLS_CC);
} /* }}} */
#endif
pthreads-2.0.6/src/modifiers.h 0000664 0001750 0001750 00000004554 12333375647 013221 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_MODIFIERS_H
#define HAVE_PTHREADS_MODIFIERS_H
#ifdef HAVE_CONFIG_H
# include
#endif
#ifndef HAVE_PTHREADS_H
# include
#endif
typedef struct {
HashTable modified;
HashTable protection;
} *pthreads_modifiers;
/* {{{ allocate modifiers object */
pthreads_modifiers pthreads_modifiers_alloc(TSRMLS_D); /* }}} */
/* {{{ initialize modifiers using the referenced class entry */
void pthreads_modifiers_init(pthreads_modifiers modifiers, zend_class_entry *entry TSRMLS_DC); /* }}} */
/* {{{ set modifiers for a method */
int pthreads_modifiers_set(pthreads_modifiers modifiers, const char *method, zend_uint modify TSRMLS_DC); /* }}} */
/* {{{ get modifiers for a method */
zend_uint pthreads_modifiers_get(pthreads_modifiers modifiers, const char *method TSRMLS_DC); /* }}} */
/* {{{ protect a method call */
zend_bool pthreads_modifiers_protect(pthreads_modifiers modifiers, const char *method, zend_bool *unprotect TSRMLS_DC); /* }}} */
/* {{{ unprotect a method call */
zend_bool pthreads_modifiers_unprotect(pthreads_modifiers modifiers, const char *method, zend_bool unprotect TSRMLS_DC); /* }}} */
/* {{{ free modifiers object */
void pthreads_modifiers_free(pthreads_modifiers modifiers TSRMLS_DC); /* }}} */
#endif
pthreads-2.0.6/src/object.c 0000664 0001750 0001750 00000071607 12333375647 012504 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_OBJECT
#define HAVE_PTHREADS_OBJECT
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
# include
#endif
#ifndef HAVE_PTHREADS_PREPARE_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
/* {{{ pthreads module entry */
extern zend_module_entry pthreads_module_entry; /* }}} */
static inline pthreads_address pthreads_address_alloc(PTHREAD object TSRMLS_DC) {
pthreads_address address = (pthreads_address) calloc(1, sizeof(*address));
if (address) {
pid_t pid = PTHREADS_PID();
/* add the space for null here, once */
address->length = snprintf(
NULL, 0, "%lu:%lu", (long)pid, (long) object
);
if (address->length) {
address->serial = calloc(1, address->length+1);
if (address->serial) {
sprintf(
(char*) address->serial, "%lu:%lu", (long)pid, (long) object
);
}
}
}
return address;
}
static inline void pthreads_address_free(pthreads_address address) {
if (address->serial) {
free(address->serial);
}
free(address);
}
/* {{{ base ctor/clone/dtor/free */
static void pthreads_base_ctor(PTHREAD base, zend_class_entry *entry TSRMLS_DC);
static void pthreads_base_dtor(void *arg, zend_object_handle handle TSRMLS_DC);
static void pthreads_base_free(void *arg TSRMLS_DC);
static void pthreads_base_clone(void *arg, void **pclone TSRMLS_DC); /* }}} */
/* {{{ connect objects */
static int pthreads_connect(PTHREAD source, PTHREAD destination TSRMLS_DC); /* }}} */
/* {{{ pthreads routine */
static void * pthreads_routine(void *arg); /* }}} */
/* {{{ set state bits on a thread, timeout where appropriate/required */
zend_bool pthreads_set_state_ex(PTHREAD thread, int mask, long timeout TSRMLS_DC) {
zend_bool locked, dowait, result;
if (mask & PTHREADS_ST_WAITING) {
if (pthreads_state_lock(thread->state, &locked TSRMLS_CC)) {
dowait = !pthreads_state_check(thread->state, PTHREADS_ST_JOINED TSRMLS_CC);
if (dowait)
pthreads_state_set_locked(thread->state, PTHREADS_ST_WAITING TSRMLS_CC);
if (locked)
pthreads_state_unlock(thread->state, locked TSRMLS_CC);
if (dowait) {
result = pthreads_synchro_wait_ex(
thread->synchro, timeout TSRMLS_CC
);
} else result = 0;
} else result = 0;
} else result = pthreads_state_set(thread->state, mask TSRMLS_CC);
return result;
} /* }}} */
/* {{{ set state bits on a thread */
zend_bool pthreads_set_state(PTHREAD thread, int mask TSRMLS_DC) {
return pthreads_set_state_ex(thread, mask, 0L TSRMLS_CC);
} /* }}} */
/* {{{ unset state bits on a thread */
zend_bool pthreads_unset_state(PTHREAD thread, int mask TSRMLS_DC){
zend_bool result = 0;
if (mask & PTHREADS_ST_WAITING) {
if (pthreads_state_unset(thread->state, mask TSRMLS_CC)) {
result = pthreads_synchro_notify(thread->synchro TSRMLS_CC);
} else result = 0;
} else result = pthreads_state_unset(thread->state, mask TSRMLS_CC);
return result;
} /* }}} */
/* {{{ save the current error for object */
static inline void pthreads_error_save(pthreads_error error TSRMLS_DC) {
if (EG(active_op_array)) {
zend_function *active = (zend_function*) EG(active_op_array);
/* deal with scope stuff */
if (active) {
if (active->common.scope) {
error->clazz = (unsigned char *)strdup(
active->common.scope->name);
} else error->clazz = NULL;
if (active->common.function_name) {
error->method = (unsigned char *)strdup(
active->common.function_name);
} else error->method = NULL;
}
/* deal with file stuff */
{
const char *tmp;
tmp = zend_get_executed_filename(TSRMLS_C);
if (tmp)
error->file = (unsigned char *)strdup(tmp);
error->line = zend_get_executed_lineno(TSRMLS_C);
}
}
} /* }}} */
/* {{{ allocate error structure */
static inline pthreads_error pthreads_error_alloc(TSRMLS_D) {
pthreads_error error = calloc(1, sizeof(*error));
error->clazz = NULL;
error->method = NULL;
error->file = NULL;
return error;
} /* }}} */
/* {{{ free the error saved for object */
static inline void pthreads_error_free(pthreads_error error TSRMLS_DC) {
if (error) {
if (error->clazz)
free(error->clazz);
if (error->method)
free(error->method);
if (error->file)
free(error->file);
free(
error);
error = NULL;
}
} /* }}} */
/* {{{ pop for php */
size_t pthreads_stack_pop(PTHREAD thread, PTHREAD work TSRMLS_DC) {
zend_bool locked;
int remain = 0;
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
if (PTHREADS_IS_WORKER(thread)) {
HashTable *stack = &thread->stack->objects;
if (work) {
HashPosition position;
PTHREAD search = NULL;
for (zend_hash_internal_pointer_reset_ex(stack, &position);
zend_hash_get_current_data_ex(stack, (void**)&search, &position) == SUCCESS;
zend_hash_move_forward_ex(stack, &position)) {
/* arghhh */
}
} else zend_hash_destroy(stack);
remain = zend_hash_num_elements(stack);
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
} else remain = -1;
return remain;
} /* }}} */
/* {{{ push an item onto the work buffer */
size_t pthreads_stack_push(PTHREAD thread, zval *work TSRMLS_DC) {
zend_bool locked;
PTHREAD threaded = PTHREADS_FETCH_FROM(work);
size_t counted = 0L;
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
HashTable *stack = &thread->stack->objects;
if (stack) {
if (!zend_hash_num_elements(stack)) {
zend_hash_clean(
stack);
thread->stack->position = 0L;
}
zend_hash_next_index_insert(
stack, (void**) &threaded, sizeof(struct _pthread_construct), NULL
);
counted = zend_hash_num_elements(stack);
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
if (counted > 0L) {
pthreads_synchro_lock(thread->synchro TSRMLS_CC);
pthreads_unset_state(
thread, PTHREADS_ST_WAITING TSRMLS_CC);
pthreads_synchro_unlock(thread->synchro TSRMLS_CC);
}
}
return counted;
} /* }}} */
/* {{{ pop the next item from the work buffer */
size_t pthreads_stack_next(PTHREAD thread, zval *this_ptr TSRMLS_DC) {
PTHREAD *work, current = NULL;
zend_bool locked;
size_t bubble = 0;
zval *that_ptr;
zend_class_entry *popped;
burst:
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
if ((bubble=zend_hash_num_elements((HashTable*) thread->stack)) > 0) {
zend_hash_index_find(
(HashTable*) thread->stack,
thread->stack->position, (void**) &work
);
if ((current = *work)) {
/*
* Allocate a $that
*/
MAKE_STD_ZVAL(that_ptr);
/*
* Initialize it with the new entry
*/
object_init_ex(
that_ptr,
pthreads_prepared_entry
(
thread,
current->std.ce TSRMLS_CC
)
);
popped = Z_OBJCE_P(that_ptr);
/*
* Setup Executor
*/
EG(This) = that_ptr;
EG(scope) = popped;
EG(called_scope) = popped;
/*
* Setup threaded object for runtime
*/
{
PTHREAD threaded = PTHREADS_FETCH_FROM(that_ptr);
if (threaded) {
current->tid = thread->tid;
current->tls = thread->tls;
pthreads_connect(current, threaded TSRMLS_CC);
pthreads_store_write(
threaded->store, "worker", sizeof("worker")-1, &this_ptr TSRMLS_CC
);
Z_ADDREF_P(this_ptr);
}
}
}
zend_hash_index_del(
(HashTable*) thread->stack, thread->stack->position++);
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
if (!bubble) {
if (!pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
pthreads_synchro_lock(thread->synchro TSRMLS_CC);
if (pthreads_set_state(thread, PTHREADS_ST_WAITING TSRMLS_CC)) {
pthreads_synchro_unlock(thread->synchro TSRMLS_CC);
goto burst;
} else pthreads_synchro_unlock(thread->synchro TSRMLS_CC);
} else return 0;
}
}
return bubble;
} /* }}} */
/* {{{ return the number of items currently stacked */
size_t pthreads_stack_length(PTHREAD thread TSRMLS_DC) {
zend_bool locked;
size_t counted = 0;
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
counted = zend_hash_num_elements(
&thread->stack->objects);
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
}
return counted;
} /* }}} */
/* {{{ thread object constructor */
zend_object_value pthreads_thread_ctor(zend_class_entry *entry TSRMLS_DC) {
zend_object_value attach;
PTHREAD thread = pthreads_globals_object_alloc(sizeof(*thread) TSRMLS_CC);
if (thread) {
thread->scope = PTHREADS_SCOPE_THREAD;
pthreads_base_ctor(thread, entry TSRMLS_CC);
thread->handle = zend_objects_store_put(
thread,
(zend_objects_store_dtor_t) pthreads_base_dtor,
(zend_objects_free_object_storage_t) pthreads_base_free,
(zend_objects_store_clone_t) pthreads_base_clone TSRMLS_CC
);
attach.handle = thread->handle;
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ worker object constructor */
zend_object_value pthreads_worker_ctor(zend_class_entry *entry TSRMLS_DC) {
zend_object_value attach;
PTHREAD worker = pthreads_globals_object_alloc(sizeof(*worker) TSRMLS_CC);
if (worker) {
worker->scope = PTHREADS_SCOPE_WORKER;
pthreads_base_ctor(worker, entry TSRMLS_CC);
worker->handle = zend_objects_store_put(
worker,
(zend_objects_store_dtor_t) pthreads_base_dtor,
(zend_objects_free_object_storage_t) pthreads_base_free,
(zend_objects_store_clone_t) pthreads_base_clone TSRMLS_CC
);
attach.handle = worker->handle;
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ threaded object constructor */
zend_object_value pthreads_threaded_ctor(zend_class_entry *entry TSRMLS_DC) {
zend_object_value attach;
PTHREAD threaded = pthreads_globals_object_alloc(sizeof(*threaded) TSRMLS_CC);
if (threaded) {
threaded->scope = PTHREADS_SCOPE_THREADED;
pthreads_base_ctor(threaded, entry TSRMLS_CC);
threaded->handle = zend_objects_store_put(
threaded,
(zend_objects_store_dtor_t) pthreads_base_dtor,
(zend_objects_free_object_storage_t) pthreads_base_free,
(zend_objects_store_clone_t) pthreads_base_clone TSRMLS_CC
);
attach.handle = threaded->handle;
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ */
void pthreads_current_thread(zval **return_value TSRMLS_DC) {
if (PTHREADS_ZG(pointer)) {
PTHREAD current = (PTHREAD) PTHREADS_ZG(pointer);
object_init_ex(
(*return_value), pthreads_prepared_entry(NULL, current->std.ce TSRMLS_CC));
pthreads_connect(current, PTHREADS_FETCH_FROM((*return_value)) TSRMLS_CC);
}
} /* }}} */
/* {{{ connect pthread objects */
static int pthreads_connect(PTHREAD source, PTHREAD destination TSRMLS_DC) {
if (source && destination) {
if (PTHREADS_IS_NOT_CONNECTION(destination)) {
pthreads_lock_free(destination->lock TSRMLS_CC);
pthreads_state_free(destination->state TSRMLS_CC);
pthreads_modifiers_free(destination->modifiers TSRMLS_CC);
pthreads_store_free(destination->store TSRMLS_CC);
pthreads_synchro_free(destination->synchro TSRMLS_CC);
pthreads_address_free(destination->address);
pthreads_error_free(destination->error TSRMLS_CC);
if (PTHREADS_IS_WORKER(destination)) {
zend_hash_destroy(
&destination->stack->objects
);
free(destination->stack);
}
destination->scope |= PTHREADS_SCOPE_CONNECTION;
return pthreads_connect
(
source,
destination TSRMLS_CC
);
}
destination->thread = source->thread;
destination->tid = source->tid;
destination->tls = source->tls;
destination->address = source->address;
destination->lock = source->lock;
destination->state = source->state;
destination->synchro = source->synchro;
destination->modifiers = source->modifiers;
destination->store = source->store;
destination->stack = source->stack;
destination->error = source->error;
if (PTHREADS_IS_DETACHED(source)) {
destination->scope |= PTHREADS_SCOPE_DETACHED;
}
return SUCCESS;
} else return FAILURE;
} /* }}} */
/* {{{ pthreads_base_init */
static inline void pthreads_base_init(PTHREAD base TSRMLS_DC) {
zend_class_entry *entry = base->std.ce;
const char *property_name = NULL;
int property_name_len = 0;
const char *class_name = estrndup(
entry->name, entry->name_length);
char *class_free = (char*) class_name;
HashPosition position;
#if PHP_VERSION_ID < 50400
zval **property;
for (zend_hash_internal_pointer_reset_ex(&entry->default_properties, &position);
zend_hash_get_current_data_ex(&entry->default_properties, (void**) &property, &position)==SUCCESS;
zend_hash_move_forward_ex(&entry->default_properties, &position)) {
char *n;
ulong i;
uint l;
if (zend_hash_get_current_key_ex(&entry->default_properties, &n, &l, &i, 0, &position)) {
zend_unmangle_property_name(
n, l,
(char**)&class_name,
(char**)&property_name);
property_name_len = strlen(property_name);
pthreads_store_write(base->store, property_name, property_name_len, property TSRMLS_CC);
}
}
#else
HashTable *table = &entry->properties_info;
zend_property_info *info = NULL;
for (zend_hash_internal_pointer_reset_ex(table, &position);
zend_hash_get_current_data_ex(table, (void**) &info, &position) == SUCCESS;
zend_hash_move_forward_ex(table, &position)) {
/* do not copy statics */
if (info->flags & ZEND_ACC_STATIC)
continue;
#if PHP_VERSION_ID >= 50500
zend_unmangle_property_name_ex(
info->name, info->name_length,
&class_name,
&property_name, &property_name_len);
#else
zend_unmangle_property_name(
info->name, info->name_length,
&class_name,
&property_name);
property_name_len = strlen(property_name);
#endif
if (entry->default_properties_table &&
entry->default_properties_table[info->offset]) {
pthreads_store_write(
base->store,
(char*) property_name, property_name_len,
&entry->default_properties_table[info->offset] TSRMLS_CC);
} else pthreads_store_write(
base->store,
(char*) property_name, property_name_len,
&EG(uninitialized_zval_ptr) TSRMLS_CC);
}
#endif
efree((char*)class_free);
} /* }}} */
/* {{{ pthreads base constructor */
static void pthreads_base_ctor(PTHREAD base, zend_class_entry *entry TSRMLS_DC) {
if (base) {
zend_object_std_init(&base->std, entry TSRMLS_CC);
#if PHP_VERSION_ID < 50400
{
zval *temp;
zend_hash_copy(
base->std.properties,
&entry->default_properties,
(copy_ctor_func_t) zval_add_ref,
&temp, sizeof(zval*)
);
}
#else
object_properties_init(&(base->std), entry);
#endif
base->cls = tsrm_ls;
base->cid = pthreads_self();
base->address = pthreads_address_alloc(base TSRMLS_CC);
base->options = PTHREADS_INHERIT_ALL;
if (!PTHREADS_IS_CONNECTION(base)) {
base->lock = pthreads_lock_alloc(TSRMLS_C);
base->state = pthreads_state_alloc(0 TSRMLS_CC);
base->synchro = pthreads_synchro_alloc(TSRMLS_C);
base->modifiers = pthreads_modifiers_alloc(TSRMLS_C);
base->store = pthreads_store_alloc(TSRMLS_C);
base->error = pthreads_error_alloc(TSRMLS_C);
pthreads_modifiers_init(base->modifiers, entry TSRMLS_CC);
if (PTHREADS_IS_WORKER(base)) {
base->stack = (pthreads_stack) calloc(1, sizeof(*base->stack));
if (base->stack) {
zend_hash_init(
&base->stack->objects, 8, NULL, NULL, 1);
base->stack->position = 0L;
}
}
pthreads_base_init(base TSRMLS_CC);
}
}
} /* }}} */
/* {{{ pthreads base destructor */
static void pthreads_base_dtor(void *arg, zend_object_handle handle TSRMLS_DC) {
PTHREAD base = (PTHREAD) arg;
if (PTHREADS_IS_NOT_CONNECTION(base) && PTHREADS_IS_NOT_DETACHED(base)) {
assert(base->cls == TSRMLS_C);
if (PTHREADS_IS_THREAD(base)||PTHREADS_IS_WORKER(base)) {
pthread_t *pthread = &base->thread;
if (pthread) {
pthreads_join(base TSRMLS_CC);
}
}
pthreads_lock_free(base->lock TSRMLS_CC);
pthreads_state_free(base->state TSRMLS_CC);
pthreads_modifiers_free(base->modifiers TSRMLS_CC);
pthreads_store_free(base->store TSRMLS_CC);
pthreads_synchro_free(base->synchro TSRMLS_CC);
pthreads_address_free(base->address);
pthreads_error_free(base->error TSRMLS_CC);
if (PTHREADS_IS_WORKER(base)) {
zend_hash_destroy(
&base->stack->objects
);
free(base->stack);
}
}
#if PHP_VERSION_ID > 50399
{
zend_object *object = &base->std;
if (object->properties_table) {
int i;
for (i = 0; i < object->ce->default_properties_count; i++) {
if (object->properties_table[i]) {
zval_ptr_dtor(&object->properties_table[i]);
}
}
efree(object->properties_table);
}
if (object->properties) {
zend_hash_destroy(object->properties);
FREE_HASHTABLE(object->properties);
}
}
#else
zend_object_std_dtor(&(base->std) TSRMLS_CC);
#endif
} /* }}} */
/* {{{ free object */
static void pthreads_base_free(void *arg TSRMLS_DC) {
PTHREAD base = (PTHREAD) arg;
if (base) {
if (PTHREADS_IS_NOT_DETACHED(base)) {
if (pthreads_globals_object_delete(base TSRMLS_CC)) {
base = NULL;
}
}
}
} /* }}} */
/* {{{ clone object */
static void pthreads_base_clone(void *arg, void **pclone TSRMLS_DC) {
printf("pthreads_base_clone: executing ...\n");
} /* }}} */
/* {{{ start a pthread */
int pthreads_start(PTHREAD thread TSRMLS_DC) {
int dostart = 0;
int started = FAILURE;
zend_bool tlocked, slocked;
if (pthreads_state_lock(thread->state, &slocked TSRMLS_CC)) {
if (!pthreads_state_check(thread->state, PTHREADS_ST_STARTED TSRMLS_CC)) {
pthreads_state_set_locked(thread->state, PTHREADS_ST_STARTED TSRMLS_CC);
dostart = 1;
} else started = PTHREADS_ST_STARTED;
if (slocked)
pthreads_state_unlock(thread->state, slocked TSRMLS_CC);
}
if (dostart) {
if (pthreads_lock_acquire(thread->lock, &tlocked TSRMLS_CC)) {
started = pthread_create(&thread->thread, NULL, pthreads_routine, (void*)thread);
if (started == SUCCESS)
pthreads_state_wait(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC);
pthreads_lock_release(thread->lock, tlocked TSRMLS_CC);
}
}
return started;
} /* }}} */
/* {{{ gracefully join a pthread object */
int pthreads_join(PTHREAD thread TSRMLS_DC) {
int dojoin = 0;
int donotify = 0;
zend_bool slocked;
if (pthreads_state_lock(thread->state, &slocked TSRMLS_CC)) {
if (pthreads_state_check(thread->state, PTHREADS_ST_STARTED TSRMLS_CC) &&
!pthreads_state_check(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
pthreads_state_set_locked(thread->state, PTHREADS_ST_JOINED TSRMLS_CC);
if (PTHREADS_IS_WORKER(thread))
donotify = pthreads_state_check(thread->state, PTHREADS_ST_WAITING TSRMLS_CC);
dojoin = 1;
}
if (slocked)
pthreads_state_unlock(thread->state, slocked TSRMLS_CC);
}
if (donotify) do {
pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
} while(pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
return dojoin ? pthread_join(thread->thread, NULL) : FAILURE;
} /* }}} */
/* {{{ detach a thread */
int pthreads_detach(PTHREAD thread TSRMLS_DC) {
if (PTHREADS_IS_NOT_DETACHED(thread)) {
if ((pthread_detach(thread->thread) == SUCCESS)) {
thread->scope |= PTHREADS_SCOPE_DETACHED;
return SUCCESS;
}
}
return FAILURE;
} /* }}} */
/* {{{ synchronization helper */
zend_bool pthreads_wait_member_ex(PTHREAD thread, zval *member, ulong timeout TSRMLS_DC) {
if (!pthreads_store_isset(thread->store, Z_STRVAL_P(member), Z_STRLEN_P(member), 2 TSRMLS_CC)) {
if (pthreads_synchro_wait_ex(thread->synchro, timeout TSRMLS_CC))
return pthreads_store_isset(thread->store, Z_STRVAL_P(member), Z_STRLEN_P(member), 2 TSRMLS_CC);
else return 0;
} else return 1;
} /* }}} */
/* {{{ synchronization helper */
zend_bool pthreads_wait_member(PTHREAD thread, zval *member TSRMLS_DC) {
return pthreads_wait_member_ex(thread, member, 0L TSRMLS_CC);
} /* }}} */
/* {{{ serialize an instance of a threaded object for connection in another thread */
int pthreads_internal_serialize(zval *object, unsigned char **buffer, zend_uint *blength, zend_serialize_data *data TSRMLS_DC) {
PTHREAD threaded = PTHREADS_FETCH_FROM(object);
if (threaded) {
(*buffer) = (unsigned char*) estrndup(
(char*)threaded->address->serial,
threaded->address->length
);
(*blength) = threaded->address->length+1;
return SUCCESS;
}
return FAILURE;
} /* }}} */
/* {{{ connects to an instance of a threaded object */
int pthreads_internal_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buffer, zend_uint blength, zend_unserialize_data *data TSRMLS_DC) {
PTHREAD address = NULL;
pid_t pid = 0L;
zend_ulong len = sscanf(
(const char*)buffer,
"%lu:%lu",
(long unsigned int *)&pid, (long unsigned int *)&address);
if (len) {
pid_t mpid = PTHREADS_PID();
if (address && pthreads_globals_object_validate((zend_ulong)address TSRMLS_CC)) {
if (pid == mpid) {
/* if we already own this object do not create another handle */
if (address->cls == TSRMLS_C) {
Z_TYPE_PP(object) = IS_OBJECT;
Z_OBJ_HANDLE_PP(object) = address->handle;
Z_OBJ_HT_PP(object) = &pthreads_handlers;
Z_OBJ_HT_PP(object)->add_ref(*object TSRMLS_CC);
return SUCCESS;
}
/* else initialize and connect to the original object */
if (object_init_ex(*object, ce) == SUCCESS) {
pthreads_connect(
address,
PTHREADS_FETCH_FROM(*object) TSRMLS_CC);
return SUCCESS;
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to connect to a %s "
"which belongs to another process", ce->name);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to connect to a %s "
"which has already been destroyed", ce->name);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads detected an attempt to connect to a %s "
"which has already is corrupted", ce->name);
}
ZVAL_NULL(*object);
return FAILURE;
} /* }}} */
#ifdef PTHREADS_KILL_SIGNAL
static inline void pthreads_kill_handler(int signo) /* {{{ */
{
TSRMLS_FETCH();
PTHREAD current = PTHREADS_ZG(pointer);
if (current) {
pthreads_state_set(
current->state, PTHREADS_ST_ERROR TSRMLS_CC);
pthreads_error_save(current->error TSRMLS_CC);
}
PTHREADS_ZG(signal) = signo;
zend_bailout();
} /* }}} */
#endif
/* {{{ this is aptly named ... */
static void * pthreads_routine(void *arg) {
/* passed the object as argument */
PTHREAD thread = (PTHREAD) arg;
char nothing[] = {0,};
#ifdef PTHREADS_KILL_SIGNAL
/* installed to support a graceful-ish kill function */
signal(
PTHREADS_KILL_SIGNAL, pthreads_kill_handler);
#endif
if (thread) {
#ifdef PTHREADS_PEDANTIC
zend_bool glocked = 0; /* global lock indicator */
#endif
zend_bool worker = 0, /* worker indicator */
inwork = 0; /* working indicator */
/* $this original pointer */
zval *this_ptr = NULL,
*this = NULL;
/* executor globals */
zend_executor_globals *ZEG = NULL;
/**
* Startup Block Begin
**/
TSRMLS_FETCH();
/* set thread local storage */
thread->tls = TSRMLS_C;
#ifdef PTHREADS_PEDANTIC
/* acquire a global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
#endif
/* set thread id for this object */
thread->tid = pthreads_self();
/* set context the same as parent */
SG(server_context) = PTHREADS_SG(thread->cls, server_context);
/* some php globals */
PG(expose_php) = 0;
PG(auto_globals_jit) = 0;
zend_alter_ini_entry(
"session.cache_limiter",
sizeof("session.cache_limiter"),
"nocache", sizeof("nocache")-1,
PHP_INI_USER, PHP_INI_STAGE_ACTIVATE);
zend_alter_ini_entry(
"session.use_cookies",
sizeof("session.cache_limiter"),
"0", sizeof("0")-1,
PHP_INI_USER, PHP_INI_STAGE_ACTIVATE);
/* fix php-fpm compatibility */
SG(sapi_started) = 0;
/* request startup */
php_request_startup(TSRMLS_C);
if (!(thread->options & PTHREADS_ALLOW_HEADERS)) {
/* do not send headers again */
SG(headers_sent)=1;
SG(request_info).no_headers = 1;
}
/* prepare environment */
pthreads_prepare(thread TSRMLS_CC);
#ifdef PTHREADS_PEDANTIC
/* release global lock */
pthreads_globals_unlock(glocked TSRMLS_CC);
#endif
/**
* Startup Block End
**/
ZEG = PTHREADS_EG_ALL(TSRMLS_C);
/*
* Allocate $this
*/
ALLOC_INIT_ZVAL(this);
/*
* Assign $this
*/
this_ptr = this;
/**
* Thread Block Begin
**/
zend_first_try {
/*
* Set worker indicator
*/
worker = PTHREADS_IS_WORKER(thread);
/* EG setup */
ZEG->in_execution = 1;
ZEG->current_execute_data=NULL;
ZEG->current_module=&pthreads_module_entry;
/* init $this */
object_init_ex
(
ZEG->This = getThis(),
ZEG->scope = pthreads_prepared_entry(
thread, thread->std.ce
TSRMLS_CC
)
);
/* connect $this */
if (pthreads_connect(PTHREADS_ZG(pointer)=thread, PTHREADS_FETCH_FROM(ZEG->This) TSRMLS_CC)==SUCCESS) {
/* execute $this */
do {
PTHREAD current = PTHREADS_FETCH_FROM(ZEG->This);
zval *zresult = NULL;
pthreads_state_set(current->state, PTHREADS_ST_RUNNING TSRMLS_CC);
{
zend_bool terminated = 0;
EG(current_execute_data) = NULL;
/* graceful fatalities */
zend_try {
/* ::run */
zend_call_method(
&ZEG->This, ZEG->scope, NULL,
ZEND_STRL("run"),
&zresult, 0, NULL, NULL TSRMLS_CC);
} zend_catch {
/* catches fatal errors and uncaught exceptions */
terminated = 1;
/* danger lurking ... */
if (PTHREADS_ZG(signal) == PTHREADS_KILL_SIGNAL) {
/* like, totally bail man ! */
zend_bailout();
}
} zend_end_try();
if (current) {
/* set terminated state */
if (terminated) {
pthreads_state_set(
current->state, PTHREADS_ST_ERROR TSRMLS_CC);
/* save error information */
pthreads_error_save(current->error TSRMLS_CC);
}
/* unset running for waiters */
pthreads_state_unset(current->state, PTHREADS_ST_RUNNING TSRMLS_CC);
}
/* deal with references to stacked objects */
if (!terminated && inwork) {
zval_ptr_dtor(&ZEG->This);
} else inwork = 1;
/* deal with zresult (ignored) */
if (zresult) {
zval_ptr_dtor(&zresult);
}
}
} while(worker && pthreads_stack_next(thread, this_ptr TSRMLS_CC));
}
} zend_end_try();
/**
* Thread Block End
**/
/*
* Free original reference to $this
*/
if (!BG(user_shutdown_function_names)) {
zval_ptr_dtor(&this);
}
/**
* Shutdown Block Begin
**/
PG(report_memleaks) = 0;
#ifdef PTHREADS_PEDANTIC
/* acquire global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
#endif
/* shutdown request */
php_request_shutdown(TSRMLS_C);
#ifdef PTHREADS_PEDANTIC
/* release global lock */
pthreads_globals_unlock(glocked TSRMLS_CC);
#endif
/**
* Shutdown Block End
**/
}
pthread_exit(NULL);
#ifdef _WIN32
return NULL; /* silence MSVC compiler */
#endif
}
/* }}} */
#endif
pthreads-2.0.6/src/object.h 0000664 0001750 0001750 00000011434 12333375647 012501 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_OBJECT_H
#define HAVE_PTHREADS_OBJECT_H
/*
* @TODO
* implement verbose debugging mode in threads
* try and find a way a thread can throw an exception in cid so that ThreadingException can be implemented and not just cause deadlocks
*/
#ifdef HAVE_CONFIG_H
# include
#endif
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ object creation and destruction */
zend_object_value pthreads_threaded_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_worker_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_thread_ctor(zend_class_entry *entry TSRMLS_DC);
/* }}} */
/*
* @NOTE
* pthreads_state_* functions work with pthreads_state directly
* pthreads_*_state functions work with specific PTHREAD state
*/
/* {{{ state and stack management */
zend_bool pthreads_set_state_ex(PTHREAD thread, int state, long timeout TSRMLS_DC);
zend_bool pthreads_set_state(PTHREAD thread, int state TSRMLS_DC);
zend_bool pthreads_unset_state(PTHREAD thread, int state TSRMLS_DC);
size_t pthreads_stack_pop(PTHREAD thread, PTHREAD work TSRMLS_DC);
size_t pthreads_stack_push(PTHREAD thread, zval *work TSRMLS_DC);
size_t pthreads_stack_next(PTHREAD thread, zval *this_ptr TSRMLS_DC);
size_t pthreads_stack_length(PTHREAD thread TSRMLS_DC);
/* }}} */
/* {{{ MISC */
void pthreads_current_thread(zval **return_value TSRMLS_DC);
/* }}} */
/* {{{ start/join */
int pthreads_start(PTHREAD thread TSRMLS_DC);
int pthreads_join(PTHREAD thread TSRMLS_DC);
int pthreads_detach(PTHREAD thread TSRMLS_DC);
/* }}} */
/* {{{ synchronization heplers */
zend_bool pthreads_wait_member(PTHREAD thread, zval *member TSRMLS_DC);
zend_bool pthreads_wait_member_ex(PTHREAD thread, zval *member, ulong timeout TSRMLS_DC); /* }}} */
/* {{{ serialize/unserialize threaded objects */
int pthreads_internal_serialize(zval *object, unsigned char **buffer, zend_uint *blength, zend_serialize_data *data TSRMLS_DC);
int pthreads_internal_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buffer, zend_uint blength, zend_unserialize_data *data TSRMLS_DC); /* }}} */
/* {{{ TSRM manipulation */
#define PTHREADS_FETCH_ALL(ls, id, type) ((type) (*((void ***) ls))[TSRM_UNSHUFFLE_RSRC_ID(id)])
#define PTHREADS_FETCH_CTX(ls, id, type, element) (((type) (*((void ***) ls))[TSRM_UNSHUFFLE_RSRC_ID(id)])->element)
#define PTHREADS_CG(ls, v) PTHREADS_FETCH_CTX(ls, compiler_globals_id, zend_compiler_globals*, v)
#define PTHREADS_CG_ALL(ls) PTHREADS_FETCH_ALL(ls, compiler_globals_id, zend_compiler_globals*)
#define PTHREADS_EG(ls, v) PTHREADS_FETCH_CTX(ls, executor_globals_id, zend_executor_globals*, v)
#define PTHREADS_SG(ls, v) PTHREADS_FETCH_CTX(ls, sapi_globals_id, sapi_globals_struct*, v)
#define PTHREADS_EG_ALL(ls) PTHREADS_FETCH_ALL(ls, executor_globals_id, zend_executor_globals*)
/* }}} */
/* {{{ fetches a PTHREAD from a specific object in a specific context */
#define PTHREADS_FETCH_FROM_EX(object, ls) (PTHREAD) zend_object_store_get_object(object, ls) /* }}} */
/* {{{ fetches a PTHREAD from a specific object in the current context */
#define PTHREADS_FETCH_FROM(object) (PTHREAD) zend_object_store_get_object(object TSRMLS_CC) /* }}} */
/* {{{ fetches the current PTHREAD from $this */
#define PTHREADS_FETCH (PTHREAD) zend_object_store_get_object(this_ptr TSRMLS_CC) /* }}} */
/* {{{ fetches a PTHREAD from object store using handle */
#define PTHREADS_FROM_HANDLE(h) (PTHREAD) zend_object_store_get_object_by_handle(h TSRMLS_CC) /* }}} */
/* {{{ handlers included here for access to macros above */
#ifndef HAVE_PTHREADS_HANDLERS_H
# include
#endif /* }}} */
#endif /* HAVE_PTHREADS_OBJECT_H */
pthreads-2.0.6/src/prepare.c 0000664 0001750 0001750 00000066720 12333375647 012674 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_PREPARE
#define HAVE_PTHREADS_PREPARE
#ifndef HAVE_PTHREADS_PREPARE_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_RESOURCES_H
# include
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
/* {{{ prepared property info ctor */
static void pthreads_preparation_property_info_copy_ctor(zend_property_info *pi); /* }}} */
/* {{{ prepared property info dtor */
static void pthreads_preparation_property_info_copy_dtor(zend_property_info *pi); /* }}} */
/* {{{ prepared property info dummy ctor */
static void pthreads_preparation_property_info_dummy_ctor(zend_property_info *pi); /* }}} */
/* {{{ prepared property info dummy dtor */
static void pthreads_preparation_property_info_dummy_dtor(zend_property_info *pi); /* }}} */
#if PHP_VERSION_ID < 50400
/* {{{ default property ctor for 5.3 */
static void pthreads_preparation_default_properties_ctor(zval **property); /* }}} */
/* {{{ default property dtor for 5.3 */
static void pthreads_preparation_default_properties_dtor(zval *property); /* }}} */
#else
/* {{{ trail alias copy for 5.4 */
static zend_trait_alias * pthreads_preparation_copy_trait_alias(PTHREAD thread, zend_trait_alias *alias TSRMLS_DC); /* }}} */
/* {{{ trait precendence for 5.4 */
static zend_trait_precedence * pthreads_preparation_copy_trait_precedence(PTHREAD thread, zend_trait_precedence *precedence TSRMLS_DC); /* }}} */
/* {{{ method reference copy for traits */
static zend_trait_method_reference * pthreads_preparation_copy_trait_method_reference(PTHREAD thread, zend_trait_method_reference *reference TSRMLS_DC); /* }}} */
#endif
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_method_scope(zend_function *function TSRMLS_DC); /* }}} */
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_property_scope(zend_property_info *info TSRMLS_DC); /* }}} */
/* {{{ prepared resource destructor */
static void pthreads_prepared_resource_dtor(zend_rsrc_list_entry *entry); /* }}} */
static zend_class_entry* pthreads_copy_entry(PTHREAD thread, zend_class_entry *candidate TSRMLS_DC) {
zval *tz;
zend_function *tf;
zend_property_info *ti;
zend_class_entry *prepared = NULL;
/* create a new user class for this context */
prepared = (zend_class_entry*) emalloc(sizeof(zend_class_entry));
prepared->name = estrndup(candidate->name, candidate->name_length);
prepared->name_length = candidate->name_length;
prepared->type = candidate->type;
/* initialize class data */
zend_initialize_class_data(prepared, 1 TSRMLS_CC);
zend_hash_index_update(
PTHREADS_ZG(resolve),
(zend_ulong) candidate,
(void**)&prepared, sizeof(zend_class_entry*), NULL);
/* set ce flags (reset by initialize) */
prepared->ce_flags = candidate->ce_flags;
prepared->refcount = 1;
/* parents are set late */
if (candidate->parent)
prepared->parent = candidate->parent;
/* declare interfaces */
if (candidate->num_interfaces) {
uint interface;
prepared->interfaces = emalloc(sizeof(zend_class_entry*) * candidate->num_interfaces);
for(interface=0; interfacenum_interfaces; interface++)
prepared->interfaces[interface] = pthreads_prepared_entry(thread, candidate->interfaces[interface] TSRMLS_CC);
prepared->num_interfaces = candidate->num_interfaces;
} else prepared->num_interfaces = 0;
#if PHP_VERSION_ID > 50399
/* traits */
if (candidate->num_traits) {
uint trait;
prepared->traits = emalloc(sizeof(zend_class_entry*) * candidate->num_traits);
for (trait=0; traitnum_traits; trait++)
prepared->traits[trait] = pthreads_prepared_entry(thread, candidate->traits[trait] TSRMLS_CC);
prepared->num_traits = candidate->num_traits;
if (candidate->trait_aliases) {
size_t alias = 0;
prepared->trait_aliases = emalloc(sizeof(zend_trait_alias*) * (prepared->num_traits+1));
while (candidate->trait_aliases[alias]) {
prepared->trait_aliases[alias] = pthreads_preparation_copy_trait_alias(
thread, candidate->trait_aliases[alias] TSRMLS_CC
);
alias++;
}
prepared->trait_aliases[alias]=NULL;
} else prepared->trait_aliases = NULL;
if (candidate->trait_precedences) {
size_t precedence = 0;
prepared->trait_precedences = emalloc(sizeof(zend_trait_precedence*) * (prepared->num_traits+1));
while (candidate->trait_precedences[precedence]) {
prepared->trait_precedences[precedence] = pthreads_preparation_copy_trait_precedence(
thread, candidate->trait_precedences[precedence] TSRMLS_CC
);
precedence++;
}
prepared->trait_precedences[precedence]=NULL;
} else prepared->trait_precedences = NULL;
} else {
prepared->num_traits = 0;
prepared->trait_aliases = 0;
prepared->trait_precedences = 0;
}
#endif
/* copy uternals ! */
{
zend_uint umethod = 0;
void *usources[18] = {
candidate->constructor,
candidate->destructor,
candidate->clone,
candidate->__get,
candidate->__set,
candidate->__unset,
candidate->__isset,
candidate->__call,
candidate->__callstatic,
candidate->__tostring,
candidate->serialize_func,
candidate->unserialize_func,
candidate->create_object,
candidate->serialize,
candidate->unserialize,
candidate->get_iterator,
candidate->interface_gets_implemented,
candidate->get_static_method
};
do {
if (usources[umethod]) {
switch(umethod){
/* user internals, I call them uternals */
case 0: zend_hash_update(&prepared->function_table, "__construct", sizeof("__construct"), &candidate->constructor, sizeof(zend_function), (void**) &prepared->constructor); break;
case 1: zend_hash_update(&prepared->function_table, "__destruct", sizeof("__destruct"), &candidate->destructor, sizeof(zend_function), (void**) &prepared->destructor); break;
case 2: zend_hash_update(&prepared->function_table, "__clone", sizeof("__clone"), &candidate->clone, sizeof(zend_function), (void**) &prepared->clone); break;
case 3: zend_hash_update(&prepared->function_table, "__get", sizeof("__get"), &candidate->__get, sizeof(zend_function), (void**) &prepared->__get); break;
case 4: zend_hash_update(&prepared->function_table, "__set", sizeof("__set"), &candidate->__set, sizeof(zend_function), (void**) &prepared->__set); break;
case 5: zend_hash_update(&prepared->function_table, "__unset", sizeof("__unset"), &candidate->__unset, sizeof(zend_function), (void**) &prepared->__unset); break;
case 6: zend_hash_update(&prepared->function_table, "__isset", sizeof("__isset"), &candidate->__isset, sizeof(zend_function), (void**) &prepared->__isset); break;
case 7: zend_hash_update(&prepared->function_table, "__call", sizeof("__call"), &candidate->__call, sizeof(zend_function), (void**) &prepared->__call); break;
case 8: zend_hash_update(&prepared->function_table, "__callstatic", sizeof("__callstatic"), &candidate->__callstatic, sizeof(zend_function), (void**) &prepared->__callstatic); break;
case 9: zend_hash_update(&prepared->function_table, "__tostring", sizeof("__tostring"), &candidate->__tostring, sizeof(zend_function), (void**) &prepared->__tostring); break;
case 10: zend_hash_update(&prepared->function_table, "serialize", sizeof("serialize"), &candidate->serialize_func, sizeof(zend_function), (void**) &prepared->serialize_func); break;
case 11: zend_hash_update(&prepared->function_table, "unserialize", sizeof("unserialize"), &candidate->unserialize_func, sizeof(zend_function), (void**) &prepared->unserialize_func); break;
/* handlers */
case 12: prepared->create_object = candidate->create_object; break;
case 13: prepared->serialize = candidate->serialize; break;
case 14: prepared->unserialize = candidate->unserialize; break;
case 15: {
prepared->get_iterator = candidate->get_iterator;
prepared->iterator_funcs = candidate->iterator_funcs;
} break;
case 16: prepared->interface_gets_implemented = candidate->interface_gets_implemented; break;
case 17: prepared->get_static_method = candidate->get_static_method; break;
}
}
} while(++umethod < 18);
}
/* copy function table */
zend_hash_copy(&prepared->function_table, &candidate->function_table, (copy_ctor_func_t) function_add_ref, &tf, sizeof(zend_function));
/* copy property info structures */
if ((thread->options & PTHREADS_INHERIT_COMMENTS)) {
zend_hash_copy(
&prepared->properties_info,
&candidate->properties_info, (copy_ctor_func_t) pthreads_preparation_property_info_copy_ctor, &ti, sizeof(zend_property_info));
prepared->properties_info.pDestructor = (dtor_func_t) pthreads_preparation_property_info_copy_dtor;
} else {
zend_hash_copy(
&prepared->properties_info,
&candidate->properties_info, (copy_ctor_func_t) pthreads_preparation_property_info_dummy_ctor, &ti, sizeof(zend_property_info));
prepared->properties_info.pDestructor = (dtor_func_t) pthreads_preparation_property_info_dummy_dtor;
}
/* copy statics and defaults */
{
#if PHP_VERSION_ID < 50400
{
HashPosition position;
zval **property;
for (zend_hash_internal_pointer_reset_ex(&candidate->default_properties, &position);
zend_hash_get_current_data_ex(&candidate->default_properties, (void**) &property, &position)==SUCCESS;
zend_hash_move_forward_ex(&candidate->default_properties, &position)) {
char *n;
ulong i;
uint l;
zval *separated;
if (zend_hash_get_current_key_ex(&candidate->default_properties, &n, &l, &i, 0, &position)) {
if (pthreads_store_separate(*property, &separated, 1, 1 TSRMLS_CC)==SUCCESS) {
zend_hash_update(&prepared->default_properties, n, l, (void**) &separated, sizeof(zval*), NULL);
}
}
}
for (zend_hash_internal_pointer_reset_ex(&candidate->default_static_members, &position);
zend_hash_get_current_data_ex(&candidate->default_static_members, (void**) &property, &position)==SUCCESS;
zend_hash_move_forward_ex(&candidate->default_static_members, &position)) {
char *n;
ulong i;
uint l;
zval *separated;
if (zend_hash_get_current_key_ex(&candidate->default_static_members, &n, &l, &i, 0, &position)) {
if (pthreads_store_separate(*property, &separated, 1, 0 TSRMLS_CC)==SUCCESS) {
zend_hash_update(&prepared->default_static_members, n, l, (void**) &separated, sizeof(zval*), NULL);
}
}
}
}
/** copy comments where required **/
if ((thread->options & PTHREADS_INHERIT_COMMENTS) &&
(prepared->doc_comment)) {
prepared->doc_comment_len = candidate->doc_comment_len;
prepared->doc_comment = estrndup(
candidate->doc_comment, candidate->doc_comment_len
);
} else {
prepared->doc_comment = NULL;
prepared->doc_comment_len = 0;
}
#else
if (candidate->default_properties_count) {
int i;
prepared->default_properties_table = emalloc(
sizeof(zval*) * candidate->default_properties_count
);
for (i=0; idefault_properties_count; i++) {
if (candidate->default_properties_table[i]) {
/* we use real separation for a reason */
pthreads_store_separate(
candidate->default_properties_table[i],
&prepared->default_properties_table[i],
1, 1 TSRMLS_CC
);
} else prepared->default_properties_table[i] = NULL;
}
prepared->default_properties_count = candidate->default_properties_count;
} else prepared->default_properties_count = 0;
if (candidate->default_static_members_count) {
int i;
prepared->default_static_members_table = emalloc(
sizeof(zval*) * candidate->default_static_members_count
);
prepared->default_static_members_count = candidate->default_static_members_count;
for (i=0; idefault_static_members_count; i++) {
if (candidate->default_static_members_table[i]) {
/* we use real separation for a reason */
(prepared->default_static_members_table[i]) = (zval*) emalloc(sizeof(zval));
memcpy(
(prepared->default_static_members_table[i]),
(candidate->default_static_members_table[i]), sizeof(zval));
pthreads_store_separate(
prepared->default_static_members_table[i],
&prepared->default_static_members_table[i],
1, 0 TSRMLS_CC
);
} else prepared->default_static_members_table[i]=NULL;
}
prepared->static_members_table = prepared->default_static_members_table;
} else prepared->default_static_members_count = 0;
/* copy user info struct */
memcpy(&prepared->info.user, &candidate->info.user, sizeof(candidate->info.user));
/* copy comments where required */
if ((thread->options & PTHREADS_INHERIT_COMMENTS) &&
(candidate->info.user.doc_comment)) {
prepared->info.user.doc_comment = estrndup(
prepared->info.user.doc_comment, prepared->info.user.doc_comment_len);
} else {
prepared->info.user.doc_comment = NULL;
prepared->info.user.doc_comment_len = 0;
}
#endif
}
/* copy constants */
zend_hash_copy(
&prepared->constants_table, &candidate->constants_table, (copy_ctor_func_t) zval_add_ref, &tz, sizeof(zval*));
return prepared;
}
/* {{{ fetch prepared class entry */
zend_class_entry* pthreads_prepared_entry(PTHREAD thread, zend_class_entry *candidate TSRMLS_DC) {
zend_class_entry *prepared = NULL, **searched = NULL;
if (candidate) {
char *lower = pthreads_global_string(
(char*) candidate->name, candidate->name_length, 1 TSRMLS_CC);
if (lower != NULL) {
/* perform lookup for existing class */
if (zend_hash_find(CG(class_table), lower, candidate->name_length+1, (void**)&searched)!=SUCCESS) {
/* create a new user class for this context */
prepared = pthreads_copy_entry(
thread, candidate TSRMLS_CC);
/* update class table */
zend_hash_update(
CG(class_table), lower, prepared->name_length+1, (void**) &prepared, sizeof(zend_class_entry*), (void**)&searched);
} else prepared = *searched;
}
}
return prepared;
} /* }}} */
static inline zend_bool pthreads_constant_exists(char *name, zend_uint name_len TSRMLS_DC) {
int retval = 1;
char *lookup_name;
if (!zend_hash_exists(EG(zend_constants), name, name_len+1)) {
lookup_name = zend_str_tolower_dup(name, name_len);
retval = zend_hash_exists(
EG(zend_constants), lookup_name, name_len+1);
efree(lookup_name);
}
return retval;
}
/* {{{ prepares the current context to execute the referenced thread */
int pthreads_prepare(PTHREAD thread TSRMLS_DC){
HashPosition position;
/* inherit ini entries from parent ... */
if (thread->options & PTHREADS_INHERIT_INI) {
zend_ini_entry *entry[2];
HashTable *table[2] = {PTHREADS_EG(thread->cls, ini_directives), EG(ini_directives)};
for(zend_hash_internal_pointer_reset_ex(table[0], &position);
zend_hash_get_current_data_ex(table[0], (void**) &entry[0], &position)==SUCCESS;
zend_hash_move_forward_ex(table[0], &position)) {
char *setting;
uint slength;
ulong idx;
if ((zend_hash_get_current_key_ex(table[0], &setting, &slength, &idx, 0, &position)==HASH_KEY_IS_STRING) &&
(zend_hash_find(table[1], setting, slength, (void**) &entry[1])==SUCCESS)) {
if (((entry[0]->value && entry[1]->value) &&
((memcmp(entry[0]->value, entry[1]->value, entry[0]->value_length) != SUCCESS)))) {
char *duplicate = NULL;
zend_bool resmod = entry[1]->modifiable;
if (!EG(modified_ini_directives)) {
ALLOC_HASHTABLE(EG(modified_ini_directives));
zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
}
if (!entry[1]->modified) {
entry[1]->orig_value = entry[1]->value;
entry[1]->orig_value_length = entry[1]->value_length;
entry[1]->orig_modifiable = entry[1]->modifiable;
entry[1]->modified = 1;
zend_hash_add(
EG(modified_ini_directives), setting, slength, &entry[1], sizeof(zend_ini_entry*), NULL);
}
duplicate = estrndup(entry[0]->value, entry[0]->value_length);
entry[1]->modifiable = ZEND_INI_SYSTEM;
if (!entry[1]->on_modify ||
entry[1]->on_modify(
entry[1], duplicate, entry[0]->value_length,
entry[1]->mh_arg1, entry[1]->mh_arg2, entry[1]->mh_arg3, ZEND_INI_STAGE_ACTIVATE TSRMLS_CC) == SUCCESS) {
if (entry[1]->modified && (entry[1]->orig_value != entry[1]->value)) {
efree(entry[1]->value);
}
entry[1]->value = duplicate;
entry[1]->value_length = entry[0]->value_length;
} else {
efree(duplicate);
}
entry[1]->modifiable = resmod;
}
}
}
}
/* copy constants */
if (thread->options & PTHREADS_INHERIT_CONSTANTS) {
zend_constant *zconstant;
HashTable *table[2] = {PTHREADS_EG(thread->cls, zend_constants), EG(zend_constants)};
for(zend_hash_internal_pointer_reset_ex(table[0], &position);
zend_hash_get_current_data_ex(table[0], (void**) &zconstant, &position)==SUCCESS;
zend_hash_move_forward_ex(table[0], &position)) {
if (strncmp(zconstant->name, "STDIN", zconstant->name_len-1)==0||
strncmp(zconstant->name, "STDOUT", zconstant->name_len-1)==0||
strncmp(zconstant->name, "STDERR", zconstant->name_len-1)==0){
continue;
} else {
zend_constant constant;
if (!pthreads_constant_exists(zconstant->name, zconstant->name_len-1 TSRMLS_CC)) {
constant.flags = zconstant->flags;
constant.module_number = zconstant->module_number;
constant.name = zend_strndup(zconstant->name, zconstant->name_len);
constant.name_len = zconstant->name_len;
switch((Z_TYPE(constant.value)=Z_TYPE(zconstant->value))) {
case IS_BOOL:
case IS_LONG: {
Z_LVAL(constant.value)=Z_LVAL(zconstant->value);
} break;
case IS_DOUBLE: Z_DVAL(constant.value)=Z_DVAL(zconstant->value); break;
case IS_STRING: {
Z_STRVAL(constant.value)=estrndup(Z_STRVAL(zconstant->value), Z_STRLEN(zconstant->value));
Z_STRLEN(constant.value)=Z_STRLEN(zconstant->value);
} break;
}
zend_register_constant(&constant TSRMLS_CC);
}
}
}
}
/* inherit function table from parent ... */
if (thread->options & PTHREADS_INHERIT_FUNCTIONS) {
zend_function function;
zend_hash_merge(
EG(function_table),
PTHREADS_EG(thread->cls, function_table),
(copy_ctor_func_t) function_add_ref,
&function, sizeof(zend_function), 0
);
}
/* inherit class table from parent ... */
if (thread->options & PTHREADS_INHERIT_CLASSES) {
zend_class_entry **entry;
HashTable *table[2] = {PTHREADS_CG(thread->cls, class_table), CG(class_table)};
HashTable store;
zend_hash_init(&store, zend_hash_num_elements(table[1]), NULL, NULL, 0);
for(zend_hash_internal_pointer_reset_ex(table[0], &position);
zend_hash_get_current_data_ex(table[0], (void**) &entry, &position)==SUCCESS;
zend_hash_move_forward_ex(table[0], &position)) {
if ((*entry)->type == ZEND_USER_CLASS) {
char *lcname;
uint lcnamel;
ulong idx;
zend_class_entry *prepared;
zend_class_entry **exists;
if (zend_hash_get_current_key_ex(table[0], &lcname, &lcnamel, &idx, 0, &position)==HASH_KEY_IS_STRING) {
if (zend_hash_find(table[1], lcname, lcnamel, (void**)&exists) != SUCCESS){
if ((prepared=pthreads_prepared_entry(thread, *entry TSRMLS_CC))==NULL) {
return FAILURE;
}
zend_hash_next_index_insert(&store, (void**) &prepared, sizeof(zend_class_entry*), NULL);
}
}
}
}
for(zend_hash_internal_pointer_reset_ex(&store, &position);
zend_hash_get_current_data_ex(&store, (void**) &entry, &position)==SUCCESS;
zend_hash_move_forward_ex(&store, &position)) {
if ((*entry)->parent) {
zend_class_entry **search = NULL;
if (zend_hash_index_find(PTHREADS_ZG(resolve), (zend_ulong) (*entry)->parent, (void**)&search) == SUCCESS) {
(*entry)->parent = *search;
}
}
zend_hash_apply(
&(*entry)->function_table, (apply_func_t) pthreads_apply_method_scope TSRMLS_CC);
zend_hash_apply(
&(*entry)->properties_info, (apply_func_t) pthreads_apply_property_scope TSRMLS_CC);
}
zend_hash_destroy(&store);
}
/* merge included files with parent */
if (thread->options & PTHREADS_INHERIT_INCLUDES){
int included;
zend_hash_merge(
&EG(included_files),
&PTHREADS_EG(thread->cls, included_files),
NULL, &included, sizeof(int), 0
);
}
/* inherit globals, I don't like this ... */
if (thread->options & PTHREADS_ALLOW_GLOBALS) {
HashPosition position;
HashTable *tables[] = {&PTHREADS_EG(thread->cls, symbol_table), &EG(symbol_table)};
zval **symbol = NULL;
for (zend_hash_internal_pointer_reset_ex(tables[0], &position);
zend_hash_get_current_data_ex(tables[0], (void**) &symbol, &position) == SUCCESS;
zend_hash_move_forward_ex(tables[0], &position)) {
char *symname = NULL;
int symlen = 0;
zend_ulong symidx = 0L;
if (zend_hash_get_current_key_ex(tables[0], &symname, &symlen, &symidx, 0, &position) == HASH_KEY_IS_STRING) {
zval *separated = NULL;
if (pthreads_store_separate_from(*symbol, &separated, 1, 1, thread->cls TSRMLS_CC) == SUCCESS) {
Z_SET_REFCOUNT_P(separated, 1);
Z_SET_ISREF_P(separated);
zend_hash_update(tables[1], symname, symlen, (void**) &separated, sizeof(zval*), NULL);
} else {
zval_ptr_dtor(&separated);
}
}
}
}
/* set sensible resource destructor */
if (!PTHREADS_G(default_resource_dtor))
PTHREADS_G(default_resource_dtor)=(EG(regular_list).pDestructor);
EG(regular_list).pDestructor = (dtor_func_t) pthreads_prepared_resource_dtor;
return SUCCESS;
} /* }}} */
/* {{{ property info ctor */
static void pthreads_preparation_property_info_copy_ctor(zend_property_info *pi) {
pi->name = estrndup(pi->name, pi->name_length);
if (pi->doc_comment)
pi->doc_comment = estrndup(pi->doc_comment, pi->doc_comment_len);
} /* }}} */
/* {{{ property info dtor */
static void pthreads_preparation_property_info_copy_dtor(zend_property_info *pi) {
#if PHP_VERSION_ID > 50399
str_efree((char*)pi->name);
#else
efree((char*)pi->name);
#endif
if (pi->doc_comment)
efree((char*)pi->doc_comment);
} /* }}} */
/* {{{ copy property info dummy ctor */
static void pthreads_preparation_property_info_dummy_ctor(zend_property_info *pi) {} /* }}} */
/* {{{ destroy property info dummy dtor */
static void pthreads_preparation_property_info_dummy_dtor(zend_property_info *pi) {} /* }}} */
#if PHP_VERSION_ID < 50400
/* {{{ default property ctor for 5.3 */
static void pthreads_preparation_default_properties_ctor(zval **property) {
} /* }}} */
/* {{{ default property dtor for 5.3 */
static void pthreads_preparation_default_properties_dtor(zval *property) {
zval_dtor(property);
} /* }}} */
#else
/* {{{ trail alias copy for 5.4 */
static zend_trait_alias * pthreads_preparation_copy_trait_alias(PTHREAD thread, zend_trait_alias *alias TSRMLS_DC) {
zend_trait_alias *copy = emalloc(sizeof(zend_trait_alias));
if (copy) {
copy->trait_method = pthreads_preparation_copy_trait_method_reference(thread, alias->trait_method TSRMLS_CC);
copy->alias = estrndup(alias->alias, alias->alias_len);
copy->alias_len = alias->alias_len;
copy->modifiers = alias->modifiers;
#if PHP_VERSION_ID < 50500
copy->function = alias->function;
#endif
}
return copy;
} /* }}} */
/* {{{ trait precendence for 5.4+ */
static zend_trait_precedence * pthreads_preparation_copy_trait_precedence(PTHREAD thread, zend_trait_precedence *precedence TSRMLS_DC) {
zend_trait_precedence *copy = emalloc(sizeof(zend_trait_precedence));
if (copy) {
copy->trait_method = pthreads_preparation_copy_trait_method_reference(thread, precedence->trait_method TSRMLS_CC);
if (precedence->exclude_from_classes) {
size_t exclude = 0;
copy->exclude_from_classes = emalloc(sizeof(zend_class_entry**));
while (precedence->exclude_from_classes[exclude]) {
copy->exclude_from_classes[exclude] = pthreads_prepared_entry(
thread, precedence->exclude_from_classes[exclude] TSRMLS_CC
);
exclude++;
}
precedence->exclude_from_classes[exclude]=NULL;
}
#if PHP_VERSION_ID < 50500
copy->function = precedence->function;
#endif
}
return copy;
} /* }}} */
/* {{{ method reference copy for traits */
static zend_trait_method_reference * pthreads_preparation_copy_trait_method_reference(PTHREAD thread, zend_trait_method_reference *reference TSRMLS_DC) {
zend_trait_method_reference *copy = emalloc(sizeof(zend_trait_method_reference));
if (copy) {
copy->mname_len = reference->mname_len;
copy->method_name = estrndup(
reference->method_name,
copy->mname_len
);
copy->cname_len = reference->cname_len;
copy->class_name = estrndup(
reference->class_name,
copy->cname_len
);
copy->ce = pthreads_prepared_entry(
thread, reference->ce TSRMLS_CC
);
}
return copy;
} /* }}} */
#endif
/* {{{ fix method scope for prepared entries, enabling self:: and parent:: to work */
static int pthreads_apply_method_scope(zend_function *function TSRMLS_DC) {
if (function && function->type == ZEND_USER_FUNCTION) {
zend_op_array *ops = &function->op_array;
if (ops->scope) {
zend_class_entry **search = NULL;
if (zend_hash_index_find(PTHREADS_ZG(resolve), (zend_ulong) ops->scope, (void**)&search) == SUCCESS) {
ops->scope = *search;
}
} else ops->scope = NULL;
function->common.prototype = NULL;
}
return ZEND_HASH_APPLY_KEEP;
} /* }}} */
/* {{{ fix scope for prepared entry properties, enabling private members in foreign objects to work */
static int pthreads_apply_property_scope(zend_property_info *info TSRMLS_DC) {
if (info->ce) {
zend_class_entry **search = NULL;
if (zend_hash_index_find(PTHREADS_ZG(resolve), (zend_ulong) info->ce, (void**)&search) == SUCCESS) {
info->ce = *search;
}
}
return ZEND_HASH_APPLY_KEEP;
} /* }}} */
/* {{{ destroy a resource, if we created it ( ie. it is not being kept by another thread ) */
static void pthreads_prepared_resource_dtor(zend_rsrc_list_entry *entry) {
TSRMLS_FETCH();
zend_try {
if (!pthreads_resources_kept(entry TSRMLS_CC)){
if (PTHREADS_G(default_resource_dtor))
PTHREADS_G(default_resource_dtor)(entry);
}
} zend_end_try();
} /* }}} */
#endif
pthreads-2.0.6/src/prepare.h 0000664 0001750 0001750 00000003046 12333375647 012671 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_PREPARE_H
#define HAVE_PTHREADS_PREPARE_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ fetch prepared class entry */
zend_class_entry* pthreads_prepared_entry(PTHREAD thread, zend_class_entry *candidate TSRMLS_DC); /* }}} */
/* {{{ prepare for execution in context */
int pthreads_prepare(PTHREAD thread TSRMLS_DC); /* }}} */
#endif
pthreads-2.0.6/src/resources.c 0000664 0001750 0001750 00000004277 12333375647 013247 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_RESOURCES
#define HAVE_PTHREADS_RESOURCES
/*
* THIS IS A TEST | THIS IS A TEST | THIS IS A TEST | THIS IS A TEST
* IF IT DOESN'T WORK TOUGH SHIT !! | IF IT DOESN'T WORK TOUGH SHIT !!
*/
#ifndef HAVE_PTHREADS_RESOURCES_H
# include
#endif
/* {{{ mark a resource for keeping */
zend_bool pthreads_resources_keep(pthreads_resource data TSRMLS_DC) {
if (!PTHREADS_ZG(resources)) {
ALLOC_HASHTABLE(PTHREADS_ZG(resources));
zend_hash_init(PTHREADS_ZG(resources), 15, NULL, NULL, 0);
}
if (zend_hash_update(PTHREADS_ZG(resources),
(char*) data->copy, sizeof(void*),
(void**) &data, sizeof(void*), NULL) == SUCCESS) {
return 1;
}
return 0;
} /* }}} */
/* {{{ tells if a resource is being kept */
zend_bool pthreads_resources_kept(zend_rsrc_list_entry *entry TSRMLS_DC) {
if (entry) {
pthreads_resource *data = NULL;
if (PTHREADS_ZG(resources) && zend_hash_find(PTHREADS_ZG(resources),
(char*) entry, sizeof(void*), (void**) &data)==SUCCESS) {
if (data && (*data)->ls != TSRMLS_C) {
return 1;
}
}
}
return 0;
} /* }}} */
#endif
pthreads-2.0.6/src/resources.h 0000664 0001750 0001750 00000003037 12333375647 013245 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_RESOURCES_H
#define HAVE_PTHREADS_RESOURCES_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
typedef struct {
int type;
void *original;
void *copy;
void ***ls;
} *pthreads_resource;
zend_bool pthreads_resources_keep(pthreads_resource data TSRMLS_DC);
zend_bool pthreads_resources_kept(zend_rsrc_list_entry *entry TSRMLS_DC);
#endif
pthreads-2.0.6/src/store.c 0000664 0001750 0001750 00000070062 12333375647 012364 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_STORE
#define HAVE_PTHREADS_STORE
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_RESOURCES_H
# include
#endif
typedef struct _pthreads_storage {
zend_uchar type;
size_t length;
zend_bool exists;
union {
long lval;
double dval;
} simple;
void *data;
} pthreads_storage;
#ifndef Z_OBJ_P
# define Z_OBJ_P(zval_p) ((zend_object*)(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zval_p)].bucket.obj.object))
#endif
/* {{{ statics */
static void pthreads_store_create(pthreads_storage *storage, zval *pzval, zend_bool complex TSRMLS_DC);
static int pthreads_store_convert(pthreads_storage *storage, zval *pzval TSRMLS_DC);
static int pthreads_store_tostring(zval *pzval, char **pstring, size_t *slength, zend_bool complex TSRMLS_DC);
static int pthreads_store_tozval(zval *pzval, char *pstring, size_t slength TSRMLS_DC);
static int pthreads_store_remove_complex_recursive(zval **pzval TSRMLS_DC);
static int pthreads_store_validate_object(zval **pzval TSRMLS_DC);
static int pthreads_store_remove_complex(zval **pzval TSRMLS_DC);
static void pthreads_store_storage_dtor (pthreads_storage *element);
/* }}} */
/* {{{ allocate storage for an object */
pthreads_store pthreads_store_alloc(TSRMLS_D) {
pthreads_store store = malloc(sizeof(*store));
if (store) {
if (zend_hash_init(&store->table, 8, NULL, (dtor_func_t) pthreads_store_storage_dtor, 1)==SUCCESS){
if ((store->lock = pthreads_lock_alloc(TSRMLS_C))) {
store->next = 0L;
return store;
}
zend_hash_destroy(&store->table);
}
free(store);
}
return NULL;
} /* }}} */
/* {{{ lock storage, userland only */
zend_bool pthreads_store_lock(zval *this_ptr TSRMLS_DC) {
PTHREAD pobject = PTHREADS_FETCH_FROM(getThis());
if (pobject) {
return pthreads_lock_acquire(
pobject->store->lock,
&pobject->hold TSRMLS_CC
);
} else return 0;
} /* }}} */
/* {{{ unlock storage, userland only */
zend_bool pthreads_store_unlock(zval *this_ptr TSRMLS_DC) {
PTHREAD pobject = PTHREADS_FETCH_FROM(getThis());
if (pobject) {
return pthreads_lock_release(
pobject->store->lock,
pobject->hold TSRMLS_CC
);
} else return 0;
} /* }}} */
/* {{{ delete a value from the store */
int pthreads_store_delete(pthreads_store store, char *key, int keyl TSRMLS_DC) {
int result = FAILURE;
zend_bool locked;
if (store) {
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
if (zend_hash_exists(&store->table, key, keyl+1)) {
if (zend_hash_del(&store->table, key, keyl+1)!=SUCCESS) {
result = FAILURE;
} else result = SUCCESS;
} else result = SUCCESS;
pthreads_lock_release(store->lock, locked TSRMLS_CC);
} else result = FAILURE;
}
return result;
}
/* }}} */
/* {{{ isset helper for handlers */
zend_bool pthreads_store_isset(pthreads_store store, char *key, int keyl, int has_set_exists TSRMLS_DC) {
zend_bool locked = 0, isset = 0;
if (store) {
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
isset = zend_hash_exists(
&store->table, key, keyl+1);
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
}
return isset;
} /* }}} */
/* {{{ read a value from store */
int pthreads_store_read(pthreads_store store, char *key, int keyl, zval **read TSRMLS_DC) {
zend_bool locked = 0;
int result = FAILURE;
if (store) {
MAKE_STD_ZVAL(*read);
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
pthreads_storage *storage = NULL;
if (zend_hash_find(&store->table, key, keyl+1, (void**)&storage)==SUCCESS) {
result = pthreads_store_convert(
storage, *read TSRMLS_CC);
}
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
if (result == SUCCESS) {
Z_SET_REFCOUNT_PP(read, 0);
} else {
FREE_ZVAL(*read);
*read = EG(
uninitialized_zval_ptr
);
Z_ADDREF_P(*read);
}
}
return SUCCESS;
} /* }}} */
/* {{{ write a value to store */
int pthreads_store_write(pthreads_store store, char *key, int keyl, zval **write TSRMLS_DC) {
int result = FAILURE;
zend_bool locked;
if (store) {
pthreads_storage storage;
pthreads_store_create(
&storage, *write, 1 TSRMLS_CC);
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
if (zend_hash_update(
&store->table, key, keyl+1, (void**) &storage, sizeof(pthreads_storage), NULL)==SUCCESS) {
result = SUCCESS;
} else free(store);
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
}
return result;
} /* }}} */
/* {{{ seperate a zval using internals */
int pthreads_store_separate(zval * pzval, zval **separated, zend_bool allocate, zend_bool complex TSRMLS_DC) {
int result = FAILURE;
pthreads_storage storage;
if (allocate) {
MAKE_STD_ZVAL(*separated);
}
if (pzval) {
pthreads_store_create(&storage, pzval, complex TSRMLS_CC);
result = pthreads_store_convert(
&storage, *separated TSRMLS_CC);
if (result == SUCCESS)
pthreads_store_storage_dtor(&storage);
else Z_TYPE_PP(separated) = IS_NULL;
} else Z_TYPE_PP(separated) = IS_NULL;
return result;
} /* }}} */
/* {{{ seperate a zval using internals */
int pthreads_store_separate_from(zval * pzval, zval **separated, zend_bool allocate, zend_bool complex, void ***parent TSRMLS_DC) {
int result = FAILURE;
pthreads_storage storage;
if (allocate) {
MAKE_STD_ZVAL(*separated);
}
if (pzval) {
pthreads_store_create(&storage, pzval, complex, parent);
result = pthreads_store_convert(
&storage, *separated TSRMLS_CC);
if (result == SUCCESS)
pthreads_store_storage_dtor(&storage);
else Z_TYPE_PP(separated) = IS_NULL;
} else Z_TYPE_PP(separated) = IS_NULL;
return result;
} /* }}} */
/* {{{ count properties */
int pthreads_store_count(zval *object, long *count TSRMLS_DC) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (pthreads) {
if (pthreads_store_lock(object TSRMLS_CC)) {
(*count) = zend_hash_num_elements(
&pthreads->store->table);
pthreads_store_unlock(object TSRMLS_CC);
} else (*count) = 0L;
} else (*count) = 0L;
return SUCCESS;
} /* }}} */
/* {{{ shift member */
int pthreads_store_shift(zval *object, zval **member TSRMLS_DC) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (pthreads) {
if (pthreads_store_lock(object TSRMLS_CC)) {
pthreads_storage *storage;
HashPosition position;
HashTable *table = &pthreads->store->table;
zend_hash_internal_pointer_reset_ex(table, &position);
if (zend_hash_get_current_data_ex(table, (void**) &storage, &position) == SUCCESS) {
char *key;
uint klen;
ulong idx;
int flag;
pthreads_store_convert(storage, *member TSRMLS_CC);
flag = zend_hash_get_current_key_ex(table, &key, &klen, &idx, 0, &position) == HASH_KEY_IS_STRING ? HASH_DEL_KEY : HASH_DEL_INDEX;
zend_hash_del_key_or_index(table, key, klen, idx, flag);
} else ZVAL_NULL(*member);
pthreads_store_unlock(object TSRMLS_CC);
return SUCCESS;
}
}
return FAILURE;
} /* }}} */
/* {{{ store chunk */
int pthreads_store_chunk(zval *object, long size, zend_bool preserve, zval **chunk TSRMLS_DC) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (pthreads) {
if (pthreads_store_lock(object TSRMLS_CC)) {
pthreads_storage *storage;
HashPosition position;
HashTable *table = &pthreads->store->table;
zend_hash_internal_pointer_reset_ex(table, &position);
array_init(*chunk);
while ((zend_hash_num_elements(Z_ARRVAL_PP(chunk)) < size) &&
(zend_hash_get_current_data_ex(table, (void**) &storage, &position) == SUCCESS)) {
char *key;
uint klen;
ulong idx = 0L;
zval *member;
int ktype = 0;
ALLOC_INIT_ZVAL(member);
pthreads_store_convert(storage, member TSRMLS_CC);
zend_hash_del_key_or_index(
table, key, klen, idx, (ktype = zend_hash_get_current_key_ex(
table, &key, &klen, &idx, 0, &position
)) == HASH_KEY_IS_STRING ? HASH_DEL_KEY : HASH_DEL_INDEX);
if (!preserve) {
zend_hash_next_index_insert(
Z_ARRVAL_PP(chunk), (void**)&member, sizeof(zval), NULL);
} else {
if (ktype == HASH_KEY_IS_STRING) {
zend_hash_update(
Z_ARRVAL_PP(chunk), key, klen, (void**) &member, sizeof(zval), NULL
);
} else zend_hash_index_update(
Z_ARRVAL_PP(chunk), idx, (void**)&member, sizeof(zval), NULL
);
}
zend_hash_move_forward_ex(table, &position);
}
pthreads_store_unlock(object TSRMLS_CC);
return SUCCESS;
}
}
return FAILURE;
} /* }}} */
/* {{{ pop member */
int pthreads_store_pop(zval *object, zval **member TSRMLS_DC) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (pthreads) {
if (pthreads_store_lock(object TSRMLS_CC)) {
pthreads_storage *storage;
HashPosition position;
HashTable *table = &pthreads->store->table;
zend_hash_internal_pointer_end_ex(table, &position);
if (zend_hash_get_current_data_ex(table, (void**) &storage, &position) == SUCCESS) {
char *key;
uint klen;
ulong idx;
pthreads_store_convert(storage, *member TSRMLS_CC);
zend_hash_del_key_or_index(
table, key, klen, idx, zend_hash_get_current_key_ex(
table, &key, &klen, &idx, 0, &position
) == HASH_KEY_IS_STRING ? HASH_DEL_KEY : HASH_DEL_INDEX);
} else ZVAL_NULL(*member);
pthreads_store_unlock(object TSRMLS_CC);
return SUCCESS;
}
}
return FAILURE;
} /* }}} */
/* {{{ copy store to hashtable */
void pthreads_store_tohash(pthreads_store store, HashTable *hash TSRMLS_DC) {
zend_bool locked;
if (store) {
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
HashTable *stored = &store->table;
HashPosition position;
pthreads_storage *storage;
for (zend_hash_internal_pointer_reset_ex(stored, &position);
zend_hash_get_current_data_ex(stored, (void**) &storage, &position)==SUCCESS;
zend_hash_move_forward_ex(stored, &position)) {
char *name;
uint nlength;
ulong idx;
if (zend_hash_get_current_key_ex(stored, &name, &nlength, &idx, 0, &position)==HASH_KEY_IS_STRING) {
if (name[0] != '$') { /* do not copy internal counter */
char *rename = estrndup(name, nlength);
{
zval *pzval;
MAKE_STD_ZVAL(pzval);
if (pthreads_store_convert(storage, pzval TSRMLS_CC)!=SUCCESS) {
ZVAL_NULL(pzval);
}
zend_hash_update(hash, rename, nlength, &pzval, sizeof(zval), NULL);
}
efree(rename);
}
}
}
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
}
} /* }}} */
/* {{{ free store storage for a thread */
void pthreads_store_free(pthreads_store store TSRMLS_DC){
if (store) {
zend_bool locked;
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
zend_hash_destroy(&store->table);
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
pthreads_lock_free(store->lock TSRMLS_CC);
free(store);
}
} /* }}} */
/* {{{ Will storeize the zval into a newly allocated buffer which must be free'd by the caller */
static void pthreads_store_create(pthreads_storage *storage, zval *unstore, zend_bool complex TSRMLS_DC){
if (unstore) {
/*
* Make an exact copy of the store data for internal storage
*/
storage->length = 0;
storage->exists = 0;
storage->data = NULL;
switch((storage->type = Z_TYPE_P(unstore))){
case IS_NULL: { /* nothing to do */ } break;
case IS_STRING: {
if ((storage->length = Z_STRLEN_P(unstore))) {
storage->data = (char*) malloc(storage->length+1);
memcpy(
storage->data, (const void*) Z_STRVAL_P(unstore), storage->length+1
);
}
} break;
case IS_BOOL:
case IS_LONG: {
storage->simple.lval = Z_LVAL_P(unstore);
} break;
case IS_RESOURCE: {
if (complex) {
pthreads_resource resource = malloc(sizeof(*resource));
if (resource) {
resource->original = zend_list_find
(Z_RESVAL_P(unstore), &resource->type);
resource->ls = TSRMLS_C;
storage->simple.lval = Z_RESVAL_P(unstore);
storage->data = resource;
zend_list_addref(Z_RESVAL_P(unstore));
}
} else {
storage->type = IS_NULL;
}
} break;
case IS_DOUBLE:
storage->simple.dval = Z_DVAL_P(unstore);
break;
case IS_OBJECT:
case IS_ARRAY: {
if (pthreads_store_tostring(unstore, (char**) &storage->data, &storage->length, complex TSRMLS_CC)==SUCCESS) {
if (storage->type==IS_ARRAY) {
storage->exists = zend_hash_num_elements(
Z_ARRVAL_P(unstore));
} else {
Z_OBJ_HT_P(unstore)->add_ref(
unstore TSRMLS_CC);
}
}
} break;
default: {
storage->exists = 0;
}
}
}
}
/* }}} */
/* {{{ Will unstoreize data into the allocated zval passed */
static int pthreads_store_convert(pthreads_storage *storage, zval *pzval TSRMLS_DC){
int result = SUCCESS;
if (storage) {
switch(storage->type) {
case IS_STRING:
if (storage->data && storage->length) {
ZVAL_STRINGL(pzval, (char*)storage->data, storage->length, 1);
} else ZVAL_EMPTY_STRING(pzval);
break;
case IS_NULL: Z_TYPE_P(pzval) = IS_NULL; break;
case IS_BOOL: ZVAL_BOOL(pzval, storage->simple.lval); break;
case IS_LONG: ZVAL_LONG(pzval, storage->simple.lval); break;
case IS_DOUBLE: ZVAL_DOUBLE(pzval, storage->simple.dval); break;
case IS_RESOURCE: {
pthreads_resource resource = (pthreads_resource) storage->data;
zend_rsrc_list_entry *original;
if (resource->ls != TSRMLS_C && zend_hash_index_find(&PTHREADS_EG(resource->ls, regular_list), storage->simple.lval, (void**)&original)==SUCCESS) {
zend_bool found = 0;
int existed = 0;
{
zend_rsrc_list_entry *search;
HashPosition position;
for(zend_hash_internal_pointer_reset_ex(&EG(regular_list), &position);
zend_hash_get_current_data_ex(&EG(regular_list), (void**) &search, &position)==SUCCESS;
zend_hash_move_forward_ex(&EG(regular_list), &position)) {
if (search->ptr == original->ptr) {
found=1;
existed++;
break;
} else ++existed;
}
}
if (!found) {
zend_rsrc_list_entry create;
{
int created;
create.type = original->type;
create.ptr = original->ptr;
create.refcount = 1;
created=zend_hash_next_free_element(&EG(regular_list));
if (zend_hash_index_update(
&EG(regular_list), created, (void*) &create, sizeof(zend_rsrc_list_entry), (void**)&resource->copy
)==SUCCESS) {
ZVAL_RESOURCE(pzval, created);
pthreads_resources_keep(resource TSRMLS_CC);
} else ZVAL_NULL(pzval);
}
} else {
ZVAL_RESOURCE(pzval, existed);
zend_list_addref(Z_RESVAL_P(pzval));
}
} else {
ZVAL_RESOURCE(pzval, storage->simple.lval);
zend_list_addref(Z_RESVAL_P(pzval));
}
} break;
case IS_ARRAY:
case IS_OBJECT: {
result = pthreads_store_tozval(
pzval,
(char*) storage->data,
storage->length TSRMLS_CC
);
if (result == FAILURE) {
/* display error, do something ... ? */
Z_TYPE_P(pzval) = IS_NULL;
}
} break;
default: {
Z_TYPE_P(pzval) = IS_NULL;
}
}
}
return result;
}
/* }}} */
/* {{{ zval to string */
static int pthreads_store_tostring(zval *pzval, char **pstring, size_t *slength, zend_bool complex TSRMLS_DC) {
int result = FAILURE;
if (pzval &&
(Z_TYPE_P(pzval) != IS_NULL) &&
(Z_TYPE_P(pzval) != IS_OBJECT || pthreads_store_validate_object(&pzval TSRMLS_CC))) {
smart_str *psmart = (smart_str*) ecalloc(1, sizeof(smart_str));
if (psmart) {
if (!complex &&
(Z_TYPE_P(pzval) == IS_OBJECT || Z_TYPE_P(pzval) == IS_ARRAY)) {
pthreads_store_remove_complex_recursive(&pzval TSRMLS_CC);
}
{
if ((Z_TYPE_P(pzval) != IS_OBJECT) ||
(Z_OBJCE_P(pzval)->serialize != zend_class_serialize_deny)) {
php_serialize_data_t vars;
PHP_VAR_SERIALIZE_INIT(vars);
php_var_serialize(
psmart,
&pzval,
&vars TSRMLS_CC
);
PHP_VAR_SERIALIZE_DESTROY(vars);
}
}
*slength = psmart->len;
if (psmart->len) {
*pstring = malloc(psmart->len+1);
if (*pstring) {
memcpy(
(char*) *pstring, (const void*) psmart->c, psmart->len
);
result = SUCCESS;
}
} else *pstring = NULL;
smart_str_free(psmart);
efree(psmart);
}
} else {
*slength = 0;
*pstring = NULL;
}
return result;
} /* }}} */
/* {{{ string to zval */
static int pthreads_store_tozval(zval *pzval, char *pstring, size_t slength TSRMLS_DC) {
int result = SUCCESS;
ulong refcount = Z_REFCOUNT_P(pzval);
if (pstring) {
const unsigned char* pointer = (const unsigned char*) pstring;
if (pointer) {
/*
* Populate PHP storage from pthreads_storage
*/
{
php_unserialize_data_t vars;
PHP_VAR_UNSERIALIZE_INIT(vars);
if (!php_var_unserialize(&pzval, &pointer, pointer+slength, &vars TSRMLS_CC)) {
result = FAILURE;
zval_dtor(pzval);
}
PHP_VAR_UNSERIALIZE_DESTROY(vars);
}
if (pzval && refcount)
Z_SET_REFCOUNT_P(pzval, refcount);
} else result = FAILURE;
} else result = FAILURE;
return result;
} /* }}} */
/* {{{ import members from one object (or array) into a pthreads object */
int pthreads_store_merge(zval *destination, zval *from, zend_bool overwrite TSRMLS_DC) {
if (Z_TYPE_P(from) != IS_ARRAY &&
Z_TYPE_P(from) != IS_OBJECT) {
return FAILURE;
}
switch (Z_TYPE_P(from)) {
case IS_OBJECT: {
/* check for a suitable pthreads object */
if (IS_PTHREADS_OBJECT(from)) {
zend_bool locked[2] = {0, 0};
PTHREAD pobjects[2] = {PTHREADS_FETCH_FROM(destination), PTHREADS_FETCH_FROM(from)};
/* acquire destination lock */
if (pthreads_lock_acquire(pobjects[0]->store->lock, &locked[0] TSRMLS_CC)) {
/* acquire other lock */
if (pthreads_lock_acquire(pobjects[1]->store->lock, &locked[1] TSRMLS_CC)) {
/* free to do what we want, everything locked */
HashPosition position;
pthreads_storage *storage;
HashTable *tables[2] = {&pobjects[0]->store->table, &pobjects[1]->store->table};
for (zend_hash_internal_pointer_reset_ex(tables[1], &position);
zend_hash_get_current_data_ex(tables[1], (void**)&storage, &position) == SUCCESS;
zend_hash_move_forward_ex(tables[1], &position)) {
char *key = NULL;
zend_uint klen = 0;
zend_ulong idx = 0L;
if (zend_hash_get_current_key_ex(tables[1], &key, &klen, &idx, 0, &position) == HASH_KEY_IS_STRING) {
/* skip if not overwriting where the
entry exists in destination table */
if (!overwrite && zend_hash_exists(tables[0], key, klen)) {
continue;
}
/* skip resources */
if (storage->type != IS_RESOURCE) {
/* copy storage */
pthreads_storage copy;
switch ((copy.type = storage->type)) {
case IS_NULL: {
copy.exists = 1;
} break;
case IS_STRING: {
if ((copy.length = storage->length)) {
copy.data = (char*) malloc(copy.length+1);
memcpy(
copy.data, (const void*) storage->data, copy.length
);
}
} break;
case IS_BOOL:
case IS_LONG: { copy.simple.lval = storage->simple.lval; } break;
case IS_DOUBLE: { copy.simple.dval = storage->simple.dval; } break;
case IS_OBJECT:
case IS_ARRAY: {
if ((copy.length = storage->length)) {
copy.data = (char*) malloc(copy.length+1);
memcpy(
copy.data, (const void*) storage->data, copy.length
);
if (copy.type == IS_ARRAY)
copy.exists = storage->exists;
}
} break;
default: { }
}
zend_hash_update(tables[0], key, klen, (void**) ©, sizeof(pthreads_storage), NULL);
}
}
}
pthreads_lock_release(pobjects[1]->store->lock, locked[1] TSRMLS_CC);
}
pthreads_lock_release(pobjects[0]->store->lock, locked[0] TSRMLS_CC);
return SUCCESS;
} else return FAILURE;
}
}
/* fall through on purpose to handle normal objects and arrays */
default: {
zend_bool locked = 0;
PTHREAD pobject = PTHREADS_FETCH_FROM(destination);
if (pthreads_lock_acquire(pobject->store->lock, &locked TSRMLS_CC)) {
HashPosition position;
zval **pzval;
zend_uint index = 0;
HashTable *table = (Z_TYPE_P(from) == IS_ARRAY) ? Z_ARRVAL_P(from) : Z_OBJPROP_P(from);
for (zend_hash_internal_pointer_reset_ex(table, &position);
zend_hash_get_current_data_ex(table, (void**)&pzval, &position) == SUCCESS;
zend_hash_move_forward_ex(table, &position)) {
char *key;
zend_uint klen;
zend_ulong idx;
switch (zend_hash_get_current_key_ex(table, &key, &klen, &idx, 0, &position)) {
case HASH_KEY_IS_STRING: {
if (!overwrite && zend_hash_exists(table, key, klen)) {
goto next;
}
pthreads_store_write(
pobject->store, key, klen-1, pzval TSRMLS_CC);
} break;
case HASH_KEY_IS_LONG: {
zval zkey;
ZVAL_LONG(&zkey, idx);
convert_to_string(&zkey);
if (!overwrite && zend_hash_exists(table, Z_STRVAL(zkey), Z_STRLEN(zkey))) {
zval_dtor(&zkey);
goto next;
}
pthreads_store_write(
pobject->store, Z_STRVAL(zkey), Z_STRLEN(zkey), pzval TSRMLS_CC);
zval_dtor(&zkey);
} break;
}
next:
index++;
}
pthreads_lock_release(pobject->store->lock, locked TSRMLS_CC);
}
} break;
}
return SUCCESS;
} /* }}} */
/* {{{ set resources to NULL for non-complex types; helper-function for pthreads_store_remove_complex_recursive */
static int pthreads_store_remove_complex(zval **pzval TSRMLS_DC) {
if (Z_TYPE_PP(pzval) == IS_RESOURCE) {
Z_TYPE_PP(pzval) = IS_NULL;
}
return pthreads_store_remove_complex_recursive(pzval TSRMLS_CC);
} /* }}} */
/* {{{ check a handle is valid before reading it */
static int pthreads_store_validate_object(zval **pzval TSRMLS_DC) {
return (EG(objects_store).top > Z_OBJ_HANDLE_PP(pzval)) && (Z_OBJ_P(*pzval));
} /* }}} */
/* {{{ set corrupt objects (like mysqli after thread duplication) to NULL and recurse */
static int pthreads_store_remove_complex_recursive(zval **pzval TSRMLS_DC) {
int is_temp;
HashTable *thash = NULL;
switch (Z_TYPE_PP(pzval)) {
case IS_ARRAY:
thash = Z_ARRVAL_PP(pzval);
case IS_OBJECT:
if (thash == NULL) {
if (!pthreads_store_validate_object(pzval TSRMLS_CC)) {
GC_REMOVE_ZVAL_FROM_BUFFER(*pzval);
Z_TYPE_PP(pzval) = IS_NULL;
return ZEND_HASH_APPLY_KEEP;
}
thash = Z_OBJDEBUG_PP(pzval, is_temp);
}
if (thash) {
zend_hash_apply(thash, (apply_func_t)pthreads_store_remove_complex TSRMLS_CC);
}
break;
}
return ZEND_HASH_APPLY_KEEP;
} /* }}} */
/* {{{ Will free store element */
static void pthreads_store_storage_dtor (pthreads_storage *storage){
if (storage) {
switch (storage->type) {
case IS_OBJECT:
case IS_STRING:
case IS_ARRAY:
case IS_RESOURCE:
if (storage->data) {
free(storage->data);
}
break;
}
}
} /* }}} */
#endif
pthreads-2.0.6/src/store.h 0000664 0001750 0001750 00000007010 12333375647 012362 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_STORE_H
#define HAVE_PTHREADS_STORE_H
#ifdef HAVE_CONFIG_H
# include
#endif
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
/* {{{ buffer structure */
typedef struct _pthreads_store {
HashTable table;
pthreads_lock lock;
zend_ulong next; /* idx of next anonymous member */
} *pthreads_store; /* }}} */
/* {{{ allocate and initialize buffers */
pthreads_store pthreads_store_alloc(TSRMLS_D); /* }}} */
/* {{{ lock storage, userland only */
zend_bool pthreads_store_lock(zval *this_ptr TSRMLS_DC); /* }}} */
/* {{{ unlock storage, userland only */
zend_bool pthreads_store_unlock(zval *this_ptr TSRMLS_DC); /* }}} */
/* {{{ merges the properties/elements of from into destination */
int pthreads_store_merge(zval *destination, zval *from, zend_bool overwrite TSRMLS_DC); /* }}} */
/* {{{ delete a value from the buffer */
int pthreads_store_delete(pthreads_store store, char *key, int keyl TSRMLS_DC); /* }}} */
/* {{{ read value from buffer */
int pthreads_store_read(pthreads_store store, char *key, int keyl, zval **read TSRMLS_DC); /* }}} */
/* {{{ see if a value isset in buffer */
zend_bool pthreads_store_isset(pthreads_store store, char *key, int keyl, int has_set_exists TSRMLS_DC); /* }}} */
/* {{{ write value to buffer */
int pthreads_store_write(pthreads_store store, char *key, int keyl, zval **write TSRMLS_DC); /* }}} */
/* {{{ separate a zval using internals */
int pthreads_store_separate(zval * pzval, zval **seperated, zend_bool allocate, zend_bool complex TSRMLS_DC); /* }}} */
/* {{{ separate a zval using internals */
int pthreads_store_separate_from(zval * pzval, zval **separated, zend_bool allocate, zend_bool complex, void ***parent TSRMLS_DC); /* }}} */
/* {{{ copy store to hashtable */
void pthreads_store_tohash(pthreads_store store, HashTable *hash TSRMLS_DC); /* }}} */
/* {{{ store shift */
int pthreads_store_shift(zval *object, zval **member TSRMLS_DC); /* }}} */
/* {{{ store chunk */
int pthreads_store_chunk(zval *object, long size, zend_bool preserve, zval **chunk TSRMLS_DC); /* }}} */
/* {{{ store pop */
int pthreads_store_pop(zval *object, zval **member TSRMLS_DC); /* }}} */
/* {{{ count properties */
int pthreads_store_count(zval *object, long *count TSRMLS_DC); /* }}} */
/* {{{ free buffers */
void pthreads_store_free(pthreads_store store TSRMLS_DC); /* }}} */
#endif
pthreads-2.0.6/src/state.c 0000664 0001750 0001750 00000011371 12333375647 012346 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
/*
* @TODO
* 1. make errors more meaningful, where are my exceptions already !!
*/
#ifndef HAVE_PTHREADS_STATE
#define HAVE_PTHREADS_STATE
#ifndef HAVE_PTHREADS_STATE_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ allocate state object */
pthreads_state pthreads_state_alloc(int mask TSRMLS_DC) {
pthreads_state state = calloc(1, sizeof(*state));
if (state != NULL) {
state->bits |= mask;
if (!(state->lock = pthreads_lock_alloc(TSRMLS_C)))
return NULL;
if (!(state->synchro = pthreads_synchro_alloc(TSRMLS_C)))
return NULL;
return state;
}
return NULL;
} /* }}} */
/* {{{ free state object */
void pthreads_state_free(pthreads_state state TSRMLS_DC) {
if (state) {
pthreads_lock_free(state->lock TSRMLS_CC);
pthreads_synchro_free(state->synchro TSRMLS_CC);
free(state);
}
} /* }}} */
/* {{{ lock state */
zend_bool pthreads_state_lock(pthreads_state state, zend_bool *locked TSRMLS_DC) {
return pthreads_lock_acquire(state->lock, locked TSRMLS_CC);
} /* }}} */
/* {{{ unlock state */
zend_bool pthreads_state_unlock(pthreads_state state, zend_bool locked TSRMLS_DC) {
return pthreads_lock_release(state->lock, locked TSRMLS_CC);
} /* }}} */
/* {{{ check state (assumes appropriate locking in place) */
int pthreads_state_check(pthreads_state state, int mask TSRMLS_DC) {
return (state->bits & mask)==mask;
} /* }}} */
/* {{{ set state (assumes appropriate locking in place */
int pthreads_state_set_locked(pthreads_state state, int mask TSRMLS_DC) {
state->was |= mask;
pthreads_synchro_notify(
state->synchro TSRMLS_CC
);
return (state->bits |= mask);
} /* }}} */
/* {{{ unset state ( assumes appropriate locking in place */
int pthreads_state_unset_locked(pthreads_state state, int mask TSRMLS_DC) {
return (state->bits &= mask);
} /* }}} */
/* {{{ set state on state object */
zend_bool pthreads_state_set(pthreads_state state, int mask TSRMLS_DC) {
zend_bool locked, result = 1;
if (state) {
if (pthreads_lock_acquire(state->lock, &locked TSRMLS_CC)) {
state->was |= mask;
pthreads_synchro_notify(
state->synchro TSRMLS_CC
);
state->bits |= mask;
pthreads_lock_release(state->lock, locked TSRMLS_CC);
} else result = 0;
} else result = 0;
return result;
} /* }}} */
/* {{{ wait until a state has been set */
zend_bool pthreads_state_wait(pthreads_state state, int mask TSRMLS_DC) {
zend_bool locked = 0, wasset = 0, result = 1;
if (state) {
if (pthreads_lock_acquire(state->lock, &locked TSRMLS_CC)) {
wasset = ((state->was & mask)==mask);
if (locked)
pthreads_lock_release(state->lock, locked TSRMLS_CC);
if (!wasset) do {
pthreads_synchro_lock(
state->synchro TSRMLS_CC);
pthreads_synchro_wait(state->synchro TSRMLS_CC);
pthreads_synchro_unlock(
state->synchro TSRMLS_CC);
} while(!((state->was & mask)==mask));
} else result = 0;
} else result = 0;
return result;
} /* }}} */
/* {{{ check for state on state object */
zend_bool pthreads_state_isset(pthreads_state state, int mask TSRMLS_DC) {
zend_bool locked = 0, isset = 0;
if (state) {
if (pthreads_lock_acquire(state->lock, &locked TSRMLS_CC)) {
isset = ((state->bits & mask)==mask);
pthreads_lock_release(state->lock, locked TSRMLS_CC);
}
}
return isset;
} /* }}} */
/* {{{ unset state on state object */
zend_bool pthreads_state_unset(pthreads_state state, int mask TSRMLS_DC) {
zend_bool locked = 0, result = 1;
if (state) {
if (pthreads_lock_acquire(state->lock, &locked TSRMLS_CC)) {
state->bits &= ~mask;
pthreads_lock_release(state->lock, locked TSRMLS_CC);
} else result = 0;
} else result = 0;
return result;
} /* }}} */
#endif
pthreads-2.0.6/src/state.h 0000664 0001750 0001750 00000004646 12333375647 012362 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_STATE_H
#define HAVE_PTHREADS_STATE_H
#define PTHREADS_ST_STARTED 1
#define PTHREADS_ST_RUNNING 2
#define PTHREADS_ST_WAITING 4
#define PTHREADS_ST_JOINED 8
#define PTHREADS_ST_ERROR 16
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef HAVE_PTHREADS_SYNCHRO_H
# include
#endif
typedef struct _pthreads_state {
pthreads_lock lock;
int bits;
pthreads_synchro synchro;
int was;
} *pthreads_state;
pthreads_state pthreads_state_alloc(int mask TSRMLS_DC);
zend_bool pthreads_state_lock(pthreads_state state, zend_bool *locked TSRMLS_DC);
int pthreads_state_check(pthreads_state, int mask TSRMLS_DC);
zend_bool pthreads_state_unlock(pthreads_state state, zend_bool locked TSRMLS_DC);
zend_bool pthreads_state_set(pthreads_state state, int mask TSRMLS_DC);
zend_bool pthreads_state_wait(pthreads_state state, int mask TSRMLS_DC);
int pthreads_state_set_locked(pthreads_state state, int mask TSRMLS_DC);
int pthreads_state_unset_locked(pthreads_state state, int mask TSRMLS_DC);
zend_bool pthreads_state_isset(pthreads_state state, int mask TSRMLS_DC);
zend_bool pthreads_state_unset(pthreads_state state, int mask TSRMLS_DC);
void pthreads_state_free(pthreads_state state TSRMLS_DC);
#endif
pthreads-2.0.6/src/synchro.c 0000664 0001750 0001750 00000011247 12333375647 012715 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_SYNCHRO
#define HAVE_PTHREADS_SYNCHRO
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_SYNCHRO_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ allocate (and initialize) a synchronization object */
pthreads_synchro pthreads_synchro_alloc(TSRMLS_D) {
pthreads_synchro sync = (pthreads_synchro) calloc(1, sizeof(*sync));
if (sync) {
if ((sync->lock = pthreads_lock_alloc(TSRMLS_C))) {
if (pthread_cond_init(&sync->notify, NULL)==SUCCESS) {
return sync;
}
pthreads_lock_free(sync->lock TSRMLS_CC);
}
free(sync);
}
return NULL;
} /* }}} */
/* {{{ wait for notification on synchronization object */
int pthreads_synchro_wait_ex(pthreads_synchro sync, long timeout TSRMLS_DC) {
int result = FAILURE;
struct timeval time;
struct timespec spec;
if (timeout>0L) {
if (gettimeofday(&time, NULL)==SUCCESS) {
time.tv_sec += (timeout / 1000000L);
time.tv_usec += (timeout % 1000000L);
} else timeout = 0L;
if (timeout > 0L) {
spec.tv_sec = time.tv_sec;
spec.tv_nsec = time.tv_usec * 1000;
}
}
if (sync) {
if (timeout > 0L) {
result = pthread_cond_timedwait(&sync->notify, &sync->lock->mutex, &spec);
} else { result = pthread_cond_wait(&sync->notify, &sync->lock->mutex); }
} else { /* report unknown error */ }
return (result == SUCCESS) ? 1 : 0;
} /* }}} */
/* {{{ wait for notification on synchronization object */
int pthreads_synchro_wait(pthreads_synchro sync TSRMLS_DC) {
return pthreads_synchro_wait_ex(sync, 0L TSRMLS_CC);
} /* }}} */
/* {{{ send notification to synchronization object */
int pthreads_synchro_notify(pthreads_synchro sync TSRMLS_DC) {
int result = FAILURE;
if (sync) {
if ((result = pthread_cond_broadcast(&sync->notify))!=SUCCESS) {
/* report error */
}
} else { /* report unknown error */ }
return (result == SUCCESS) ? 1 : 0;
} /* }}} */
/* {{{ the ability to execute a block of code truly synchronized */
void pthreads_synchro_block(zval *this_ptr, zend_fcall_info *info, zend_fcall_info_cache *cache, uint argc, zval ***argv, zval *return_value TSRMLS_DC) {
zval *retval = NULL;
zend_bool failed = 0;
PTHREAD pobject = PTHREADS_FETCH_FROM(getThis());
if (!pobject)
return;
/* set argc and argv for function call */
zend_fcall_info_argp(info TSRMLS_CC, argc, argv);
/* set local return value */
info->retval_ptr_ptr = &retval;
/* acquire synchronization lock and execute function synchronized */
{
pthreads_synchro_lock(pobject->synchro TSRMLS_CC);
zend_try {
/* call the closure */
zend_call_function(
info,
cache
TSRMLS_CC);
} zend_catch {
failed = 1;
} zend_end_try ();
pthreads_synchro_unlock(pobject->synchro TSRMLS_CC);
}
zend_fcall_info_args_clear(info, 1);
/* return the result */
if (!failed && retval) {
ZVAL_ZVAL(return_value, retval, 1, 1);
} else {
ZVAL_NULL(return_value);
}
} /* }}} */
/* {{{ free synchronization object */
void pthreads_synchro_free(pthreads_synchro sync TSRMLS_DC) {
pthread_cond_destroy(&sync->notify);
pthreads_lock_free(sync->lock TSRMLS_CC);
free(sync);
} /* }}} */
/* {{{ acquire lock internally for userland synchronization */
int pthreads_synchro_lock(pthreads_synchro sync TSRMLS_DC) {
return pthread_mutex_lock(&sync->lock->mutex);
} /* }}} */
/* {{{ release lock internally for userland synchronization */
int pthreads_synchro_unlock(pthreads_synchro sync TSRMLS_DC) {
return pthread_mutex_unlock(&sync->lock->mutex);
} /* }}} */
#endif
pthreads-2.0.6/src/synchro.h 0000664 0001750 0001750 00000004567 12333375647 012731 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_SYNCHRO_H
#define HAVE_PTHREADS_SYNCHRO_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
typedef struct _pthreads_synchro {
pthreads_lock lock;
pthread_cond_t notify;
zend_bool *synchronized;
} *pthreads_synchro;
/* {{{ allocate synchronization object */
pthreads_synchro pthreads_synchro_alloc(TSRMLS_D); /* }}} */
/* {{{ lock synchronzation object */
int pthreads_synchro_lock(pthreads_synchro sync TSRMLS_DC); /* }}} */
/* {{{ unlock synchronization object */
int pthreads_synchro_unlock(pthreads_synchro sync TSRMLS_DC); /* }}} */
/* {{{ wait for notification */
int pthreads_synchro_wait_ex(pthreads_synchro sync, long timeout TSRMLS_DC); /* }}} */
/* {{{ wait for notification */
int pthreads_synchro_wait(pthreads_synchro sync TSRMLS_DC); /* }}} */
/* {{{ send notification */
int pthreads_synchro_notify(pthreads_synchro sync TSRMLS_DC); /* }}} */
/* {{{ execute a block of code synchronized */
void pthreads_synchro_block(zval *this_ptr, zend_fcall_info *info, zend_fcall_info_cache *cache, uint argc, zval ***argv, zval *return_value TSRMLS_DC); /* }}} */
/* {{{ free synchronization object */
void pthreads_synchro_free(pthreads_synchro sync TSRMLS_DC); /* }}} */
#endif
pthreads-2.0.6/src/thread.h 0000664 0001750 0001750 00000012673 12333375647 012510 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_THREAD_H
#define HAVE_PTHREADS_THREAD_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef HAVE_PTHREADS_STATE_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
#ifndef HAVE_PTHREADS_RESOURCES_H
# include
#endif
/* {{{ stack structure */
typedef struct _pthreads_stack {
HashTable objects;
ulong position;
} *pthreads_stack; /* }}} */
/* {{{ address structure */
typedef struct _pthreads_address {
unsigned char *serial;
size_t length;
} *pthreads_address; /* }}} */
/* {{{ error structure */
typedef struct _pthreads_error *pthreads_error;
struct _pthreads_error {
unsigned char *file;
unsigned char *clazz;
unsigned char *method;
uint line;
}; /* }}} */
/* {{{ thread structure */
typedef struct _pthread_construct {
/*
* Standard Entry
*/
zend_object std;
/*
* Thread Object
*/
pthread_t thread;
/*
* Thread Scope
*/
uint scope;
/*
* Thread Identity and LS
*/
ulong tid;
void ***tls;
/*
* Creator Identity and LS
*/
ulong cid;
void ***cls;
/*
* Store Hold
*/
zend_bool hold;
/*
* Options
*/
zend_ulong options;
/*
* Thread Lock
*/
pthreads_lock lock;
/*
* Thread State
*/
pthreads_state state;
/*
* Thread Sync
*/
pthreads_synchro synchro;
/*
* Method modifiers
*/
pthreads_modifiers modifiers;
/*
* Serial Buffers
*/
pthreads_store store;
/*
* Work List
*/
pthreads_stack stack;
/*
* Thread Address
*/
pthreads_address address;
/*
* Threading Error
*/
pthreads_error error;
/*
* Object Handle
*/
zend_object_handle handle;
} *PTHREAD;
/* {{{ comparison function */
static inline int pthreads_equal(PTHREAD first, PTHREAD second) {
if (first && second) {
if ((first == second))
return 1;
}
return 0;
} /* }}} */
/* {{{ comparison callback for llists */
static inline int pthreads_equal_func(void **first, void **second){
if (first && second)
return pthreads_equal((PTHREAD)*first, (PTHREAD)*second);
return 0;
} /* }}} */
/* {{{ option constants */
#define PTHREADS_INHERIT_NONE 0x00000000
#define PTHREADS_INHERIT_INI 0x00000001
#define PTHREADS_INHERIT_CONSTANTS 0x00000010
#define PTHREADS_INHERIT_FUNCTIONS 0x00000100
#define PTHREADS_INHERIT_CLASSES 0x00001000
#define PTHREADS_INHERIT_INCLUDES 0x00010000
#define PTHREADS_INHERIT_COMMENTS 0x00100000
#define PTHREADS_INHERIT_ALL 0x00111111
#define PTHREADS_ALLOW_GLOBALS 0x01000000
#define PTHREADS_ALLOW_HEADERS 0x10000000 /* }}} */
/* {{{ scope constants */
#define PTHREADS_SCOPE_UNKNOWN 0
#define PTHREADS_SCOPE_THREADED 1
#define PTHREADS_SCOPE_THREAD 2
#define PTHREADS_SCOPE_WORKER 4
#define PTHREADS_SCOPE_CONNECTION 8
#define PTHREADS_SCOPE_DETACHED 16 /* }}} */
/* {{{ scope macros */
#define PTHREADS_IS_KNOWN_ENTRY(t) ((t)->scope)
#define PTHREADS_IS_CONNECTION(t) ((t)->scope & PTHREADS_SCOPE_CONNECTION)
#define PTHREADS_IS_NOT_CONNECTION(t) (!PTHREADS_IS_CONNECTION(t))
#define PTHREADS_IS_THREAD(t) ((t)->scope & PTHREADS_SCOPE_THREAD)
#define PTHREADS_IS_NOT_THREAD(t) (!PTHREADS_IS_THREAD(t))
#define PTHREADS_IS_WORKER(t) ((t)->scope & PTHREADS_SCOPE_WORKER)
#define PTHREADS_IS_NOT_WORKER(t) (!PTHREADS_IS_WORKER(t))
#define PTHREADS_IS_THREADED(t) ((t)->scope & PTHREADS_SCOPE_THREADED)
#define PTHREADS_IS_NOT_THREADED(t) (!PTHREADS_IS_THREADED(t))
#define PTHREADS_IS_DETACHED(t) ((t)->scope & PTHREADS_SCOPE_DETACHED)
#define PTHREADS_IS_NOT_DETACHED(t) (!PTHREADS_IS_DETACHED(t))
/* }}} */
#ifdef HAVE_SIGNAL_H
#ifdef _WIN32
# define PTHREADS_KILL_SIGNAL SIGBREAK
#else
# define PTHREADS_KILL_SIGNAL SIGUSR1
#endif
#endif
/* {{{ pthread_self wrapper */
static inline ulong pthreads_self() {
#ifdef _WIN32
return (ulong) GetCurrentThreadId();
#else
return (ulong) pthread_self();
#endif
} /* }}} */
/* {{{ tell if the calling thread created referenced PTHREAD */
#define PTHREADS_IN_CREATOR(t) (t->cls == tsrm_ls) /* }}} */
/* {{{ tell if the referenced thread is the threading context */
#define PTHREADS_IN_THREAD(t) (t->tls == tsrm_ls) /* }}} */
#endif /* HAVE_PTHREADS_THREAD_H */
pthreads-2.0.6/classes/threaded.h 0000664 0001750 0001750 00000025002 12333375647 013655 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_THREADED_H
#define HAVE_PTHREADS_CLASS_THREADED_H
PHP_METHOD(Threaded, run);
PHP_METHOD(Threaded, wait);
PHP_METHOD(Threaded, notify);
PHP_METHOD(Threaded, isRunning);
PHP_METHOD(Threaded, isWaiting);
PHP_METHOD(Threaded, isTerminated);
PHP_METHOD(Threaded, getTerminationInfo);
PHP_METHOD(Threaded, synchronized);
PHP_METHOD(Threaded, lock);
PHP_METHOD(Threaded, unlock);
PHP_METHOD(Threaded, merge);
PHP_METHOD(Threaded, shift);
PHP_METHOD(Threaded, chunk);
PHP_METHOD(Threaded, pop);
PHP_METHOD(Threaded, count);
ZEND_BEGIN_ARG_INFO_EX(Threaded_run, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_wait, 0, 0, 0)
ZEND_ARG_INFO(0, timeout)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_notify, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_isRunning, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_isWaiting, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_isTerminated, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_getTerminationInfo, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_synchronized, 0, 0, 1)
ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_lock, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_unlock, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_merge, 0, 0, 1)
ZEND_ARG_INFO(0, from)
ZEND_ARG_INFO(0, overwrite)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_shift, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_chunk, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_ARG_INFO(0, preserve)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_pop, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Threaded_count, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_threaded_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_THREADED
# define HAVE_PTHREADS_CLASS_THREADED
zend_function_entry pthreads_threaded_methods[] = {
PHP_ME(Threaded, run, Threaded_run, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, wait, Threaded_wait, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, notify, Threaded_notify, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, isRunning, Threaded_isRunning, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, isWaiting, Threaded_isWaiting, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, isTerminated, Threaded_isTerminated, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, getTerminationInfo, Threaded_getTerminationInfo, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, synchronized, Threaded_synchronized, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, lock, Threaded_lock, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, unlock, Threaded_unlock, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, merge, Threaded_merge, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, shift, Threaded_shift, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, chunk, Threaded_chunk, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, pop, Threaded_pop, ZEND_ACC_PUBLIC)
PHP_ME(Threaded, count, Threaded_count, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* {{{ */
PHP_METHOD(Threaded, run) {} /* }}} */
/* {{{ proto boolean Threaded::wait([long timeout])
Will cause the calling thread to wait for notification from the referenced object
When a timeout is used and reached boolean false will return
Otherwise returns a boolean indication of success */
PHP_METHOD(Threaded, wait)
{
PTHREAD thread = PTHREADS_FETCH;
long timeout = 0L;
if (thread) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &timeout)==SUCCESS) {
if (ZEND_NUM_ARGS()) {
RETURN_BOOL(pthreads_set_state_ex(thread, PTHREADS_ST_WAITING, timeout TSRMLS_CC));
} else RETURN_BOOL(pthreads_set_state_ex(thread, PTHREADS_ST_WAITING, 0L TSRMLS_CC));
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to wait for a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Threaded::notify()
Send notification to everyone waiting on the Threaded
Will return a boolean indication of success */
PHP_METHOD(Threaded, notify)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to notify a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Threaded::isRunning()
Will return true while the referenced Threaded is being executed by a Worker */
PHP_METHOD(Threaded, isRunning)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Threaded::isWaiting()
Will return true if the referenced Threaded is waiting for notification */
PHP_METHOD(Threaded, isWaiting)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Threaded::isTerminated()
Will return true if the referenced Threaded suffered fatal errors or uncaught exceptions */
PHP_METHOD(Threaded, isTerminated)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_ERROR TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Threaded::getTerminationInfo()
Will return information concerning the location of the termination to aid debugging */
PHP_METHOD(Threaded, getTerminationInfo)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_ERROR TSRMLS_CC)) {
array_init(return_value);
if (thread->error->clazz) {
add_assoc_string(
return_value, "scope", (char *)thread->error->clazz, 1);
}
if (thread->error->method) {
add_assoc_string(
return_value, "function", (char *)thread->error->method, 1);
}
if (thread->error->file) {
add_assoc_string(
return_value, "file", (char *)thread->error->file, 1);
add_assoc_long(return_value, "line", thread->error->line);
}
} else {
RETURN_FALSE;
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto void Threaded::synchronized(Callable function, ...)
Will synchronize the object, call the function, passing anything after the function as parameters
*/
PHP_METHOD(Threaded, synchronized)
{
zend_fcall_info *info = emalloc(sizeof(zend_fcall_info));
zend_fcall_info_cache *cache = emalloc(sizeof(zend_fcall_info_cache));
uint argc = 0;
zval ***argv = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|+", info, cache, &argv, &argc) == SUCCESS) {
pthreads_synchro_block(getThis(), info, cache, argc, argv, return_value TSRMLS_CC);
}
if (argc)
efree(argv);
efree(info);
efree(cache);
} /* }}} */
/* {{{ proto boolean Threaded::lock()
Will acquire the storage lock */
PHP_METHOD(Threaded, lock)
{
ZVAL_BOOL(return_value, pthreads_store_lock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Threaded::unlock()
Will release the storage lock */
PHP_METHOD(Threaded, unlock)
{
ZVAL_BOOL(return_value, pthreads_store_unlock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Threaded::merge(mixed $data, [boolean $overwrite = true])
Will merge data with the referenced Threaded */
PHP_METHOD(Threaded, merge)
{
zval *from;
zend_bool overwrite = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &from, &overwrite) != SUCCESS) {
return;
}
RETURN_BOOL((pthreads_store_merge(getThis(), from, overwrite TSRMLS_CC)==SUCCESS));
} /* }}} */
/* {{{ proto mixed Threaded::shift()
Will shift the first member from the object */
PHP_METHOD(Threaded, shift)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_shift(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Threaded::chunk(integer $size [, boolean $preserve = false])
Will shift the first member from the object */
PHP_METHOD(Threaded, chunk)
{
long size;
zend_bool preserve = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &size, &preserve) != SUCCESS) {
return;
}
pthreads_store_chunk(getThis(), size, preserve, &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Threaded::pop()
Will pop the last member from the object */
PHP_METHOD(Threaded, pop)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_pop(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto boolean Threaded::count()
Will return the size of the properties table */
PHP_METHOD(Threaded, count)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
ZVAL_LONG(return_value, 0);
pthreads_store_count(
getThis(), &Z_LVAL_P(return_value) TSRMLS_CC);
} /* }}} */
# endif
#endif
pthreads-2.0.6/classes/thread.h 0000664 0001750 0001750 00000024156 12333375647 013355 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_THREAD_H
#define HAVE_PTHREADS_CLASS_THREAD_H
PHP_METHOD(Thread, start);
PHP_METHOD(Thread, wait);
PHP_METHOD(Thread, notify);
PHP_METHOD(Thread, join);
PHP_METHOD(Thread, detach);
PHP_METHOD(Thread, isStarted);
PHP_METHOD(Thread, isJoined);
PHP_METHOD(Thread, getThreadId);
PHP_METHOD(Thread, getCurrentThreadId);
PHP_METHOD(Thread, getCurrentThread);
PHP_METHOD(Thread, getCreatorId);
PHP_METHOD(Thread, kill);
PHP_METHOD(Thread, globally);
ZEND_BEGIN_ARG_INFO_EX(Thread_globally, 0, 0, 1)
ZEND_ARG_INFO(0, block)
ZEND_ARG_INFO(0, args)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_start, 0, 0, 0)
ZEND_ARG_INFO(0, options)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_run, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_join, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_detach, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getThreadId, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getCurrentThreadId, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getCurrentThread, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getCreatorId, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_isStarted, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_isJoined, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_isTerminated, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_merge, 0, 0, 1)
ZEND_ARG_INFO(0, from)
ZEND_ARG_INFO(0, overwrite)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_kill, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_thread_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_THREAD
# define HAVE_PTHREADS_CLASS_THREAD
zend_function_entry pthreads_thread_methods[] = {
PHP_ME(Thread, start, Thread_start, ZEND_ACC_PUBLIC)
PHP_ME(Thread, join, Thread_join, ZEND_ACC_PUBLIC)
PHP_ME(Thread, detach, Thread_detach, ZEND_ACC_PUBLIC)
PHP_ME(Thread, isStarted, Thread_isStarted, ZEND_ACC_PUBLIC)
PHP_ME(Thread, isJoined, Thread_isJoined, ZEND_ACC_PUBLIC)
PHP_ME(Thread, getThreadId, Thread_getThreadId, ZEND_ACC_PUBLIC)
PHP_ME(Thread, getCreatorId, Thread_getThreadId, ZEND_ACC_PUBLIC)
PHP_ME(Thread, getCurrentThreadId, Thread_getCurrentThreadId, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Thread, getCurrentThread, Thread_getCurrentThread, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(Thread, kill, Thread_kill, ZEND_ACC_PUBLIC)
PHP_ME(Thread, globally, Thread_globally, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
{NULL, NULL, NULL}
};
/* {{{ proto boolean Thread::start([long $options = PTHREADS_INHERIT_ALL])
Starts executing the implementations run method in a thread, will return a boolean indication of success
$options should be a mask of inheritance constants */
PHP_METHOD(Thread, start)
{
PTHREAD thread = PTHREADS_FETCH;
int result = FAILURE;
long options = PTHREADS_INHERIT_ALL;
/* get options */
if (ZEND_NUM_ARGS()) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &options) != SUCCESS) {
return;
}
/* set thread options */
thread->options = options;
}
/*
* See if there are any limits in this environment
*/
if (PTHREADS_IS_NOT_CONNECTION(thread)) {
/* attempt to create the thread */
if ((result = pthreads_start(thread TSRMLS_CC)) != SUCCESS) {
/*
* Report the error, there's no chance of recovery ...
*/
switch(result) {
case PTHREADS_ST_STARTED:
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to start %s (%lu), which has been previously started", PTHREADS_FRIENDLY_NAME);
break;
case EAGAIN:
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected that the %s could not be started, the system "
"lacks the necessary resources or the system-imposed limit would be exceeded", PTHREADS_FRIENDLY_NAME);
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected that the %s could not be started because of an unspecified system error (%d)", PTHREADS_NAME, result);
}
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to start %s from an invalid context, the creating context must start %s", PTHREADS_NAME, PTHREADS_NAME);
}
if (result==SUCCESS) {
RETURN_TRUE;
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto Thread::isStarted()
Will return true if a Thread has been started */
PHP_METHOD(Thread, isStarted)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_STARTED TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto Thread::isJoined()
Will return true if a Thread has been joined already */
PHP_METHOD(Thread, isJoined)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Thread::isWaiting()
Will return true if the referenced thread is waiting for notification */
PHP_METHOD(Thread, isWaiting)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to read the state of a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto boolean Thread::join()
Will return a boolean indication of success */
PHP_METHOD(Thread, join)
{
PTHREAD thread = PTHREADS_FETCH;
/*
* Check that we are in the correct context
*/
if (PTHREADS_IS_NOT_CONNECTION(thread)) {
/*
* Ensure this thread was started
*/
RETURN_BOOL((pthreads_join(thread TSRMLS_CC)==SUCCESS));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to shutdown %s (%lu) from an incorrect context", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
}
} /* }}} */
/* {{{ proto boolean Thread::detach()
Will return a boolean indication of success */
PHP_METHOD(Thread, detach)
{
PTHREAD thread = PTHREADS_FETCH;
int result = FAILURE;
if (thread) {
result = pthreads_detach(thread, 0);
if (result != SUCCESS) {
RETURN_FALSE;
}
RETURN_TRUE;
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while preparing to detach a %s", PTHREADS_NAME);
}
} /* }}} */
/* {{{ proto long Thread::getThreadId()
Will return the identifier of the referenced Thread */
PHP_METHOD(Thread, getThreadId)
{
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->tid);
} /* }}} */
/* {{{ proto long Thread::getCurrentThreadId()
Will return the identifier of the current Thread */
PHP_METHOD(Thread, getCurrentThreadId)
{
ZVAL_LONG(return_value, pthreads_self());
} /* }}} */
/* {{{ proto Thread Thread::getCurrentThread()
Will return the currently executing Thread */
PHP_METHOD(Thread, getCurrentThread)
{
pthreads_current_thread(&return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto long Thread::getCreatorId()
Will return the identifier of the thread ( or process ) that created the referenced Thread */
PHP_METHOD(Thread, getCreatorId)
{
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->cid);
} /* }}} */
/* {{{ proto boolean Thread::kill()
Will kill the referenced thread, forcefully */
PHP_METHOD(Thread, kill)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
#ifdef PTHREADS_KILL_SIGNAL
{
PTHREAD thread = PTHREADS_FETCH;
/* allowing sending other signals here is just too dangerous */
RETURN_BOOL(
pthread_kill(thread->thread, PTHREADS_KILL_SIGNAL)==SUCCESS);
}
#endif
} /* }}} */
/* {{{ proto mixed Thread::globally(Callable block [, ... args])
Will execute the block in the global scope */
PHP_METHOD(Thread, globally)
{
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval ***argv = NULL;
zend_uint argc = 0;
zval *retval = NULL;
zend_bool failed = 0;
HashTable *symbols = EG(active_symbol_table);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f|+", &fci, &fcc, &argv, &argc) != SUCCESS) {
return;
}
/* set argc and argv for function call */
zend_fcall_info_argp(&fci TSRMLS_CC, argc, argv);
fci.retval_ptr_ptr = &retval;
fci.symbol_table = &EG(symbol_table);
zend_try {
zend_call_function(&fci, &fcc TSRMLS_CC);
} zend_catch {
failed = 1;
} zend_end_try();
zend_fcall_info_args_clear(&fci, 1);
/* return the result */
if (!failed && retval) {
ZVAL_ZVAL(return_value, retval, 1, 1);
} else {
ZVAL_NULL(return_value);
}
} /* }}} */
# endif
#endif
pthreads-2.0.6/classes/worker.h 0000664 0001750 0001750 00000015274 12333375647 013420 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_WORKER_H
#define HAVE_PTHREADS_CLASS_WORKER_H
PHP_METHOD(Worker, shutdown);
PHP_METHOD(Worker, isShutdown);
PHP_METHOD(Worker, isWorking);
PHP_METHOD(Worker, stack);
PHP_METHOD(Worker, unstack);
PHP_METHOD(Worker, getStacked);
ZEND_BEGIN_ARG_INFO_EX(Worker_shutdown, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_isShutdown, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_isWorking, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_stack, 0, 0, 1)
ZEND_ARG_INFO(1, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_unstack, 0, 0, 0)
ZEND_ARG_INFO(1, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_getStacked, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_worker_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_WORKER
# define HAVE_PTHREADS_CLASS_WORKER
zend_function_entry pthreads_worker_methods[] = {
PHP_ME(Worker, shutdown, Worker_shutdown, ZEND_ACC_PUBLIC)
PHP_ME(Worker, stack, Worker_stack, ZEND_ACC_PUBLIC)
PHP_ME(Worker, unstack, Worker_unstack, ZEND_ACC_PUBLIC)
PHP_ME(Worker, getStacked, Worker_getStacked, ZEND_ACC_PUBLIC)
PHP_ME(Worker, isShutdown, Worker_isShutdown, ZEND_ACC_PUBLIC)
PHP_ME(Worker, isWorking, Worker_isWorking, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* {{{ proto int Worker::stack(Threaded &$work)
Pushes an item onto the Thread Stack, returns the size of stack */
PHP_METHOD(Worker, stack)
{
PTHREAD thread = PTHREADS_FETCH;
zval *work;
if (thread) {
if (!pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, pthreads_threaded_entry)==SUCCESS) {
if (Z_REFCOUNT_P(work) < 2) {
zend_throw_exception(
spl_ce_InvalidArgumentException, "Worker::stack expects $work to be a reference", 0 TSRMLS_CC);
return;
}
RETURN_LONG(pthreads_stack_push(thread, work TSRMLS_CC));
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to stack onto %s (%lu) which has already been shutdown", PTHREADS_FRIENDLY_NAME);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while stacking onto %s (%lu)", PTHREADS_FRIENDLY_NAME);
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto int Worker::unstack([Threaded &$work])
Removes an item from the Thread stack, if no item is specified the stack is cleared, returns the size of stack */
PHP_METHOD(Worker, unstack)
{
PTHREAD thread = PTHREADS_FETCH;
zval * work;
if (thread) {
if (ZEND_NUM_ARGS() > 0) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, pthreads_threaded_entry)==SUCCESS) {
if (Z_REFCOUNT_P(work) < 2) {
zend_throw_exception(
spl_ce_InvalidArgumentException, "Worker::unstack expects $work to be a reference", 0 TSRMLS_CC);
return;
}
RETURN_LONG(pthreads_stack_pop(thread, PTHREADS_FETCH_FROM(work) TSRMLS_CC));
}
} else RETURN_LONG(pthreads_stack_pop(thread, NULL TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while unstacking from %s (%lu)", PTHREADS_FRIENDLY_NAME);
}
RETURN_FALSE;
}
/* {{{ proto int Worker::getStacked()
Returns the current size of the stack */
PHP_METHOD(Worker, getStacked)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_LONG(pthreads_stack_length(thread TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while getting the stack length of %s (%lu)", PTHREADS_FRIENDLY_NAME);
}
RETURN_FALSE;
}
/* {{{ proto Worker::isShutdown()
Will return true if the Worker has been shutdown */
PHP_METHOD(Worker, isShutdown)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while determining the state of %s (%lu)", PTHREADS_FRIENDLY_NAME);
}
} /* }}} */
/* {{{ proto boolean Worker::isWorking()
Can be used to tell if a Worker is executing any Stackables or waiting */
PHP_METHOD(Worker, isWorking)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(!pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has experienced an internal error while determining the state of %s (%lu)", PTHREADS_FRIENDLY_NAME);
}
} /* }}} */
/* {{{ proto boolean Worker::shutdown()
Will wait for execution of all Stackables to complete before shutting down the Worker */
PHP_METHOD(Worker, shutdown)
{
PTHREAD thread = PTHREADS_FETCH;
/*
* Check that we are in the correct context
*/
if (PTHREADS_IN_CREATOR(thread)) {
RETURN_BOOL((pthreads_join(thread TSRMLS_CC)==SUCCESS));
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to shutdown %s (%lu) from an incorrect context", PTHREADS_FRIENDLY_NAME);
}
} /* }}} */
/* {{{ proto long Worker::getThreadId()
Will return the identifier of the referenced Worker */
PHP_METHOD(Worker, getThreadId)
{
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->tid);
} /* }}} */
/* {{{ proto long Worker::getCreatorId()
Will return the identifier of the thread ( or process ) that created the referenced Worker */
PHP_METHOD(Worker, getCreatorId)
{
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->cid);
} /* }}} */
# endif
#endif
pthreads-2.0.6/classes/mutex.h 0000664 0001750 0001750 00000021736 12333375647 013251 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_MUTEX_H
#define HAVE_PTHREADS_CLASS_MUTEX_H
PHP_METHOD(Mutex, __construct);
PHP_METHOD(Mutex, create);
PHP_METHOD(Mutex, lock);
PHP_METHOD(Mutex, trylock);
PHP_METHOD(Mutex, unlock);
PHP_METHOD(Mutex, destroy);
ZEND_BEGIN_ARG_INFO_EX(Mutex_construct, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Mutex_create, 0, 0, 0)
ZEND_ARG_INFO(0, lock)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Mutex_lock, 0, 0, 1)
ZEND_ARG_INFO(0, mutex)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Mutex_trylock, 0, 0, 1)
ZEND_ARG_INFO(0, mutex)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Mutex_unlock, 0, 0, 1)
ZEND_ARG_INFO(0, mutex)
ZEND_ARG_INFO(0, destroy)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Mutex_destroy, 0, 0, 1)
ZEND_ARG_INFO(0, mutex)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_mutex_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_MUTEX
# define HAVE_PTHREADS_CLASS_MUTEX
zend_function_entry pthreads_mutex_methods[] = {
PHP_ME(Mutex, __construct, Mutex_construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
PHP_ME(Mutex, create, Mutex_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Mutex, lock, Mutex_lock, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Mutex, trylock, Mutex_trylock, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Mutex, unlock, Mutex_unlock, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Mutex, destroy, Mutex_destroy, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* {{{ proto void Mutex::__construct() */
PHP_METHOD(Mutex, __construct)
{
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to incorrectly create a Mutex, please refer to the PHP manual");
} /* }}} */
/* {{{ proto long Mutex::create([boolean lock])
Will create a new mutex and return it's handle. If lock is true it will lock the mutex before returning the handle to the calling thread.
Because of their nature you need to destroy these explicitly with Mutex::destroy */
PHP_METHOD(Mutex, create)
{
zend_bool lock;
pthread_mutex_t *mutex;
int rc = SUCCESS;
if ((mutex=(pthread_mutex_t*) calloc(1, sizeof(pthread_mutex_t)))!=NULL) {
switch((rc = pthread_mutex_init(mutex, NULL))){
case SUCCESS:
if (ZEND_NUM_ARGS()) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &lock)==SUCCESS) {
if (lock) {
switch((rc = pthread_mutex_lock(mutex))){
case SUCCESS: RETURN_LONG((ulong)mutex); break;
case EDEADLK: RETURN_LONG((ulong)mutex); break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while attempting to lock new mutex");
pthread_mutex_destroy(mutex);
free(mutex);
}
} else { RETURN_LONG((ulong)mutex); }
}
} else { RETURN_LONG((ulong)mutex); }
break;
case EAGAIN:
zend_throw_exception_ex(
spl_ce_RuntimeException, EAGAIN TSRMLS_CC,
"pthreads detected that the system lacks the necessary resources (other than memory) to initialise another mutex");
free(mutex);
break;
case ENOMEM: /* I would imagine we would fail to write this message to output if we are really out of memory */
zend_throw_exception_ex(
spl_ce_RuntimeException, ENOMEM TSRMLS_CC,
"pthreads detected that the system lacks the necessary memory to initialise another mutex");
free(mutex);
break;
case EPERM:
zend_throw_exception_ex(
spl_ce_RuntimeException, EPERM TSRMLS_CC,
"pthreads detected that the caller does not have permission to initialize mutex");
free(mutex);
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while attempting to initialize mutex");
free(mutex);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads failed to allocate memory for new mutex");
}
} /* }}} */
/* {{{ proto boolean Mutex::lock(long mutex)
Locks the mutex referenced so that the calling thread owns the mutex */
PHP_METHOD(Mutex, lock)
{
pthread_mutex_t *mutex;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch ((rc = pthread_mutex_lock(mutex))) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the variable passed is not a valid mutex");
break;
case EAGAIN:
zend_throw_exception_ex(
spl_ce_RuntimeException, EAGAIN TSRMLS_CC,
"The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while locking mutex");
}
}
} /* }}} */
/* {{{ proto boolean Mutex::trylock(long mutex)
Will attempt to lock the mutex without causing the calling thread to block */
PHP_METHOD(Mutex, trylock)
{
pthread_mutex_t *mutex;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch ((rc = pthread_mutex_trylock(mutex))) {
case SUCCESS: RETURN_TRUE; break;
case EBUSY: RETURN_FALSE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the variable passed is not a valid mutex");
break;
case EAGAIN:
zend_throw_exception_ex(
spl_ce_RuntimeException, EAGAIN TSRMLS_CC,
"pthreads detected that the mutex could not be acquired because the maximum number of recursive locks has been exceeded");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while trying to lock mutex");
}
}
} /* }}} */
/* {{{ proto boolean Mutex::unlock(long mutex, [bool destroy])
Will unlock the mutex referenced, and optionally destroy it */
PHP_METHOD(Mutex, unlock)
{
pthread_mutex_t *mutex;
zend_bool destroy = 0;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &mutex, &destroy)==SUCCESS && mutex) {
switch ((rc = pthread_mutex_unlock(mutex))) {
case SUCCESS:
if (destroy > 0) {
pthread_mutex_destroy(mutex);
free(mutex);
}
RETURN_TRUE;
break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the variable passed is not a valid mutex");
break;
case EPERM:
zend_throw_exception_ex(
spl_ce_RuntimeException, EPERM TSRMLS_CC,
"pthreads has detected that the calling thread does not own the mutex");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while unlocking mutex");
}
}
} /* }}} */
/* {{{ proto boolean Mutex::destroy(long mutex)
Will destroy the mutex referenced and free memory associated */
PHP_METHOD(Mutex, destroy)
{
pthread_mutex_t *mutex;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch ((rc = pthread_mutex_destroy(mutex))) {
case SUCCESS:
free(mutex);
RETURN_TRUE;
break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the variable passed is not a valid mutex");
break;
case EBUSY:
zend_throw_exception_ex(
spl_ce_RuntimeException, EBUSY TSRMLS_CC,
"pthreads has detected an attempt to destroy mutex while it is locked or referenced");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while attempting to destroy mutex");
}
}
} /* }}} */
# endif
#endif
pthreads-2.0.6/classes/cond.h 0000664 0001750 0001750 00000021243 12333375647 013023 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_COND_H
#define HAVE_PTHREADS_CLASS_COND_H
PHP_METHOD(Cond, __construct);
PHP_METHOD(Cond, create);
PHP_METHOD(Cond, signal);
PHP_METHOD(Cond, broadcast);
PHP_METHOD(Cond, wait);
PHP_METHOD(Cond, destroy);
ZEND_BEGIN_ARG_INFO_EX(Cond_construct, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Cond_create, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Cond_signal, 0, 0, 1)
ZEND_ARG_INFO(0, condition)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Cond_wait, 0, 0, 2)
ZEND_ARG_INFO(0, condition)
ZEND_ARG_INFO(0, mutex)
ZEND_ARG_INFO(0, timeout)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Cond_broadcast, 0, 0, 1)
ZEND_ARG_INFO(0, condition)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Cond_destroy, 0, 0, 1)
ZEND_ARG_INFO(0, condition)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_condition_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_COND
# define HAVE_PTHREADS_CLASS_COND
zend_function_entry pthreads_condition_methods[] = {
PHP_ME(Cond, __construct, Cond_construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR|ZEND_ACC_FINAL)
PHP_ME(Cond, create, Cond_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Cond, signal, Cond_signal, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Cond, wait, Cond_wait, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Cond, broadcast, Cond_broadcast, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Cond, destroy, Cond_destroy, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* {{{ proto void Cond::__construct() */
PHP_METHOD(Cond, __construct)
{
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads has detected an attempt to incorrectly create a Condition, please refer to the PHP manual");
} /* }}} */
/* {{{ proto long Cond::create()
This will create a condition, because of their nature you need to destroy these explicitly with Cond::destroy */
PHP_METHOD(Cond, create)
{
pthread_cond_t *condition;
int rc = SUCCESS;
if ((condition=(pthread_cond_t*) calloc(1, sizeof(pthread_cond_t)))!=NULL) {
switch ((rc = pthread_cond_init(condition, NULL))) {
case SUCCESS:
RETURN_LONG((ulong)condition);
break;
case EAGAIN:
zend_throw_exception_ex(
spl_ce_RuntimeException, EAGAIN TSRMLS_CC,
"pthreads detected that the system lacks the necessary resources (other than memory) to initialise another condition");
free(condition);
break;
case ENOMEM: /* I would imagine we would fail to write this message to output if we are really out of memory */
zend_throw_exception_ex(
spl_ce_RuntimeException, ENOMEM TSRMLS_CC,
"pthreads detected that the system lacks the necessary memory to initialise another condition");
free(condition);
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while initializing new condition");
free(condition);
}
} else {
zend_throw_exception_ex(
spl_ce_RuntimeException, 0 TSRMLS_CC,
"pthreads failed to allocate memory for new condition");
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Cond::signal(long condition)
This will signal a condition */
PHP_METHOD(Cond, signal)
{
pthread_cond_t *condition;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition) == SUCCESS && condition) {
switch ((rc = pthread_cond_signal(condition))) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected the condition referenced does not refer to a valid condition");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while signaling condition");
}
}
} /* }}} */
/* {{{ proto boolean Cond::broadcast(long condition)
This will broadcast a condition */
PHP_METHOD(Cond, broadcast)
{
pthread_cond_t *condition;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition)==SUCCESS && condition) {
switch ((rc = pthread_cond_broadcast(condition))) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected the condition referenced does not refer to a valid condition");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while broadcasting condition");
}
}
} /* }}} */
/* {{{ proto boolean Cond::wait(long condition, long mutex, [long timeout])
This will wait for a signal or broadcast on condition, you must have mutex locked by the calling thread
Timeout should be expressed in microseconds ( millionths ) */
PHP_METHOD(Cond, wait)
{
pthread_cond_t *condition;
pthread_mutex_t *mutex;
long timeout = 0L;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll|l", &condition, &mutex, &timeout)==SUCCESS && condition && mutex) {
if (timeout > 0L) {
struct timeval time;
struct timespec spec;
if (timeout>0L) {
if (gettimeofday(&time, NULL)==SUCCESS) {
time.tv_sec += (timeout / 1000000L);
time.tv_usec += (timeout % 1000000L);
} else timeout = 0L;
if (timeout > 0L) {
spec.tv_sec = time.tv_sec;
spec.tv_nsec = time.tv_usec * 1000;
}
}
switch((rc = pthread_cond_timedwait(condition, mutex, &spec))){
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the condition you are attempting to wait on does not refer to a valid condition variable");
break;
case ETIMEDOUT:
zend_throw_exception_ex(
spl_ce_RuntimeException, ETIMEDOUT TSRMLS_CC,
"pthreads detected a timeout while waiting for condition");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while waiting for condition");
}
} else {
switch ((rc = pthread_cond_wait(condition, mutex))) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected that the condition you are attempting to wait on does not refer to a valid condition variable");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while waiting for condition");
}
}
}
} /* }}} */
/* {{{ proto boolean Cond::destroy()
This will destroy a condition and free the memory associated with it */
PHP_METHOD(Cond, destroy)
{
pthread_cond_t *condition;
int rc = SUCCESS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition)==SUCCESS && condition) {
switch ((rc = pthread_cond_destroy(condition))) {
case SUCCESS:
free(condition);
RETURN_TRUE;
break;
case EINVAL:
zend_throw_exception_ex(
spl_ce_RuntimeException, EINVAL TSRMLS_CC,
"pthreads has detected the condition referenced does not refer to a valid condition variable");
break;
case EBUSY:
zend_throw_exception_ex(
spl_ce_RuntimeException, EBUSY TSRMLS_CC,
"pthreads has detected an attempt to destroy the object referenced by condition while it is referenced by another thread");
break;
default:
zend_throw_exception_ex(
spl_ce_RuntimeException, rc TSRMLS_CC,
"pthreads detected an internal error while destroying condition");
}
}
} /* }}} */
# endif
#endif
pthreads-2.0.6/classes/pool.h 0000664 0001750 0001750 00000027432 12333375647 013057 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_CLASS_POOL_H
#define HAVE_PTHREADS_CLASS_POOL_H
PHP_METHOD(Pool, __construct);
PHP_METHOD(Pool, resize);
PHP_METHOD(Pool, submit);
PHP_METHOD(Pool, submitTo);
PHP_METHOD(Pool, collect);
PHP_METHOD(Pool, shutdown);
ZEND_BEGIN_ARG_INFO_EX(Pool___construct, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_ARG_INFO(0, class)
ZEND_ARG_INFO(0, ctor)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Pool_resize, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Pool_submit, 0, 0, 1)
ZEND_ARG_INFO(0, task)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Pool_submitTo, 0, 0, 2)
ZEND_ARG_INFO(0, worker)
ZEND_ARG_INFO(0, task)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Pool_collect, 0, 0, 1)
ZEND_ARG_INFO(0, collector)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Pool_noargs, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_pool_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_POOL
# define HAVE_PTHREADS_CLASS_POOL
zend_function_entry pthreads_pool_methods[] = {
PHP_ME(Pool, __construct, Pool___construct, ZEND_ACC_PUBLIC)
PHP_ME(Pool, resize, Pool_resize, ZEND_ACC_PUBLIC)
PHP_ME(Pool, submit, Pool_submit, ZEND_ACC_PUBLIC)
PHP_ME(Pool, submitTo, Pool_submitTo, ZEND_ACC_PUBLIC)
PHP_ME(Pool, collect, Pool_collect, ZEND_ACC_PUBLIC)
PHP_ME(Pool, shutdown, Pool_noargs, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* {{{ proto Pool Pool::__construct(integer size, [class worker, [array $ctor]])
Construct a pool ready to create a maximum of $size workers of class $worker
$ctor will be used as arguments to constructor when spawning workers */
PHP_METHOD(Pool, __construct)
{
long size = 0;
zend_class_entry *clazz = NULL;
zval *ctor = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|Ca", &size, &clazz, &ctor) != SUCCESS) {
return;
}
if (clazz == NULL || Z_TYPE_P(clazz) == IS_NULL)
clazz = pthreads_worker_entry;
if (!instanceof_function(clazz, pthreads_worker_entry TSRMLS_CC)) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
"The class provided (%s) does not extend Worker", clazz->name);
}
zend_update_property_long(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("size"), size TSRMLS_CC);
zend_update_property_stringl(
Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("class"), clazz->name, clazz->name_length TSRMLS_CC);
if (ctor)
zend_update_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("ctor"), ctor TSRMLS_CC);
} /* }}} */
/* {{{ proto void Pool::resize(integer size)
Resize the pool to the given number of workers, if the pool size is being reduced
then the last workers started will be shutdown until the pool is the requested size */
PHP_METHOD(Pool, resize) {
long newsize = 0;
zval *workers = NULL;
zval *size = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &newsize) != SUCCESS) {
return;
}
workers = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("workers"), 1 TSRMLS_CC);
size = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("size"), 1 TSRMLS_CC);
if (Z_TYPE_P(workers) == IS_ARRAY &&
newsize < zend_hash_num_elements(Z_ARRVAL_P(workers))) {
do {
zval **worker = NULL;
long top = zend_hash_num_elements(Z_ARRVAL_P(workers));
if (zend_hash_index_find(
Z_ARRVAL_P(workers), top-1, (void**)&worker) == SUCCESS) {
zend_call_method(
worker, Z_OBJCE_PP(worker), NULL, ZEND_STRL("shutdown"), NULL, 0, NULL, NULL TSRMLS_CC);
}
zend_hash_index_del(Z_ARRVAL_P(workers), top-1);
} while (zend_hash_num_elements(Z_ARRVAL_P(workers)) != newsize);
}
ZVAL_LONG(size, newsize);
} /* }}} */
/* {{{ proto integer Pool::submit(Threaded task)
Will submit the given task to the next worker in the pool, by default workers are selected round robin */
PHP_METHOD(Pool, submit) {
zval *task = NULL;
zval *last = NULL;
zval *size = NULL;
zval *workers = NULL;
zval *worker = NULL;
zval *clazz = NULL;
zval *ctor = NULL;
zval *work = NULL;
zval **working = NULL;
zval **selected = NULL;
zend_class_entry **ce = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &task, pthreads_threaded_entry) != SUCCESS) {
return;
}
last = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("last"), 1 TSRMLS_CC);
size = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("size"), 1 TSRMLS_CC);
workers = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("workers"), 1 TSRMLS_CC);
work = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("work"), 1 TSRMLS_CC);
if (Z_TYPE_P(workers) != IS_ARRAY)
array_init(workers);
if (Z_TYPE_P(work ) != IS_ARRAY)
array_init(work);
if (Z_LVAL_P(last) >= Z_LVAL_P(size))
ZVAL_LONG(last, 0);
if (zend_hash_index_find(Z_ARRVAL_P(workers), Z_LVAL_P(last), (void**)&selected) != SUCCESS) {
clazz = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("class"), 1 TSRMLS_CC);
if (Z_TYPE_P(clazz) != IS_STRING) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
"this Pool has not been initialized properly, Worker class not valid");
return;
}
if (zend_lookup_class(
Z_STRVAL_P(clazz), Z_STRLEN_P(clazz), &ce TSRMLS_CC) != SUCCESS) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
"this Pool has not been initialized properly, the Worker class %s could not be found",
Z_STRVAL_P(clazz));
return;
}
ctor = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("ctor"), 1 TSRMLS_CC);
MAKE_STD_ZVAL(worker);
object_init_ex(worker, *ce);
{
zend_class_entry *scope = EG(scope);
zend_function *constructor = NULL;
zval *retval = NULL;
EG(scope) = *ce;
constructor = Z_OBJ_HT_P(worker)->get_constructor(worker TSRMLS_CC);
EG(scope) = scope;
if (constructor) {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
memset(&fci, 0, sizeof(zend_fcall_info));
memset(&fcc, 0, sizeof(zend_fcall_info_cache));
fci.size = sizeof(zend_fcall_info);
fci.function_table = EG(function_table);
fci.object_ptr = worker;
fci.retval_ptr_ptr = &retval;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.function_handler = constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(worker);
fcc.object_ptr = worker;
if (ctor)
zend_fcall_info_args(&fci, ctor TSRMLS_CC);
zend_call_function(&fci, &fcc TSRMLS_CC);
if (ctor)
zend_fcall_info_args_clear(&fci, 1);
if (retval)
zval_ptr_dtor(&retval);
}
zend_call_method(&worker, Z_OBJCE_P(worker), NULL, ZEND_STRL("start"), NULL, 0, NULL, NULL TSRMLS_CC);
}
zend_hash_index_update(
Z_ARRVAL_P(workers), Z_LVAL_P(last),
(void**)&worker, sizeof(zval*), (void**)&selected);
Z_OBJ_HT_P(worker)->add_ref(worker TSRMLS_CC);
}
zend_hash_next_index_insert(
Z_ARRVAL_P(work), (void**) &task, sizeof(zval*), (void**)&working);
Z_SET_ISREF_P(task);
Z_ADDREF_P(task);
zend_call_method(selected, Z_OBJCE_PP(selected), NULL, ZEND_STRL("stack"), NULL, 1, task, NULL TSRMLS_CC);
ZVAL_LONG(return_value, Z_LVAL_P(last));
Z_LVAL_P(last)++;
} /* }}} */
/* {{{ proto integer Pool::submitTo(integer $worker, Threaded task)
Will submit the given task to the specified worker */
PHP_METHOD(Pool, submitTo) {
zval *task = NULL;
zval *workers = NULL;
long worker = 0;
zval *work = NULL;
zval **working = NULL;
zval **selected = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lO", &worker, &task, pthreads_threaded_entry) != SUCCESS) {
return;
}
workers = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("workers"), 1 TSRMLS_CC);
work = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("work"), 1 TSRMLS_CC);
if (Z_TYPE_P(workers) != IS_ARRAY)
array_init(workers);
if (Z_TYPE_P(work ) != IS_ARRAY)
array_init(work);
if (zend_hash_index_find(Z_ARRVAL_P(workers), worker, (void**)&selected) == SUCCESS) {
zend_hash_next_index_insert(
Z_ARRVAL_P(work), (void**) &task, sizeof(zval*), (void**)&working);
Z_SET_ISREF_P(task);
Z_ADDREF_P(task);
zend_call_method(selected, Z_OBJCE_PP(selected), NULL, ZEND_STRL("stack"), NULL, 1, task, NULL TSRMLS_CC);
ZVAL_LONG(return_value, worker);
} else {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
"The selected worker (%ld) does not exist", worker);
}
} /* }}} */
/* {{{ */
typedef struct _pool_call_t {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
} pool_call_t; /* }}} */
/* {{{ */
static inline int pool_collect_function(void *bucket, void *argument TSRMLS_DC) {
zval **task = (zval**) bucket;
pool_call_t *call = (pool_call_t*) argument;
zval *remove = NULL;
int result = ZEND_HASH_APPLY_KEEP;
call->fci.retval_ptr_ptr = &remove;
zend_fcall_info_argn(&call->fci TSRMLS_CC, 1, task);
if (zend_call_function(&call->fci, &call->fcc TSRMLS_CC) == SUCCESS) {
if (remove) {
convert_to_boolean(remove);
if (Z_BVAL_P(remove)) {
result = ZEND_HASH_APPLY_REMOVE;
}
}
}
zend_fcall_info_argn(&call->fci TSRMLS_CC, 0);
if (remove)
zval_ptr_dtor(&remove);
return result;
} /* }}} */
/* {{{ proto void Pool::collect(Callable collector)
Shall execute the collector on each of the tasks in the working set
removing the task if the collector returns positively
the collector should be a function accepting a single task */
PHP_METHOD(Pool, collect) {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval *work = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fcc) != SUCCESS) {
return;
}
work = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("work"), 1 TSRMLS_CC);
if (Z_TYPE_P(work) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(work))) {
pool_call_t call;
call.fci = fci;
call.fcc = fcc;
zend_hash_apply_with_argument(Z_ARRVAL_P(work), pool_collect_function, &call TSRMLS_CC);
if (!zend_hash_num_elements(Z_ARRVAL_P(work))) {
zend_hash_clean(Z_ARRVAL_P(work));
}
}
} /* }}} */
/* {{{ */
static inline int pthreads_pool_shutdown(void *data TSRMLS_DC) {
zval **worker = (zval**) data;
zend_call_method(
worker, Z_OBJCE_PP(worker), NULL, ZEND_STRL("shutdown"), NULL, 0, NULL, NULL TSRMLS_CC);
return ZEND_HASH_APPLY_REMOVE;
} /* }}} */
/* {{{ proto void Pool::shutdown(void)
Will cause all the workers to finish executing their stacks and shutdown */
PHP_METHOD(Pool, shutdown) {
zval *workers = NULL;
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
workers = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("workers"), 1 TSRMLS_CC);
if (Z_TYPE_P(workers) == IS_ARRAY) {
if (zend_hash_num_elements(Z_ARRVAL_P(workers))) {
zend_hash_apply(Z_ARRVAL_P(workers), pthreads_pool_shutdown TSRMLS_CC);
}
zend_hash_clean(Z_ARRVAL_P(workers));
}
} /* }}} */
# endif
#endif
pthreads-2.0.6/iterators/iterator.h 0000664 0001750 0001750 00000002637 12333375647 014316 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_ITERATOR_H
#define HAVE_PTHREADS_ITERATOR_H
/* {{{ object iterator structure */
typedef struct _pobject_iterator_t {
zend_object_iterator zit;
HashTable properties;
HashPosition position;
zend_bool end;
} pobject_iterator_t; /* }}} */
#endif
pthreads-2.0.6/iterators/default.h 0000664 0001750 0001750 00000013115 12333375647 014102 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PTHREADS_ITERATOR_DEFAULT
#define HAVE_PTHREADS_ITERATOR_DEFAULT
#ifndef HAVE_PTHREADS_ITERATOR_H
# include
#endif
static inline void pthreads_object_iterator_dtor(zend_object_iterator* iterator TSRMLS_DC);
static inline int pthreads_object_iterator_validate(zend_object_iterator* iterator TSRMLS_DC);
static inline void pthreads_object_iterator_current_data(zend_object_iterator* iterator, zval ***data TSRMLS_DC);
#if PHP_VERSION_ID >= 50500
static inline void pthreads_object_iterator_current_key(zend_object_iterator* iterator, zval *key TSRMLS_DC);
#else
static inline int pthreads_object_iterator_current_key(zend_object_iterator* iterator, char **key, uint *klen, ulong *ukey TSRMLS_DC);
#endif
static inline void pthreads_object_iterator_move_forward(zend_object_iterator* iterator TSRMLS_DC);
zend_object_iterator_funcs pthreads_object_iterator_funcs = {
pthreads_object_iterator_dtor,
pthreads_object_iterator_validate,
pthreads_object_iterator_current_data,
pthreads_object_iterator_current_key,
pthreads_object_iterator_move_forward,
NULL
};
static inline zend_object_iterator* pthreads_object_iterator_ctor(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) {
pobject_iterator_t *iterator = emalloc(sizeof(pobject_iterator_t));
iterator->zit.funcs = &pthreads_object_iterator_funcs;
zend_hash_init(
&iterator->properties, 8, NULL, ZVAL_PTR_DTOR, 0);
{
PTHREAD pobject = PTHREADS_FETCH_FROM(object);
pthreads_store_tohash(
pobject->store, &iterator->properties TSRMLS_CC);
zend_hash_internal_pointer_reset_ex(
&iterator->properties, &iterator->position);
iterator->end = 0;
}
return (zend_object_iterator*) iterator;
}
static inline void pthreads_object_iterator_dtor(zend_object_iterator* iterator TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
{
zend_hash_destroy(
&intern->properties
);
}
efree(intern);
}
static inline int pthreads_object_iterator_validate(zend_object_iterator* iterator TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
if (zend_hash_num_elements(&intern->properties)) {
return (((pobject_iterator_t*)iterator)->end) ? FAILURE : SUCCESS;
} else return FAILURE;
}
static inline void pthreads_object_iterator_current_data(zend_object_iterator* iterator, zval ***data TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
if (!intern->end) {
if (zend_hash_get_current_data_ex(
&intern->properties, (void**) data, &intern->position) != SUCCESS) {
intern->end = 1;
}
}
}
#if PHP_VERSION_ID >= 50500
static inline void pthreads_object_iterator_current_key(zend_object_iterator* iterator, zval* key TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
char *skey = NULL;
uint sklen;
ulong ukey;
switch (zend_hash_get_current_key_ex(
&intern->properties, &skey, &sklen, &ukey, 0, &intern->position)) {
case HASH_KEY_IS_STRING: {
ZVAL_STRINGL(key, skey, sklen - 1, 1);
} break;
case HASH_KEY_IS_LONG: {
ZVAL_LONG(key, ukey);
} break;
default: {
intern->end = 1;
}
}
}
#else
static inline int pthreads_object_iterator_current_key(zend_object_iterator* iterator, char **key, uint *klen, ulong *ukey TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
switch (zend_hash_get_current_key_ex(
&intern->properties, key, klen, ukey, 1, &intern->position)) {
case HASH_KEY_IS_STRING:
return HASH_KEY_IS_STRING;
case HASH_KEY_IS_LONG:
return HASH_KEY_IS_LONG;
default: {
intern->end = 1;
}
}
return FAILURE;
}
#endif
static inline void pthreads_object_iterator_move_forward(zend_object_iterator* iterator TSRMLS_DC) {
pobject_iterator_t *intern = (pobject_iterator_t*) iterator;
if (!intern->end) {
zend_hash_move_forward_ex(
&intern->properties, &intern->position);
{
if (zend_hash_get_current_data_ex(
&intern->properties, (void**) &intern->zit.data, &intern->position) != SUCCESS) {
intern->end = 1;
}
}
}
}
#endif
pthreads-2.0.6/config.m4 0000664 0001750 0001750 00000001763 12333375647 012006 0 ustar PHP_ARG_ENABLE(pthreads, whether to enable Threading API,
[ --enable-pthreads Enable Threading API])
PHP_ARG_ENABLE(pthreads-pedantic, whether to enable pedantic locking,
[ --enable-pthreads-pedantic Enable pedantic locking], no, no)
if test "$PHP_PTHREADS" != "no"; then
AC_DEFINE(HAVE_PTHREADS, 1, [Wether you have user-land threading support])
AC_MSG_CHECKING([checking for ZTS])
if test "$PHP_THREAD_SAFETY" != "no"; then
AC_MSG_RESULT([ok])
else
AC_MSG_ERROR([pthreads requires ZTS, please re-compile PHP with ZTS enabled])
fi
if test "$PHP_PTHREADS_PEDANTIC" != "no"; then
AC_DEFINE(PTHREADS_PEDANTIC, 1, [Wether to use pedantic locking])
fi
PHP_NEW_EXTENSION(pthreads, php_pthreads.c src/lock.c src/globals.c src/prepare.c src/synchro.c src/state.c src/store.c src/resources.c src/modifiers.c src/handlers.c src/object.c, $ext_shared)
PHP_ADD_BUILD_DIR($ext_builddir/src, 1)
PHP_ADD_INCLUDE($ext_builddir)
PHP_SUBST(PTHREADS_SHARED_LIBADD)
PHP_ADD_MAKEFILE_FRAGMENT
fi
pthreads-2.0.6/config.w32 0000664 0001750 0001750 00000004475 12333375647 012104 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
var PTHREADS_EXT_NAME="pthreads";
var PTHREADS_EXT_SRC="lock.c globals.c prepare.c synchro.c state.c store.c resources.c modifiers.c handlers.c object.c";
var PTHREADS_EXT_DIR="ext/pthreads/src";
var PTHREADS_EXT_API="php_pthreads.c";
var PTHREADS_EXT_FLAGS="/I" + configure_module_dirname;
var PTHREADS_EXT_DEP="pthreadVC2.lib";
/* --------------------------------------------------------------------- */
ARG_WITH("pthreads", "for pthreads support", "no");
ARG_ENABLE("pthreads-pedantic", "for pthreads pedantic locking", "no");
if (PHP_PTHREADS != "no") {
if(CHECK_HEADER_ADD_INCLUDE("pthread.h", "CFLAGS_PTHREADS", PHP_PTHREADS + ";" + configure_module_dirname) &&
CHECK_HEADER_ADD_INCLUDE("sched.h", "CFLAGS_PTHREADS", PHP_PTHREADS + ";" + configure_module_dirname) &&
CHECK_LIB(PTHREADS_EXT_DEP, PTHREADS_EXT_NAME, PHP_PTHREADS) ) {
if (PHP_PTHREADS_PEDANTIC != "no") {
AC_DEFINE('PTHREADS_PEDANTIC', 1);
}
EXTENSION(PTHREADS_EXT_NAME, PTHREADS_EXT_API, PHP_PTHREADS_SHARED, PTHREADS_EXT_FLAGS);
ADD_SOURCES(
PTHREADS_EXT_DIR,
PTHREADS_EXT_SRC,
PTHREADS_EXT_NAME
);
} else {
WARNING("pthreads not enabled; libraries and headers not found");
}
}
pthreads-2.0.6/LICENSE 0000664 0001750 0001750 00000006147 12333375647 011305 0 ustar --------------------------------------------------------------------
The PHP License, version 3.01
Copyright (c) 2012-2014 Joe Watkins. All rights reserved.
--------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, is permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
3. The name "PHP" must not be used to endorse or promote products
derived from this software without prior written permission. For
written permission, please contact group@php.net.
4. Products derived from this software may not be called "PHP", nor
may "PHP" appear in their name, without prior written permission
from group@php.net. You may indicate that your software works in
conjunction with PHP by saying "Foo for PHP" instead of calling
it "PHP Foo" or "phpfoo"
5. The PHP Group may publish revised and/or new versions of the
license from time to time. Each version will be given a
distinguishing version number.
Once covered code has been published under a particular version
of the license, you may always continue to use it under the terms
of that version. You may also choose to use such covered code
under the terms of any subsequent version of the license
published by the PHP Group. No one other than the PHP Group has
the right to modify the terms applicable to covered code created
under this License.
6. Redistributions of any form whatsoever must retain the following
acknowledgment:
"This product includes PHP software, freely available from
.
PHP includes the Zend Engine, freely available at
.
pthreads-2.0.6/php_pthreads.c 0000664 0001750 0001750 00000024574 12333375647 013131 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PHP_PTHREADS
#define HAVE_PHP_PTHREADS
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_LOCK_H
# include
#endif
#ifndef HAVE_PHP_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_STATE_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef ZTS
# error "pthreads requires that Thread Safety is enabled, add --enable-maintainer-zts to your PHP build configuration"
#endif
#if COMPILE_DL_PTHREADS
ZEND_GET_MODULE(pthreads)
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
# include
#endif
zend_module_entry pthreads_module_entry = {
STANDARD_MODULE_HEADER,
PHP_PTHREADS_EXTNAME,
NULL,
PHP_MINIT(pthreads),
PHP_MSHUTDOWN(pthreads),
PHP_RINIT(pthreads),
PHP_RSHUTDOWN(pthreads),
PHP_MINFO(pthreads),
PHP_PTHREADS_VERSION,
STANDARD_MODULE_PROPERTIES
};
zend_class_entry *pthreads_threaded_entry;
zend_class_entry *pthreads_thread_entry;
zend_class_entry *pthreads_worker_entry;
zend_class_entry *pthreads_mutex_entry;
zend_class_entry *pthreads_condition_entry;
zend_class_entry *pthreads_pool_entry;
zend_object_handlers pthreads_handlers;
zend_object_handlers *zend_handlers;
void ***pthreads_instance = NULL;
#ifndef HAVE_SPL
zend_class_entry *spl_ce_InvalidArgumentException;
zend_class_entry *spl_ce_Countable;
zend_class_entry *spl_ce_RuntimeException;
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef PTHREADS_NAME
# define PTHREADS_NAME Z_OBJCE_P(getThis())->name
#endif
#ifndef PTHREADS_TID
# define PTHREADS_TID thread->tid
#endif
#ifndef PTHREADS_FRIENDLY_NAME
# define PTHREADS_FRIENDLY_NAME PTHREADS_NAME, PTHREADS_TID
#endif
ZEND_DECLARE_MODULE_GLOBALS(pthreads)
#ifndef HAVE_PTHREADS_ITERATOR_DEFAULT
# include
#endif
static inline void pthreads_globals_ctor(zend_pthreads_globals *pg TSRMLS_DC) {
pg->pointer = NULL;
pg->pid = 0L;
pg->signal = 0;
pg->resources = NULL;
pg->resolve = NULL;
pg->functions = NULL;
}
PHP_MINIT_FUNCTION(pthreads)
{
zend_class_entry ce;
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_ALL", PTHREADS_INHERIT_ALL, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_NONE", PTHREADS_INHERIT_NONE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_INI", PTHREADS_INHERIT_INI, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_CONSTANTS", PTHREADS_INHERIT_CONSTANTS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_CLASSES", PTHREADS_INHERIT_CLASSES, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_FUNCTIONS", PTHREADS_INHERIT_FUNCTIONS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_INCLUDES", PTHREADS_INHERIT_INCLUDES, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_INHERIT_COMMENTS", PTHREADS_INHERIT_COMMENTS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_ALLOW_HEADERS", PTHREADS_ALLOW_HEADERS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("PTHREADS_ALLOW_GLOBALS", PTHREADS_ALLOW_GLOBALS, CONST_CS | CONST_PERSISTENT);
INIT_CLASS_ENTRY(ce, "Threaded", pthreads_threaded_methods);
ce.serialize = pthreads_internal_serialize;
ce.unserialize = pthreads_internal_unserialize;
pthreads_threaded_entry=zend_register_internal_class(&ce TSRMLS_CC);
pthreads_threaded_entry->get_iterator = pthreads_object_iterator_ctor;
pthreads_threaded_entry->create_object = pthreads_threaded_ctor;
zend_class_implements(pthreads_threaded_entry TSRMLS_CC, 1, zend_ce_traversable);
{
/* NOTE: SPL SUCKS ASS */
zend_class_entry **spl = NULL;
if (zend_hash_find(CG(class_table), "countable", sizeof("countable"), (void**) &spl) == SUCCESS) {
spl_ce_Countable = *spl;
zend_class_implements(
pthreads_threaded_entry TSRMLS_CC, 1, spl_ce_Countable);
}
}
/* for BC with <= 1* */
zend_register_class_alias_ex(
ZEND_STRL("Stackable"), pthreads_threaded_entry TSRMLS_CC);
INIT_CLASS_ENTRY(ce, "Thread", pthreads_thread_methods);
ce.serialize = pthreads_internal_serialize;
ce.unserialize = pthreads_internal_unserialize;
pthreads_thread_entry=zend_register_internal_class_ex(&ce, pthreads_threaded_entry, NULL TSRMLS_CC);
pthreads_thread_entry->get_iterator = pthreads_object_iterator_ctor;
pthreads_thread_entry->create_object = pthreads_thread_ctor;
INIT_CLASS_ENTRY(ce, "Worker", pthreads_worker_methods);
ce.serialize = pthreads_internal_serialize;
ce.unserialize = pthreads_internal_unserialize;
pthreads_worker_entry=zend_register_internal_class_ex(&ce, pthreads_thread_entry, NULL TSRMLS_CC);
pthreads_worker_entry->get_iterator = pthreads_object_iterator_ctor;
pthreads_worker_entry->create_object = pthreads_worker_ctor;
INIT_CLASS_ENTRY(ce, "Mutex", pthreads_mutex_methods);
ce.serialize = zend_class_serialize_deny;
ce.unserialize = zend_class_unserialize_deny;
pthreads_mutex_entry=zend_register_internal_class(&ce TSRMLS_CC);
pthreads_mutex_entry->ce_flags |= ZEND_ACC_FINAL;
INIT_CLASS_ENTRY(ce, "Cond", pthreads_condition_methods);
ce.serialize = zend_class_serialize_deny;
ce.unserialize = zend_class_unserialize_deny;
pthreads_condition_entry=zend_register_internal_class(&ce TSRMLS_CC);
pthreads_condition_entry->ce_flags |= ZEND_ACC_FINAL;
INIT_CLASS_ENTRY(ce, "Pool", pthreads_pool_methods);
pthreads_pool_entry=zend_register_internal_class(&ce TSRMLS_CC);
zend_declare_property_long(pthreads_pool_entry, ZEND_STRL("size"), 1, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(pthreads_pool_entry, ZEND_STRL("class"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(pthreads_pool_entry, ZEND_STRL("workers"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(pthreads_pool_entry, ZEND_STRL("work"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(pthreads_pool_entry, ZEND_STRL("ctor"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(pthreads_pool_entry, ZEND_STRL("last"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
/*
* Setup standard and pthreads object handlers
*/
zend_handlers = zend_get_std_object_handlers();
memcpy(&pthreads_handlers, zend_handlers, sizeof(zend_object_handlers));
pthreads_handlers.cast_object = pthreads_cast_object;
pthreads_handlers.count_elements = pthreads_count_properties;
pthreads_handlers.get_debug_info = pthreads_read_debug;
pthreads_handlers.get_properties = pthreads_read_properties;
pthreads_handlers.get_method = pthreads_get_method;
pthreads_handlers.call_method = pthreads_call_method;
pthreads_handlers.read_property = pthreads_read_property;
pthreads_handlers.write_property = pthreads_write_property;
pthreads_handlers.has_property = pthreads_has_property;
pthreads_handlers.unset_property = pthreads_unset_property;
pthreads_handlers.read_dimension = pthreads_read_dimension;
pthreads_handlers.write_dimension = pthreads_write_dimension;
pthreads_handlers.has_dimension = pthreads_has_dimension;
pthreads_handlers.unset_dimension = pthreads_unset_dimension;
pthreads_handlers.get_property_ptr_ptr = NULL;
pthreads_handlers.get = NULL;
pthreads_handlers.set = NULL;
#if PHP_VERSION_ID > 50399
/* when the gc runs, it will fetch properties, every time */
/* so we pass in a dummy function to control memory usage */
/* properties copied will be destroyed with the object */
pthreads_handlers.get_gc = NULL;
#endif
pthreads_handlers.clone_obj = pthreads_clone_object;
ZEND_INIT_MODULE_GLOBALS(pthreads, pthreads_globals_ctor, NULL);
if (pthreads_globals_init(TSRMLS_C)) {
/*
* Global Init
*/
pthreads_instance = TSRMLS_C;
}
#ifndef HAVE_SPL
spl_ce_InvalidArgumentException = zend_exception_get_default(TSRMLS_C);
spl_ce_Countable = zend_exception_get_default(TSRMLS_C);
spl_ce_RuntimeException = zend_exception_get_default(TSRMLS_C);
#endif
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(pthreads)
{
if (pthreads_instance == TSRMLS_C) {
pthreads_globals_shutdown(TSRMLS_C);
}
return SUCCESS;
}
PHP_RINIT_FUNCTION(pthreads) {
ALLOC_HASHTABLE(PTHREADS_ZG(resolve));
zend_hash_init(PTHREADS_ZG(resolve), 15, NULL, NULL, 0);
ALLOC_HASHTABLE(PTHREADS_ZG(functions));
zend_hash_init(PTHREADS_ZG(functions), 15, NULL, NULL, 0);
}
PHP_RSHUTDOWN_FUNCTION(pthreads) {
zend_hash_destroy(PTHREADS_ZG(resolve));
FREE_HASHTABLE(PTHREADS_ZG(resolve));
zend_hash_destroy(PTHREADS_ZG(functions));
FREE_HASHTABLE(PTHREADS_ZG(functions));
if (PTHREADS_ZG(resources)) {
zend_hash_destroy(PTHREADS_ZG(resources));
FREE_HASHTABLE(PTHREADS_ZG(resources));
PTHREADS_ZG(resources) = NULL;
}
}
PHP_MINFO_FUNCTION(pthreads)
{
php_info_print_table_start();
php_info_print_table_row(2, "Version", PHP_PTHREADS_VERSION);
php_info_print_table_end();
}
#ifndef HAVE_PTHREADS_CLASS_THREADED
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_THREAD
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_WORKER
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_MUTEX
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_COND
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_POOL
# include
#endif
#endif
pthreads-2.0.6/php_pthreads.h 0000664 0001750 0001750 00000003663 12333375647 013132 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2014 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
#ifndef HAVE_PHP_PTHREADS_H
#define HAVE_PHP_PTHREADS_H
#define PHP_PTHREADS_EXTNAME "pthreads"
#define PHP_PTHREADS_VERSION "2.0.6"
PHP_MINIT_FUNCTION(pthreads);
PHP_MSHUTDOWN_FUNCTION(pthreads);
PHP_RINIT_FUNCTION(pthreads);
PHP_RSHUTDOWN_FUNCTION(pthreads);
PHP_MINFO_FUNCTION(pthreads);
#ifndef HAVE_PTHREADS_CLASS_THREADED_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_WORKER_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_MUTEX_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_COND_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_POOL_H
# include
#endif
extern zend_module_entry pthreads_module_entry;
#define phpext_pthreads_ptr &pthreads_module_entry
#endif
pthreads-2.0.6/README.md 0000664 0001750 0001750 00000012125 12333375647 011550 0 ustar # Threading for PHP - Share Nothing, Do Everything :)
This project provides multi-threading that is compatible with PHP based on Posix Threads.
## Highlights
* An easy to use, quick to learn Threading API for PHP5.3+
* Execute any and all predefined and user declared methods and functions asynchronously
* Ready made synchronization included, geared towards the PHP environment
* Seamless operation in multi-threaded SAPI environments
* A world of possibilities ...
## Technical Features
* Posix Threads
* Synchronization
* Worker Threads
* Synchronized Methods
* Complete Support for OO - ie. traits, interfaces, inheritance
* Full read/write/execute support for threaded objects
* Mutex ( direct, subset )
* Conditions ( direct, subset )
pthreads was written with simplicity, compatibility and efficiency in mind, it's performance beggars belief !!
## Requirements
* PHP5.3+
* ZTS Enabled ( Thread Safety )
* Posix Threads Implementation
Testing has been carried out on x86, x64 and ARM, in general you just need a compiler and pthread.h
### Supported PHP Versions
pthreads should compile and work in any version of PHP from 5.3.0 to the latest release.
### Windows Support
Yes !! Windows support is offered thanks to the pthread-w32 library.
Releases for Windows can be found: http://windows.php.net/downloads/pecl/releases/pthreads/
##### Simple Windows Installation
* Add `pthreadVC2.dll` (included with the Windows releases) to the same directory as `php.exe` eg. `C:\xampp\php`
* Add `php_pthreads.dll` to PHP extention folder eg. `C:\xampp\php\ext`
### Mac OSX Support
Yes !! Users of Mac will be glad to hear that pthreads is now tested on OSX as part of the development process.
### Hello World
As is customary in our line of work:
```php
arg = $arg;
}
public function run(){
if($this->arg){
printf("Hello %s\n", $this->arg);
}
}
}
$thread = new AsyncOperation("World");
if($thread->start())
$thread->join();
?>
```
### Are you serious ?
Absolutely, this is not a hack, we _don't_ use forking or any other such nonsense, what you create are honest to goodness posix threads that are completely compatible with PHP and safe ... this is true multi-threading :)
PHP is awesomely powerful, but the simple fact of the matter is, the number of extensions or features a language has doesn't matter one bit. What matters is how many features or extensions you can utilize in your latest and greatest project.
We only have about one or two seconds to send a page to a user, in practice we end up picking and choosing which of PHP's features we will use because time is always a factor. Enterprising applications usually have to look to Java or the .NET
framework if they are designed to do heavy lifting, aggregation, mathematics or the like.
No man is an island: today's websites have to interact with several sources of data - from reference databases, to social networking API's and content feeds ... and everything inbetween ... they have to use and reuse caches, update those caches and then, log all about it, they have to do this several hundred million times a week, if your startup is successful.
PHP excells at all of those tasks; but having to execute them synchronously will often mean that when you do start getting the traffic you want to your new project, things are a bit shaky, and from that moment on you're looking to replace the perfectly good code that you "made it" with, or even worse you're looking for features to remove !
Bringing threads to PHP stretches your two seconds as far as it will go; and I believe allow you to design your applications to do more than you would if Threads were not available; and allow you to develop much faster than
you can in Java or .NET, or any other language ( perhaps ), and as a result, you will be a happier human being, as will your boss, and your projects have virtually no limits ...
### SAPI Support
No restrictions here, you should have no problem running pthreads in your chosen SAPI.
### Documentation
Documentation can be found in the PHP manual: http://docs.php.net/manual/en/book.pthreads.php, and some examples can be found in the "examples" folder in the master repository.
Further insights and occasional announcements can be read at the http://pthreads.org site where pthreads is developed and tested in the real world.
Here are some links to articles I have prepared for users: everybody should read them before they do anything else:
- https://gist.github.com/krakjoe/6437782
- https://gist.github.com/krakjoe/9384409
If you have had the time to put any cool demo's together and would like them showcased on pthreads.org please get in touch.
### Feedback
Please submit issues, and send your feedback and suggestions as often as you have them.
### Developers
There is no defined API for you to create your own threads in your extensions, this project aims to provide Userland threading, it does not aim to provide a threading API for extension developers. I suggest you allow users to decide what they thread and keep your own extension focused on your functionality.