package.xml 0000644 0000000 0000000 00000012653 12046565267 011715 0 ustar root root
pthreadspecl.php.netThreading APIA compatible Threading API for PHP5.3+Joe Watkinskrakjoepthreads@pthreads.orgyes2012-11-070.0.370.0.37betabetaPHP License
default properties working as expected
leaks from default properties plugged
advancements in state detection
cleanup of PHP API, methods / parameters / classes etc ( final )
stability improvements, various
object functionality improvements
storage improvements, various
5.3.01.4.0b1pthreads
pthreads-0.0.37/examples/AdvancedSynchronization.php 0000644 0000000 0000000 00000006254 12046565267 021313 0 ustar root root 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.37/examples/CallAnyFunction.php 0000644 0000000 0000000 00000004272 12046565267 017513 0 ustar root root 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.37/examples/Mutexes.php 0000644 0000000 0000000 00000003065 12046565267 016113 0 ustar root root 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.37/examples/Fetch.php 0000644 0000000 0000000 00000003076 12046565267 015514 0 ustar root root 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.37/examples/Notifications.php 0000644 0000000 0000000 00000002014 12046565267 017263 0 ustar root root 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.37/examples/ObjectsAsParameters.php 0000644 0000000 0000000 00000006075 12046565267 020366 0 ustar root root 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(($response = $this->response)){
if($response->getUrl()){
$response->setStart(microtime(true));
$response->setData(file_get_contents($response->url));
$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.37/examples/Objects.php 0000644 0000000 0000000 00000012241 12046565267 016046 0 ustar root root 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 function __construct($storage) {
$this->storage = $storage;
$this->stored = 0;
print_r($this);
}
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)
);
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);
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<2) {
/* 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.37/examples/Pooling.php 0000644 0000000 0000000 00000011643 12046565267 016071 0 ustar root root 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", $worker->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.37/examples/Scope.php 0000644 0000000 0000000 00000003727 12046565267 015537 0 ustar root root 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));
return $this->data;
}
}
/*
* 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.37/examples/SimpleWebRequest.php 0000644 0000000 0000000 00000001657 12046565267 017726 0 ustar root root url = $url;
}
public function run(){
if($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($this->url);
} else printf("Thread #%lu was not provided a URL\n", $this->getThreadId());
return strlen($this->data);
}
}
$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.37/examples/Stacking.php 0000644 0000000 0000000 00000005570 12046565267 016227 0 ustar root root 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.37/tests/mutex.phpt 0000644 0000000 0000000 00000000555 12046565267 015334 0 ustar root root --TEST--
Test mutex operations
--DESCRIPTION--
This test will ensures mutex functionality, including error checking
--FILE--
--EXPECT--
bool(true)
bool(false)
bool(true)
bool(true)
pthreads-0.0.37/tests/oomethods.phpt 0000644 0000000 0000000 00000000662 12046565267 016172 0 ustar root root --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())
var_dump($thread->objectTest());
?>
--EXPECT--
int(1) pthreads-0.0.37/tests/staticmethods.phpt 0000644 0000000 0000000 00000000740 12046565267 017041 0 ustar root root --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--
start())
var_dump($thread->join());
?>
--EXPECT--
int(1) pthreads-0.0.37/tests/thread.phpt 0000644 0000000 0000000 00000000533 12046565267 015435 0 ustar root root --TEST--
Test basic threading
--DESCRIPTION--
This test will create and join a simple thread
--FILE--
start())
var_dump($thread->join());
?>
--EXPECT--
int(100) pthreads-0.0.37/tests/wait.phpt 0000644 0000000 0000000 00000000527 12046565267 015135 0 ustar root root --TEST--
Test wait/notify
--DESCRIPTION--
This test will verify wait/notify functionality
--FILE--
notify();
}
}
$thread = new ThreadTest();
if($thread->start(true)) {
var_dump($thread->join()); /* should return int 1 */
}
?>
--EXPECT--
int(1) pthreads-0.0.37/src/pthreads.h 0000644 0000000 0000000 00000004425 12046565267 014705 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
#include
#ifndef _WIN32
#define _GNU_SOURCE
#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
zend_class_entry *pthreads_thread_entry;
zend_class_entry *pthreads_worker_entry;
zend_class_entry *pthreads_stackable_entry;
zend_class_entry *pthreads_mutex_entry;
zend_class_entry *pthreads_condition_entry;
zend_class_entry *pthreads_exception_entry;
zend_object_handlers pthreads_handlers;
zend_object_handlers *zend_handlers;
#endif
pthreads-0.0.37/src/globals.c 0000644 0000000 0000000 00000010555 12046565267 014512 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
/* {{{ pthreads_globals_init */
void pthreads_globals_init(){
if (!PTHREADS_G(init)) {
PTHREADS_G(init)=1;
PTHREADS_G(peak)=0;
PTHREADS_G(nid)=1;
PTHREADS_G(importing)=INI_BOOL("pthreads.importing");
PTHREADS_G(max)=INI_INT("pthreads.max");
pthread_mutex_init(&PTHREADS_G(lock), &defmutex);
zend_llist_init(&PTHREADS_G(objects), sizeof(void**), NULL, 1);
}
} /* }}} */
/* {{{ pthreads_globals_lock */
int pthreads_globals_lock(int *acquired){
switch (pthread_mutex_lock(&PTHREADS_G(lock))) {
case SUCCESS:
return (((*acquired)=1)==1);
case EDEADLK:
return (((*acquired)=0)==0);
default: return (((*acquired)=0)==1);
}
} /* }}} */
/* {{{ pthreads_globals_unlock */
void pthreads_globals_unlock(int *acquired) {
if ((*acquired)==1) {
pthread_mutex_unlock(&PTHREADS_G(lock));
}
} /* }}} */
/* {{{ pthreads_globals_count */
size_t pthreads_globals_count() {
size_t result = 0L;
int locked;
if (pthreads_globals_lock(&locked)) {
result = PTHREADS_G(objects).count;
pthreads_globals_unlock(&locked);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
return result;
} /* }}} */
/* {{{ pthreads_globals_add */
void pthreads_globals_add(PTHREAD thread) {
int locked;
if (pthreads_globals_lock(&locked)) {
PTHREADS_LIST_INSERT(
&PTHREADS_G(objects), thread
);
if (PTHREADS_G(peak)gid = ++PTHREADS_G(nid);
pthreads_globals_unlock(&locked);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
} /* }}} */
/* {{{ pthreads_globals_del */
void pthreads_globals_del(PTHREAD thread) {
int locked;
if (pthreads_globals_lock(&locked)) {
PTHREADS_LIST_REMOVE(&PTHREADS_G(objects), thread);
pthreads_globals_unlock(&locked);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
} /* }}} */
/* {{{ pthreads_globals_peak */
long pthreads_globals_peak() {
long result = 0L;
int locked;
if (pthreads_globals_lock(&locked)) {
result = PTHREADS_G(peak);
pthreads_globals_unlock(&locked);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
return result;
} /* }}} */
/* {{{ pthreads_globals_find */
PTHREAD pthreads_globals_find(ulong tid) {
PTHREAD search = NULL;
zend_bool found = 0;
int locked = 0;
if (pthreads_globals_lock(&locked)) {
PTHREADS_LIST_BEGIN_LOOP(&PTHREADS_G(objects), search)
if (search->tid == tid) {
found = 1;
break;
}
PTHREADS_LIST_END_LOOP(&PTHREADS_G(objects), search)
pthreads_globals_unlock(&locked);
}
if (found) {
return search;
} else return NULL;
} /* }}} */
/* {{{ pthreads_globals_fetch */
PTHREAD pthreads_globals_fetch(ulong gid) {
PTHREAD search = NULL;
zend_bool fetched = 0;
int locked = 0;
if (pthreads_globals_lock(&locked)) {
PTHREADS_LIST_BEGIN_LOOP(&PTHREADS_G(objects), search)
if (search->gid == gid) {
fetched = 1;
break;
}
PTHREADS_LIST_END_LOOP(&PTHREADS_G(objects), search)
pthreads_globals_unlock(&locked);
}
if (fetched) {
return search;
} else return NULL;
} /* }}} */
#endif
pthreads-0.0.37/src/globals.h 0000644 0000000 0000000 00000006500 12046565267 014512 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
* 2. providing a mechanism for limiting the threads a user can create may be useful to server admin in shared hosting environments
* 3. providing peak usage and current realtime statistics can help you to design and execute more efficiently
* 4. these globals are completely safe; they are protected by mutex
* 5. in some SAPI environments it may not make sense to use pthreads.max ini setting, that is for the server administrator to decide
* 6. in some SAPI environments it may make sense to disable importing Threads for security reasons, pthreads.importing should be set to 0
* 7. pthreads.* ini settings are system only for security
*
* TODO
* 1. make errors more meaningful
*/
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ pthreads_globals */
struct {
/*
* Initialized flag
*/
zend_bool init;
/*
* Globals Mutex
*/
pthread_mutex_t lock;
/*
* Peak Number of Objects
*/
size_t peak;
/*
* Maximum number of Objects
*/
size_t max;
/*
* Flag for disable/enable importing
*/
zend_bool importing;
/*
* Objects
*/
zend_llist objects;
/*
* Next Object Identifier
*/
ulong nid;
} pthreads_globals; /* }}} */
/* {{{ PTHREADS_G */
#define PTHREADS_G(v) pthreads_globals.v
/* }}} */
/* {{{ initialize (true) globals */
void pthreads_globals_init(); /* }}} */
/* {{{ acquire global lock */
int pthreads_globals_lock(int *acquired); /* }}} */
/* {{{ release global lock */
void pthreads_globals_unlock(int *acquired); /* }}} */
/* {{{ get current number of accessible objects */
size_t pthreads_globals_count(); /* }}} */
/* {{{ push an object into global list */
void pthreads_globals_add(PTHREAD thread); /* }}} */
/* {{{ pop an object from global list */
void pthreads_globals_del(PTHREAD thread); /* }}} */
/* {{{ get peak number of accessible objects */
long pthreads_globals_peak(); /* }}} */
/* {{{ find an object using internal ids */
PTHREAD pthreads_globals_fetch(ulong target); /* }}} */
#endif /* HAVE_PTHREADS_GLOBAL_H */
pthreads-0.0.37/src/handlers.c 0000644 0000000 0000000 00000024341 12046565267 014665 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 a property from a thread, wherever it is available */
zval * pthreads_read_property (PTHREADS_READ_PROPERTY_PASSTHRU_D) {
zval *value = NULL;
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (Z_TYPE_P(member)==IS_STRING) {
if (pthreads_store_read(
pthreads->store,
Z_STRVAL_P(member), Z_STRLEN_P(member),
&value TSRMLS_CC
)!=SUCCESS) {
value = zend_handlers->read_property(PTHREADS_READ_PROPERTY_PASSTHRU_C);
} else zend_handlers->write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_C);
} else value = zend_handlers->read_property(PTHREADS_READ_PROPERTY_PASSTHRU_C);
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);
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_BOOL: {
if (pthreads_store_write(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &value TSRMLS_CC)!=SUCCESS){
zend_error_noreturn(
E_WARNING,
"pthreads failed to write member %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member)
);
} else zend_handlers->write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_C);
} break;
default: zend_handlers->write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_C);
}
} else zend_handlers->write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_C);
}
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;
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (!(isset = pthreads_store_isset(
pthreads->store,
Z_STRVAL_P(member), Z_STRLEN_P(member),
has_set_exists TSRMLS_CC
))) {
isset = zend_handlers->has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_C);
}
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) {
PTHREAD pthreads = PTHREADS_FETCH_FROM(object);
if (pthreads_store_delete(pthreads->store, Z_STRVAL_P(member), Z_STRLEN_P(member) TSRMLS_CC)!=SUCCESS){
zend_error_noreturn(
E_WARNING,
"pthreads has experienced an internal error while deleting %s::$%s",
Z_OBJCE_P(object)->name, Z_STRVAL_P(member)
);
}
zend_handlers->unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_C);
}
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, acquire = 0, argc = ZEND_NUM_ARGS(), access = ZEND_ACC_PUBLIC, mlength = 0;
char *lcname;
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_noreturn(
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) {
acquire = pthreads_modifiers_protect(thread->modifiers, method TSRMLS_CC);
} else acquire = EDEADLK;
if (acquire == SUCCESS || acquire == EDEADLK) {
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(called_scope);
cache.called_scope = scope;
cache.object_ptr = getThis();
if ((called=zend_call_function(&info, &cache TSRMLS_CC))!=SUCCESS) {
zend_error_noreturn(
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
);
} else {
#if PHP_VERSION_ID > 50399
{
zend_op_array *ops = &call->op_array;
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) {
if (acquire != EDEADLK) {
pthreads_modifiers_unprotect(thread->modifiers, method TSRMLS_CC);
}
}
} else {
zend_error_noreturn(
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_noreturn(
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.37/src/handlers.h 0000644 0000000 0000000 00000013712 12046565267 014672 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 are mutex aware for safer operation in multi-threaded applications
*/
#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_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_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 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.37/src/modifiers.c 0000644 0000000 0000000 00000012176 12046565267 015051 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_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) {
zend_uint *modified = calloc(1, sizeof(*modified));
{
*modified = modify;
if (zend_hash_add(
&modifiers->modified,
method, sizeof(method),
(void**) &modified, sizeof(zend_uint*),
NULL
)==SUCCESS) {
pthread_mutex_t *lock = calloc(1, sizeof(*lock));
if (lock) {
pthread_mutex_init(lock, &defmutex);
return zend_hash_add(
&modifiers->protection,
method, sizeof(method),
(void**) &lock, sizeof(pthread_mutex_t*),
NULL
);
}
}
}
return FAILURE;
} /* }}} */
/* {{{ get access modifier for method */
zend_uint pthreads_modifiers_get(pthreads_modifiers modifiers, const char *method TSRMLS_DC) {
zend_uint **modified;
if (zend_hash_find(
&modifiers->modified,
method, sizeof(method),
(void**) &modified
)==SUCCESS) {
return **modified;
}
return 0;
} /* }}} */
/* {{{ protect a method call */
int pthreads_modifiers_protect(pthreads_modifiers modifiers, const char *method TSRMLS_DC) {
pthread_mutex_t **protection;
if (zend_hash_find(&modifiers->protection, method, sizeof(method), (void**)&protection)==SUCCESS) {
return pthread_mutex_lock(*protection);
} else return FAILURE;
} /* }}} */
/* {{{ unprotect a method call */
int pthreads_modifiers_unprotect(pthreads_modifiers modifiers, const char *method TSRMLS_DC) {
pthread_mutex_t **protection;
if (zend_hash_find(&modifiers->protection, method, sizeof(method), (void**)&protection)==SUCCESS) {
return pthread_mutex_unlock(*protection);
} else return FAILURE;
} /* }}} */
/* {{{ 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) {
zend_uint *modified = (zend_uint *) *element;
if (modified && *modified) {
free(modified);
}
} /* }}} */
/* {{{ destructor callback for modifiers (protection) hash table */
static void pthreads_modifiers_protection_dtor(void **element) {
pthread_mutex_t *protection = (pthread_mutex_t *) *element;
if (protection) {
pthread_mutex_destroy(protection);
free(protection);
}
} /* }}} */
#endif
pthreads-0.0.37/src/modifiers.h 0000644 0000000 0000000 00000004461 12046565267 015054 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 */
int pthreads_modifiers_protect(pthreads_modifiers modifiers, const char *method TSRMLS_DC); /* }}} */
/* {{{ unprotect a method call */
int pthreads_modifiers_unprotect(pthreads_modifiers modifiers, const char *method TSRMLS_DC); /* }}} */
/* {{{ free modifiers object */
void pthreads_modifiers_free(pthreads_modifiers modifiers TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.37/src/object.c 0000644 0000000 0000000 00000054340 12046565267 014335 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
/* {{{ pthreads module entry */
extern zend_module_entry pthreads_module_entry; /* }}} */
/* {{{ 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 */
int pthreads_set_state_ex(PTHREAD thread, int mask, long timeout TSRMLS_DC) {
int result = 0;
if (mask & PTHREADS_ST_WAITING) {
int slocked = pthreads_state_lock(thread->state TSRMLS_CC);
int dowait = 0;
if (slocked == SUCCESS ||slocked == EDEADLK) {
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 (slocked != EDEADLK)
pthreads_state_unlock(thread->state 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 */
int 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 */
int pthreads_unset_state(PTHREAD thread, int mask TSRMLS_DC){
int 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 */
int pthreads_stack_pop(PTHREAD thread, PTHREAD work TSRMLS_DC) {
int acquire = 0;
int remain = 0;
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
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;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else remain = -1;
return remain;
} /* }}} */
/* {{{ push an item onto the work buffer */
int pthreads_stack_push(PTHREAD thread, PTHREAD work TSRMLS_DC) {
int acquire = 0;
int counted = -1;
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
zend_llist *stack = &thread->stack->objects;
if (stack) {
zend_llist_add_element(
stack, &work
);
counted = stack->count;
} else counted = -1;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
if (counted > 0) {
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 */
int pthreads_stack_next(PTHREAD thread, zval *this_ptr TSRMLS_DC) {
PTHREAD *work = NULL;
PTHREAD current = NULL;
int acquire = 0;
int bubble = 0;
zval *that_ptr;
zend_function *run;
burst:
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
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
)
);
/*
* Switch scope to the next stackable
*/
if (zend_hash_find(&Z_OBJCE_P(that_ptr)->function_table, "run", sizeof("run"), (void**) &run)==SUCCESS) {
/*
* Setup Executor
*/
EG(This)=that_ptr;
EG(scope)=Z_OBJCE_P(that_ptr);
EG(called_scope)=Z_OBJCE_P(that_ptr);
/*
* 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);
if (zend_hash_update(
Z_OBJPROP_P(that_ptr), "worker", sizeof("worker"),
(void**) &getThis(), sizeof(zval*), NULL
)==SUCCESS) {
Z_ADDREF_P(getThis());
}
}
}
/*
* Cleanup List
*/
zend_llist_del_element(stack, work, (int (*)(void *, void *)) pthreads_equal_func);
}
}
}
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
}
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 */
int pthreads_stack_length(PTHREAD thread TSRMLS_DC) {
int acquire = 0;
int counted = -1;
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
zend_llist *stack = &thread->stack->objects;
if (stack)
counted = stack->count;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else counted = -1;
return counted;
} /* }}} */
/* {{{ import a thread created in another context into the current context */
int pthreads_import(PTHREAD thread, zval** return_value TSRMLS_DC){
int acquire = 0;
int imported = 1;
if (!PTHREADS_IN_CREATOR(thread)) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
/*
* Initialize the object in this context
*/
if (object_init_ex(
*return_value,
pthreads_prepared_entry
(
thread,
thread->std.ce TSRMLS_CC
)
)==SUCCESS) {
pthreads_connect(thread, PTHREADS_FETCH_FROM(*return_value) TSRMLS_CC);
} else { imported = 0; }
if (acquire != EDEADLK) {
pthread_mutex_unlock(thread->lock);
}
} else imported = 0;
} else imported = 0;
return imported;
} /* }}} */
/* {{{ 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_globals_del(destination);
if (destination->lock) {
pthread_mutex_destroy(destination->lock);
free(destination->lock);
}
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);
if (PTHREADS_IS_WORKER(destination)) {
zend_llist_destroy(&destination->stack->objects);
free(destination->stack);
}
destination->scope |= PTHREADS_SCOPE_CONNECTION;
destination->target = source->gid;
return pthreads_connect
(
source,
destination TSRMLS_CC
);
}
destination->thread = source->thread;
destination->tid = source->tid;
destination->tls = source->tls;
destination->cid = source->cid;
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
if (PTHREADS_IS_CONNECTION(base)) {
base->tid = pthreads_self();
base->tls = tsrm_ls;
} else {
base->target = 0L;
base->cid = pthreads_self();
base->cls = tsrm_ls;
if ((base->lock = (pthread_mutex_t*) calloc(1, sizeof(pthread_mutex_t)))!=NULL) {
pthread_mutex_init(base->lock, &defmutex);
}
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);
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_globals_add(base);
}
pthreads_prepare_classes_init(base TSRMLS_CC);
}
} /* }}} */
/* {{{ 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_globals_del(base);
if (base->lock) {
pthread_mutex_destroy(base->lock);
free(base->lock);
}
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);
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
pthreads_prepare_classes_free(
base TSRMLS_CC
);
} /* }}} */
/* {{{ 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;
int tlocked = FAILURE;
int slocked = pthreads_state_lock(thread->state TSRMLS_CC);
if (slocked == SUCCESS||slocked == EDEADLK) {
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 != EDEADLK)
pthreads_state_unlock(thread->state TSRMLS_CC);
}
if (dostart) {
tlocked = pthread_mutex_lock(thread->lock);
if (tlocked == SUCCESS||tlocked == EDEADLK) {
started = pthread_create(&thread->thread, NULL, pthreads_routine, (void*)thread);
if (started == SUCCESS)
pthreads_state_wait(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC);
if (tlocked != EDEADLK)
pthread_mutex_unlock(thread->lock);
}
}
return started;
} /* }}} */
/* {{{ gracefully join a pthread object */
int pthreads_join(PTHREAD thread TSRMLS_DC) {
int dojoin = 0;
int donotify = 0;
int slocked = pthreads_state_lock(thread->state TSRMLS_CC);
if (slocked == SUCCESS || slocked == EDEADLK) {
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 != EDEADLK)
pthreads_state_unlock(thread->state 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;
} /* }}} */
/* {{{ 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) = (char*) emalloc(64);
if ((*buffer)) {
(*blength) = sprintf(
(*buffer),
"%lu",
(threaded->target > 0L) ? threaded->target : threaded->gid
)+1;
return SUCCESS;
}
}
return FAILURE;
} /* }}} */
/* {{{ connects to an instance of a threaded object */
int pthreads_internal_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buffer, zend_uint blength, zend_unserialize_data *data TSRMLS_DC) {
ulong target;
if (sscanf((char*)buffer, "%lu", &target)) {
PTHREAD source = pthreads_globals_fetch(target);
if (source) {
if (object_init_ex(
*object, pthreads_prepared_entry(source, ce TSRMLS_CC)
)==SUCCESS) {
PTHREAD destination = PTHREADS_FETCH_FROM(*object);
if (pthreads_connect(
source, destination TSRMLS_CC
)==SUCCESS) {
INIT_PZVAL(*object);
return SUCCESS;
}
} else printf("failed to initialize object %s\n", buffer);
} else printf("failed to fetch %lu\n", target);
} else printf("failed to scanf %s\n", buffer);
return FAILURE;
} /* }}} */
/* {{{ this is aptly named ... */
static void * pthreads_routine(void *arg) {
/*
* The thread object
*/
PTHREAD thread = (PTHREAD) arg;
if (thread) {
/*
* Thread safe storage
*/
void ***tsrm_ls;
/*
* Global lock acquisition indicator
*/
int glocked;
/*
* Startup Block
*/
{
/*
* Acquire Global Lock
*/
pthreads_globals_lock(&glocked);
/*
* Allocate Context
*/
tsrm_ls = tsrm_new_interpreter_context();
/*
* Set Context/TSRMLS
*/
tsrm_set_interpreter_context(tsrm_ls);
/*
* Set Thread Identifier
*/
thread->tid = pthreads_self();
/*
* Activate Zend
*/
#if COMPILE_DL_PTHREADS
/*
* Same server context as parent
*/
SG(server_context)=PTHREADS_SG(thread->cls, server_context);
/*
* Stops PHP from attempting to add headers to null structs
*/
PG(expose_php) = 0;
PG(auto_globals_jit) = 0;
/*
* Startup the request ...
*/
php_request_startup(TSRMLS_C);
/*
* Stop any pointless output from threads
*/
SG(headers_sent)=1;
SG(request_info).no_headers = 1;
#else
/*
* Not nearly as much work !!
*/
zend_activate(TSRMLS_C);
zend_activate_modules(TSRMLS_C);
#endif
/*
* Prepare for Execution
*/
pthreads_prepare(thread TSRMLS_CC);
/*
* Release global lock
*/
pthreads_globals_unlock(&glocked);
}
/*
* Thread Block
*/
{
/*
* Pointers to the usual
*/
zval *this_ptr = NULL;
/*
* A new reference to $this for the current context
*/
MAKE_STD_ZVAL(this_ptr);
/*
* Set bailout address
*/
zend_first_try {
/*
* First some basic executor setup
*/
EG(in_execution) = 1;
EG(current_execute_data)=NULL;
EG(current_module)=&pthreads_module_entry;
/*
* Initialize thread and connection
*/
{
/*
* Initialize $this
*/
object_init_ex
(
EG(This)=getThis(),
EG(scope) = pthreads_prepared_entry
(
thread,
thread->std.ce TSRMLS_CC
)
);
/*
* Make connection
*/
pthreads_connect(thread, PTHREADS_FETCH_FROM(EG(This)) TSRMLS_CC);
}
/*
* Runtime ...
*/
{
/* always the same no point recreating this for every execution */
zval zmethod;
ZVAL_STRINGL(&zmethod, "run", sizeof("run"), 0);
/*
* Now time to execute ::run
*/
do {
zend_function *zrun;
/* find zrun method */
if (zend_hash_find(&EG(scope)->function_table, "run", sizeof("run"), (void**) &zrun)==SUCCESS) {
zval *zresult;
zend_fcall_info info;
zend_fcall_info_cache cache;
/* populate a cache and call the run method */
{
/* set if not set explicitly elsewhere */
if (!EG(called_scope)) {
EG(called_scope)=EG(scope);
}
/* initialize info object */
info.size = sizeof(info);
info.object_ptr = EG(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 = EG(scope);
cache.called_scope = EG(called_scope);
cache.object_ptr = EG(This);
/* call the function */
pthreads_state_set((PTHREADS_FETCH_FROM(EG(This)))->state, PTHREADS_ST_RUNNING TSRMLS_CC);
if (zend_call_function(&info, &cache TSRMLS_CC)!=SUCCESS) {
pthreads_state_unset((PTHREADS_FETCH_FROM(EG(This)))->state, PTHREADS_ST_RUNNING TSRMLS_CC);
zend_error_noreturn(E_ERROR, "pthreads has experienced an internal error while calling %s::run", EG(scope)->name);
break;
} else pthreads_state_unset((PTHREADS_FETCH_FROM(EG(This)))->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 zresult (ignored) */
if (zresult) {
zval_ptr_dtor(&zresult);
}
}
} else zend_error_noreturn(E_ERROR, "pthreads has experienced an internal error while trying to execute %s::run", EG(scope)->name);
} while(PTHREADS_IS_WORKER(thread) && pthreads_stack_next(thread, getThis() TSRMLS_CC));
}
} zend_catch {
/* do something, it's all gone wrong */
} zend_end_try();
}
/*
* Shutdown Block
*/
{
/*
* Acquire global lock
*/
pthreads_globals_lock(&glocked);
/*
* Deactivate Zend
*/
#if COMPILE_DL_PTHREADS
php_request_shutdown(TSRMLS_C);
#else
zend_deactivate_modules(TSRMLS_C);
zend_deactivate(TSRMLS_C);
#endif
/*
* Free Context
*/
tsrm_free_interpreter_context(tsrm_ls);
/*
* Release global lock
*/
pthreads_globals_unlock(&glocked);
}
}
/*
* Donetime ...
*/
pthread_exit(NULL);
#ifdef _WIN32
/*
* Silence MSVC Compiler
*/
return NULL;
#endif
}
/* }}} */
#endif
pthreads-0.0.37/src/object.h 0000644 0000000 0000000 00000010510 12046565267 014331 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 */
int pthreads_set_state_ex(PTHREAD thread, int state, long timeout TSRMLS_DC);
int pthreads_set_state(PTHREAD thread, int state TSRMLS_DC);
int pthreads_unset_state(PTHREAD thread, int state TSRMLS_DC);
int pthreads_import(PTHREAD thread, zval** return_value TSRMLS_DC);
int pthreads_stack_pop(PTHREAD thread, PTHREAD work TSRMLS_DC);
int pthreads_stack_push(PTHREAD thread, PTHREAD work TSRMLS_DC);
int pthreads_stack_next(PTHREAD thread, zval *this_ptr TSRMLS_DC);
int pthreads_stack_length(PTHREAD thread TSRMLS_DC);
/* }}} */
/* {{{ start/join */
int pthreads_start(PTHREAD thread TSRMLS_DC);
int pthreads_join(PTHREAD thread 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) /* }}} */
/* {{{ handlers included here for access to macros above */
#ifndef HAVE_PTHREADS_HANDLERS_H
# include
#endif /* }}} */
#endif /* HAVE_PTHREADS_OBJECT_H */
pthreads-0.0.37/src/prepare.c 0000644 0000000 0000000 00000031352 12046565267 014523 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
#ifdef AG
# undef AG
#endif
#define AG(v) TSRMG(alloc_globals_id, zend_alloc_globals *, v)
/* {{{ prepared function ctor */
static void pthreads_preparation_function_ctor(zend_function *pfe); /* }}} */
/* {{{ prepared property info ctor */
static void pthreads_preparation_property_info_ctor(zend_property_info *pi); /* }}} */
/* {{{ prepared classes dtor */
static void pthreads_preparation_classes_dtor(void **ppce); /* }}} */
/* {{{ prepared function ctor */
static void pthreads_preparation_function_dtor(zend_function *pfe); /* }}} */
/* {{{ 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); /* }}} */
#endif
/* {{{ empty method entries */
zend_function_entry pthreads_empty_methods[] = {
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ initialize prepared class entry storage */
void pthreads_prepare_classes_init(PTHREAD thread TSRMLS_DC) {
zend_llist *classes = &thread->preparation.classes;
if (!classes || !classes->dtor)
zend_llist_init(classes, sizeof(zend_class_entry*), (llist_dtor_func_t) pthreads_preparation_classes_dtor, 1);
} /* }}} */
/* {{{ free prepared class storage */
void pthreads_prepare_classes_free(PTHREAD thread TSRMLS_DC) {
zend_llist *classes = &thread->preparation.classes;
if (classes) {
zend_llist_destroy(classes);
}
} /* }}} */
/* {{{ fetch prepared class entry */
zend_class_entry* pthreads_prepared_entry(PTHREAD thread, zend_class_entry *candidate TSRMLS_DC) {
zend_class_entry *prepared = NULL, **searched = NULL;
if (candidate) {
char *lcname = (char*) malloc(candidate->name_length+1);
if (lcname != NULL) {
zend_str_tolower_copy(lcname, candidate->name, candidate->name_length);
/*
* look for class entry in current context
*/
if (zend_hash_find(CG(class_table), lcname, candidate->name_length+1, (void**)&searched)!=SUCCESS) {
/*
* create class entry in current context
*/
zend_class_entry ce;
/*
* Initialize an interned class entry
*/
INIT_CLASS_ENTRY_EX(
ce,
candidate->name,
candidate->name_length,
pthreads_empty_methods
);
/*
* Attach appropriate handlers
*/
if (candidate->create_object)
ce.create_object = candidate->create_object;
if (candidate->serialize)
ce.serialize = candidate->serialize;
if (candidate->unserialize)
ce.unserialize = candidate->unserialize;
if (candidate->clone)
ce.clone = candidate->clone;
/*
_zend_function *constructor;
_zend_function *destructor;
_zend_function *clone;
_zend_function *__get;
_zend_function *__set;
_zend_function *__unset;
_zend_function *__isset;
_zend_function *__call;
_zend_function *__callstatic;
_zend_function *__tostring;
_zend_function *serialize_func;
_zend_function *unserialize_func;
*/
/*
* Registration
*/
prepared=zend_register_internal_class(&ce TSRMLS_CC);
{
zend_uint umethod = 0;
zend_function *usources[13] = {
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,
NULL
};
do {
zend_function **utarget;
if (usources[umethod]) {
switch(umethod){
case 0: utarget = &prepared->constructor; break;
case 1: utarget = &prepared->destructor; break;
case 2: utarget = &prepared->clone; break;
case 3: utarget = &prepared->__get; break;
case 4: utarget = &prepared->__set; break;
case 5: utarget = &prepared->__unset; break;
case 6: utarget = &prepared->__isset; break;
case 7: utarget = &prepared->__call; break;
case 8: utarget = &prepared->__callstatic; break;
case 9: utarget = &prepared->__tostring; break;
case 10: utarget = &prepared->serialize_func; break;
case 11: utarget = &prepared->unserialize_func; break;
}
if (utarget) {
*utarget = (zend_function*) emalloc(sizeof(zend_function));
if ((*utarget)) {
memcpy(
(*utarget), usources[umethod], sizeof(zend_function)
);
}
}
}
} while(++umethod < 13);
}
/*
* Copy Function Table
*/
{
zend_function *tf;
zend_hash_copy
(
&prepared->function_table,
&candidate->function_table,
(copy_ctor_func_t) pthreads_preparation_function_ctor,
&tf, sizeof(zend_function)
);
prepared->function_table.pDestructor = (dtor_func_t) pthreads_preparation_function_dtor;
}
/*
* Copy Property Info
*/
{
zend_property_info *ti;
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 Defaults
*/
{
/*
* Default Properties
*/
#if PHP_VERSION_ID < 50400
{
zval *tp;
zend_hash_copy
(
&prepared->default_properties,
&candidate->default_properties,
(copy_ctor_func_t) pthreads_preparation_default_properties_ctor,
&tp, sizeof(zval*)
);
prepared->default_properties.pDestructor = (dtor_func_t) pthreads_preparation_default_properties_dtor;
}
#else
if (candidate->default_properties_count) {
int i;
prepared->default_properties_table = malloc(
sizeof(zval*) * candidate->default_properties_count
);
for (i=0; idefault_properties_count; i++) {
prepared->default_properties_table[i]=candidate->default_properties_table[i];
if (candidate->default_properties_table[i]) {
ALLOC_ZVAL(prepared->default_properties_table[i]);
Z_ADDREF_P(prepared->default_properties_table[i]);
INIT_PZVAL(prepared->default_properties_table[i]);
}
}
prepared->default_properties_count = candidate->default_properties_count;
}
if (candidate->default_static_members_count) {
prepared->default_static_members_count = 0;
}
#endif
/*
* Static Properties are pointless and cannot be static in the context of threading
*/
}
/*
* Copy Constants
*/
{
zval *tc;
zend_hash_copy
(
&prepared->constants_table,
&candidate->constants_table,
(copy_ctor_func_t) zval_add_ref,
&tc, sizeof(zval*)
);
}
#if PHP_VERSION_ID > 50399
/*
* Copy user info struct
*/
memcpy(&prepared->info.user, &candidate->info.user, sizeof(candidate->info.user));
#endif
/*
* Adjust refcount such that pthreads is responsible for freeing this entry
*/
(prepared->refcount)++;
} else {
prepared = *searched;
}
/* free lowercase name buffer */
free(lcname);
} 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;
zend_class_entry **entry;
HashTable *source = PTHREADS_CG(thread->cls, class_table);
HashTable *destination = CG(class_table);
for(zend_hash_internal_pointer_reset_ex(source, &position);
zend_hash_get_current_data_ex(source, (void**) &entry, &position)==SUCCESS;
zend_hash_move_forward_ex(source, &position)) {
char *lcname;
uint lcnamel;
ulong idx;
zend_class_entry *prepared;
if (zend_hash_get_current_key_ex(source, &lcname, &lcnamel, &idx, 0, &position)==HASH_KEY_IS_STRING) {
if (!zend_hash_exists(destination, lcname, lcnamel)){
if ((prepared=pthreads_prepared_entry(thread, *entry TSRMLS_CC))!=NULL) {
zend_llist_add_element(&(thread->preparation.classes), (void**) &prepared);
} else {
zend_error_noreturn(
E_ERROR, "pthreads detected failure while preparing %s in %s", (*entry)->name, thread->std.ce->name, thread->tid
);
break;
}
}
}
}
} /* }}} */
/* {{{ 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 dtor for 5.3 */
static void pthreads_preparation_default_properties_ctor(zval **property) {
ALLOC_ZVAL(*property);
MAKE_COPY_ZVAL(property, *property);
INIT_PZVAL(*property);
} /* }}} */
/* {{{ default property dtor for 5.3 */
static void pthreads_preparation_default_properties_dtor(zval *property) {
zval_ptr_dtor(&property);
} /* }}} */
#endif
/* {{{ construct prepared function
@TODO statics */
static void pthreads_preparation_function_ctor(zend_function *pfe) {
zend_function *function = (zend_function*) pfe;
if (function) {
if (function->type == ZEND_USER_FUNCTION) {
#if PHP_VERSION_ID > 50399
zend_op_array *ops = &function->op_array;
if (ops) {
if (ops->run_time_cache) {
ops->run_time_cache = NULL;
}
(*ops->refcount)++;
}
#endif
}
}
} /* }}} */
/* {{{ destroy prepared function
@TODO statics */
static void pthreads_preparation_function_dtor(zend_function *pfe) {
zend_function *function = (zend_function*) pfe;
if (function) {
if (function->type == ZEND_USER_FUNCTION) {
#if PHP_VERSION_ID > 50399
zend_op_array *ops = &function->op_array;
if (ops) {
if (--(*ops->refcount)>0) {
return;
}
if (ops->run_time_cache) {
efree(ops->run_time_cache);
ops->run_time_cache = NULL;
}
}
#endif
}
}
} /* }}} */
/* {{{ destroy prepared classes */
static void pthreads_preparation_classes_dtor(void **ppce) {
zend_class_entry *pce = (zend_class_entry*) *ppce;
if(pce) {
if (--pce->refcount == 0) {
#if PHP_VERSION_ID > 50399
if (pce->default_properties_count) {
int i;
for(i=0; idefault_properties_count; i++) {
if (pce->default_properties_table[i]) {
//zval_dtor(pce->default_properties_table[i]);
}
}
free(pce->default_properties_table);
}
#else
zend_hash_destroy(&pce->default_properties);
#endif
#if PHP_VERSION_ID > 50399
if (pce->default_static_members_count) {
int i;
for(i=0; idefault_static_members_count; i++) {
if (pce->default_static_members_table[i]) {
zval_ptr_dtor(&pce->default_static_members_table[i]);
}
}
free(pce->default_static_members_table);
}
#else
/* we don't use statics but the table is still initialized so must be destroyed */
zend_hash_destroy(&pce->default_static_members);
#endif
zend_hash_destroy(&pce->properties_info);
zend_hash_destroy(&pce->constants_table);
zend_hash_destroy(&pce->function_table);
if (pce->name) {
free((char*)pce->name);
}
free(pce);
}
}
} /* }}} */
#endif
pthreads-0.0.37/src/prepare.h 0000644 0000000 0000000 00000003402 12046565267 014523 0 ustar root root /*
+----------------------------------------------------------------------+
| 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); /* }}} */
/* {{{ initialize prepared class storage */
void pthreads_prepare_classes_init(PTHREAD thread TSRMLS_DC); /* }}} */
/* {{{ free prepared classes */
void pthreads_prepare_classes_free(PTHREAD thread TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.37/src/store.c 0000644 0000000 0000000 00000022727 12046565267 014227 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_GLOBALS_H
# include
#endif
typedef struct _pthreads_storage {
void *data;
size_t length;
zend_uchar type;
zend_bool exists;
long lval;
double dval;
} *pthreads_storage;
/* {{{ statics */
static pthreads_storage pthreads_store_create(zval *pzval 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 TSRMLS_DC);
static int pthreads_store_tozval(zval *pzval, char *pstring, size_t slength TSRMLS_DC);
static void pthreads_store_storage_dtor (pthreads_storage *element);
/* }}} */
/* {{{ allocate storage for an object */
pthreads_store pthreads_store_alloc(TSRMLS_D) {
pthreads_store store = calloc(1, sizeof(*store));
if (store) {
if (zend_ts_hash_init(&store->table, 32, NULL, (dtor_func_t) pthreads_store_storage_dtor, 1)==SUCCESS){
if (pthread_mutex_init(&store->lock, &defmutex)==SUCCESS) {
return store;
} else zend_ts_hash_destroy(&store->table);
} else free(store);
}
return NULL;
} /* }}} */
/* {{{ lock buffer */
int pthreads_store_lock(pthreads_store store, int *acquired TSRMLS_DC) {
if (store) {
switch (pthread_mutex_lock(&store->lock)) {
case SUCCESS:
return (((*acquired)=1)==1);
case EDEADLK:
return (((*acquired)=0)==0);
default:
return (((*acquired)=0)==1);
}
} 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, locked = 0;
if (store) {
if (pthreads_store_lock(store, &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_store_unlock(store, &locked TSRMLS_CC);
} else result = FAILURE;
}
return result;
}
/* }}} */
/* {{{ isset helper for handlers */
int pthreads_store_isset(pthreads_store store, char *key, int keyl, int has_set_exists TSRMLS_DC) {
int locked = 0, result = 0;
if (store) {
if (pthreads_store_lock(store, &locked TSRMLS_CC)) {
pthreads_storage *storage;
if (zend_ts_hash_find(&store->table, key, keyl, (void**)&storage)==SUCCESS) {
result=((*storage)->exists);
}
pthreads_store_unlock(store, &locked TSRMLS_CC);
}
}
return result;
} /* }}} */
/* {{{ read a value from store */
int pthreads_store_read(pthreads_store store, char *key, int keyl, zval **read TSRMLS_DC) {
int result = FAILURE, locked = 0;
if (store) {
if (pthreads_store_lock(store, &locked TSRMLS_CC)) {
pthreads_storage *storage;
if (zend_ts_hash_find(&store->table, key, keyl, (void**)&storage)==SUCCESS) {
ALLOC_ZVAL(*read);
if ((result = pthreads_store_convert(*storage, *read TSRMLS_CC))!=SUCCESS) {
FREE_ZVAL(*read);
} else Z_SET_REFCOUNT_PP(read, 0);
}
pthreads_store_unlock(store, &locked TSRMLS_CC);
}
}
return result;
} /* }}} */
/* {{{ write a value to store */
int pthreads_store_write(pthreads_store store, char *key, int keyl, zval **write TSRMLS_DC) {
int result = FAILURE, locked = 0;
if (store) {
pthreads_storage storage = pthreads_store_create(*write TSRMLS_CC);
if (storage) {
if (pthreads_store_lock(store, &locked TSRMLS_CC)) {
if (zend_ts_hash_update(&store->table, key, keyl, (void**) &storage, sizeof(pthreads_storage), NULL)==SUCCESS) {
result = SUCCESS;
} else free(store);
pthreads_store_unlock(store, &locked TSRMLS_CC);
}
}
}
return result;
} /* }}} */
/* {{{ unlock store */
int pthreads_store_unlock(pthreads_store store, int *acquired TSRMLS_DC) {
if (store) {
if ((*acquired)) {
return pthread_mutex_unlock(&store->lock);
} else return 1;
} else return 0;
} /* }}} */
/* {{{ free store storage for a thread */
void pthreads_store_free(pthreads_store store TSRMLS_DC){
if (store) {
int locked;
if (pthreads_store_lock(store, &locked TSRMLS_CC)) {
zend_ts_hash_destroy(&store->table);
pthreads_store_unlock(store, &locked TSRMLS_CC);
}
pthread_mutex_destroy(&store->lock);
free(store);
}
} /* }}} */
/* {{{ zval to string */
static int pthreads_store_tostring(zval *pzval, char **pstring, size_t *slength TSRMLS_DC) {
smart_str *psmart = (smart_str*) calloc(1, sizeof(smart_str));
int result = FAILURE;
if (psmart) {
php_serialize_data_t vars;
PHP_VAR_SERIALIZE_INIT(vars);
php_var_serialize(
psmart,
&pzval,
&vars TSRMLS_CC
);
PHP_VAR_SERIALIZE_DESTROY(vars);
if (psmart) {
*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;
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);
}
} else result = FAILURE;
} else result = FAILURE;
return result;
} /* }}} */
/* {{{ 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 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_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 TSRMLS_CC)==SUCCESS) {
if (storage->type==IS_ARRAY) {
storage->exists = zend_hash_num_elements(Z_ARRVAL_P(unstore));
} else storage->exists = 1;
} else free(storage);
} 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_ARRAY:
case IS_OBJECT: {
result = pthreads_store_tozval(
pzval,
(char*) storage->data,
storage->length TSRMLS_CC
);
} break;
default: ZVAL_NULL(pzval);
}
Z_ADDREF_P(pzval);
}
return result;
}
/* }}} */
/* {{{ 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:
if ((*storage)->data) {
free((*storage)->data);
}
break;
}
free((*storage));
}
} /* }}} */
#endif
pthreads-0.0.37/src/store.h 0000644 0000000 0000000 00000004766 12046565267 014237 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 ZEND_TS_HASH_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;
pthread_mutex_t lock;
} *pthreads_store; /* }}} */
/* {{{ allocate and initialize buffers */
pthreads_store pthreads_store_alloc(TSRMLS_D); /* }}} */
/* {{{ lock buffer */
int pthreads_store_lock(pthreads_store store, int *acquired 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 */
int 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); /* }}} */
/* {{{ unlock buffer */
int pthreads_store_unlock(pthreads_store store, int *acquired TSRMLS_DC); /* }}} */
/* {{{ free buffers */
void pthreads_store_free(pthreads_store store TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.37/src/state.c 0000644 0000000 0000000 00000012612 12046565267 014203 0 ustar root root /*
+----------------------------------------------------------------------+
| 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 (pthread_mutex_init(&state->lock, &defmutex)==SUCCESS) {
state->synchro = pthreads_synchro_alloc(TSRMLS_C);
return state;
} else free(state);
}
return NULL;
} /* }}} */
/* {{{ free state object */
void pthreads_state_free(pthreads_state state TSRMLS_DC) {
if (state) {
if (pthread_mutex_destroy(&state->lock)==SUCCESS) {
pthreads_synchro_free(state->synchro TSRMLS_CC);
free(state);
state=NULL;
} else zend_error(E_WARNING, "pthreads_state_free failed to destroy state lock");
} else zend_error(E_WARNING, "pthreads_state_free failed to read state object");
} /* }}} */
/* {{{ lock state */
int pthreads_state_lock(pthreads_state state TSRMLS_DC) {
return pthread_mutex_lock(&state->lock);
} /* }}} */
/* {{{ unlock state */
int pthreads_state_unlock(pthreads_state state TSRMLS_DC) {
return pthread_mutex_unlock(&state->lock);
} /* }}} */
/* {{{ 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 */
int pthreads_state_set(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
int result = 1;
if (state) {
acquired = pthread_mutex_lock(&state->lock);
if (acquired == SUCCESS ||acquired == EDEADLK) {
state->was |= mask;
pthreads_synchro_notify(
state->synchro TSRMLS_CC
);
state->bits |= mask;
if (acquired != EDEADLK)
pthread_mutex_unlock(&state->lock);
} else {
result = 0;
zend_error_noreturn(E_WARNING, "pthreads_state_set failed to lock state object");
}
} else {
result = 0;
zend_error_noreturn(E_WARNING, "pthreads_state_set failed to read state object");
}
return result;
} /* }}} */
/* {{{ wait until a state has been set */
int pthreads_state_wait(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
int result = 1;
int wasset = 0;
if (state) {
acquired = pthread_mutex_lock(&state->lock);
if (acquired == SUCCESS||acquired == EDEADLK) {
wasset = ((state->was & mask)==mask);
if (acquired != EDEADLK)
pthread_mutex_unlock(&state->lock);
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 */
int pthreads_state_isset(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
int isset = -1;
if (state) {
acquired = pthread_mutex_lock(&state->lock);
if (acquired == SUCCESS ||acquired == EDEADLK){
isset = ((state->bits & mask)==mask);
if (acquired != EDEADLK)
pthread_mutex_unlock(&state->lock);
} else zend_error_noreturn(E_WARNING, "pthreads_state_isset failed to lock state object");
} else zend_error_noreturn(E_WARNING, "pthreads_state_isset failed to read state object");
return isset;
} /* }}} */
/* {{{ unset state on state object */
int pthreads_state_unset(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
int result = 1;
if (state) {
acquired = pthread_mutex_lock(&state->lock);
if (acquired == SUCCESS ||acquired == EDEADLK) {
state->bits &= ~mask;
if (acquired != EDEADLK)
pthread_mutex_unlock(&state->lock);
} else {
result = 0;
zend_error_noreturn(E_WARNING, "pthreads_state_unset failed to lock state object");
}
} else {
result = 0;
zend_error_noreturn(E_WARNING, "pthreads_state_unset failed to read state object");
}
return result;
} /* }}} */
#endif
pthreads-0.0.37/src/state.h 0000644 0000000 0000000 00000004355 12046565267 014215 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_SYNCHRO_H
# include
#endif
typedef struct _pthreads_state {
pthread_mutex_t lock;
int bits;
pthreads_synchro synchro;
int was;
} *pthreads_state;
pthreads_state pthreads_state_alloc(int mask TSRMLS_DC);
int pthreads_state_lock(pthreads_state state TSRMLS_DC);
int pthreads_state_check(pthreads_state, int mask TSRMLS_DC);
int pthreads_state_unlock(pthreads_state state TSRMLS_DC);
int pthreads_state_set(pthreads_state state, int mask TSRMLS_DC);
int 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);
int pthreads_state_isset(pthreads_state state, int mask TSRMLS_DC);
int pthreads_state_unset(pthreads_state state, int mask TSRMLS_DC);
void pthreads_state_free(pthreads_state state TSRMLS_DC);
#endif
pthreads-0.0.37/src/synchro.c 0000644 0000000 0000000 00000006754 12046565267 014562 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_SYNCHRO_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ allocate (and initialize) a synchronization object */
pthreads_synchro pthreads_synchro_alloc(TSRMLS_D) {
pthreads_synchro sync = (pthreads_synchro) calloc(1, sizeof(*sync));
if (sync) {
if (pthread_mutex_init(&sync->lock, &defmutex)==SUCCESS) {
if (pthread_cond_init(&sync->notify, NULL)==SUCCESS) {
return sync;
} else free(sync);
} else 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 now;
struct timespec until;
if (timeout>0L) {
if (gettimeofday(&now, NULL)==SUCCESS) {
long nsec = timeout * 1000;
if (nsec > 1000000000L) {
until.tv_sec = now.tv_sec + (nsec / 1000000000L);
until.tv_nsec = (now.tv_usec * 1000) + (nsec % 1000000000L);
} else {
until.tv_sec = now.tv_sec;
until.tv_nsec = (now.tv_usec * 1000) + timeout;
}
} else timeout = 0L;
}
if (sync) {
if (pthread_mutex_lock(&sync->lock) == SUCCESS) {
if (timeout > 0L) {
result = pthread_cond_timedwait(&sync->notify, &sync->lock, &until);
} else { result = pthread_cond_wait(&sync->notify, &sync->lock); }
pthread_mutex_unlock(&sync->lock);
} else { /* report fatality */ }
} 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 (pthread_mutex_lock(&sync->lock) == SUCCESS) {
if ((result = pthread_cond_broadcast(&sync->notify))!=SUCCESS) {
/* report error */
}
pthread_mutex_unlock(&sync->lock);
} else { /* report error */ }
} else { /* report unknown error */ }
return (result == SUCCESS) ? 1 : 0;
} /* }}} */
/* {{{ free synchronization object */
void pthreads_synchro_free(pthreads_synchro sync TSRMLS_DC) {
pthread_cond_destroy(&sync->notify);
pthread_mutex_destroy(&sync->lock);
free(sync);
} /* }}} */
#endif
pthreads-0.0.37/src/synchro.h 0000644 0000000 0000000 00000003556 12046565267 014564 0 ustar root root /*
+----------------------------------------------------------------------+
| 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
typedef struct _pthreads_synchro {
pthread_mutex_t lock;
pthread_cond_t notify;
} *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); /* }}} */
/* {{{ free synchronization object */
void pthreads_synchro_free(pthreads_synchro sync TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.37/src/thread.h 0000644 0000000 0000000 00000012576 12046565267 014350 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_STATE_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
#ifndef HAVE_PTHREADS_STORE_H
# include
#endif
/* {{{ stack structure */
typedef struct _pthreads_stack {
zend_llist objects;
} *pthreads_stack; /* }}} */
/* {{{ thread structure */
typedef struct _pthread_construct {
/*
* Standard Entry
*/
zend_object std;
/*
* Thread Object
*/
pthread_t thread;
/*
* Thread Scope
*/
int scope;
/*
* Global Object Identity
*/
ulong gid;
/*
* Target Identity
*/
ulong target;
/*
* Thread Identity and LS
*/
ulong tid;
void ***tls;
/*
* Creator Identity and LS
*/
ulong cid;
void ***cls;
/*
* Thread Lock
*/
pthread_mutex_t *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;
/*
* Preparation
*/
struct {
zend_llist classes;
} preparation;
} *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) /* }}} */
/* {{{ begin a loop over a list of threads */
#define PTHREADS_LIST_BEGIN_LOOP(l, s) \
zend_llist_position position;\
PTHREAD *pointer;\
if ((pointer = (PTHREAD*) zend_llist_get_first_ex(l, &position))!=NULL) {\
do {\
(s) = (*pointer);
/* }}} */
/* {{{ end a loop over a list of threads */
#define PTHREADS_LIST_END_LOOP(l, s) \
} while((pointer = (PTHREAD*) zend_llist_get_next_ex(l, &position))!=NULL);\
} else zend_error(E_WARNING, "pthreads has not yet created any threads, nothing to search");
/* }}} */
/* {{{ insert an item into a list of threads */
#define PTHREADS_LIST_INSERT(l, t) zend_llist_add_element(l, &t)
/* }}} */
/* {{{ remove an item from a list of threads */
#define PTHREADS_LIST_REMOVE(l, t) zend_llist_del_element(l, &t, (int (*)(void *, void *)) pthreads_equal_func);
/* }}} */
/* {{{ defmutex setup */
#ifndef _WIN32
# ifdef PTHREAD_MUTEX_ERRORCHECK_NP
# define DEFAULT_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK_NP
# elifdef PTHREAD_MUTEX_ERRORCHECK
# define DEFAULT_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
# endif
#endif
/* }}} */
/* {{{ default mutex attributes */
pthread_mutexattr_t defmutex; /* }}} */
#endif /* }}} */ /* HAVE_PTHREADS_THREAD_H */
pthreads-0.0.37/classes/thread.h 0000644 0000000 0000000 00000021227 12046565267 015207 0 ustar root root /*
+----------------------------------------------------------------------+
| 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);
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()
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)
PHP_ME(Thread, getCreatorId, Thread_getCreatorId, 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)) {
if (PTHREADS_G(max) && !(pthreads_globals_count()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 process or thread to wait for the referenced thread to notify
When a timeout is used an reached boolean false will return
When no timeout is used a boolean indication of success will return */
PHP_METHOD(Thread, wait)
{
PTHREAD thread = PTHREADS_FETCH;
long timeout = 0L;
if(ZEND_NUM_ARGS()){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout)!=SUCCESS) {
RETURN_FALSE;
}
}
if (thread) {
RETURN_BOOL(pthreads_set_state_ex(thread, PTHREADS_ST_WAITING, timeout TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to wait for a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ 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_IN_CREATOR(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)
{
ZVAL_LONG(return_value, (PTHREADS_FETCH_FROM(getThis()))->tid);
} /* }}} */
/* {{{ 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);
} /* }}} */
# endif
#endif
pthreads-0.0.37/classes/worker.h 0000644 0000000 0000000 00000022746 12046565267 015260 0 ustar root root /*
+----------------------------------------------------------------------+
| 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)) {
if (PTHREADS_G(max) && !(pthreads_globals_count()state, PTHREADS_ST_JOINED TSRMLS_CC)) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, pthreads_stackable_entry)==SUCCESS) {
size = pthreads_stack_push(thread, PTHREADS_FETCH_FROM(work) TSRMLS_CC);
if (size) {
RETURN_LONG(size);
}
}
} else zend_error(E_ERROR, "pthreads has detected an attempt to stack onto %s (%lu) which has already been joined", PTHREADS_FRIENDLY_NAME);
} else zend_error(E_WARNING, "pthreads has detected an attempt to call an external method on %s (%lu), you cannot stack in this context", 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 (PTHREADS_IS_NOT_CONNECTION(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_WARNING, "pthreads has detected an attempt to call an external method on %s (%lu), you cannot unstack in this context", PTHREADS_FRIENDLY_NAME);
} 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 join from an incorrect context, only the creating context may join with %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.37/classes/stackable.h 0000644 0000000 0000000 00000010541 12046565267 015666 0 ustar root root /*
+----------------------------------------------------------------------+
| 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);
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()
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)
{NULL, NULL, NULL}
};
/* {{{ proto boolean Stackable::wait([long timeout])
Will cause the calling thread to wait for notification from the referenced Stackable
When a timeout is used an reached boolean false will return
When no timeout is used a boolean indication of success will return */
PHP_METHOD(Stackable, wait)
{
PTHREAD thread = PTHREADS_FETCH;
long timeout = 0L;
if(ZEND_NUM_ARGS()){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &timeout)!=SUCCESS) {
RETURN_FALSE;
}
}
if (thread) {
RETURN_BOOL(pthreads_set_state_ex(thread, PTHREADS_ST_WAITING, timeout TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to wait for a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ 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);
} /* }}} */
# endif
#endif
pthreads-0.0.37/classes/mutex.h 0000644 0000000 0000000 00000020177 12046565267 015105 0 ustar root root /*
+----------------------------------------------------------------------+
| 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, create);
PHP_METHOD(Mutex, lock);
PHP_METHOD(Mutex, trylock);
PHP_METHOD(Mutex, unlock);
PHP_METHOD(Mutex, destroy);
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, 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 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, &defmutex)){
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 EDEADLK:
zend_error(E_WARNING, "pthreads has detected that the calling thread already owns the mutex");
RETURN_TRUE;
break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
/* the default type of mutex prohibits this error from being raised
there may be more control over mutex types in the future so left for completeness */
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 EDEADLK:
zend_error(E_WARNING, "pthreads has detected that the calling thread already owns the mutex");
RETURN_TRUE;
break;
case EINVAL:
zend_error(E_WARNING, "pthreads has detected that the variable passed is not a valid mutex");
break;
/* again the defmutex setup prohibits this from occuring, present for completeness */
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.37/classes/cond.h 0000644 0000000 0000000 00000017153 12046565267 014666 0 ustar root root /*
+----------------------------------------------------------------------+
| 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, create);
PHP_METHOD(Cond, signal);
PHP_METHOD(Cond, broadcast);
PHP_METHOD(Cond, wait);
PHP_METHOD(Cond, destroy);
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, 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 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 )
@NOTE timeouts dodgy in windows because of a lack of proper gettimeofday implementation, dispite it being defined, somewhere ... */
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 now;
if (gettimeofday(&now, NULL)==SUCCESS) {
struct timespec until;
long nsec = timeout * 1000;
if (nsec > 1000000000L) {
until.tv_sec = now.tv_sec + (nsec / 1000000000L);
until.tv_nsec = (now.tv_usec * 1000) + (nsec % 1000000000L);
} else {
until.tv_sec = now.tv_sec;
until.tv_nsec = (now.tv_usec * 1000) + timeout;
}
switch(pthread_cond_timedwait(condition, mutex, &until)){
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 {
zend_error(E_ERROR, "pthreads has detected a failure while attempting to get the time from the system");
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.37/config.m4 0000644 0000000 0000000 00000001460 12046565267 013636 0 ustar root root PHP_ARG_ENABLE(pthreads, whether to enable pthreads Threading API,
[ --enable-pthreads Enable pthreads Threading API])
if test "$PHP_PTHREADS" != "no"; then
AC_DEFINE(HAVE_PTHREADS, 1, [Wether you have pthreads support])
AC_MSG_CHECKING([checking for PHP zts])
if test "$PHP_THREAD_SAFETY" != "no"; then
AC_MSG_RESULT([ok])
else
AC_MSG_ERROR([pthreads require ZTS, please re-compile your PHP with ZTS enabled])
fi
PHP_NEW_EXTENSION(pthreads, php_pthreads.c \
src/globals.c \
src/prepare.c \
src/synchro.c \
src/state.c \
src/store.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.37/config.w32 0000644 0000000 0000000 00000000552 12046565267 013732 0 ustar root root ARG_ENABLE("pthreads", "for pthreads support", "no");
if (PHP_PTHREADS != "no") {
CHECK_LIB("pthreadVC2.lib", "pthreads", PHP_PTHREADS);
EXTENSION("pthreads", "php_pthreads.c", true, "/I" + configure_module_dirname);
ADD_SOURCES(
"ext/pthreads/src",
"globals.c prepare.c synchro.c state.c store.c modifiers.c handlers.c object.c", "pthreads"
);
} pthreads-0.0.37/LICENSE 0000644 0000000 0000000 00000006153 12046565267 013140 0 ustar root root --------------------------------------------------------------------
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.37/php_pthreads.c 0000644 0000000 0000000 00000014332 12046565267 014756 0 ustar root root /*
+----------------------------------------------------------------------+
| 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_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_GLOBALS_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
};
PHP_INI_BEGIN()
/* {{{ pthreads.max allows admins some control over how many objects an instance can create */
PHP_INI_ENTRY("pthreads.max", "0", PHP_INI_SYSTEM, NULL) /* }}} */
PHP_INI_END()
#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
PHP_MINIT_FUNCTION(pthreads)
{
zend_class_entry te;
zend_class_entry me;
zend_class_entry ce;
zend_class_entry se;
zend_class_entry we;
REGISTER_INI_ENTRIES();
/*
* Global Init
*/
if (!PTHREADS_G(init))
pthreads_globals_init();
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);
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);
if ( pthread_mutexattr_init(&defmutex)==SUCCESS ) {
#ifdef DEFAULT_MUTEX_TYPE
pthread_mutexattr_settype(
&defmutex,
DEFAULT_MUTEX_TYPE
);
#endif
}
/*
* 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_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;
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(pthreads)
{
UNREGISTER_INI_ENTRIES();
pthread_mutexattr_destroy(
&defmutex
);
return SUCCESS;
}
PHP_MINFO_FUNCTION(pthreads)
{
char numbers[10];
php_info_print_table_start();
php_info_print_table_row(2, "Version", PHP_PTHREADS_VERSION);
if (PTHREADS_G(max)) {
php_info_print_table_row(2, "Maximum Objects", INI_STR("pthreads.max"));
} else php_info_print_table_row(2, "Maximum Objects", "No Limits");
snprintf(numbers, sizeof(numbers), "%d", pthreads_globals_count());
php_info_print_table_row(2, "Current Objects", numbers);
snprintf(numbers, sizeof(numbers), "%d", pthreads_globals_peak());
php_info_print_table_row(2, "Peak Objects", numbers);
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.37/php_pthreads.h 0000644 0000000 0000000 00000003451 12046565267 014763 0 ustar root root /*
+----------------------------------------------------------------------+
| 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.37"
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.37/README.md 0000644 0000000 0000000 00000011120 12046565267 013400 0 ustar root root # 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
* Mutex
* Conditions
* Synchronization
* Worker Threads
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 5.4.7, many versions of PHP are used in testing from both 5.3 and 5.4 series
### Windows Support
Yes !! Windows support is offered thanks to the pthread-w32 library. Pre-built binary downloads are available on the github downloads page for Windows users.
### Mac OSX Support
Yes !! It's reported to me that pthreads compiles fine on your machines, I don't have access to a Mac so any reports are very welcome :)
### 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.
You should bear in mind that in a SAPI environment your threads cannot write the standard output or read the standard input of the serving process, this may be obvious to some of you, but being a new subject probably worth mentioning.
### Documentation
Documentation can be found on http://pthreads.org, and some examples can be found in the "examples" folder in the master repository.
### 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.