package.xml 0000664 0001750 0001750 00000017636 12100610723 011316 0 ustar joe joe
pthreadspecl.php.netThreading APIA compatible Threading API for PHP5.3+Joe Watkinskrakjoepthreads@pthreads.orgyes2013-01-250.0.410.0.41betabetaPHP License
stability and bug fix update
remove ::wait(member, [timeout])
fix bugs in synchronization
remove the need to use default object properties
less calls to EG at thread runtime
remove complex variables ( resources / objects ) from static class members
rely completely on pthreads storage for object members
5.3.01.4.0b1pthreads
pthreads-0.0.41/examples/AdvancedSynchronization.php 0000664 0001750 0001750 00000006254 12100610723 020701 0 ustar joe joe my)*rand();
}
public function __construct(){
$this->start();
}
/*
* This doesn't do anything useful, does a bit of read/writing and waiting ...
* Uninteresting, move along ...
*/
public function run(){
$stdout = fopen("php://stdout", "w");
/* set a variable to test fetching from an imported thread */
$this->my = "data";
fprintf($stdout, "%s: %lu running\n", __CLASS__, $this->getThreadId());
fprintf($stdout, "%s: %lu waiting\n", __CLASS__, $this->getThreadId());
/* wait for someone to write some data if necessary */
if (!$this->isFinished())
fprintf($stdout, "%s: %lu notified: %d\n", __CLASS__, $this->getThreadId(), $this->wait());
fprintf($stdout, "%s: %lu read %s\n", __CLASS__, $this->getThreadId(), $this->reading);
fprintf($stdout, "%s: %lu leaving\n", __CLASS__, $this->getThreadId());
fflush($stdout);
$this->my = strrev($this->my);
}
/*
* This is a good example of using a protected method:
* The nature of wait() means a condition has failed, ie
* if (conditionFailed())
wait()
else noNeedToWait();
* Using protected here gives the finished flag authority
* because it is the only method that read/writes the variable
* Calling notify from the getter/setter means that if another context
* calls isFinished(true) and this object is waiting at the time of the call
* it will get the notification it is waiting for
*/
protected function isFinished($flag = null) {
if ($flag === null) {
return $this->finished;
} else {
$this->finished = $flag;
if ($this->isWaiting())
$this->notify();
return $this->finished;
}
}
}
class Tester extends Thread {
public function __construct($tests){
$this->tests = $tests;
}
public function run(){
printf("%s: %lu running\n", __CLASS__, $this->getThreadId());
foreach($this->tests as $test) {
/* this tests protected method access on a nonsense method, and reads some data directly */
printf("%s: %lu working %lu ... %s/%d\n", __CLASS__, $this->getThreadId(), $test->getThreadId(), $test->my, $test->scopeTestFunc());
/* this is us directly writing another threads members, just for something to do */
$test->reading = ((rand()*10)*microtime(true))/10;
/* tell the test thread we are done and it can read what was written now */
$test->isFinished(true);
}
/* the process is waiting to handle failed tests */
printf("%s: %lu notifying process: %d\n", __CLASS__, $this->getThreadId(), $this->notify());
}
}
printf("Process: running\n");
$tests = array(new SyncTest(), new SyncTest());
$tester = new Tester($tests);
$tester->start();
$tester->wait();
printf("Process: notified\n");
foreach($tests as $test){
if(!$test->isJoined() && $test->isWaiting()) {
printf("Process: notifying %lu\n", $test->getThreadId());
printf("Process: notified %lu: %d\n", $test->getThreadId(), $test->notify());
} else printf("Process: done with %lu\n", $test->getThreadId());
printf("Process: read %lu: %s\n", $test->getThreadId(), $test->reading);
}
printf("Process: notifying %lu\n", $tester->getThreadId());
?> pthreads-0.0.41/examples/CallAnyFunction.php 0000664 0001750 0001750 00000004272 12100610723 017101 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($future));
/* you can reference again as a string because you cached the result, YOU CANNOT JOIN TWICE */
printf("First 16 chars: %s\n", substr($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-0.0.41/examples/Fetch.php 0000664 0001750 0001750 00000003077 12100610723 015103 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->notify();
}
}
$thread = new Fetching();
/*
* You cannot start synchronized, because the run method will attempt to acquire the thread lock in order to manipulate members
*/
$thread->start();
/*
* Wait for the thread to tell us the members are ready
*/
$thread->wait();
/*
* 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");
}
?>
pthreads-0.0.41/examples/Mutexes.php 0000664 0001750 0001750 00000003065 12100610723 015501 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:<-", $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-0.0.41/examples/NewSynchronization.php 0000664 0001750 0001750 00000003446 12100610723 017725 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-0.0.41/examples/Notifications.php 0000664 0001750 0001750 00000002014 12100610723 016651 0 ustar joe joe notify());
printf("Process Waiting ...\n");
printf("Thread Notifying Process 2: %b\n", $this->notify());
$this->wait();
printf("Thread exiting ...");
}
}
$t = new ExampleThread();
if ($t->start(true)) {
printf("Process Working ... then ...\n");
printf("Process Waited: %d\n", $t->wait());
printf("Now doing some work while thread is waiting ...\n");
usleep(1000000);
printf("And notify thread: %d\n", $t->notify());
}
?>
pthreads-0.0.41/examples/ObjectsAsParameters.php 0000664 0001750 0001750 00000006062 12100610723 017750 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-0.0.41/examples/Objects.php 0000664 0001750 0001750 00000013104 12100610723 015433 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-0.0.41/examples/Pooling.php 0000664 0001750 0001750 00000011646 12100610723 015462 0 ustar joe joe local = $data;
}
public function run() {
$this->worker->addAttempt();
$this->worker->addData(
$this->local
);
}
public function getData() { return $this->local; }
}
class ExampleWorker extends Worker {
public function __construct($name) {
$this->name = $name;
$this->data = array();
$this->setup = false;
$this->attempts = 0;
}
public function run(){
$this->setName(sprintf("%s (%lu)", $this->getName(), $this->getThreadId()));
}
public function setSetup($setup) { $this->setup = $setup; }
public function getName() { return $this->name; }
public function setName($name) { $this->name = $name; }
public function addAttempt() { $this->attempts++; }
public function getAttempts() { return $this->attempts; }
public function setData($data) { $this->data = $data; }
public function addData($data) { $this->data = array_merge($this->data, array($data)); }
public function getData() { return $this->data; }
}
/* Dead simple pthreads pool */
class Pool {
/* to hold worker threads */
public $workers;
/* to hold exit statuses */
public $status;
/* prepare $size workers */
public function __construct($size = 10) {
$this->size = $size;
}
/* submit Stackable to Worker */
public function submit(Stackable $stackable) {
if (count($this->workers)<$this->size) {
$id = count($this->workers);
$this->workers[$id] = new ExampleWorker(sprintf("Worker [%d]", $id));
$this->workers[$id]->start();
if ($this->workers[$id]->stack($stackable)) {
return $stackable;
} else trigger_error(sprintf("failed to push Stackable onto %s", $this->workers[$id]->getName()), E_USER_WARNING);
}
if (($select = $this->workers[array_rand($this->workers)])) {
if ($select->stack($stackable)) {
return $stackable;
} else trigger_error(sprintf("failed to stack onto selected worker %s", $select->getName()), E_USER_WARNING);
} else trigger_error(sprintf("failled to select a worker for Stackable"), E_USER_WARNING);
return false;
}
/* Shutdown the pool of threads cleanly, retaining exit status locally */
public function shutdown() {
foreach($this->workers as $worker) {
$this->status[$worker->getThreadId()]=$worker->shutdown();
}
}
}
$start = microtime(true);
/* Create a pool of ten threads */
$pool = new Pool(10);
/* Create and submit an array of Stackables */
$work = array();
while(++$target<100)
$work[]=$pool->submit(new ExampleWork(array_rand($_SERVER)));
$pool->shutdown();
/*
* Look inside
*/
$runtime = (microtime(true)-$start);
if ($_SERVER["HTTP_HOST"]) echo "
";
printf("---------------------------------------------------------\n");
printf("Executed %d tasks in %f seconds in %d threads\n", count($work), $runtime, 10);
printf("---------------------------------------------------------\n");
if ($_SERVER["HTTP_HOST"])
printf("%s | %.3fMB RAM\n", $_SERVER["SERVER_SOFTWARE"], memory_get_peak_usage(true)/1048576);
else printf("%.3fMB RAM\n", memory_get_peak_usage(true)/1048576);
printf("---------------------------------------------------------\n");
$attempts = 0;
foreach($pool->workers as $worker) {
printf("%s made %d attempts ...\n", $worker->getName(), $worker->getAttempts());
print_r($worker->getData());
$attempts+=$worker->getAttempts();
}
printf("---------------------------------------------------------\n");
printf("Average processing time of %f seconds per task\n", $runtime/$attempts);
printf("---------------------------------------------------------\n");
if ($_SERVER["HTTP_HOST"]) echo "
";
?>
pthreads-0.0.41/examples/Scope.php 0000664 0001750 0001750 00000003701 12100610723 015115 0 ustar joe joe getThreadId(), __METHOD__);
}
/*
* This protected method can only be called by one thread at a time
*/
protected function synchronized($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->synchronized(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->synchronized());
/*
* 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-0.0.41/examples/SharingResources.php 0000664 0001750 0001750 00000004051 12100610723 017331 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-0.0.41/examples/SimpleWebRequest.php 0000664 0001750 0001750 00000001663 12100610723 017311 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-0.0.41/examples/SocketServer.php 0000664 0001750 0001750 00000005464 12100610723 016473 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-0.0.41/examples/SQLWorker.php 0000664 0001750 0001750 00000004061 12100610723 015675 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-0.0.41/examples/Stacking.php 0000664 0001750 0001750 00000005570 12100610723 015615 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-0.0.41/tests/binding.phpt 0000664 0001750 0001750 00000001716 12100610723 015172 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-0.0.41/tests/callstatic-etc.phpt 0000664 0001750 0001750 00000000753 12100610723 016454 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-0.0.41/tests/complex-statics.phpt 0000664 0001750 0001750 00000002252 12100610723 016673 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-0.0.41/tests/complex-statics-set-null.phpt 0000664 0001750 0001750 00000002341 12100610723 020433 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-0.0.41/tests/conditions.phpt 0000664 0001750 0001750 00000001172 12100610723 015725 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-0.0.41/tests/constants.phpt 0000664 0001750 0001750 00000000571 12100610723 015572 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-0.0.41/tests/corrupted-resources.phpt 0000664 0001750 0001750 00000001272 12100610723 017574 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-0.0.41/tests/foreign-private-members.phpt 0000664 0001750 0001750 00000001110 12100610723 020275 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-0.0.41/tests/functions.phpt 0000664 0001750 0001750 00000000613 12100610723 015563 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-0.0.41/tests/global-constants.phpt 0000664 0001750 0001750 00000001302 12100610723 017021 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-0.0.41/tests/included-files.phpt 0000664 0001750 0001750 00000000747 12100610723 016452 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-0.0.41/tests/ini.phpt 0000664 0001750 0001750 00000000656 12100610723 014341 0 ustar joe joe --TEST--
Test INI inheritance (bug 20)
--DESCRIPTION--
This test will ensure that INI directives are inherited and or created upon initialization of new threads
--FILE--
start();
?>
--EXPECT--
Test::run: :/var/lib/other
pthreads-0.0.41/tests/interface.phpt 0000664 0001750 0001750 00000001113 12100610723 015507 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-0.0.41/tests/mutex.phpt 0000664 0001750 0001750 00000000443 12100610723 014716 0 ustar joe joe --TEST--
Test mutex operations
--DESCRIPTION--
This test will ensures mutex functionality
--FILE--
--EXPECT--
bool(true)
bool(true)
bool(true)
pthreads-0.0.41/tests/norefs.phpt 0000664 0001750 0001750 00000000752 12100610723 015053 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-0.0.41/tests/oomethods.phpt 0000664 0001750 0001750 00000000712 12100610723 015554 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-0.0.41/tests/staticmethods.phpt 0000664 0001750 0001750 00000001001 12100610723 016416 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-0.0.41/tests/statics.phpt 0000664 0001750 0001750 00000000641 12100610723 015226 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-0.0.41/tests/synchronization.phpt 0000664 0001750 0001750 00000001033 12100610723 017011 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-0.0.41/tests/thread.phpt 0000664 0001750 0001750 00000000466 12100610723 015030 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-0.0.41/tests/unset-defaults.phpt 0000664 0001750 0001750 00000000566 12100610723 016525 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-0.0.41/tests/waiting-timeouts.phpt 0000664 0001750 0001750 00000000701 12100610723 017062 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-0.0.41/tests/wait.phpt 0000664 0001750 0001750 00000002063 12100610723 014520 0 ustar joe joe --TEST--
Test wait/notify
--DESCRIPTION--
This test will verify wait/notify functionality
--FILE--
isSent(true);
}
/* good use of protection ! kudos, me !! */
protected function isSent($flag = null) {
if ($flag === null) {
return $this->sent;
} else return ($this->sent = $this->notify());
}
}
$thread = new ThreadTest();
if($thread->start()) {
/*
you only ever wait FOR something !
*/
if (!$thread->isSent()) {
var_dump($thread->wait());
} else printf("bool(true)\n");
/* note that: this works because of protection */
/* without protection, notify in the other thread can cause the process to continue */
/* without the other thread having set the value of "sent" */
/* the call to notify is made in the same protected method that writes the variable */
/* and this thread uses that same method to access the variable */
var_dump($thread->isSent());
} else printf("bool(false)\n");
?>
--EXPECT--
bool(true)
bool(true) pthreads-0.0.41/src/pthreads.h 0000664 0001750 0001750 00000005075 12100610723 014275 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_H
#define HAVE_PTHREADS_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include
#ifndef _WIN32
#define __USE_UNIX98
#include
#include
#else
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#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;
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;
ZEND_END_MODULE_GLOBALS(pthreads)
# define PTHREADS_ZG(v) TSRMG(pthreads_globals_id, zend_pthreads_globals *, v)
#endif
#endif
pthreads-0.0.41/src/globals.c 0000664 0001750 0001750 00000004643 12100610723 014101 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_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
/* {{{ 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;
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);
} /* }}} */
/* {{{ shutdown global structures */
void pthreads_globals_shutdown(TSRMLS_D) {
if (PTHREADS_G(init)) {
pthreads_lock_free(
PTHREADS_G(lock) TSRMLS_CC
);
}
} /* }}} */
#endif
pthreads-0.0.41/src/globals.h 0000664 0001750 0001750 00000004524 12100610723 014104 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_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/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); /* }}} */
/* {{{ shutdown global structures */
void pthreads_globals_shutdown(TSRMLS_D); /* }}} */
#endif /* HAVE_PTHREADS_GLOBAL_H */
pthreads-0.0.41/src/handlers.c 0000664 0001750 0001750 00000031173 12100610723 014254 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_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
/* {{{ 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 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) {
pthreads_lock_acquire(pthreads->store->lock, &locked TSRMLS_CC);
{
zval *pcounter;
MAKE_STD_ZVAL(member);
if(pthreads_store_isset(pthreads->store, "$\0", 2, 1 TSRMLS_CC)) {
pthreads_store_read(pthreads->store, "$\0", 2, &pcounter TSRMLS_CC);
} else {
MAKE_STD_ZVAL(pcounter);
ZVAL_LONG(pcounter, 0);
}
++Z_LVAL_P(pcounter);
pthreads_store_write(pthreads->store, "$\0", 2, &pcounter TSRMLS_CC);
ZVAL_LONG(member, Z_LVAL_P(pcounter)-1);
FREE_ZVAL(pcounter);
nulled = 1;
}
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;
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) {
if (ops->run_time_cache) {
efree(ops->run_time_cache);
ops->run_time_cache = NULL;
}
}
}
#endif
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;
}
} /* }}} */
#endif
pthreads-0.0.41/src/handlers.h 0000664 0001750 0001750 00000014520 12100610723 014256 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 |
+----------------------------------------------------------------------+
*/
/*
* These handlers provide thread-safe read/write/call 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
/* {{{ 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_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_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 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); /* }}} */
/* {{{ 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); /* }}} */
#endif
pthreads-0.0.41/src/lock.c 0000664 0001750 0001750 00000007774 12100610723 013416 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_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: {
zend_error(
E_ERROR, "pthreads has experienced an internal error while acquiring lock @ %p and cannot continue", lock
);
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-0.0.41/src/lock.h 0000664 0001750 0001750 00000004062 12100610723 013406 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_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-0.0.41/src/modifiers.c 0000664 0001750 0001750 00000012074 12100610723 014434 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_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, 0);
zend_hash_init(&modifiers->protection, 32, NULL, (dtor_func_t) pthreads_modifiers_protection_dtor, 0);
}
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) {
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-0.0.41/src/modifiers.h 0000664 0001750 0001750 00000004550 12100610723 014441 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_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-0.0.41/src/object.c 0000664 0001750 0001750 00000053177 12100610723 013732 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_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) {
pthreads_address address = (pthreads_address) calloc(1, sizeof(*address));
if (address) {
/* add the space for null here, once */
address->length = snprintf(
NULL, 0, "%lu", (long) object
);
if (address->length) {
address->serial = calloc(1, address->length+1);
if (address->serial) {
sprintf(
(char*) address->serial, "%lu", (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 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;
} /* }}} */
/* {{{ 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)) {
zend_llist *stack = &thread->stack->objects;
if (work) {
zend_llist_del_element(stack, &work, (int (*)(void *, void *)) pthreads_equal_func);
} else zend_llist_destroy(stack);
remain = stack->count;
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)) {
zend_llist *stack = &thread->stack->objects;
if (stack) {
zend_llist_add_element(
stack, &stackable
);
counted = stack->count;
Z_OBJ_HT_P(work)->add_ref(work TSRMLS_CC);
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
if (counted > 0L) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC)) {
pthreads_unset_state(thread, PTHREADS_ST_WAITING 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 = NULL, current = NULL;
zend_bool locked;
size_t bubble = 0;
zval *that_ptr;
zend_function *run;
zend_class_entry *popped;
burst:
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
zend_llist *stack = &thread->stack->objects;
if ((bubble=stack->count) > 0) {
work = zend_llist_get_first(stack);
if (work && (current = *work) && current) {
/*
* 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);
/*
* Switch scope to the next stackable
*/
if (zend_hash_find(&popped->function_table, "run", sizeof("run"), (void**) &run)==SUCCESS) {
/*
* 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);
}
}
/*
* Cleanup List
*/
zend_llist_del_element(stack, work, (int (*)(void *, void *)) pthreads_equal_func);
}
}
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
if (!bubble) {
if (!pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
if (pthreads_set_state(thread, PTHREADS_ST_WAITING TSRMLS_CC)) {
goto burst;
}
} 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)) {
zend_llist *stack = &thread->stack->objects;
if (stack)
counted = stack->count;
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;
} /* }}} */
/* {{{ 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);
if (PTHREADS_IS_WORKER(destination)) {
zend_llist_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->cls = source->cls;
destination->cid = source->cid;
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;
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->address = pthreads_address_alloc(base);
if (PTHREADS_IS_CONNECTION(base)) {
base->tid = pthreads_self();
} else {
base->cid = pthreads_self();
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);
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_llist_init(&base->stack->objects, sizeof(void**), NULL, 1);
}
}
}
} /* }}} */
/* {{{ pthreads base destructor */
static void pthreads_base_dtor(void *arg TSRMLS_DC) {
PTHREAD base = (PTHREAD) arg;
if (PTHREADS_IS_NOT_CONNECTION(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);
if (PTHREADS_IS_WORKER(base)) {
zend_llist_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) {
free(base);
}
} /* }}} */
/* {{{ 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;
} /* }}} */
/* {{{ 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;
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;
if (sscanf((const char*)buffer, "%lu", &address)) {
if (address) {
if (object_init_ex(
*object, pthreads_prepared_entry(address, ce TSRMLS_CC)
)==SUCCESS) {
PTHREAD destination = PTHREADS_FETCH_FROM(*object);
if (pthreads_connect(
address, destination TSRMLS_CC
)==SUCCESS) {
return SUCCESS;
}
}
}
}
return FAILURE;
} /* }}} */
/* {{{ this is aptly named ... */
static void * pthreads_routine(void *arg) {
/* passed the object as argument */
PTHREAD thread = (PTHREAD) arg;
if (thread) {
/* TSRM */
void ***tsrm_ls = NULL;
zend_bool glocked = 0, /* global lock indicator */
worker = 0, /* worker indicator */
inwork = 0; /* working indicator */
/* $this original pointer */
zval *this_ptr;
/* executor globals */
zend_executor_globals *ZEG = NULL;
/**
* Startup Block Begin
**/
/* acquire a global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
/* 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;
/* request startup */
php_request_startup(TSRMLS_C);
/* fix php-fpm compatibility */
SG(sapi_started)=0;
/* do not send headers again */
SG(headers_sent)=1;
SG(request_info).no_headers = 1;
/* prepare environment */
pthreads_prepare(thread TSRMLS_CC);
/* release global lock */
pthreads_globals_unlock(glocked TSRMLS_CC);
/**
* Startup Block End
**/
ZEG = PTHREADS_EG_ALL(TSRMLS_C);
/**
* Thread Block Begin
**/
zend_first_try {
/*
* Set worker indicator
*/
worker = PTHREADS_IS_WORKER(thread);
/*
* Allocate original $this
*/
MAKE_STD_ZVAL(this_ptr);
/* 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) {
/* always the same no point recreating this for every execution */
zval zmethod;
ZVAL_STRINGL(&zmethod, "run", sizeof("run"), 0);
/* execute $this */
do {
zend_function *zrun;
/* find zrun method */
if (zend_hash_find(&(ZEG->scope->function_table), "run", sizeof("run"), (void**) &zrun)==SUCCESS) {
zval *zresult;
zend_fcall_info info;
zend_fcall_info_cache cache;
PTHREAD current = PTHREADS_FETCH_FROM(ZEG->This);
/* populate a cache and call the run method */
{
/* initialize info object */
info.size = sizeof(info);
info.object_ptr = ZEG->This;
info.function_name = &zmethod;
info.retval_ptr_ptr = &zresult;
info.no_separation = 1;
info.symbol_table = NULL;
info.param_count = 0;
info.params = NULL;
/* initialize cache object */
cache.initialized = 1;
cache.function_handler = zrun;
cache.calling_scope = ZEG->scope;
cache.called_scope = ZEG->called_scope;
cache.object_ptr = ZEG->This;
/* call the function */
pthreads_state_set(current->state, PTHREADS_ST_RUNNING TSRMLS_CC);
{
zend_call_function(&info, &cache TSRMLS_CC);
if (current)
pthreads_state_unset(current->state, PTHREADS_ST_RUNNING TSRMLS_CC);
}
#if PHP_VERSION_ID > 50399
{
zend_op_array *ops = &zrun->op_array;
if (ops) {
if (ops->run_time_cache) {
efree(ops->run_time_cache);
ops->run_time_cache = NULL;
}
}
}
#endif
/* deal with references to stackable */
if (inwork) {
zval_ptr_dtor(&ZEG->This);
} else inwork = 1;
/* deal with zresult (ignored) */
if (zresult) {
zval_ptr_dtor(&zresult);
}
}
} else zend_error(E_ERROR, "pthreads has experienced an internal error while trying to execute %s::run", ZEG->scope->name);
} while(worker && pthreads_stack_next(thread, this_ptr TSRMLS_CC));
}
} zend_catch {
/* do something, it's all gone wrong */
} zend_end_try();
/*
* Free original reference to $this
*/
FREE_ZVAL(this_ptr);
/**
* Thread Block End
**/
/**
* Shutdown Block Begin
**/
/* acquire global lock */
pthreads_globals_lock(&glocked TSRMLS_CC);
/* shutdown request */
php_request_shutdown(TSRMLS_C);
/* free interpreter */
tsrm_free_interpreter_context(tsrm_ls);
/* release global lock */
pthreads_globals_unlock(glocked TSRMLS_CC);
/**
* Shutdown Block End
**/
}
pthread_exit(NULL);
#ifdef _WIN32
return NULL; /* silence MSVC compiler */
#endif
}
/* }}} */
#endif
pthreads-0.0.41/src/object.h 0000664 0001750 0001750 00000011223 12100610723 013721 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_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);
/* }}} */
/* {{{ start/join */
int pthreads_start(PTHREAD thread TSRMLS_DC);
int pthreads_join(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-0.0.41/src/prepare.c 0000664 0001750 0001750 00000056342 12100610723 014117 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_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_ctor(zend_property_info *pi); /* }}} */
/* {{{ prepared property info dtor */
static void pthreads_preparation_property_info_dtor(zend_property_info *pi); /* }}} */
#if PHP_VERSION_ID < 50400
/* {{{ default property ctor for 5.3 */
static void pthreads_preparation_default_properties_ctor(zval **property); /* }}} */
/* {{{ default property dtor for 5.3 */
static void pthreads_preparation_default_properties_dtor(zval *property); /* }}} */
#else
/* {{{ trail alias copy for 5.4 */
static zend_trait_alias * pthreads_preparation_copy_trait_alias(PTHREAD thread, zend_trait_alias *alias TSRMLS_DC); /* }}} */
/* {{{ trait precendence for 5.4 */
static zend_trait_precedence * pthreads_preparation_copy_trait_precedence(PTHREAD thread, zend_trait_precedence *precedence TSRMLS_DC); /* }}} */
/* {{{ method reference copy for traits */
static zend_trait_method_reference * pthreads_preparation_copy_trait_method_reference(PTHREAD thread, zend_trait_method_reference *reference TSRMLS_DC); /* }}} */
#endif
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_method_scope(zend_function *function, zend_class_entry *scope TSRMLS_DC); /* }}} */
/* {{{ fix the scope of methods such that self:: and parent:: work everywhere */
static int pthreads_apply_property_scope(zend_property_info *info, zend_class_entry *scope TSRMLS_DC); /* }}} */
/* {{{ prepared resource destructor */
static void pthreads_prepared_resource_dtor(zend_rsrc_list_entry *entry); /* }}} */
/* {{{ 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) {
#if PHP_VERSION_ID > 50399
char *lcname = (char*) emalloc(candidate->name_length+1);
#else
char *lcname = (char*) malloc(candidate->name_length+1);
#endif
if (lcname != NULL) {
/* lowercase name for lookup/insertion */
zend_str_tolower_copy(lcname, candidate->name, candidate->name_length);
/* perform lookup for existing class */
if (zend_hash_find(CG(class_table), lcname, candidate->name_length+1, (void**)&searched)!=SUCCESS) {
zval *tz;
zend_function *tf;
zend_property_info *ti;
/* 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;
prepared->ce_flags = candidate->ce_flags;
/* initialize class data */
zend_initialize_class_data(prepared, 1 TSRMLS_CC);
/* perform inheritance */
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);
case 4: zend_hash_update(&prepared->function_table, "__set", sizeof("__set"), &candidate->__set, sizeof(zend_function), (void**) &prepared->__set);
case 5: zend_hash_update(&prepared->function_table, "__unset", sizeof("__unset"), &candidate->__unset, sizeof(zend_function), (void**) &prepared->__unset);
case 6: zend_hash_update(&prepared->function_table, "__isset", sizeof("__isset"), &candidate->__isset, sizeof(zend_function), (void**) &prepared->__isset);
case 7: zend_hash_update(&prepared->function_table, "__call", sizeof("__call"), &candidate->__call, sizeof(zend_function), (void**) &prepared->__call);
case 8: zend_hash_update(&prepared->function_table, "__callstatic", sizeof("__callstatic"), &candidate->__callstatic, sizeof(zend_function), (void**) &prepared->__callstatic);
case 9: zend_hash_update(&prepared->function_table, "__tostring", sizeof("__tostring"), &candidate->__tostring, sizeof(zend_function), (void**) &prepared->__tostring);
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 */
zend_hash_copy(&prepared->properties_info, &candidate->properties_info, (copy_ctor_func_t) pthreads_preparation_property_info_ctor, &ti, sizeof(zend_property_info));
prepared->properties_info.pDestructor = (dtor_func_t) pthreads_preparation_property_info_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);
}
}
}
}
/** pointless copy **/
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));
/* null doc comments, pointless copy */
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*));
/* update class table */
#if PHP_VERSION_ID > 50399
lcname = (char*)zend_new_interned_string(lcname, prepared->name_length+1, 1 TSRMLS_CC);
if (IS_INTERNED(lcname)) {
zend_hash_quick_update(CG(class_table), lcname, prepared->name_length+1, INTERNED_HASH(lcname), &prepared, sizeof(zend_class_entry*), (void**)&searched);
} else zend_hash_update(CG(class_table), lcname, prepared->name_length+1, &prepared, sizeof(zend_class_entry*), (void**)&searched);
#else
zend_hash_update(CG(class_table), lcname, prepared->name_length+1, &prepared, sizeof(zend_class_entry*), (void**)&searched);
#endif
prepared = *searched;
} else {
prepared = *searched;
}
/* free lowercase name buffer */
#if PHP_VERSION_ID > 50399
str_efree(lcname);
#else
free(lcname);
#endif
} 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;
} /* }}} */
/* {{{ prepares the current context to execute the referenced thread */
void pthreads_prepare(PTHREAD thread TSRMLS_DC){
HashPosition position;
/* inherit ini entries from parent ... */
{
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) && (strcmp(entry[0]->value, entry[1]->value) != 0)) || entry[0]->value) {
zend_bool modifiable = entry[1]->modifiable;
zend_alter_ini_entry_ex(
setting, slength,
entry[0]->value, entry[0]->value_length,
ZEND_INI_STAGE_ACTIVATE, ZEND_INI_SYSTEM, 1 TSRMLS_CC
);
entry[1]->modifiable = modifiable;
}
}
}
}
/* copy 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;
zval pzconstant;
if (!zend_get_constant(zconstant->name, zconstant->name_len-1, &pzconstant 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);
} else zval_dtor(&pzconstant);
}
}
}
/* inherit function table from parent ... */
{
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 ... */
{
zend_class_entry **entry;
HashTable *table[2] = {PTHREADS_CG(thread->cls, class_table), CG(class_table)};
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)) {
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", (*entry)->name, thread->std.ce->name, thread->tid
);
return;
}
} else prepared = *exists;
/*
* fix scope in properties
*/
zend_hash_apply_with_argument(&prepared->properties_info, (apply_func_arg_t) pthreads_apply_property_scope, (void*) prepared TSRMLS_CC);
/*
* fix scope in methods
*/
zend_hash_apply_with_argument(&prepared->function_table, (apply_func_arg_t) pthreads_apply_method_scope, (void*) prepared TSRMLS_CC);
}
}
}
/* merge included files with parent, more compatible than copying ( think apc ) */
{
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;
} /* }}} */
/* {{{ copy property info
@TODO possibly adjust scope here */
static void pthreads_preparation_property_info_ctor(zend_property_info *pi) {} /* }}} */
/* {{{ destroy property info
@TODO possibly undo/free for adjustments made above */
static void pthreads_preparation_property_info_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 < 50600
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 < 50600
copy->function = precedence->function;
#endif
}
return copy;
} /* }}} */
/* {{{ method reference copy for traits */
static zend_trait_method_reference * pthreads_preparation_copy_trait_method_reference(PTHREAD thread, zend_trait_method_reference *reference TSRMLS_DC) {
zend_trait_method_reference *copy = emalloc(sizeof(zend_trait_method_reference));
if (copy) {
copy->mname_len = reference->mname_len;
copy->method_name = estrndup(
reference->method_name,
copy->mname_len
);
copy->cname_len = reference->cname_len;
copy->class_name = estrndup(
reference->class_name,
copy->cname_len
);
copy->ce = pthreads_prepared_entry(
thread, reference->ce TSRMLS_CC
);
}
return copy;
} /* }}} */
#endif
/* {{{ fix method scope for prepared entries, enabling self:: and parent:: to work */
static int pthreads_apply_method_scope(zend_function *function, zend_class_entry *scope TSRMLS_DC) {
if (function && scope) {
zend_op_array *ops = (zend_op_array*) function;
if (ops) {
ops->scope = scope;
}
}
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, zend_class_entry *scope TSRMLS_DC) {
if (info && scope) {
info->ce = scope;
}
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-0.0.41/src/prepare.h 0000664 0001750 0001750 00000003043 12100610723 014112 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_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-0.0.41/src/resources.c 0000664 0001750 0001750 00000005274 12100610723 014471 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_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-0.0.41/src/resources.h 0000664 0001750 0001750 00000003443 12100610723 014472 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_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-0.0.41/src/store.c 0000664 0001750 0001750 00000041031 12100610723 013602 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_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 {
void *data;
size_t length;
zend_uchar type;
zend_bool exists;
long lval;
double dval;
} *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 pthreads_storage pthreads_store_create(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_resources_recursive(zval **pzval TSRMLS_DC);
static int pthreads_store_validate_resource(zval **pzval TSRMLS_DC);
static int pthreads_store_remove_resources(zval **pzval TSRMLS_DC);
static void pthreads_store_storage_dtor (pthreads_storage *element);
static void pthreads_store_event_dtor (pthreads_synchro *element);
/* }}} */
/* {{{ allocate storage for an object */
pthreads_store pthreads_store_alloc(TSRMLS_D) {
pthreads_store store = calloc(1, sizeof(*store));
if (store) {
if (zend_ts_hash_init(&store->table, 8, NULL, (dtor_func_t) pthreads_store_storage_dtor, 1)==SUCCESS){
if (zend_ts_hash_init(&store->event, 8, NULL, (dtor_func_t) pthreads_store_event_dtor, 1)==SUCCESS) {
if ((store->lock = pthreads_lock_alloc(TSRMLS_C))) {
return store;
}
zend_ts_hash_destroy(&store->event);
}
zend_ts_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_ts_hash_exists(&store->table, key, keyl)) {
if (zend_ts_hash_del(&store->table, key, keyl)!=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)) {
pthreads_storage *storage = NULL;
if (zend_ts_hash_find(&store->table, key, keyl, (void**)&storage)==SUCCESS && storage) {
isset=((*storage)->exists);
}
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_ts_hash_find(&store->table, key, keyl, (void**)&storage)==SUCCESS && storage) {
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(*write, 1 TSRMLS_CC);
if (storage) {
if (pthreads_lock_acquire(store->lock, &locked TSRMLS_CC)) {
if (zend_ts_hash_update(&store->table, key, keyl, (void**) &storage, sizeof(storage), NULL)==SUCCESS) {
if (zend_ts_hash_exists(&store->event, key, keyl)) {
pthreads_synchro *psync;
if (zend_ts_hash_find(&store->event, key, keyl, (void**)&psync)==SUCCESS) {
pthreads_synchro_notify(*psync TSRMLS_CC);
}
}
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 (pzval) {
storage = pthreads_store_create(pzval, complex TSRMLS_CC);
if (storage) {
if (allocate) {
MAKE_STD_ZVAL(*separated);
}
result = pthreads_store_convert(storage, *separated TSRMLS_CC);
if (result == SUCCESS)
pthreads_store_storage_dtor(&storage);
}
}
return result;
} /* }}} */
/* {{{ 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)) {
TsHashTable *safe = &store->table;
HashTable *stored = TS_HASH(safe);
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+1, &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_ts_hash_destroy(&store->table);
zend_ts_hash_destroy(&store->event);
pthreads_lock_release(store->lock, locked TSRMLS_CC);
}
pthreads_lock_free(store->lock TSRMLS_CC);
free(store);
store = NULL;
}
} /* }}} */
/* {{{ Will storeize the zval into a newly allocated buffer which must be free'd by the caller */
static pthreads_storage pthreads_store_create(zval *unstore, zend_bool complex TSRMLS_DC){
pthreads_storage storage;
if (unstore) {
/*
* Make an exact copy of the store data for internal storage
*/
storage = (pthreads_storage) calloc(1, sizeof(*storage));
if (storage) {
storage->length = 0;
switch((storage->type = Z_TYPE_P(unstore))){
case IS_NULL:
storage->data = NULL;
storage->exists = 0;
break;
case IS_STRING: {
if ((storage->length = Z_STRLEN_P(unstore))) {
storage->data = (char*) calloc(1, storage->length+1);
memmove(
storage->data, (const void*) Z_STRVAL_P(unstore), storage->length
);
storage->exists = (storage->length > 0);
} else {
storage->data = NULL;
}
} break;
case IS_BOOL:
case IS_LONG: {
storage->exists = ((storage->lval=Z_LVAL_P(unstore)) > 0L);
} break;
case IS_RESOURCE: {
if (complex) {
pthreads_resource resource = calloc(1, sizeof(*resource));
if (resource) {
resource->scope = EG(scope);
resource->ls = TSRMLS_C;
storage->lval = Z_RESVAL_P(unstore);
storage->exists = 1;
storage->data = resource;
zend_list_addref(Z_RESVAL_P(unstore));
}
} else {
storage->exists = 0;
storage->type = IS_NULL;
}
} break;
case IS_DOUBLE: storage->exists = ((storage->dval=Z_DVAL_P(unstore)) > 0.0); 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 {
if (Z_OBJ_HT_P(unstore)->add_ref) {
Z_OBJ_HT_P(unstore)->add_ref(unstore TSRMLS_CC);
}
storage->exists = 1;
}
}
} break;
default: storage->exists = 0;
}
}
}
return storage;
}
/* }}} */
/* {{{ 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: ZVAL_NULL(pzval); break;
case IS_BOOL: ZVAL_BOOL(pzval, storage->lval); break;
case IS_LONG: ZVAL_LONG(pzval, storage->lval); break;
case IS_DOUBLE: ZVAL_DOUBLE(pzval, storage->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->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) {
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->lval);
zend_list_addref(Z_RESVAL_P(pzval));
}
} else {
ZVAL_RESOURCE(pzval, storage->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
);
} break;
default: ZVAL_NULL(pzval);
}
}
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_OBJECT || Z_OBJ_P(pzval))) {
smart_str *psmart = (smart_str*) calloc(1, sizeof(smart_str));
if (psmart) {
if (!complex && (Z_TYPE_P(pzval) == IS_OBJECT || Z_TYPE_P(pzval) == IS_ARRAY)) {
pthreads_store_remove_resources_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 = calloc(1, psmart->len+1);
if (*pstring) {
memmove(
(char*) *pstring, (const void*) psmart->c, psmart->len
);
result = SUCCESS;
}
} else *pstring = NULL;
smart_str_free(psmart);
free(psmart);
}
}
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;
} /* }}} */
/* {{{ set resources to NULL for non-complex types; helper-function for pthreads_store_remove_resources_recursive */
static int pthreads_store_remove_resources(zval **pzval TSRMLS_DC) {
if (Z_TYPE_PP(pzval) == IS_RESOURCE) {
Z_TYPE_PP(pzval) = IS_NULL;
}
return pthreads_store_remove_resources_recursive(pzval TSRMLS_CC);
} /* }}} */
/* {{{ check a handle is valid before reading it */
static int pthreads_store_validate_resource(zval **pzval TSRMLS_DC) {
return (EG(objects_store).top > Z_OBJ_HANDLE_PP(pzval));
} /* }}} */
/* {{{ set corrupt objects (like mysqli after thread duplication) to NULL and recurse */
static int pthreads_store_remove_resources_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_resource(pzval TSRMLS_CC) || !Z_OBJ_P(*pzval)) {
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_resources TSRMLS_CC);
}
break;
}
return ZEND_HASH_APPLY_KEEP;
} /* }}} */
/* {{{ Will free store element */
static void pthreads_store_storage_dtor (pthreads_storage *storage){
if (storage && (*storage)) {
switch ((*storage)->type) {
case IS_OBJECT:
case IS_STRING:
case IS_ARRAY:
case IS_RESOURCE:
if ((*storage)->data) {
free((*storage)->data);
}
break;
}
free((*storage));
}
} /* }}} */
/* {{{ Will free store event */
static void pthreads_store_event_dtor (pthreads_synchro *psync){
TSRMLS_FETCH();
if (psync && (*psync)) {
pthreads_synchro_free(*psync TSRMLS_CC);
}
} /* }}} */
#endif
pthreads-0.0.41/src/store.h 0000664 0001750 0001750 00000005452 12100610723 013616 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_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
#define PTHREADS_STORE_OK 0
#define PTHREADS_STORE_PASS 1
#define PTHREADS_STORE_EMPTY 2
/* {{{ buffer structure */
typedef struct _pthreads_store {
TsHashTable table;
TsHashTable event;
pthreads_lock lock;
} *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); /* }}} */
/* {{{ 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); /* }}} */
/* {{{ free buffers */
void pthreads_store_free(pthreads_store store TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.41/src/state.c 0000664 0001750 0001750 00000011132 12100610723 013565 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 |
+----------------------------------------------------------------------+
*/
/*
* @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) {
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_wait(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-0.0.41/src/state.h 0000664 0001750 0001750 00000004560 12100610723 013601 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_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
#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-0.0.41/src/synchro.c 0000664 0001750 0001750 00000011511 12100610723 014133 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_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
static int pthreads_synchro_lock(pthreads_synchro sync TSRMLS_DC);
static int pthreads_synchro_unlock(pthreads_synchro sync TSRMLS_DC);
/* {{{ 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_try {
/* set argc and argv for function call */
{
info->param_count = argc;
info->params = argv;
info->retval_ptr_ptr = &retval;
}
/* acquire synchronization lock and execute function synchronized */
{
PTHREAD pobject = PTHREADS_FETCH_FROM(getThis());
if (pobject) {
/* synchronized block execution */
{
pthreads_synchro_lock(pobject->synchro TSRMLS_CC);
/* call the closure */
zend_call_function(
info,
cache
TSRMLS_CC
);
pthreads_synchro_unlock(pobject->synchro TSRMLS_CC);
}
/* end synchronization */
}
}
/* return the result */
ZVAL_ZVAL(return_value, retval, 1, ZVAL_PTR_DTOR);
} zend_catch {
/* something horrible happened */
ZVAL_NULL(return_value);
} zend_end_try();
} /* }}} */
/* {{{ 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 */
static int pthreads_synchro_lock(pthreads_synchro sync TSRMLS_DC) {
return pthread_mutex_lock(&sync->lock->mutex);
} /* }}} */
/* {{{ release lock internally for userland synchronization */
static int pthreads_synchro_unlock(pthreads_synchro sync TSRMLS_DC) {
return pthread_mutex_unlock(&sync->lock->mutex);
} /* }}} */
#endif
pthreads-0.0.41/src/synchro.h 0000664 0001750 0001750 00000004225 12100610723 014144 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_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); /* }}} */
/* {{{ 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-0.0.41/src/thread.h 0000664 0001750 0001750 00000011002 12100610723 013715 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_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 {
zend_llist objects;
} *pthreads_stack; /* }}} */
/* {{{ address structure */
typedef struct _pthreads_address {
unsigned char *serial;
size_t length;
} *pthreads_address; /* }}} */
/* {{{ thread structure */
typedef struct _pthread_construct {
/*
* Standard Entry
*/
zend_object std;
/*
* Thread Object
*/
pthread_t thread;
/*
* Thread Scope
*/
int scope;
/*
* Thread Identity and LS
*/
ulong tid;
void ***tls;
/*
* Creator Identity and LS
*/
ulong cid;
void ***cls;
/*
* 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;
/**
* Shared Resources
**/
pthreads_resources resources;
/*
* Store Hold
*/
zend_bool hold;
} *PTHREAD;
/* {{{ comparison function */
static inline int pthreads_equal(PTHREAD first, PTHREAD second) {
if (first && second) {
return (first == second);
}
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;
} /* }}} */
/* {{{ scope constants */
#define PTHREADS_SCOPE_UNKNOWN 0
#define PTHREADS_SCOPE_THREAD 1
#define PTHREADS_SCOPE_WORKER 2
#define PTHREADS_SCOPE_STACKABLE 4
#define PTHREADS_SCOPE_CONNECTION 8
/* }}} */
/* {{{ scope macros */
#define PTHREADS_IS_KNOWN_ENTRY(t) (((t)->scope & PTHREADS_SCOPE_UNKNOWN)!=PTHREADS_SCOPE_UNKNOWN)
#define PTHREADS_IS_CONNECTION(t) (((t)->scope & PTHREADS_SCOPE_CONNECTION)==PTHREADS_SCOPE_CONNECTION)
#define PTHREADS_IS_NOT_CONNECTION(t) (((t)->scope & PTHREADS_SCOPE_CONNECTION)!=PTHREADS_SCOPE_CONNECTION)
#define PTHREADS_IS_THREAD(t) (((t)->scope & PTHREADS_SCOPE_THREAD)==PTHREADS_SCOPE_THREAD)
#define PTHREADS_IS_NOT_THREAD(t) (((t)->scope & PTHREADS_SCOPE_THREAD)!=PTHREADS_SCOPE_THREAD)
#define PTHREADS_IS_WORKER(t) (((t)->scope & PTHREADS_SCOPE_WORKER)==PTHREADS_SCOPE_WORKER)
#define PTHREADS_IS_NOT_WORKER(t) (((t)->scope & PTHREADS_SCOPE_WORKER)!=PTHREADS_SCOPE_WORKER)
#define PTHREADS_IS_STACKABLE(t) (((t)->scope & PTHREADS_SCOPE_STACKABLE)==PTHREADS_SCOPE_STACKABLE)
#define PTHREADS_IS_NOT_STACKABLE(t) (((t)->scope & PTHREADS_SCOPE_STACKABLE)!=PTHREADS_SCOPE_STACKABLE)
/* }}} */
/* {{{ 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-0.0.41/classes/thread.h 0000664 0001750 0001750 00000023535 12100610723 014601 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, isStarted);
PHP_METHOD(Thread, isRunning);
PHP_METHOD(Thread, isJoined);
PHP_METHOD(Thread, isWaiting);
PHP_METHOD(Thread, getThreadId);
PHP_METHOD(Thread, getCreatorId);
PHP_METHOD(Thread, synchronized);
PHP_METHOD(Thread, lock);
PHP_METHOD(Thread, unlock);
ZEND_BEGIN_ARG_INFO_EX(Thread_start, 0, 0, 0)
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_getThreadId, 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_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()
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, 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, getThreadId, Thread_getThreadId, 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)
{NULL, NULL, NULL}
};
/* {{{ proto boolean Thread::start()
Starts executing the implementations run method in a thread, will return a boolean indication of success */
PHP_METHOD(Thread, start)
{
PTHREAD thread = PTHREADS_FETCH;
int result = FAILURE;
/*
* 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::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 long Thread::getThreadId()
Will return the identifier of the referenced Thread */
PHP_METHOD(Thread, getThreadId)
{
if (getThis()) {
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->tid);
} else ZVAL_LONG(return_value, pthreads_self());
} /* }}} */
/* {{{ 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));
} /* }}} */
# endif
#endif
pthreads-0.0.41/classes/worker.h 0000664 0001750 0001750 00000021274 12100610723 014641 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, shutdown);
PHP_METHOD(Worker, isStarted);
PHP_METHOD(Worker, isShutdown);
PHP_METHOD(Worker, isWorking);
PHP_METHOD(Worker, stack);
PHP_METHOD(Worker, unstack);
PHP_METHOD(Worker, getStacked);
PHP_METHOD(Worker, getThreadId);
PHP_METHOD(Worker, getCreatorId);
ZEND_BEGIN_ARG_INFO_EX(Worker_start, 0, 0, 0)
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_stack, 0, 0, 1)
ZEND_ARG_INFO(0, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_unstack, 0, 0, 0)
ZEND_ARG_INFO(0, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Worker_getStacked, 0, 0, 0)
ZEND_END_ARG_INFO()
extern zend_function_entry pthreads_worker_methods[];
#else
# ifndef HAVE_PTHREADS_CLASS_WORKER
# define HAVE_PTHREADS_CLASS_WORKER
zend_function_entry pthreads_worker_methods[] = {
PHP_ME(Worker, start, Worker_start, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ABSTRACT_ME(Worker, run, Worker_run)
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)
{NULL, NULL, NULL}
};
/* {{{ proto boolean Worker::start()
Starts a new Worker Thread, executing the Workers implementation of Worker::run and then waiting for Stackables */
PHP_METHOD(Worker, start)
{
PTHREAD thread = PTHREADS_FETCH;
int result = FAILURE;
/*
* 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) {
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) {
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::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);
} /* }}} */
# endif
#endif
pthreads-0.0.41/classes/stackable.h 0000664 0001750 0001750 00000013466 12100610723 015265 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, wait);
PHP_METHOD(Stackable, notify);
PHP_METHOD(Stackable, isRunning);
PHP_METHOD(Stackable, isWaiting);
PHP_METHOD(Stackable, synchronized);
PHP_METHOD(Stackable, lock);
PHP_METHOD(Stackable, unlock);
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_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()
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_ABSTRACT_ME(Stackable, run, Stackable_run)
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, 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)
{NULL, NULL, NULL}
};
/* {{{ 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 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));
} /* }}} */
# endif
#endif
pthreads-0.0.41/classes/mutex.h 0000664 0001750 0001750 00000017745 12100610723 014502 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-0.0.41/classes/cond.h 0000664 0001750 0001750 00000017253 12100610723 014255 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-0.0.41/config.m4 0000664 0001750 0001750 00000001355 12100610723 013227 0 ustar joe joe PHP_ARG_ENABLE(pthreads, whether to enable Threading API,
[ --enable-pthreads Enable Threading API])
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
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-0.0.41/config.w32 0000664 0001750 0001750 00000003504 12100610723 013320 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 |
+----------------------------------------------------------------------+
*/
PTHREADS_EXT_NAME="pthreads";
PTHREADS_EXT_SRC="lock.c globals.c prepare.c synchro.c state.c store.c resources.c modifiers.c handlers.c object.c";
PTHREADS_EXT_DIR="ext/pthreads/src";
PTHREADS_EXT_API="php_pthreads.c";
PTHREADS_EXT_FLAGS="/I" + configure_module_dirname;
PTHREADS_EXT_DEP="pthreadVC2.lib";
/* --------------------------------------------------------------------- */
ARG_ENABLE("pthreads", "for pthreads support", "no");
if (PHP_PTHREADS != "no") {
CHECK_LIB(PTHREADS_EXT_DEP, PTHREADS_EXT_NAME, PHP_PTHREADS);
EXTENSION(PTHREADS_EXT_NAME, PTHREADS_EXT_API, PHP_PTHREADS_SHARED, PTHREADS_EXT_FLAGS);
ADD_SOURCES(
PTHREADS_EXT_DIR,
PTHREADS_EXT_SRC,
PTHREADS_EXT_NAME
);
}
pthreads-0.0.41/LICENSE 0000664 0001750 0001750 00000006153 12100610723 012526 0 ustar joe joe --------------------------------------------------------------------
The PHP License, version 3.01
Copyright (c) 1999 - 2011 The PHP Group. 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
".
THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND
ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PHP
DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------
The PHP Group can be contacted via Email at group@php.net.
For more information on the PHP Group and the PHP project,
please see .
PHP includes the Zend Engine, freely available at
.
pthreads-0.0.41/php_pthreads.c 0000664 0001750 0001750 00000014165 12100610723 014350 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_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_object_handlers pthreads_handlers;
zend_object_handlers *zend_handlers;
void ***pthreads_instance = NULL;
#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)
static inline void pthreads_globals_ctor(zend_pthreads_globals *pg TSRMLS_DC) {
pg->pointer = NULL;
}
PHP_MINIT_FUNCTION(pthreads)
{
zend_class_entry te;
zend_class_entry me;
zend_class_entry ce;
zend_class_entry se;
zend_class_entry we;
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);
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);
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);
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;
/*
* Setup standard and pthreads object handlers
*/
zend_handlers = zend_get_std_object_handlers();
memcpy(&pthreads_handlers, zend_handlers, sizeof(zend_object_handlers));
pthreads_handlers.get_debug_info = pthreads_read_debug;
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;
ZEND_INIT_MODULE_GLOBALS(pthreads, pthreads_globals_ctor, NULL);
if (pthreads_globals_init(TSRMLS_C)) {
/*
* Global Init
*/
pthreads_instance = TSRMLS_C;
}
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
#endif
pthreads-0.0.41/php_pthreads.h 0000664 0001750 0001750 00000003451 12100610723 014351 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_PHP_PTHREADS_H
#define HAVE_PHP_PTHREADS_H
#define PHP_PTHREADS_EXTNAME "pthreads"
#define PHP_PTHREADS_VERSION "0.41"
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
extern zend_module_entry pthreads_module_entry;
#define phpext_pthreads_ptr &pthreads_module_entry
#endif
pthreads-0.0.41/README.md 0000664 0001750 0001750 00000011530 12100610723 012773 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
* Seemless 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, compatibiilty and efficiency in mind, it's performance beggars belief !!
## Requirements
* PHP5.3+ on x64 or x86
* ZTS Enabled ( Thread Safety )
* Posix Threads implementation that PHP will compile with
Testing has been carried out both on x86 and x64 architechtures with varying hardware, this code may work in untested environments, keep me updated ...
### 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/
Snapshots for Windows can (sometimes) be found: http://pthreads.org/snapshots/
### 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.
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.