package.xml 0000664 0001750 0001750 00000025036 12307011302 011304 0 ustar joe joe
pthreads
pecl.php.net
Threading API
A compatible Threading API for PHP5.3+
Joe Watkins
krakjoe
pthreads@pthreads.org
yes
2014-03-09
07:05:38
1.0.1
1.0.1
stable
stable
PHP License
Fix fault in logic of Pool
Fix segfaut in synchronized blocks on exception #236
5.3.0
1.4.0b1
pthreads
pthreads-1.0.1/examples/Benchmark.php 0000664 0001750 0001750 00000001431 12307011302 015646 0 ustar joe joe 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-1.0.1/examples/CallAnyFunction.php 0000664 0001750 0001750 00000004277 12307011302 017020 0 ustar joe joe 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-1.0.1/examples/Fetch.php 0000664 0001750 0001750 00000003320 12307011302 015004 0 ustar joe joe 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-1.0.1/examples/KeepAliveSession.php 0000664 0001750 0001750 00000015140 12307011302 017167 0 ustar joe joe 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-1.0.1/examples/Mutexes.php 0000664 0001750 0001750 00000003073 12307011302 015412 0 ustar joe joe 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-1.0.1/examples/NewSynchronization.php 0000664 0001750 0001750 00000003446 12307011302 017637 0 ustar joe joe 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-1.0.1/examples/Notifications.php 0000664 0001750 0001750 00000003404 12307011302 016567 0 ustar joe joe 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-1.0.1/examples/ObjectsAsParameters.php 0000664 0001750 0001750 00000006062 12307011302 017662 0 ustar joe joe 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-1.0.1/examples/Objects.php 0000664 0001750 0001750 00000013104 12307011302 015345 0 ustar joe joe 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-1.0.1/examples/Pooling.php 0000664 0001750 0001750 00000002330 12307011302 015362 0 ustar joe joe logger = $logger;
}
protected $loger;
}
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-1.0.1/examples/Scope.php 0000664 0001750 0001750 00000003671 12307011302 015035 0 ustar joe joe 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-1.0.1/examples/SelectiveInheritance.php 0000664 0001750 0001750 00000003465 12307011302 020062 0 ustar joe joe
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-1.0.1/examples/SharingResources.php 0000664 0001750 0001750 00000004051 12307011302 017243 0 ustar joe joe 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-1.0.1/examples/SimpleWebRequest.php 0000664 0001750 0001750 00000001663 12307011302 017223 0 ustar joe joe 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-1.0.1/examples/Singleton.php 0000664 0001750 0001750 00000002016 12307011302 015716 0 ustar joe joe 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-1.0.1/examples/SocketServer.php 0000664 0001750 0001750 00000005464 12307011302 016405 0 ustar joe joe 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-1.0.1/examples/SQLWorker.php 0000664 0001750 0001750 00000004061 12307011302 015607 0 ustar joe joe 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-1.0.1/examples/StackableArray.php 0000664 0001750 0001750 00000004327 12307011302 016653 0 ustar joe joe 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-1.0.1/examples/Stacking.php 0000664 0001750 0001750 00000005570 12307011302 015527 0 ustar joe joe 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){
printf(
"Stacking: %d/%d\n", $i, $worker->stack($work[]=new Work(array(rand()*100)))
);
}
$worker->start();
usleep(10000);
while($i++<20){
printf(
"Stacking: %d/%d\n", $i, $worker->stack($work[]=new Work(array(rand()*100)))
);
}
$worker->shutdown();
printf("Result: %d/%d\n", $worker->getAttempts(), $worker->getStacked());
print_r($worker->getData());
?> pthreads-1.0.1/tests/binding.phpt 0000664 0001750 0001750 00000001716 12307011302 015104 0 ustar joe joe --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-1.0.1/tests/callstatic-etc.phpt 0000664 0001750 0001750 00000000756 12307011302 016371 0 ustar joe joe --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-1.0.1/tests/chunk.phpt 0000664 0001750 0001750 00000000734 12307011302 014601 0 ustar joe joe --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-1.0.1/tests/complex-statics.phpt 0000664 0001750 0001750 00000002261 12307011302 016605 0 ustar joe joe --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-1.0.1/tests/complex-statics-set-null.phpt 0000664 0001750 0001750 00000002350 12307011302 020345 0 ustar joe joe --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-1.0.1/tests/conditions.phpt 0000664 0001750 0001750 00000001172 12307011302 015637 0 ustar joe joe --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-1.0.1/tests/constants.phpt 0000664 0001750 0001750 00000000571 12307011302 015504 0 ustar joe joe --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-1.0.1/tests/corrupted-resources.phpt 0000664 0001750 0001750 00000001272 12307011302 017506 0 ustar joe joe --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)#3 (0) {
}
resource(2) of type (stream)
resource(2) of type (stream)
pthreads-1.0.1/tests/counting-members.phpt 0000664 0001750 0001750 00000000455 12307011302 016747 0 ustar joe joe --TEST--
Testing member count
--DESCRIPTION--
This test verifies that getting member counts works without effort
--FILE--
--EXPECT--
int(3)
pthreads-1.0.1/tests/detach.phpt 0000664 0001750 0001750 00000000504 12307011302 014714 0 ustar joe joe --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-1.0.1/tests/doc-comments.phpt 0000664 0001750 0001750 00000003040 12307011302 016052 0 ustar joe joe --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-1.0.1/tests/foreign-private-members.phpt 0000664 0001750 0001750 00000001110 12307011302 020207 0 ustar joe joe --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-1.0.1/tests/functions.phpt 0000664 0001750 0001750 00000000613 12307011302 015475 0 ustar joe joe --TEST--
Test function table inheritance
--DESCRIPTION--
This test verifies that the function table is inherited by pthreads correctly
--FILE--
start();
?>
--EXPECT--
TestFunction
pthreads-1.0.1/tests/global-constants.phpt 0000664 0001750 0001750 00000001302 12307011302 016733 0 ustar joe joe --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-1.0.1/tests/gone.phpt 0000664 0001750 0001750 00000000700 12307011302 014412 0 ustar joe joe --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);
?>
--EXPECT--
object(O)#2 (0) {
}
pthreads-1.0.1/tests/graceful-fatalities.phpt 0000664 0001750 0001750 00000000572 12307011302 017404 0 ustar joe joe --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-1.0.1/tests/included-files.phpt 0000664 0001750 0001750 00000000747 12307011302 016364 0 ustar joe joe --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-1.0.1/tests/includeme.inc 0000664 0001750 0001750 00000000036 12307011302 015227 0 ustar joe joe start();
?>
--EXPECT--
Test::run: :/var/lib/other
pthreads-1.0.1/tests/interface.phpt 0000664 0001750 0001750 00000001113 12307011302 015421 0 ustar joe joe --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-1.0.1/tests/interfaces.phpt 0000664 0001750 0001750 00000001141 12307011302 015605 0 ustar joe joe --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-1.0.1/tests/isset-unset.phpt 0000664 0001750 0001750 00000001715 12307011302 015754 0 ustar joe joe --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-1.0.1/tests/merging-members.phpt 0000664 0001750 0001750 00000001436 12307011302 016551 0 ustar joe joe --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-1.0.1/tests/merging-range.phpt 0000664 0001750 0001750 00000000470 12307011302 016210 0 ustar joe joe --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-1.0.1/tests/mutex.phpt 0000664 0001750 0001750 00000000443 12307011302 014630 0 ustar joe joe --TEST--
Test mutex operations
--DESCRIPTION--
This test will ensures mutex functionality
--FILE--
--EXPECT--
bool(true)
bool(true)
bool(true)
pthreads-1.0.1/tests/norefs.phpt 0000664 0001750 0001750 00000000752 12307011302 014765 0 ustar joe joe --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)#3 (0) {
}
}
pthreads-1.0.1/tests/normalize-members.phpt 0000664 0001750 0001750 00000000546 12307011302 017122 0 ustar joe joe --TEST--
Testing normalizing members
--DESCRIPTION--
This tests that normalizing members works without effort
--FILE--
--EXPECT--
bool(true)
pthreads-1.0.1/tests/normal-reads.phpt 0000664 0001750 0001750 00000000654 12307011302 016056 0 ustar joe joe --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-1.0.1/tests/null-member-crash.phpt 0000664 0001750 0001750 00000000460 12307011302 017002 0 ustar joe joe --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-1.0.1/tests/oomethods.phpt 0000664 0001750 0001750 00000000712 12307011302 015466 0 ustar joe joe --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-1.0.1/tests/pools.phpt 0000664 0001750 0001750 00000004171 12307011302 014624 0 ustar joe joe --TEST--
Test pooling
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
logger = $logger;
}
public function run(){}
protected $loger;
}
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 = array()) {
$args = func_get_args();
if (($message = array_shift($args))) {
echo vsprintf(
"{$message}\n", $args);
}
}
public function run(){}
}
$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-1.0.1/tests/selective-inheritance.phpt 0000664 0001750 0001750 00000001445 12307011302 017743 0 ustar joe joe --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-1.0.1/tests/shift-pop.phpt 0000664 0001750 0001750 00000006663 12307011302 015411 0 ustar joe joe --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-1.0.1/tests/shutdown-handler.phpt 0000664 0001750 0001750 00000000626 12307011302 016757 0 ustar joe joe --TEST--
Test shutdown handlers #204
--DESCRIPTION--
Shutdown handlers that were closures were causing segfaults
--FILE--
start();
?>
--EXPECTF--
object(stdClass)#%d (0) {
}
pthreads-1.0.1/tests/stateful-fatalities.phpt 0000664 0001750 0001750 00000000473 12307011302 017443 0 ustar joe joe --TEST--
Test stateful fatalities
--DESCRIPTION--
This test verifies that state includes fatalities
--FILE--
start();
$test->join();
var_dump($test->isTerminated());
?>
--EXPECTF--
bool(true)
pthreads-1.0.1/tests/stack-by-reference.phpt 0000664 0001750 0001750 00000001067 12307011302 017142 0 ustar joe joe --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-1.0.1/tests/stack-by-reference-pass.phpt 0000664 0001750 0001750 00000000602 12307011302 020100 0 ustar joe joe --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-1.0.1/tests/staticmethods.phpt 0000664 0001750 0001750 00000001001 12307011302 016330 0 ustar joe joe --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-1.0.1/tests/static-resolution.phpt 0000664 0001750 0001750 00000000775 12307011302 017166 0 ustar joe joe --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-1.0.1/tests/statics.phpt 0000664 0001750 0001750 00000000641 12307011302 015140 0 ustar joe joe --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-1.0.1/tests/synchronization.phpt 0000664 0001750 0001750 00000001033 12307011302 016723 0 ustar joe joe --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-1.0.1/tests/thorn-in-side.phpt 0000664 0001750 0001750 00000000761 12307011302 016151 0 ustar joe joe --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-1.0.1/tests/thread.phpt 0000664 0001750 0001750 00000000466 12307011302 014742 0 ustar joe joe --TEST--
Test basic threading
--DESCRIPTION--
This test will create and join a simple thread
--FILE--
start())
var_dump($thread->join());
?>
--EXPECT--
bool(true) pthreads-1.0.1/tests/unset-defaults.phpt 0000664 0001750 0001750 00000000566 12307011302 016437 0 ustar joe joe --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-1.0.1/tests/waiting-timeouts.phpt 0000664 0001750 0001750 00000000701 12307011302 016774 0 ustar joe joe --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-1.0.1/tests/wait.phpt 0000664 0001750 0001750 00000001173 12307011302 014433 0 ustar joe joe --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-1.0.1/src/pthreads.h 0000664 0001750 0001750 00000006611 12307011302 014204 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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
#define __USE_UNIX98
#include
#include
#else
#include
#include
#endif
#include
#include
#include
#include
#ifdef HAVE_PHP_SESSION
# include
#endif
#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_thread_entry;
extern zend_class_entry *pthreads_worker_entry;
extern zend_class_entry *pthreads_stackable_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_thread_entry TSRMLS_CC) || \
instanceof_function(c, pthreads_worker_entry TSRMLS_CC) || \
instanceof_function(c, pthreads_stackable_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)
void *pointer;
pid_t pid;
int signal;
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-1.0.1/src/globals.c 0000664 0001750 0001750 00000006732 12307011302 014014 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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));
} /* }}} */
/* {{{ 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);
}
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;
} /* }}} */
/* {{{ 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));
pthreads_lock_free(PTHREADS_G(lock) TSRMLS_CC);
}
} /* }}} */
#endif
pthreads-1.0.1/src/globals.h 0000664 0001750 0001750 00000005021 12307011302 014007 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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);
}; /* }}} */
extern struct _pthreads_globals pthreads_globals;
ZEND_EXTERN_MODULE_GLOBALS(pthreads)
/* {{{ PTHREADS_G */
#define PTHREADS_G(v) pthreads_globals.v
/* }}} */
/* {{{ 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-1.0.1/src/handlers.c 0000664 0001750 0001750 00000033612 12307011302 014166 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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);
convert_to_string(mstring);
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 {
zend_error(E_WARNING, "pthreads detected an attempt to use an unsupported kind of key in %s", Z_OBJCE_P(object)->name);
if (value != NULL) {
value = EG(
uninitialized_zval_ptr
);
Z_ADDREF_P(value);
}
}
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);
convert_to_string(mstring);
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_error(
E_WARNING,
"pthreads failed to write member %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member)
);
}
} break;
default: {
zend_error(
E_WARNING,
"pthreads detected an attempt to use an unsupported kind of data for %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member)
);
}
}
} else zend_error(
E_WARNING,
"pthreads detected an attempt to use an unsupported kind of key in %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);
convert_to_string(mstring);
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_error(E_WARNING, "pthreads has detected an attempt to use an unsupported kind of key in %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);
convert_to_string(mstring);
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_error(
E_WARNING,
"pthreads has experienced an internal error while deleting %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member)
);
}
} else zend_error(E_WARNING, "pthreads detected an attempt to use an unsupported kind of key in %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_error(
E_ERROR,
"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_error(
E_ERROR,
"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 PHP_VERSION_ID > 50399
{
zend_op_array *ops = (zend_op_array*) call;
if (ops && ops->type == ZEND_USER_FUNCTION) {
if (ops->run_time_cache) {
efree(ops->run_time_cache);
ops->run_time_cache = NULL;
}
}
}
#endif
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_error(
E_ERROR,
"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_error(
E_ERROR,
"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_error(
E_ERROR, "pthreads objects cannot be cloned");
return attach;
} /* }}} */
#endif
pthreads-1.0.1/src/handlers.h 0000664 0001750 0001750 00000016632 12307011302 014176 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/lock.c 0000664 0001750 0001750 00000007567 12307011302 013330 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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) {
/* whatever the default type will do */
if (pthread_mutex_init(&lock->mutex, NULL)==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) {
if (!TSRMLS_C || lock->owner != TSRMLS_C){
switch (pthread_mutex_lock(&lock->mutex)) {
case SUCCESS:
locked = (((*acquired)=1)==1);
lock->owner = TSRMLS_C;
lock->locks = 1;
break;
default: {
locked = (((*acquired)=0)==1);
}
}
} else {
locked = (((*acquired)=0)==0);
lock->locks++;
}
} 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) {
if (acquired) {
lock->locks--;
lock->owner = NULL;
switch (pthread_mutex_unlock(&lock->mutex)) {
case SUCCESS:
released = 1;
break;
default: {
zend_error(
E_ERROR,
"pthreads has experienced an internal error while releasing lock @ %p and cannot continue",
lock
);
released = 0;
}
}
} else --lock->locks;
} 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-1.0.1/src/lock.h 0000664 0001750 0001750 00000004066 12307011302 013324 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/modifiers.c 0000664 0001750 0001750 00000012141 12307011302 014341 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/modifiers.h 0000664 0001750 0001750 00000004554 12307011302 014357 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/object.c 0000664 0001750 0001750 00000063610 12307011302 013635 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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 stackable = 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**) &stackable, 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 stackable for runtime
*/
{
PTHREAD stackable = PTHREADS_FETCH_FROM(that_ptr);
if (stackable) {
current->tid = thread->tid;
current->tls = thread->tls;
pthreads_connect(current, stackable TSRMLS_CC);
pthreads_store_write(
stackable->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 = calloc(1, sizeof(*thread));
if (thread) {
thread->scope = PTHREADS_SCOPE_THREAD;
pthreads_base_ctor(thread, entry TSRMLS_CC);
attach.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.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 = calloc(1, sizeof(*worker));
if (worker) {
worker->scope = PTHREADS_SCOPE_WORKER;
pthreads_base_ctor(worker, entry TSRMLS_CC);
attach.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.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ stackable object constructor */
zend_object_value pthreads_stackable_ctor(zend_class_entry *entry TSRMLS_DC) {
zend_object_value attach;
PTHREAD stackable = calloc(1, sizeof(*stackable));
if (stackable) {
stackable->scope = PTHREADS_SCOPE_STACKABLE;
pthreads_base_ctor(stackable, entry TSRMLS_CC);
attach.handle = zend_objects_store_put(
stackable,
(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.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_resources_free(destination->resources 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->resources = source->resources;
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 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->resources = pthreads_resources_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 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)) {
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_resources_free(base->resources 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)) {
free(
base
);
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;
if (object_init_ex(
*object, ce
)==SUCCESS) {
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 != NULL) {
if (pid == mpid) {
PTHREAD destination = PTHREADS_FETCH_FROM(*object);
if (destination) {
pthreads_connect(address, destination TSRMLS_CC);
}
} else {
zend_error(
E_WARNING,
"pthreads detected an attempt to connect to a thread in another belonging to another process");
}
}
}
}
return SUCCESS;
} /* }}} */
#ifdef PTHREADS_KILL_SIGNAL
static inline void pthreads_kill_handler(int signo) /* {{{ */
{
TSRMLS_FETCH();
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;
#ifdef PTHREADS_KILL_SIGNAL
/* installed to support a graceful-ish kill function */
signal(
PTHREADS_KILL_SIGNAL, pthreads_kill_handler);
#endif
if (thread) {
/* TSRM */
void ***tsrm_ls = NULL;
#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
**/
#ifdef PTHREADS_PEDANTIC
/* acquire a global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
#endif
/* create new context */
thread->tls = tsrm_ls = tsrm_new_interpreter_context();
/* set interpreter context */
tsrm_set_interpreter_context(tsrm_ls);
/* 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;
#ifdef HAVE_PHP_SESSION
/* fixup sessions for compatibility */
if (!(thread->options & PTHREADS_ALLOW_HEADERS)) {
PS(cache_limiter) = 0;
PS(use_cookies) = 0;
}
#endif
/* request startup */
php_request_startup(TSRMLS_C);
/* fix php-fpm compatibility */
SG(sapi_started)=0;
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;
/* 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 stackable */
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_catch {
/* do something, it's all gone wrong */
} zend_end_try();
/**
* Thread Block End
**/
/*
* Free original reference to $this
*/
if (!BG(user_shutdown_function_names)) {
zval_ptr_dtor(&this);
} else {
/*
* Note, this doesn't stop them being freed
* This has to be done to stop closures set as
* shutdown handlers from being freed before they
* are invoked
*/
}
PG(report_memleaks) = 0;
/**
* Shutdown Block Begin
**/
#ifdef PTHREADS_PEDANTIC
/* acquire global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
#endif
/* shutdown request */
php_request_shutdown(TSRMLS_C);
/* free interpreter */
tsrm_free_interpreter_context(tsrm_ls);
#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-1.0.1/src/object.h 0000664 0001750 0001750 00000011435 12307011302 013640 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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_stackable_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-1.0.1/src/prepare.c 0000664 0001750 0001750 00000070065 12307011302 014027 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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 inheritance works correctly */
static int pthreads_apply_method_prototype(zend_op_array *ops, zend_class_entry **ce TSRMLS_DC); /* }}} */
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_method_scope(zend_op_array *ops, PTHREAD thread TSRMLS_DC); /* }}} */
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_property_scope(zend_property_info *info, PTHREAD thread 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);
/* set ce flags (reset by initialize) */
prepared->ce_flags = candidate->ce_flags;
/* set parent */
if (candidate->parent)
prepared->parent = pthreads_prepared_entry(thread, candidate->parent TSRMLS_CC);
/* 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);
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);
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 */
pthreads_store_separate(
candidate->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, &prepared, sizeof(zend_class_entry*), (void**)&searched);
} else prepared = *searched;
} else zend_error(E_ERROR, "pthreads has detected a memory error while attempting to prepare %s for execution in %s %lu", candidate->name, thread->std.ce->name, thread->tid);
}
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 */
void 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) {
zend_error(
E_ERROR, "pthreads detected failure while preparing %s in %s (%lu)", (*entry)->name, thread->std.ce->name, thread->tid
);
return;
}
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)) {
zend_hash_apply_with_argument(
&(*entry)->properties_info, (apply_func_arg_t) pthreads_apply_property_scope, (void*) thread TSRMLS_CC);
zend_hash_apply_with_argument(
&(*entry)->function_table, (apply_func_arg_t) pthreads_apply_method_scope, (void*) thread TSRMLS_CC);
zend_hash_apply_with_argument(
&(*entry)->function_table, (apply_func_arg_t) pthreads_apply_method_prototype, (void*) entry 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
);
}
/* 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;
} /* }}} */
/* {{{ 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 prototype for prepared entries, enabling inheritance to function correctly */
static int pthreads_apply_method_prototype(zend_op_array *ops, zend_class_entry **ce TSRMLS_DC) {
if ((ops && ce) &&
(ops->type == ZEND_USER_FUNCTION)) {
if (ops->prototype && ops->line_end) {
zend_function *prototype;
if ((*ce)->parent) {
if (memcmp(ops->prototype->common.scope->name, (*ce)->parent->name, (*ce)->parent->name_length+1) == SUCCESS) {
if ((zend_hash_find(
&(*ce)->parent->function_table,
ops->prototype->common.function_name,
strlen(ops->prototype->common.function_name)+1,
(void**) &prototype) == SUCCESS)) {
ops->prototype = prototype;
} else ops->prototype = NULL;
}
} else if (memcmp(ops->prototype->common.scope->name, (*ce)->name, (*ce)->name_length+1) == SUCCESS) {
if ((zend_hash_find(
&(*ce)->function_table,
ops->prototype->common.function_name,
strlen(ops->prototype->common.function_name)+1,
(void**) &prototype) == SUCCESS)) {
ops->prototype = prototype;
} else ops->prototype = NULL;
}
} else {
ops->prototype = NULL;
}
}
return ZEND_HASH_APPLY_KEEP;
} /* }}} */
/* {{{ fix method scope for prepared entries, enabling self:: and parent:: to work */
static int pthreads_apply_method_scope(zend_op_array *ops, PTHREAD thread TSRMLS_DC) {
if (thread && ops) {
if (ops->scope) {
ops->scope = pthreads_prepared_entry(thread, ops->scope TSRMLS_CC);
}
}
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, PTHREAD thread TSRMLS_DC) {
if (thread && info) {
info->ce = pthreads_prepared_entry(thread, info->ce TSRMLS_CC);
}
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();
if (EG(This)) {
zend_try {
PTHREAD object = PTHREADS_ZG(pointer);
if (object) {
if (object->resources) {
if (!pthreads_resources_kept(object->resources, entry TSRMLS_CC)){
if (PTHREADS_G(default_resource_dtor))
PTHREADS_G(default_resource_dtor)(entry);
}
}
}
} zend_catch {
zend_error(E_WARNING, "pthreads has detected failure while cleaning resources and is likely to fail");
} zend_end_try();
}
} /* }}} */
#endif
pthreads-1.0.1/src/prepare.h 0000664 0001750 0001750 00000003047 12307011302 014030 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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 */
void pthreads_prepare(PTHREAD thread TSRMLS_DC); /* }}} */
#endif
pthreads-1.0.1/src/resources.c 0000664 0001750 0001750 00000005300 12307011302 014371 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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
/* {{{ allocate resource structure */
pthreads_resources pthreads_resources_alloc(TSRMLS_D) {
pthreads_resources resources = calloc(1, sizeof(*resources));
if (resources) {
zend_ts_hash_init(&resources->keep, 3, NULL, NULL, 1);
}
return resources;
} /* }}} */
/* {{{ mark a resource for keeping */
zend_bool pthreads_resources_keep(pthreads_resources resources, zend_rsrc_list_entry *entry, pthreads_resource data TSRMLS_DC) {
if (resources) {
char *key = (char*) entry;
if (zend_ts_hash_update(
&resources->keep, key, sizeof(key), (void**) &data, sizeof(pthreads_resource), NULL
) == SUCCESS) {
return 1;
}
}
return 0;
} /* }}} */
/* {{{ tells if a resource is being kept */
zend_bool pthreads_resources_kept(pthreads_resources resources, zend_rsrc_list_entry *entry TSRMLS_DC) {
pthreads_resource *data;
if (entry) {
char *key = (char*) entry;
if (zend_ts_hash_find(&resources->keep, key, sizeof(key), (void**) &data)==SUCCESS) {
pthreads_resource resource = *data;
if ((EG(scope)!= resource->scope) || (TSRMLS_C != resource->ls)) {
return 1;
}
}
}
return 0;
} /* }}} */
/* {{{ free resource structure */
void pthreads_resources_free(pthreads_resources resources TSRMLS_DC) {
if (resources) {
zend_ts_hash_destroy(
&resources->keep
);
free(resources);
}
} /* }}} */
#endif
pthreads-1.0.1/src/resources.h 0000664 0001750 0001750 00000003447 12307011302 014410 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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 {
TsHashTable keep;
} *pthreads_resources;
typedef struct {
void ***ls;
zend_class_entry *scope;
} *pthreads_resource;
pthreads_resources pthreads_resources_alloc(TSRMLS_D);
zend_bool pthreads_resources_keep(pthreads_resources resources, zend_rsrc_list_entry *entry, pthreads_resource data TSRMLS_DC);
zend_bool pthreads_resources_kept(pthreads_resources resources, zend_rsrc_list_entry *entry TSRMLS_DC);
void pthreads_resources_free(pthreads_resources resources TSRMLS_DC);
#endif
pthreads-1.0.1/src/store.c 0000664 0001750 0001750 00000067771 12307011302 013537 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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;
} /* }}} */
/* {{{ 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;
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;
} /* }}} */
/* {{{ 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->scope = EG(scope);
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;
if (EG(scope) != resource->scope) {
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 && EG(This)) {
PTHREAD object = PTHREADS_FETCH_FROM(EG(This));
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), NULL
)==SUCCESS) {
ZVAL_RESOURCE(pzval, created);
pthreads_resources_keep(
object->resources, &create, 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));
}
} 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;
default: {
zend_error(E_WARNING, "pthreads detected an unsupported key type for merging, ignoring data at %lu", (long)index);
}
}
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-1.0.1/src/store.h 0000664 0001750 0001750 00000006520 12307011302 013525 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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); /* }}} */
/* {{{ 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-1.0.1/src/state.c 0000664 0001750 0001750 00000011371 12307011302 013504 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/state.h 0000664 0001750 0001750 00000004646 12307011302 013520 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/synchro.c 0000664 0001750 0001750 00000011247 12307011302 014053 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/synchro.h 0000664 0001750 0001750 00000004567 12307011302 014067 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/src/thread.h 0000664 0001750 0001750 00000012714 12307011302 013642 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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;
/**
* Shared Resources
**/
pthreads_resources resources;
} *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_HEADERS 0x01000000 /* }}} */
/* {{{ scope constants */
#define PTHREADS_SCOPE_UNKNOWN 0x00000000
#define PTHREADS_SCOPE_THREAD 0x00000001
#define PTHREADS_SCOPE_WORKER 0x00000010
#define PTHREADS_SCOPE_STACKABLE 0x00000100
#define PTHREADS_SCOPE_CONNECTION 0x00001000
#define PTHREADS_SCOPE_DETACHED 0x00010000 /* }}} */
/* {{{ 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_STACKABLE(t) ((t)->scope & PTHREADS_SCOPE_STACKABLE)
#define PTHREADS_IS_NOT_STACKABLE(t) (!PTHREADS_IS_STACKABLE(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-1.0.1/classes/thread.h 0000664 0001750 0001750 00000040747 12307011302 014517 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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, isRunning);
PHP_METHOD(Thread, isJoined);
PHP_METHOD(Thread, isWaiting);
PHP_METHOD(Thread, isTerminated);
PHP_METHOD(Thread, getThreadId);
PHP_METHOD(Thread, getCurrentThreadId);
PHP_METHOD(Thread, getCurrentThread);
PHP_METHOD(Thread, getCreatorId);
PHP_METHOD(Thread, synchronized);
PHP_METHOD(Thread, lock);
PHP_METHOD(Thread, unlock);
PHP_METHOD(Thread, merge);
PHP_METHOD(Thread, shift);
PHP_METHOD(Thread, pop);
PHP_METHOD(Thread, chunk);
PHP_METHOD(Thread, getTerminationInfo);
PHP_METHOD(Thread, kill);
PHP_METHOD(Thread, count);
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_wait, 0, 0, 0)
ZEND_ARG_INFO(0, timeout)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_notify, 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_isRunning, 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_isWaiting, 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_getTerminationInfo, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_synchronized, 0, 0, 1)
ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_lock, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_unlock, 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_shift, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_pop, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_chunk, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_kill, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_count, 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|ZEND_ACC_FINAL)
PHP_ABSTRACT_ME(Thread, run, Thread_run)
PHP_ME(Thread, wait, Thread_wait, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, notify, Thread_notify, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, join, Thread_join, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, detach, Thread_detach, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, isStarted, Thread_isStarted, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, isRunning, Thread_isRunning, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, isJoined, Thread_isJoined, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, isWaiting, Thread_isWaiting, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, isTerminated, Thread_isTerminated, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getTerminationInfo, Thread_getTerminationInfo, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getThreadId, Thread_getThreadId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getCurrentThreadId, Thread_getCurrentThreadId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL|ZEND_ACC_STATIC)
PHP_ME(Thread, getCurrentThread, Thread_getCurrentThread, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL|ZEND_ACC_STATIC)
PHP_ME(Thread, getCreatorId, Thread_getCreatorId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, synchronized, Thread_synchronized, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, lock, Thread_lock, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, unlock, Thread_lock, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, merge, Thread_merge, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, shift, Thread_shift, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, pop, Thread_pop, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, chunk, Thread_chunk, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, kill, Thread_kill, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, count, Thread_count, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{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_error(E_WARNING, "pthreads has detected an attempt to start %s (%lu), which has been previously started", PTHREADS_FRIENDLY_NAME);
break;
case EAGAIN:
zend_error(E_WARNING, "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_NAME);
break;
default: zend_error(E_WARNING, "pthreads has detected that the %s could not be started because of an unspecified system error (%d)", PTHREADS_NAME, result);
}
}
} else zend_error(E_WARNING, "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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto Thread::isRunning()
Will return true while a thread is executing */
PHP_METHOD(Thread, isRunning)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", 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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", 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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Thread::isTerminated()
Will return true if the referenced thread suffered fatal errors or uncaught exceptions */
PHP_METHOD(Thread, isTerminated)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_ERROR TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Thread::getTerminationInfo()
Will return information concerning the location of the termination to aid debugging */
PHP_METHOD(Thread, 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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Thread::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(Thread, wait)
{
PTHREAD thread = PTHREADS_FETCH;
long timeout = 0L;
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));
}
} /* }}} */
/* {{{ proto boolean Thread::notify()
Notify anyone waiting that they can continue
Will return a boolean indication of success */
PHP_METHOD(Thread, notify)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC));
}else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to notify a %s and cannot continue", PTHREADS_NAME);
RETURN_FALSE;
} /* }}} */
/* {{{ 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_error(E_WARNING, "pthreads has detected an attempt to join from an incorrect context, only the creating context may join with %s (%lu)", 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;
}
RETURN_FALSE;
} /* }}} */
/* {{{ 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 void Thread::synchronized(Callable function, ...)
Will synchronize the thread, call the function, passing anything after the function as parameters
*/
PHP_METHOD(Thread, 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 Thread::lock()
Will acquire the storage lock */
PHP_METHOD(Thread, lock)
{
ZVAL_BOOL(return_value, pthreads_store_lock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Thread::unlock()
Will release the storage lock */
PHP_METHOD(Thread, unlock)
{
ZVAL_BOOL(return_value, pthreads_store_unlock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Thread::merge(mixed $data, [boolean $overwrite = true])
Will merge data with the referenced Thread */
PHP_METHOD(Thread, 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 Thread::shift()
Will shift the first member from the object */
PHP_METHOD(Thread, shift)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_shift(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Thread::pop()
Will pop the last member from the object */
PHP_METHOD(Thread, pop)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_pop(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Thread::chunk(integer $size [, boolean $preserve])
Will shift the first member from the object */
PHP_METHOD(Thread, 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 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 boolean Thread::count()
Will return the size of the properties table */
PHP_METHOD(Thread, 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-1.0.1/classes/worker.h 0000664 0001750 0001750 00000034770 12307011302 014560 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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, start);
PHP_METHOD(Worker, run);
PHP_METHOD(Worker, shutdown);
PHP_METHOD(Worker, isStarted);
PHP_METHOD(Worker, isShutdown);
PHP_METHOD(Worker, isWorking);
PHP_METHOD(Worker, isTerminated);
PHP_METHOD(Worker, getTerminationInfo);
PHP_METHOD(Worker, stack);
PHP_METHOD(Worker, unstack);
PHP_METHOD(Worker, getStacked);
PHP_METHOD(Worker, getThreadId);
PHP_METHOD(Worker, getCreatorId);
PHP_METHOD(Worker, merge);
PHP_METHOD(Worker, shift);
PHP_METHOD(Worker, pop);
PHP_METHOD(Worker, chunk);
PHP_METHOD(Worker, kill);
PHP_METHOD(Worker, count);
ZEND_BEGIN_ARG_INFO_EX(Worker_start, 0, 0, 0)
ZEND_ARG_INFO(0, options)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_run, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_shutdown, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_getThreadId, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_getCreatorId, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_isStarted, 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_isTerminated, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_getTerminationInfo, 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()
ZEND_BEGIN_ARG_INFO_EX(Worker_merge, 0, 0, 1)
ZEND_ARG_INFO(0, from)
ZEND_ARG_INFO(0, overwrite)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_shift, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_pop, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_chunk, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_kill, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_count, 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, start, Worker_start, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, run, Worker_run, ZEND_ACC_PUBLIC)
PHP_ME(Worker, shutdown, Worker_shutdown, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, getThreadId, Worker_getThreadId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, getCreatorId, Worker_getCreatorId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, stack, Worker_stack, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, unstack, Worker_unstack, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, getStacked, Worker_getStacked, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, isShutdown, Worker_isShutdown, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, isStarted, Worker_isStarted, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, isWorking, Worker_isWorking, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, isTerminated, Worker_isTerminated, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, getTerminationInfo, Worker_getTerminationInfo, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, merge, Worker_merge, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, shift, Worker_shift, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, pop, Worker_pop, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, chunk, Worker_chunk, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, kill, Worker_kill, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Worker, count, Worker_count, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* {{{ proto void Worker::run(void) */
PHP_METHOD(Worker, run) {} /* }}} */
/* {{{ proto boolean Worker::start([long $options = PTHREADS_INHERIT_ALL])
Starts a new Worker Thread, executing the Workers implementation of Worker::run and then waiting for Stackables
$options should be a mask of inheritance constants */
PHP_METHOD(Worker, 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_error(E_WARNING, "pthreads has detected an attempt to start %s (%lu), which has been previously started", PTHREADS_FRIENDLY_NAME);
break;
case EAGAIN:
zend_error(E_WARNING, "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_NAME);
break;
default: zend_error(E_WARNING, "pthreads has detected that the %s could not be started because of an unspecified system error (%d)", PTHREADS_NAME, result);
}
}
} else zend_error(E_WARNING, "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 int Worker::stack(Stackable &$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_stackable_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_error(E_ERROR, "pthreads has detected an attempt to stack onto %s (%lu) which has already been shutdown", PTHREADS_FRIENDLY_NAME);
} else zend_error(E_ERROR, "pthreads has experienced an internal error while stacking onto %s (%lu) and cannot continue", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
} /* }}} */
/* {{{ proto int Worker::unstack([Stackable &$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_stackable_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_error(E_ERROR, "pthreads has experienced an internal error while unstacking from %s (%lu) and cannot continue", 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_error(E_ERROR, "pthreads has experienced an internal error while getting the stack length of a %s and cannot continue", PTHREADS_NAME);
RETURN_FALSE;
}
/* {{{ proto Worker::isStarted()
Will return true if the Worker has been started */
PHP_METHOD(Worker, isStarted)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_STARTED TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto Worker::isJoined()
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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Worker::isTerminated()
Will return true if the referenced thread suffered fatal errors or uncaught exceptions */
PHP_METHOD(Worker, isTerminated)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_ERROR TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Worker::getTerminationInfo()
Will return information concerning the location of the termination to aid debugging */
PHP_METHOD(Worker, 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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_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_error(E_WARNING, "pthreads has detected an attempt to shutdown from an incorrect context, only the creating context may shutdown %s (%lu)", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
}
} /* }}} */
/* {{{ 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);
} /* }}} */
/* {{{ proto boolean Worker::merge(mixed $data, [boolean $overwrite = true])
Will merge data with the referenced Worker */
PHP_METHOD(Worker, 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 Worker::shift()
Will shift the first member from the object */
PHP_METHOD(Worker, shift)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_shift(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Worker::pop()
Will pop the last member from the object */
PHP_METHOD(Worker, pop)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_pop(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Worker::chunk(integer $size [, boolean $preserve])
Will shift the first member from the object */
PHP_METHOD(Worker, 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 boolean Worker::kill(])
Will kill the referenced worker, forcefully */
PHP_METHOD(Worker, 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 boolean Worker::count()
Will return the size of the properties table */
PHP_METHOD(Worker, 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-1.0.1/classes/stackable.h 0000664 0001750 0001750 00000024636 12307011302 015200 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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_STACKABLE_H
#define HAVE_PTHREADS_CLASS_STACKABLE_H
PHP_METHOD(Stackable, run);
PHP_METHOD(Stackable, wait);
PHP_METHOD(Stackable, notify);
PHP_METHOD(Stackable, isRunning);
PHP_METHOD(Stackable, isWaiting);
PHP_METHOD(Stackable, isTerminated);
PHP_METHOD(Stackable, getTerminationInfo);
PHP_METHOD(Stackable, synchronized);
PHP_METHOD(Stackable, lock);
PHP_METHOD(Stackable, unlock);
PHP_METHOD(Stackable, merge);
PHP_METHOD(Stackable, shift);
PHP_METHOD(Stackable, chunk);
PHP_METHOD(Stackable, pop);
PHP_METHOD(Stackable, count);
ZEND_BEGIN_ARG_INFO_EX(Stackable_run, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_wait, 0, 0, 0)
ZEND_ARG_INFO(0, timeout)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_notify, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_isRunning, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_isWaiting, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_isTerminated, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_getTerminationInfo, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_synchronized, 0, 0, 1)
ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_lock, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_unlock, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_merge, 0, 0, 1)
ZEND_ARG_INFO(0, from)
ZEND_ARG_INFO(0, overwrite)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_shift, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_chunk, 0, 0, 1)
ZEND_ARG_INFO(0, size)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_pop, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Stackable_count, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_stackable_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_STACKABLE
# define HAVE_PTHREADS_CLASS_STACKABLE
zend_function_entry pthreads_stackable_methods[] = {
PHP_ME(Stackable, run, Stackable_run, ZEND_ACC_PUBLIC)
PHP_ME(Stackable, wait, Stackable_wait, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, notify, Stackable_notify, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, isRunning, Stackable_isRunning, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, isWaiting, Stackable_isWaiting, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, isTerminated, Stackable_isTerminated, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, getTerminationInfo, Stackable_getTerminationInfo, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, synchronized, Stackable_synchronized, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, lock, Stackable_lock, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, unlock, Stackable_unlock, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, merge, Stackable_merge, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, shift, Stackable_shift, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, chunk, Stackable_chunk, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, pop, Stackable_pop, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Stackable, count, Stackable_count, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* {{{ */
PHP_METHOD(Stackable, run) {} /* }}} */
/* {{{ proto boolean Stackable::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(Stackable, wait)
{
PTHREAD thread = PTHREADS_FETCH;
long timeout = 0L;
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));
}
} /* }}} */
/* {{{ proto boolean Stackable::notify()
Send notification to everyone waiting on the Stackable
Will return a boolean indication of success */
PHP_METHOD(Stackable, notify)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC));
}else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to notify a %s and cannot continue", PTHREADS_NAME);
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Stackable::isRunning()
Will return true while the referenced Stackable is being executed by a Worker */
PHP_METHOD(Stackable, isRunning)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Stackable::isWaiting()
Will return true if the referenced Stackable is waiting for notification */
PHP_METHOD(Stackable, isWaiting)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Stackable::isTerminated()
Will return true if the referenced Stackable suffered fatal errors or uncaught exceptions */
PHP_METHOD(Stackable, isTerminated)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_ERROR TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Stackable::getTerminationInfo()
Will return information concerning the location of the termination to aid debugging */
PHP_METHOD(Stackable, 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_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto void Stackable::synchronized(Callable function, ...)
Will synchronize the object, call the function, passing anything after the function as parameters
*/
PHP_METHOD(Stackable, 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 Stackable::lock()
Will acquire the storage lock */
PHP_METHOD(Stackable, lock)
{
ZVAL_BOOL(return_value, pthreads_store_lock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Stackable::unlock()
Will release the storage lock */
PHP_METHOD(Stackable, unlock)
{
ZVAL_BOOL(return_value, pthreads_store_unlock(getThis() TSRMLS_CC));
} /* }}} */
/* {{{ proto boolean Stackable::merge(mixed $data, [boolean $overwrite = true])
Will merge data with the referenced Stackable */
PHP_METHOD(Stackable, 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 Stackable::shift()
Will shift the first member from the object */
PHP_METHOD(Stackable, shift)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_shift(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto mixed Stackable::chunk(integer $size [, boolean $preserve = false])
Will shift the first member from the object */
PHP_METHOD(Stackable, 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 Stackable::pop()
Will pop the last member from the object */
PHP_METHOD(Stackable, pop)
{
if (zend_parse_parameters_none() != SUCCESS) {
return;
}
pthreads_store_pop(getThis(), &return_value TSRMLS_CC);
} /* }}} */
/* {{{ proto boolean Stackable::count()
Will return the size of the properties table */
PHP_METHOD(Stackable, 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-1.0.1/classes/mutex.h 0000664 0001750 0001750 00000017745 12307011302 014414 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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_error(E_ERROR, "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;
if ((mutex=(pthread_mutex_t*) calloc(1, sizeof(pthread_mutex_t)))!=NULL) {
switch(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(pthread_mutex_lock(mutex)){
case SUCCESS: RETURN_LONG((ulong)mutex); break;
case EDEADLK: RETURN_LONG((ulong)mutex); break;
default:
zend_error(E_ERROR, "pthreads detected an unspecified 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_error(E_ERROR, "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_error(E_ERROR, "pthreads detected that the system lacks the necessary memory to initialise another mutex");
free(mutex);
break;
case EPERM:
zend_error(E_ERROR, "pthreads detected that the caller does not have permission to initialize mutex");
free(mutex);
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while attempting to initialize mutex");
free(mutex);
}
} else zend_error(E_ERROR, "pthreads has failed to allocate memory for mutex and cannot continue");
RETURN_FALSE;
} /* }}} */
/* {{{ 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;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch (pthread_mutex_lock(mutex)) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
case E_ERROR:
zend_error(E_WARNING, "The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while locking mutex and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ 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;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch (pthread_mutex_trylock(mutex)) {
case SUCCESS: RETURN_TRUE; break;
case EBUSY: RETURN_FALSE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
case EAGAIN:
zend_error(E_WARNING, "pthreads detected that the mutex could not be acquired because the maximum number of recursive locks has been exceeded");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while trying to lock mutex and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ 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;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &mutex, &destroy)==SUCCESS && mutex) {
switch (pthread_mutex_unlock(mutex)) {
case SUCCESS:
if (destroy > 0) {
pthread_mutex_destroy(mutex);
free(mutex);
}
RETURN_TRUE;
break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
case EPERM:
zend_error(E_WARNING, "pthreads has detected that the calling thread does not own the mutex");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while unlocking mutex and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Mutex::destroy(long mutex)
Will destroy the mutex referenced and free memory associated */
PHP_METHOD(Mutex, destroy)
{
pthread_mutex_t *mutex;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mutex)==SUCCESS && mutex) {
switch (pthread_mutex_destroy(mutex)) {
case SUCCESS:
free(mutex);
RETURN_TRUE;
break;
case EBUSY:
zend_error(E_WARNING, "pthreads has detected an attempt to destroy mutex while it is locked or referenced");
break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while attempting to destroy mutex and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
# endif
#endif
pthreads-1.0.1/classes/cond.h 0000664 0001750 0001750 00000017253 12307011302 014167 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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_error(E_ERROR, "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;
if ((condition=(pthread_cond_t*) calloc(1, sizeof(pthread_cond_t)))!=NULL) {
switch (pthread_cond_init(condition, NULL)) {
case SUCCESS:
RETURN_LONG((ulong)condition);
break;
case EAGAIN:
zend_error(E_ERROR, "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_error(E_ERROR, "pthreads detected that the system lacks the necessary memory to initialise another condition");
free(condition);
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while initializing new condition and cannot conitnue");
free(condition);
}
} else zend_error(E_ERROR, "pthreads failed to allocate memory for new condition and cannot continue");
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Cond::signal(long condition)
This will signal a condition */
PHP_METHOD(Cond, signal)
{
pthread_cond_t *condition;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition) == SUCCESS && condition) {
switch (pthread_cond_signal(condition)) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected the condition referenced does not refer to a valid condition");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while signaling condition and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Cond::broadcast(long condition)
This will broadcast a condition */
PHP_METHOD(Cond, broadcast)
{
pthread_cond_t *condition;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition)==SUCCESS && condition) {
switch (pthread_cond_broadcast(condition)) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected the condition referenced does not refer to a valid condition");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while broadcasting condition and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ 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;
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(pthread_cond_timedwait(condition, mutex, &spec)){
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the condition you are attempting to wait on does not refer to a valid condition variable");
RETURN_FALSE;
break;
case ETIMEDOUT:
zend_error(E_WARNING, "pthreads detected a timeout while waiting for condition");
RETURN_FALSE;
break;
default: RETURN_FALSE;
}
} else {
switch (pthread_cond_wait(condition, mutex)) {
case SUCCESS: RETURN_TRUE; break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the condition you are attempting to wait on does not refer to a valid condition variable");
RETURN_FALSE;
break;
default: RETURN_FALSE;
}
}
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto boolean Cond::destroy()
This will destroy a condition and free the memory associated with it */
PHP_METHOD(Cond, destroy)
{
pthread_cond_t *condition;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &condition)==SUCCESS && condition) {
switch (pthread_cond_destroy(condition)) {
case SUCCESS:
free(condition);
RETURN_TRUE;
break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected the condition referenced does not refer to a valid condition variable");
break;
case EBUSY:
zend_error(E_WARNING, "pthreads has detected an attempt to destroy the object referenced by condition while it is referenced by another thread");
break;
default:
zend_error(E_ERROR, "pthreads detected an internal error while destroying condition and cannot continue");
}
}
RETURN_FALSE;
} /* }}} */
# endif
#endif
pthreads-1.0.1/classes/pool.h 0000664 0001750 0001750 00000030076 12307011302 014213 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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);
PHP_METHOD(Pool, __destruct);
ZEND_BEGIN_ARG_INFO_EX(Pool___construct, 0, 0, 2)
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)
PHP_ME(Pool, __destruct, 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, "lC|a", &size, &clazz, &ctor) != SUCCESS) {
return;
}
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(Stackable 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_stackable_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) {
MAKE_STD_ZVAL(worker);
clazz = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("class"), 1 TSRMLS_CC);
ctor = zend_read_property(Z_OBJCE_P(getThis()), getThis(), ZEND_STRL("ctor"), 1 TSRMLS_CC);
zend_lookup_class(
Z_STRVAL_P(clazz), Z_STRLEN_P(clazz), &ce TSRMLS_CC);
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);
}
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, Stackable 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_stackable_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));
}
} /* }}} */
/* {{{ proto void Pool::__destruct()
Will shutdown all workers and destroy all references held to work */
PHP_METHOD(Pool, __destruct) {
zval *workers = NULL;
zval *work = NULL;
if (zend_parse_parameters_none() != 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) {
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));
}
if (Z_TYPE_P(work) == IS_ARRAY)
zend_hash_clean(Z_ARRVAL_P(work));
} /* }}} */
# endif
#endif
pthreads-1.0.1/iterators/iterator.h 0000664 0001750 0001750 00000002637 12307011302 015454 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/iterators/default.h 0000664 0001750 0001750 00000013115 12307011302 015240 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/config.m4 0000664 0001750 0001750 00000001763 12307011302 013144 0 ustar joe joe 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-1.0.1/config.w32 0000664 0001750 0001750 00000004475 12307011302 013242 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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-1.0.1/LICENSE 0000664 0001750 0001750 00000006147 12307011302 012443 0 ustar joe joe --------------------------------------------------------------------
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-1.0.1/php_pthreads.c 0000664 0001750 0001750 00000023174 12307011302 014262 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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),
NULL,
NULL,
PHP_MINFO(pthreads),
PHP_PTHREADS_VERSION,
STANDARD_MODULE_PROPERTIES
};
zend_class_entry *pthreads_thread_entry;
zend_class_entry *pthreads_worker_entry;
zend_class_entry *pthreads_stackable_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;
#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;
}
PHP_MINIT_FUNCTION(pthreads)
{
zend_class_entry te;
zend_class_entry me;
zend_class_entry ce;
zend_class_entry se;
zend_class_entry we;
zend_class_entry pe;
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);
INIT_CLASS_ENTRY(te, "Thread", pthreads_thread_methods);
te.create_object = pthreads_thread_ctor;
te.serialize = pthreads_internal_serialize;
te.unserialize = pthreads_internal_unserialize;
pthreads_thread_entry=zend_register_internal_class(&te TSRMLS_CC);
pthreads_thread_entry->get_iterator = pthreads_object_iterator_ctor;
zend_class_implements(pthreads_thread_entry TSRMLS_CC, 1, zend_ce_traversable);
#ifdef HAVE_SPL
zend_class_implements(pthreads_thread_entry TSRMLS_CC, 1, spl_ce_Countable);
#endif
INIT_CLASS_ENTRY(we, "Worker", pthreads_worker_methods);
we.create_object = pthreads_worker_ctor;
we.serialize = pthreads_internal_serialize;
we.unserialize = pthreads_internal_unserialize;
pthreads_worker_entry=zend_register_internal_class(&we TSRMLS_CC);
pthreads_worker_entry->get_iterator = pthreads_object_iterator_ctor;
zend_class_implements(pthreads_worker_entry TSRMLS_CC, 1, zend_ce_traversable);
#ifdef HAVE_SPL
zend_class_implements(pthreads_worker_entry TSRMLS_CC, 1, spl_ce_Countable);
#endif
INIT_CLASS_ENTRY(se, "Stackable", pthreads_stackable_methods);
se.create_object = pthreads_stackable_ctor;
se.serialize = pthreads_internal_serialize;
se.unserialize = pthreads_internal_unserialize;
pthreads_stackable_entry=zend_register_internal_class(&se TSRMLS_CC);
pthreads_stackable_entry->get_iterator = pthreads_object_iterator_ctor;
zend_class_implements(pthreads_stackable_entry TSRMLS_CC, 1, zend_ce_traversable);
#ifdef HAVE_SPL
zend_class_implements(pthreads_stackable_entry TSRMLS_CC, 1, spl_ce_Countable);
#endif
INIT_CLASS_ENTRY(me, "Mutex", pthreads_mutex_methods);
me.serialize = zend_class_serialize_deny;
me.unserialize = zend_class_unserialize_deny;
pthreads_mutex_entry=zend_register_internal_class(&me 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(pe, "Pool", pthreads_pool_methods);
//pe.serialize = zend_class_serialize_deny;
//pe.unserialize = zend_class_unserialize_deny;
pthreads_pool_entry=zend_register_internal_class(&pe 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);
#endif
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(pthreads)
{
if (pthreads_instance == TSRMLS_C) {
pthreads_globals_shutdown(TSRMLS_C);
}
return SUCCESS;
}
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_THREAD
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_WORKER
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_STACKABLE
# 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-1.0.1/php_pthreads.h 0000664 0001750 0001750 00000003565 12307011302 014271 0 ustar joe joe /*
+----------------------------------------------------------------------+
| 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 "1.0.1"
PHP_MINIT_FUNCTION(pthreads);
PHP_MSHUTDOWN_FUNCTION(pthreads);
PHP_MINFO_FUNCTION(pthreads);
#ifndef HAVE_PTHREADS_CLASS_THREAD_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_WORKER_H
# include
#endif
#ifndef HAVE_PTHREADS_CLASS_STACKABLE_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-1.0.1/README.md 0000664 0001750 0001750 00000012125 12307011302 012706 0 ustar joe joe # 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.