package.xml 0000644 0000000 0000000 00000011711 12042774354 011702 0 ustar root root
pthreadspecl.php.netThreading APIA compatible Threading API for PHP5.3+Joe Watkinskrakjoepthreads@pthreads.orgyes2012-10-270.0.360.0.36betabetaPHP License
Advancedments in Worker/Stackable functionality
Better use of object funcionality
protected methods provide synchronized access to instance methods for stackables, workers and threads
private methods only allowed to be executed within the threading context
read/write access to all thread data
__prepare no longer required
5.3.01.4.0b1pthreads
pthreads-0.0.36/examples/AdvancedSynchronization.php 0000644 0000000 0000000 00000004345 12042774354 021304 0 ustar root root my)*rand();
}
public function __construct(){
$this->start();
}
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());
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);
}
}
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 $tid) {
if (($test = Thread::getThread($tid))) {
printf("%s: %lu working %lu ... %s/%d\n", __CLASS__, $this->getThreadId(), $tid, $test->my, $test->scopeTestFunc());
$test->reading = ((rand()*10)*microtime(true))/10;
if ($test->isWaiting()) {
printf("%s: %lu notifying %lu: %d\n", __CLASS__, $this->getThreadId(), $tid, $test->notify());
}
} else printf("%s: %lu failed to find %s\n", __CLASS__, $this->getThreadId(), $tid);
}
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(array($tests[0]->getThreadId(), $tests[1]->getThreadId()));
$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.36/examples/CallAnyFunction.php 0000644 0000000 0000000 00000004272 12042774354 017505 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.36/examples/Mutexes.php 0000644 0000000 0000000 00000003206 12042774354 016102 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);
printf("Peak Usage: %d/Max Allowed: %d\n", Thread::getPeak(), Thread::getMax());
?> pthreads-0.0.36/examples/Fetch.php 0000644 0000000 0000000 00000003076 12042774354 015506 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.36/examples/Notifications.php 0000644 0000000 0000000 00000002014 12042774354 017255 0 ustar root root notify());
printf("Process Waiting ...\n");
printf("Thread Notifying Process 2: %d\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.36/examples/ObjectsAsParameters.php 0000644 0000000 0000000 00000004151 12042774354 020351 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; }
}
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(){
/*
* Read/Write objects as little as possible
*/
$response = $this->response;
if($response){
if($response->url){
$response->setStart(microtime(true));
$response->setData(file_get_contents($response->url));
$response->setFinish(microtime(true));
}
}
/*
* Write the object back to the thread now you're done manipulating it
*/
$this->response = $response;
/*
* Tell whoever is listening how much we got ...
*/
return $response->getLength();
}
}
/*
* Initialize a new threaded request with a response object as the only parameter
*/
$request = new Request(
new Response(
sprintf("http://www.google.com/?q=%s", md5(rand()*time()))
)
);
/*
* Tell you all about it ...
*/
printf("Fetching: %s ", $request->response->getUrl());
if($request->start()){
while($request->isRunning()) {
echo ".";
usleep(100);
}
if($request->join()){
printf(" got %d bytes in %f seconds\n", $request->response->getLength(), $request->response->getDuration());
}
}
?> pthreads-0.0.36/examples/Pooling.php 0000644 0000000 0000000 00000011036 12042774354 016057 0 ustar root root worker = 0;
}
protected function setWorker($wid){ $this->worker = $wid; }
protected function getWorker() { return $this->worker; }
/* do anything simple */
public function run(){
$this->wait();
if (($worker = Thread::getThread($this->getThreadId()))) {
$worker->addAttempt();
printf(
"%s executing in %s on attempt %d\n",
__CLASS__, $worker->getName(), $worker->getAttempts()
);
} else printf("Failed to find the Thread #%lu in the current context ...\n", $this->worker);
}
}
/* a worker thread */
class ExampleWorker extends Worker {
public function __construct($name){
$this->name = $name;
$this->init = false;
$this->attempts = 0;
}
/* the only thing to do here is initialize an environment which is conducive to the stackables you'll be stacking ... */
public function run(){
if (!$this->init) {
$this->init = true;
if (isset($this->name))
$this->name = sprintf("%s (%lu)", __CLASS__, $this->getThreadId());
}
}
/* get name of the worker */
public function getName() { return $this->name; }
public function addAttempt(){ $this->attempts = ($this->attempts+1); }
public function getAttempts() { return $this->attempts; }
}
/*
* 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) {
$this->workers[] = $worker = new ExampleWorker(sprintf("Worker [%d]", count($this->workers)-1));
$worker->start();
if ($worker->stack($stackable)) {
$stackable->setWorker($worker->getThreadId());
if($stackable->notify())
return $stackable;
} else trigger_error(sprintf("failed to push Stackable onto %s", $worker->getName()), E_USER_WARNING);
}
if (($select = $this->workers[array_rand($this->workers)])) {
if ($select->stack($stackable)) {
$stackable->setWorker($select->getThreadId());
if ($stackable->notify())
return $stackable;
trigger_error(sprintf("failed to notify stackable in %s", $worker->getName()), E_USER_WARNING);
} 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->join();
}
}
}
/*
* Create a pool of ten threads
*/
$pool = new Pool(10);
/*
* Create and submit an array of Stackables
*/
$work = array();
/*
* Submit 100 tasks to the pool
*/
while(++$target<100) {
$work[]=$pool->submit(new ExampleWork(array_rand($_SERVER)));
}
/*
* Shutdown the pool
*/
$pool->shutdown();
/*
* Look inside ...
*/
foreach($pool->workers as $worker) {
printf("Thread %lu made %d attempts ...\n", $worker->getThreadId(), $worker->getAttempts());
}
?> pthreads-0.0.36/examples/Scope.php 0000644 0000000 0000000 00000003727 12042774354 015531 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.36/examples/SimpleWebRequest.php 0000644 0000000 0000000 00000001623 12042774354 017711 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));
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.36/examples/Stacking.php 0000644 0000000 0000000 00000006160 12042774354 016215 0 ustar root root local = $data;
}
public function run() {
/*
* We import the worker here to execute it's methods
*/
if (($worker = Thread::getThread($this->getThreadId()))) {
printf("Running %s in %s\n", __CLASS__, $worker->getName());
$worker->addAttempt();
$this->setWorkerData($worker);
} else printf("failed to get worker something is wrong ...\n");
print_r($this);
}
public function setWorkerData($worker) { $worker->addData($this->local); }
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
*/
/* protection isn't required for this sort of thing under any circumstances - getAttempts cannot read $this->attempts while addAttempt is writing it anyway */
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->join();
printf("Result: %d/%d\n", $worker->getAttempts(), $worker->getStacked());
print_r($worker->getData());
?> pthreads-0.0.36/tests/mutex.phpt 0000644 0000000 0000000 00000000555 12042774354 015326 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.36/tests/oomethods.phpt 0000644 0000000 0000000 00000000653 12042774354 016164 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--
objectTest();
}
}
$thread = new ThreadTest();
if($thread->start())
var_dump($thread->join());
?>
--EXPECT--
int(1) pthreads-0.0.36/tests/staticmethods.phpt 0000644 0000000 0000000 00000000740 12042774354 017033 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.36/tests/thread.phpt 0000644 0000000 0000000 00000000533 12042774354 015427 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.36/tests/wait.phpt 0000644 0000000 0000000 00000000527 12042774354 015127 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.36/src/pthreads.h 0000644 0000000 0000000 00000004351 12042774354 014675 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_object_handlers pthreads_handlers;
zend_object_handlers *zend_handlers;
#endif
pthreads-0.0.36/src/globals.c 0000644 0000000 0000000 00000007535 12042774354 014510 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(importing)=INI_BOOL("pthreads.importing");
PTHREADS_G(max)=INI_INT("pthreads.max");
pthread_mutex_init(&PTHREADS_G(lock), &defmutex);
zend_llist_init(&PTHREADS_G(threads), 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 */
long pthreads_globals_count() {
long result = 0L;
int locked;
if (pthreads_globals_lock(&locked)) {
result = PTHREADS_G(threads).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(threads), thread);
if (PTHREADS_G(peak)tid == tid) {
found = 1;
break;
}
PTHREADS_LIST_END_LOOP(&PTHREADS_G(threads), search)
pthreads_globals_unlock(&locked);
}
if (found) {
return search;
} else return NULL;
} /* }}} */
#endif
pthreads-0.0.36/src/globals.h 0000644 0000000 0000000 00000006373 12042774354 014514 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
* 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 Running Threads
*/
size_t peak;
/*
* Maximum number of Running Threads
*/
size_t max;
/*
* Flag for disable/enable importing
*/
zend_bool importing;
/*
* Running Thread List
*/
zend_llist threads;
} 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 executing contexts */
long pthreads_globals_count(); /* }}} */
/* {{{ push a thread into global list */
void pthreads_globals_add(PTHREAD thread); /* }}} */
/* {{{ pop a thread from global list */
void pthreads_globals_del(PTHREAD thread); /* }}} */
/* {{{ get peak number of executing contexts */
long pthreads_globals_peak(); /* }}} */
/* {{{ find a thread by id in global list */
PTHREAD pthreads_globals_find(ulong tid); /* }}} */
#endif /* HAVE_PTHREADS_GLOBAL_H */
pthreads-0.0.36/src/handlers.c 0000644 0000000 0000000 00000026150 12042774354 014657 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_SERIAL_H
# include
#endif
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif
/* {{ reads a property from a thread, wherever it is available */
zval * pthreads_read_property (PTHREADS_READ_PROPERTY_PASSTHRU_D) {
int acquire = 0;
zval *prop = NULL;
PTHREAD thread = PTHREADS_FETCH_FROM(object);
if (thread) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
pthreads_serial line;
if(pthreads_serial_contains(thread->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &line TSRMLS_CC)) {
if (pthreads_serial_read(line, Z_STRVAL_P(member), Z_STRLEN_P(member), &prop TSRMLS_CC)!=SUCCESS) {
zend_error_noreturn(E_WARNING, "pthreads has experienced an internal error while reading %s::$%s (%lu)", Z_OBJCE_P(object)->name, Z_STRVAL_P(member), thread->tid);
} else {
zend_hash_update(
Z_OBJPROP_P(object),
Z_STRVAL_P(member), Z_STRLEN_P(member)+1,
(void**)&prop, sizeof(zval*),
NULL
);
Z_SET_REFCOUNT_P(prop, 1);
}
} else prop = zend_handlers->read_property(PTHREADS_READ_PROPERTY_PASSTHRU_C);
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error_noreturn(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
return prop;
} /* }}} */
/* {{{ writes a property to a thread in the appropriate way */
void pthreads_write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_D) {
int acquire = 0;
PTHREAD thread = PTHREADS_FETCH_FROM(object);
if (thread) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
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_serial_write(thread->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 (%lu)", Z_OBJCE_P(object)->name, Z_STRVAL_P(member), thread->tid);
}
} break;
default: zend_handlers->write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_C);
}
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
} /* }}} */
/* {{{ check if a thread has a property set, wherever it is available */
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D) {
PTHREAD thread = PTHREADS_FETCH_FROM(object);
int acquire = 0, result = -1;
if (thread) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
pthreads_serial line;
if (pthreads_serial_contains(thread->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &line TSRMLS_CC)) {
result = pthreads_serial_isset(line, Z_STRVAL_P(member), Z_STRLEN_P(member), has_set_exists TSRMLS_CC);
} else result = zend_handlers->has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_C);
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
return result;
} /* }}} */
/* {{{ unset an object property */
void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_D) {
PTHREAD thread = PTHREADS_FETCH_FROM(object);
int acquire = 0;
if (thread) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
pthreads_serial line;
if (pthreads_serial_contains(thread->store, Z_STRVAL_P(member), Z_STRLEN_P(member), &line TSRMLS_CC)) {
if (pthreads_serial_delete(line, 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 from %s (%lu)", Z_STRVAL_P(member), Z_OBJCE_P(object)->name, thread->tid);
}
}
zend_handlers->unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_C);
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
} /* }}} */
/* {{{ 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;
PTHREAD thread = PTHREADS_FETCH_FROM(*pobject);
if (thread) {
switch(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 *cops = &call->op_array;
if (cops->run_time_cache) {
efree(cops->run_time_cache);
cops->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.36/src/handlers.h 0000644 0000000 0000000 00000010766 12042774354 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
* They also have the ability to reference the threading context and import variables into the current context
*/
#ifndef HAVE_PTHREADS_HANDLERS_H
#define HAVE_PTHREADS_HANDLERS_H
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef HAVE_PTHREADS_SERIAL_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_PROPERTY_PASSTHRU_C object, member, type, key TSRMLS_CC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_D zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_C object, member, value, key 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_PROPERTY_PASSTHRU_C object, member, has_set_exists, key TSRMLS_CC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_D zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_C object, member, key 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_PROPERTY_PASSTHRU_C object, member, type TSRMLS_CC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_D zval *object, zval *member, zval *value TSRMLS_DC
# define PTHREADS_WRITE_PROPERTY_PASSTHRU_C object, member, value TSRMLS_CC
# define PTHREADS_HAS_PROPERTY_PASSTHRU_D zval *object, zval *member, int has_set_exists TSRMLS_DC
# define PTHREADS_HAS_PROPERTY_PASSTHRU_C object, member, has_set_exists TSRMLS_CC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_D zval *object, zval *member TSRMLS_DC
# define PTHREADS_UNSET_PROPERTY_PASSTHRU_C object, member TSRMLS_CC
# 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); /* }}} */
/* {{{ write a property to the referenced thread */
void pthreads_write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_D); /* }}} */
/* {{{ check if the referenced thread has a specific property */
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D); /* }}} */
/* {{{ unset a property in the referenced thread */
void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_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.36/src/modifiers.c 0000644 0000000 0000000 00000012176 12042774354 015043 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.36/src/modifiers.h 0000644 0000000 0000000 00000004461 12042774354 015046 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.36/src/object.c 0000644 0000000 0000000 00000047457 12042774354 014342 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; /* }}} */
/* {{{ connect objects */
static void pthreads_connect(PTHREAD source, PTHREAD destination); /* }}} */
/* {{{ 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;
switch(mask){
case PTHREADS_ST_WAITING: {
if (pthreads_state_set(thread->state, PTHREADS_ST_WAITING TSRMLS_CC)) {
result = pthreads_synchro_wait_ex(
thread->synchro, timeout TSRMLS_CC
);
}
} break;
default: 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;
switch(mask) {
case PTHREADS_ST_WAITING: {
if (pthreads_state_unset(thread->state, mask TSRMLS_CC)) {
result = pthreads_synchro_notify(thread->synchro TSRMLS_CC);
} else result = 0;
} break;
default: 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) {
if (work) {
zend_llist_del_element(thread->stack, &work, (int (*)(void *, void *)) pthreads_equal_func);
} else zend_llist_destroy(thread->stack);
remain = thread->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_add_element(thread->stack, &work);
counted = thread->stack->count;
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 TSRMLS_DC) {
PTHREAD *work = NULL;
PTHREAD current = NULL;
int acquire = 0;
int bubble = 0;
zval *that_ptr;
zend_class_entry *scope;
zend_function *run;
burst:
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
if ((bubble=thread->stack->count) > 0) {
work = zend_llist_get_first(thread->stack);
if (work && (current = *work) && current) {
/*
* Find the class entry for work item
*/
{
if ((scope=pthreads_prepared_entry(thread, current->std.ce TSRMLS_CC))==NULL) {
if (acquire != EDEADLK) {
pthread_mutex_unlock(thread->lock);
}
return 0;
}
}
/*
* Allocate a $that
*/
MAKE_STD_ZVAL(that_ptr);
/*
* Initialize it with the new entry
*/
object_and_properties_init(that_ptr, scope, current->std.properties);
/*
* 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);
pthreads_state_set(
current->state, PTHREADS_ST_RUNNING TSRMLS_CC
);
}
}
/*
* Cleanup List
*/
zend_llist_del_element(thread->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) {
counted = thread->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;
PTHREAD imported = NULL;
zend_class_entry *pce;
if (!PTHREADS_IS_CREATOR(thread)) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
/*
* Find the class entry for the selected thread in the current context
*/
{
if ((pce=pthreads_prepared_entry(thread, thread->std.ce TSRMLS_CC))==NULL) {
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
imported = NULL;
}
}
/*
* Initialize the object in this context
*/
if (pce && object_and_properties_init(*return_value, pce, thread->std.properties)==SUCCESS) {
if ((imported = PTHREADS_FETCH_FROM(*return_value))!=NULL) {
/*
* Connect to the imported thread
*/
pthreads_connect(thread, imported);
/*
* Set the imports significant other
*/
imported->sig = thread->sig;
}
}
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
}
}
return imported != NULL ? 1 : 0;
} /* }}} */
/* {{{ thread object constructor */
zend_object_value pthreads_object_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) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ thread connection object constructor */
zend_object_value pthreads_connection_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_SCOPE_CONNECTION;
pthreads_base_ctor(thread, entry TSRMLS_CC);
attach.handle = zend_objects_store_put(
thread,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ worker object constructor */
zend_object_value pthreads_object_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) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ worker connection object constructor */
zend_object_value pthreads_connection_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_SCOPE_CONNECTION;
pthreads_base_ctor(worker, entry TSRMLS_CC);
attach.handle = zend_objects_store_put(
worker,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ stackable object constructor */
zend_object_value pthreads_object_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) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ stackable connection object constructor */
zend_object_value pthreads_connection_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_SCOPE_CONNECTION;
pthreads_base_ctor(stackable, entry TSRMLS_CC);
attach.handle = zend_objects_store_put(
stackable,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
pthreads_base_dtor,
NULL TSRMLS_CC
);
attach.handlers = &pthreads_handlers;
}
return attach;
} /* }}} */
/* {{{ connect pthread objects */
static void pthreads_connect(PTHREAD source, PTHREAD destination) {
if (source && destination) {
destination->thread = source->thread;
destination->tid = source->tid;
destination->tls = source->tls;
destination->cid = source->cid;
destination->synchronized = source->synchronized;
destination->lock = source->lock;
destination->state = source->state;
destination->synchro = source->synchro;
destination->modifiers = source->modifiers;
destination->store = source->store;
destination->stack = source->stack;
destination->status = source->status;
}
} /* }}} */
/* {{{ pthreads base constructor */
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 < 50399
{
zval *temp;
zend_hash_copy(
base->std.properties,
&entry->default_properties,
ZVAL_COPY_CTOR,
&temp, sizeof(zval*)
);
}
#else
object_properties_init(&(base->std), entry);
#endif
if (PTHREADS_IS_CONNECTION(base)) {
base->tid = pthreads_self();
base->tls = tsrm_ls;
pthreads_prepare_classes_init(base TSRMLS_CC);
} else {
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_serial_alloc(TSRMLS_C);
base->status = (long*) calloc(1, sizeof(long));
(*base->status) = 0L;
pthreads_prepare_classes_init(base TSRMLS_CC);
pthreads_modifiers_init(base->modifiers, entry TSRMLS_CC);
if (PTHREADS_IS_WORKER(base)) {
base->stack = (zend_llist*) calloc(1, sizeof(zend_llist));
zend_llist_init(base->stack, sizeof(void**), NULL, 1);
}
if (PTHREADS_IS_THREAD(base)||PTHREADS_IS_WORKER(base)) {
pthreads_globals_add(base);
}
}
}
} /* }}} */
/* {{{ pthreads base destructor */
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)) {
if (pthreads_state_isset(base->state, PTHREADS_ST_STARTED TSRMLS_CC)) {
if (!pthreads_state_isset(base->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
pthreads_state_set(base->state, PTHREADS_ST_JOINED TSRMLS_CC);
if (pthread_join(base->thread, NULL)!=SUCCESS) {
/* do something */
}
}
}
pthreads_globals_del(base);
}
free(base->status);
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_serial_free(base->store TSRMLS_CC);
pthreads_synchro_free(base->synchro TSRMLS_CC);
if (PTHREADS_IS_WORKER(base)) {
zend_llist_destroy(base->stack);
free(base->stack);
}
}
zend_llist_destroy(&(base->preparation.classes));
if (base->std.properties) {
zend_hash_destroy(base->std.properties);
FREE_HASHTABLE(base->std.properties);
base->std.properties = NULL;
}
#if PHP_VERSION_ID > 50399
if (base->std.ce->default_properties_count > 0 && base->std.properties_table) {
int i=0;
for (;istd.ce->default_properties_count;i++){
if (base->std.properties_table[i]) {
zval_ptr_dtor(&base->std.properties_table[i]);
}
}
efree(base->std.properties_table);
}
#endif
free(base);
} /* }}} */
/* {{{ this is aptly named ... */
void * PHP_PTHREAD_ROUTINE(void *arg){
/*
* The thread object
*/
PTHREAD thread = (PTHREAD) arg;
if (thread) {
/*
* The connection to the thread object
*/
PTHREAD connection = NULL;
/*
* 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
/*
* Release global lock
*/
pthreads_globals_unlock(&glocked);
}
/*
* Thread Block
*/
{
/*
* Pointers to the usual
*/
zval *this_ptr = NULL;
zend_class_entry *scope = 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;
/*
* Prepare for execution
*/
pthreads_prepare(thread TSRMLS_CC);
/*
* Initialize thread and connection
*/
{
/*
* Fetch prepared entry for connection
*/
scope = pthreads_prepared_entry
(
thread,
thread->std.ce TSRMLS_CC
);
/*
* Initialize $this
*/
object_and_properties_init
(
getThis(),
scope,
thread->std.properties
);
/*
* Fetch connection from object storage in this context
*/
connection = PTHREADS_FETCH_FROM(getThis());
/*
* Make connection
*/
pthreads_connect(thread, connection);
/*
* Set significant other and local storage pointers
*/
{
thread->sig = connection;
connection->sig = thread;
connection->tls = tsrm_ls;
}
}
/*
* Allow the creating thread to continue where appropriate
*/
if (!thread->synchronized)
pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
/*
* Runtime ...
*/
{
/*
* Now time to execute ::run
*/
zend_try {
EG(called_scope) = scope;
EG(scope) = scope;
EG(This) = getThis();
do {
zend_function *run;
zval *return_value;
if (zend_hash_find(&EG(scope)->function_table, "run", sizeof("run"), (void**) &run)==SUCCESS) {
/* Distinct *return and ::run */
EG(in_execution) = 1;
EG(active_op_array)=(zend_op_array*)run;
EG(return_value_ptr_ptr)=&return_value;
/* Do the dance ... */
zend_execute
(
EG(active_op_array) TSRMLS_CC
);
#if PHP_VERSION_ID > 50399
/* Deal with cache ... */
{
zend_op_array *ran = &run->op_array;
if (ran->run_time_cache) {
efree(ran->run_time_cache);
ran->run_time_cache = NULL;
}
}
#endif
/* Handle *return from ::run */
if (return_value) {
switch(Z_TYPE_P(return_value)){
case IS_NULL: (*connection->status) = 0L; break;
case IS_LONG: (*connection->status) = Z_LVAL_P(return_value); break;
case IS_DOUBLE: (*connection->status) = (long) Z_LVAL_P(return_value); break;
case IS_BOOL: (*connection->status) = (long) Z_BVAL_P(return_value); break;
default:
zend_error_noreturn(E_WARNING, "pthreads has detected that %s::run (%lu) attempted to return an unsupported type", EG(scope)->name, connection->tid);
(*connection->status) = 0L;
}
FREE_ZVAL(return_value);
} else (*connection->status) = 0L;
} 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 TSRMLS_CC));
} zend_catch {
} zend_end_try();
}
} zend_catch {
/* do something, it's all gone wrong */
} zend_end_try();
/*
* Unset running flag
*/
pthreads_unset_state(thread, PTHREADS_ST_RUNNING TSRMLS_CC);
}
/*
* 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.36/src/object.h 0000644 0000000 0000000 00000010430 12042774354 014324 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_connection_stackable_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_object_stackable_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_connection_worker_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_object_worker_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_connection_thread_ctor(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_object_thread_ctor(zend_class_entry *entry TSRMLS_DC);
void pthreads_base_ctor(PTHREAD base, zend_class_entry *entry TSRMLS_DC);
void pthreads_base_dtor(void *arg TSRMLS_DC);
void * PHP_PTHREAD_ROUTINE(void *);
/* }}} */
/*
* @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 TSRMLS_DC);
int pthreads_stack_length(PTHREAD thread 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.36/src/prepare.c 0000644 0000000 0000000 00000026372 12042774354 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
/* {{{ attach appropriate handlers to candidate for origin in thread */
static void pthreads_preparation_handlers(PTHREAD thread, zend_class_entry *candidate, zend_class_entry *attach TSRMLS_DC); /* }}} */
/* {{{ 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); /* }}} */
/* {{{ 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_init(&(thread->preparation.classes), sizeof(zend_class_entry*), (llist_dtor_func_t) pthreads_preparation_classes_dtor, 1);
} /* }}} */
/* {{{ 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
*/
pthreads_preparation_handlers(thread, candidate, &ce TSRMLS_CC);
/*
* Registration
*/
prepared=zend_register_internal_class(&ce TSRMLS_CC);
/*
* 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 and Statics
*/
{
/*
* Default Properties
*/
#if PHP_VERSION_ID > 50399
if (candidate->default_properties_count) {
int i;
prepared->default_properties_table = emalloc(sizeof(zval*) * candidate->default_properties_count);
for (i = 0; i < candidate->default_properties_count; i++) {
prepared->default_properties_table[i] = candidate->default_properties_table[i];
if (candidate->default_properties_table[i]) {
ALLOC_INIT_ZVAL(prepared->default_properties_table[i]);
MAKE_COPY_ZVAL(
&candidate->default_properties_table[i], prepared->default_properties_table[i]
);
}
}
prepared->default_properties_count = candidate->default_properties_count;
}
#else
{
zval *tp;
zend_hash_copy
(
&prepared->default_properties,
&candidate->default_properties,
(copy_ctor_func_t) zval_add_ref,
&tp, sizeof(zval*)
);
}
#endif
/*
* Static Properties
*/
#if PHP_VERSION_ID > 50399
if (candidate->default_static_members_count) {
int i;
prepared->default_static_members_table = perealloc(
prepared->default_static_members_table,
sizeof(zval*) * candidate->default_static_members_count, 1
);
for (i = 0; i < candidate->default_static_members_count; i++) {
prepared->default_static_members_table[i] = candidate->default_static_members_table[i];
if (candidate->default_static_members_table[i]) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(&candidate->default_static_members_table[i]);
prepared->default_static_members_table[i] = candidate->default_static_members_table[i];
Z_ADDREF_P(prepared->default_static_members_table[i]);
}
}
prepared->default_static_members_count = candidate->default_static_members_count;
}
#else
{
zval *ts;
zend_hash_copy
(
&prepared->default_static_members,
&candidate->default_static_members,
(copy_ctor_func_t) zval_add_ref,
&ts, sizeof(zval*)
);
}
#endif
}
/*
* Copy Constants Table
*/
{
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+=2;
} 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;
}
}
}
}
} /* }}} */
/* {{{ attach appropriate object handlers for candidate with respect to scope of thread */
static void pthreads_preparation_handlers(PTHREAD thread, zend_class_entry *candidate, zend_class_entry *attach TSRMLS_DC) {
int scope = pthreads_scope_detect(thread, candidate TSRMLS_CC);
zend_bool connect = PTHREADS_IS_NOT_CONNECTION(thread);
if (scope) {
if (((scope & PTHREADS_SCOPE_THREAD)==PTHREADS_SCOPE_THREAD)) {
if (connect) {
attach->create_object = pthreads_connection_thread_ctor;
} else attach->create_object = pthreads_object_thread_ctor;
} else if (((scope & PTHREADS_SCOPE_WORKER)==PTHREADS_SCOPE_WORKER)) {
if (connect) {
attach->create_object = pthreads_connection_worker_ctor;
} else attach->create_object = pthreads_object_worker_ctor;
} else if (((scope & PTHREADS_SCOPE_STACKABLE)==PTHREADS_SCOPE_STACKABLE)) {
if (connect) {
attach->create_object = pthreads_connection_stackable_ctor;
} else attach->create_object = pthreads_object_stackable_ctor;
}
if (attach->create_object) {
attach->serialize = zend_class_serialize_deny;
attach->unserialize = zend_class_unserialize_deny;
attach->clone = NULL;
}
} else if (candidate->create_object) {
attach->create_object = candidate->create_object;
attach->clone = candidate->clone;
attach->serialize = candidate->serialize;
attach->unserialize = candidate->unserialize;
}
} /* }}} */
/* {{{ 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) {} /* }}} */
/* {{{ 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;
}
}
#endif
}
}
} /* }}} */
/* {{{ destroy prepared function
@TODO statics */
static void pthreads_preparation_function_dtor(zend_function *pfe) {
} /* }}} */
/* {{{ destroy prepared classes */
static void pthreads_preparation_classes_dtor(void **ppce) {
zend_class_entry *pce = (zend_class_entry*) *ppce;
if(pce) {
if (--pce->refcount == 1) {
#if PHP_VERSION_ID > 50399
#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
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.36/src/prepare.h 0000644 0000000 0000000 00000003402 12042774354 014515 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.36/src/serial.c 0000644 0000000 0000000 00000024161 12042774354 014336 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_SERIAL
#define HAVE_PTHREADS_SERIAL
/*
* @TODO
* 1. write in support for other serialization methods like msgpack
*/
#ifndef HAVE_PTHREADS_SERIAL_H
# include
#endif
#ifndef HAVE_PTHREADS_THREAD_H
# include
#endif
/* {{{ serial buffer element structure */
typedef struct _pthreads_storage {
char *serial; /* serial data */
size_t length; /* serial length */
size_t strlen; /* length of original string */
zend_uchar type; /* type of data */
zend_bool exists; /* preset exists to aid in quicker isset() */
} *pthreads_storage; /* }}} */
/* {{{ statics */
static pthreads_storage pthreads_serialize(zval *pzval TSRMLS_DC);
static int pthreads_unserialize(pthreads_storage storage, zval *pzval TSRMLS_DC);
static void pthreads_serial_store_dtor (void **element);
/* }}} */
/* {{{ allocate serial storage for a thread */
pthreads_serial pthreads_serial_alloc(TSRMLS_D) {
pthreads_serial serial = calloc(1, sizeof(*serial));
if (serial) {
serial->line = NULL;
if (zend_ts_hash_init(&serial->store, 32, NULL, (dtor_func_t) pthreads_serial_store_dtor, 1)==SUCCESS){
if (pthread_mutex_init(&serial->lock, &defmutex)==SUCCESS) {
return serial;
} else zend_ts_hash_destroy(&serial->store);
} else free(serial);
}
return NULL;
} /* }}} */
/* {{{ lock serial buffer */
int pthreads_serial_lock(pthreads_serial serial, int *acquired TSRMLS_DC) {
if (serial) {
switch (pthread_mutex_lock(&serial->lock)) {
case SUCCESS:
return (((*acquired)=1)==1);
case EDEADLK:
return (((*acquired)=0)==0);
default:
return (((*acquired)=0)==1);
}
} else return 0;
} /* }}} */
/* {{{ extend serial line */
int pthreads_serial_extend(pthreads_serial serial, pthreads_serial line TSRMLS_DC) {
int result = SUCCESS;
if (serial && line) {
if (serial != line) {
int locked[2] = {0, 0};
if (pthreads_serial_lock(serial, &locked[0] TSRMLS_CC)) {
if (pthreads_serial_lock(line, &locked[1] TSRMLS_CC)) {
serial->line = &line;
pthreads_serial_unlock(line, &locked[1] TSRMLS_CC);
} else result = FAILURE;
pthreads_serial_unlock(serial, &locked[0] TSRMLS_CC);
} else result = FAILURE;
} else result = FAILURE;
} else result = FAILURE;
return result;
} /* }}} */
/* {{{ tell if the serial buffer contains a specific value */
int pthreads_serial_contains(pthreads_serial serial, char *key, int keyl, pthreads_serial *line TSRMLS_DC) {
int contains = 0, locked = 0;
if (serial) {
pthreads_serial *pointer = &serial;
do {
if (pthreads_serial_lock((*pointer), &locked TSRMLS_CC)) {
if (zend_ts_hash_exists(&((*pointer)->store), key, keyl)) {
contains = 1;
}
pthreads_serial_unlock((*pointer), &locked TSRMLS_CC);
} else break;
} while(!contains && (pointer=((*pointer)->line))!=NULL);
if (contains) {
*line = *pointer;
}
}
return contains;
} /* }}} */
/* {{{ delete a value from the serial buffer */
int pthreads_serial_delete(pthreads_serial serial, char *key, int keyl TSRMLS_DC) {
int result = FAILURE, locked = 0;
if (serial) {
pthreads_serial *pointer = &serial;
do {
if (pthreads_serial_lock((*pointer), &locked TSRMLS_CC)) {
if (zend_ts_hash_exists(&((*pointer)->store), key, keyl)) {
if (zend_ts_hash_del(&((*pointer)->store), key, keyl)!=SUCCESS) {
result = FAILURE;
} else result = SUCCESS;
} else result = SUCCESS;
pthreads_serial_unlock((*pointer), &locked TSRMLS_CC);
} else break;
} while(result != FAILURE && (pointer=((*pointer)->line))!=NULL);
}
return result;
}
/* }}} */
/* {{{ isset proxy for handlers to avoid unserializing members when isset() is used */
int pthreads_serial_isset(pthreads_serial serial, char *key, int keyl, int has_set_exists TSRMLS_DC) {
int locked = 0, result = 0;
if (serial) {
pthreads_serial line;
if (pthreads_serial_contains(serial, key, keyl, &line TSRMLS_CC)) {
if (pthreads_serial_lock(line, &locked TSRMLS_CC)) {
pthreads_storage *store;
if (zend_ts_hash_find(&line->store, key, keyl, (void**)&store)==SUCCESS) {
result=((*store)->exists);
}
pthreads_serial_unlock(line, &locked TSRMLS_CC);
}
}
}
return result;
} /* }}} */
/* {{{ read a value from serial input */
int pthreads_serial_read(pthreads_serial serial, char *key, int keyl, zval **read TSRMLS_DC) {
int result = FAILURE, locked = 0;
if (serial) {
pthreads_serial line;
if (pthreads_serial_contains(serial, key, keyl, &line TSRMLS_CC)) {
if (pthreads_serial_lock(line, &locked TSRMLS_CC)) {
pthreads_storage *store;
if (zend_ts_hash_find(&line->store, key, keyl, (void**)&store)==SUCCESS) {
ALLOC_ZVAL(*read);
if ((result = pthreads_unserialize(*store, *read TSRMLS_CC))!=SUCCESS) {
FREE_ZVAL(*read);
} else Z_SET_REFCOUNT_PP(read, 0);
}
pthreads_serial_unlock(line, &locked TSRMLS_CC);
}
}
} else { /* report error */ }
return result;
} /* }}} */
/* {{{ write a value to serial output */
int pthreads_serial_write(pthreads_serial serial, char *key, int keyl, zval **write TSRMLS_DC) {
int result = FAILURE, locked = 0;
if (serial) {
pthreads_storage store = pthreads_serialize(*write TSRMLS_CC);
if (store) {
if (pthreads_serial_lock(serial, &locked TSRMLS_CC)) {
if (zend_ts_hash_update(&serial->store, key, keyl, (void**) &store, sizeof(pthreads_storage), NULL)==SUCCESS) {
result = SUCCESS;
} else free(store);
pthreads_serial_unlock(serial, &locked TSRMLS_CC);
} else { /* report error */ }
} else { /* report error */ }
} else { /* report error */ }
return result;
} /* }}} */
/* {{{ unlock serial buffer */
int pthreads_serial_unlock(pthreads_serial serial, int *acquired TSRMLS_DC) {
if (serial) {
if ((*acquired)) {
return pthread_mutex_unlock(&serial->lock);
} else return 1;
} else return 0;
} /* }}} */
/* {{{ free serial storage for a thread */
void pthreads_serial_free(pthreads_serial serial TSRMLS_DC){
if (serial) {
int locked;
if (pthreads_serial_lock(serial, &locked TSRMLS_CC)) {
zend_ts_hash_destroy(&serial->store);
pthreads_serial_unlock(serial, &locked TSRMLS_CC);
}
pthread_mutex_destroy(&serial->lock);
free(serial);
}
} /* }}} */
/* {{{ Will serialize the zval into a newly allocated buffer which must be free'd by the caller */
static pthreads_storage pthreads_serialize(zval *unserial TSRMLS_DC){
pthreads_storage storage;
if (unserial) {
smart_str *output = (smart_str*) calloc(1, sizeof(smart_str));
if (output) {
/*
* Populate PHP storage
*/
{
/*
* This might seem like the long way round
* pthreads_storage can be cast to a smart_str pointer but zend doesn't like it
*/
php_serialize_data_t vars;
PHP_VAR_SERIALIZE_INIT(vars);
php_var_serialize(
output,
&unserial,
&vars TSRMLS_CC
);
PHP_VAR_SERIALIZE_DESTROY(vars);
}
/*
* Populate pthreads storage
*/
if (output) {
/*
* Make an exact copy of the serial data for internal storage
*/
storage = (pthreads_storage) calloc(1, sizeof(*storage));
if (storage) {
storage->strlen = 0;
storage->serial = (char*) calloc(1, output->len);
if (storage->serial) {
/*
* Set serialized storage length
*/
storage->length = output->len;
/*
* Set some storage flags
*/
switch((storage->type = Z_TYPE_P(unserial))){
case IS_STRING:
storage->strlen = Z_STRLEN_P(unserial);
storage->exists = (storage->strlen > 0);
break;
case IS_LONG: storage->exists = (Z_LVAL_P(unserial) > 0L); break;
case IS_DOUBLE: storage->exists = (Z_DVAL_P(unserial) > 0.0); break;
case IS_ARRAY: storage->exists = zend_hash_num_elements(Z_ARRVAL_P(unserial)); break;
default: storage->exists = 0;
}
/*
* not memcpy or strndup or anything that cares about null termination
*/
memmove(
storage->serial, (const void*) output->c, output->len
);
} else free(storage);
}
/*
* Free PHP storage
*/
{
smart_str_free(output);
free(output);
}
}
}
}
return storage;
}
/* }}} */
/* {{{ Will unserialize data into the allocated zval passed */
static int pthreads_unserialize(pthreads_storage storage, zval *pzval TSRMLS_DC){
int result = SUCCESS;
if (storage) {
const unsigned char* pointer = (const unsigned char*) storage->serial;
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+storage->length, &vars TSRMLS_CC)) {
result = FAILURE;
zval_dtor(pzval);
}
PHP_VAR_UNSERIALIZE_DESTROY(vars);
}
}
}
return result;
}
/* }}} */
/* {{{ Will free serial element */
static void pthreads_serial_store_dtor (void **element){
if (*element) {
pthreads_storage storage = (pthreads_storage) *element;
if (storage->serial) {
free(storage->serial);
}
free(storage);
}
} /* }}} */
#endif
pthreads-0.0.36/src/serial.h 0000644 0000000 0000000 00000005652 12042774354 014347 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_SERIAL_H
#define HAVE_PTHREADS_SERIAL_H
#ifdef HAVE_CONFIG_H
# include
#endif
#ifndef HAVE_PTHREADS_H
# include
#endif
#ifndef ZEND_TS_HASH_H
# include
#endif
#define PTHREADS_SERIAL_EMPTY 0
#define PTHREADS_SERIAL_INLINE 1
#define PTHREADS_SERIAL_LINE 2
/* {{{ serial buffer structure */
typedef struct _pthreads_serial {
TsHashTable store;
pthread_mutex_t lock;
struct _pthreads_serial **line;
} *pthreads_serial; /* }}} */
/* {{{ allocate and initialize serial buffers */
pthreads_serial pthreads_serial_alloc(TSRMLS_D); /* }}} */
/* {{{ lock serial buffer */
int pthreads_serial_lock(pthreads_serial serial, int *acquired TSRMLS_DC); /* }}} */
/* {{{ extend serial line */
int pthreads_serial_extend(pthreads_serial serial, pthreads_serial line TSRMLS_DC); /* }}} */
/* {{{ tell if the serial buffer contains a specific value */
int pthreads_serial_contains(pthreads_serial serial, char *key, int keyl, pthreads_serial *line TSRMLS_DC); /* }}} */
/* {{{ delete a value from the serial buffer */
int pthreads_serial_delete(pthreads_serial serial, char *key, int keyl TSRMLS_DC); /* }}} */
/* {{{ read value from serial buffer */
int pthreads_serial_read(pthreads_serial serial, char *key, int keyl, zval **read TSRMLS_DC); /* }}} */
/* {{{ see if a value isset in serial buffer */
int pthreads_serial_isset(pthreads_serial serial, char *key, int keyl, int has_set_exists TSRMLS_DC); /* }}} */
/* {{{ write value to serial buffer */
int pthreads_serial_write(pthreads_serial serial, char *key, int keyl, zval **write TSRMLS_DC); /* }}} */
/* {{{ unlock serial buffer */
int pthreads_serial_unlock(pthreads_serial serial, int *acquired TSRMLS_DC); /* }}} */
/* {{{ free serial buffers */
void pthreads_serial_free(pthreads_serial serial TSRMLS_DC); /* }}} */
#endif
pthreads-0.0.36/src/state.c 0000644 0000000 0000000 00000010433 12042774354 014174 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) {
return state;
} else free(state);
}
return NULL;
} /* }}} */
/* {{{ acquire lock for state object */
int pthreads_state_lock(pthreads_state state, int *acquired TSRMLS_DC) {
switch(pthread_mutex_lock(&state->lock)){
case SUCCESS:
return (((*acquired)=1)==1);
case EDEADLK:
return (((*acquired)=0)==0);
default: {
zend_error(E_WARNING, "pthreads has experienced an internal error and is likely to fail");
return (((*acquired)=0)==1);
}
}
} /* }}} */
/* {{{ release lock for state object */
int pthreads_state_unlock(pthreads_state state, int *acquired TSRMLS_DC) {
if ((*acquired)) {
if (pthread_mutex_unlock(&state->lock)==SUCCESS) {
return 1;
} else return 0;
} else return 1;
} /* }}} */
/* {{{ free state object */
void pthreads_state_free(pthreads_state state TSRMLS_DC) {
if (state) {
if (pthread_mutex_destroy(&state->lock)==SUCCESS) {
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");
} /* }}} */
/* {{{ set state on state object */
int pthreads_state_set(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
if (state) {
if (pthreads_state_lock(state, &acquired TSRMLS_CC)) {
state->bits |= mask;
return pthreads_state_unlock(state, &acquired TSRMLS_CC);
} else {
zend_error_noreturn(E_WARNING, "pthreads_state_set failed to lock state object");
return 0;
}
} else {
zend_error_noreturn(E_WARNING, "pthreads_state_set failed to read state object");
return 0;
}
} /* }}} */
/* {{{ check for state on state object */
int pthreads_state_isset(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
if (state) {
if (pthreads_state_lock(state, &acquired TSRMLS_CC)){
if (((state->bits & mask)==mask)) {
pthreads_state_unlock(state, &acquired TSRMLS_CC);
return 1;
} else {
pthreads_state_unlock(state, &acquired TSRMLS_CC);
return 0;
}
} else {
zend_error(E_WARNING, "pthreads_state_isset failed to lock state object");
return 0;
}
} else {
zend_error(E_WARNING, "pthreads_state_isset failed to read state object");
return 0;
}
} /* }}} */
/* {{{ unset state on state object */
int pthreads_state_unset(pthreads_state state, int mask TSRMLS_DC) {
int acquired;
if (state) {
if (pthreads_state_lock(state, &acquired TSRMLS_CC)) {
state->bits &= ~mask;
return pthreads_state_unlock(state, &acquired TSRMLS_CC);
} else {
zend_error(E_WARNING, "pthreads_state_unset failed to lock state object");
return 0;
}
} else {
zend_error(E_WARNING, "pthreads_state_unset failed to read state object");
return 0;
}
} /* }}} */
#endif
pthreads-0.0.36/src/state.h 0000644 0000000 0000000 00000003712 12042774354 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 |
+----------------------------------------------------------------------+
*/
#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_state;
pthreads_state pthreads_state_alloc(int mask TSRMLS_DC);
int pthreads_state_lock(pthreads_state state, int *acquired TSRMLS_DC);
int pthreads_state_unlock(pthreads_state state, int *acquired TSRMLS_DC);
void pthreads_state_free(pthreads_state state TSRMLS_DC);
int pthreads_state_set(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);
#endif
pthreads-0.0.36/src/synchro.c 0000644 0000000 0000000 00000007770 12042774354 014553 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) {
sync->waiting = 0;
sync->hanging = 0;
if (pthread_mutex_init(&sync->wait, &defmutex)==SUCCESS) {
if (pthread_cond_init(&sync->notify, NULL)==SUCCESS &&
pthread_cond_init(&sync->hang, 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->wait) == SUCCESS) {
if (sync->hanging) {
sync->hanging = 0;
if (pthread_cond_broadcast(&sync->hang)!=SUCCESS) {
/* report error */
}
}
sync->waiting = 1;
do {
if (timeout > 0L) {
result = pthread_cond_timedwait(&sync->notify, &sync->wait, &until);
} else { result = pthread_cond_wait(&sync->notify, &sync->wait); }
} while(sync->waiting);
pthread_mutex_unlock(&sync->wait);
} 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->wait) == SUCCESS) {
if (!sync->waiting) {
sync->hanging = 1;
do {
if(pthread_cond_wait(&sync->hang, &sync->wait)!=SUCCESS){
/* report error */
break;
}
} while(sync->hanging);
}
sync->waiting = 0;
if ((result = pthread_cond_broadcast(&sync->notify))!=SUCCESS) {
/* report error */
}
pthread_mutex_unlock(&sync->wait);
} 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->wait);
free(sync);
} /* }}} */
#endif
pthreads-0.0.36/src/synchro.h 0000644 0000000 0000000 00000003653 12042774354 014554 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 wait;
pthread_cond_t notify;
pthread_cond_t hang;
zend_bool waiting;
zend_bool hanging;
} *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.36/src/thread.h 0000644 0000000 0000000 00000013366 12042774354 014340 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_SERIAL_H
# include
#endif
/* {{{ thread structure */
typedef struct _pthread_construct {
/*
* Standard Entry
*/
zend_object std;
/*
* Thread Object
*/
pthread_t thread;
/*
* Thread Scope
*/
int scope;
/*
* Thread Identity and LS
*/
ulong tid;
void ***tls;
/*
* Creator Identity and LS
*/
ulong cid;
void ***cls;
/*
* Thread Lock
*/
pthread_mutex_t *lock;
/*
* Thread State
*/
pthreads_state state;
/*
* Thread Sync
*/
pthreads_synchro synchro;
/*
* Method modifiers
*/
pthreads_modifiers modifiers;
/*
* Serial Buffers
*/
pthreads_serial store;
/*
* Thread Flags
*/
zend_bool synchronized;
/*
* Work List
*/
zend_llist *stack;
/*
* Preparation
*/
struct {
zend_llist classes;
} preparation;
/*
* Exit Status
*/
long *status;
/*
* Significant Other
*/
struct _pthread_construct *sig;
} *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)
/* }}} */
/* {{{ detect the scope of candidate with respect to thread */
static inline int pthreads_scope_detect(PTHREAD thread, zend_class_entry *candidate TSRMLS_DC) {
int detection = 0;
zend_class_entry *scope = candidate;
do {
if (scope == pthreads_thread_entry) {
detection |= PTHREADS_SCOPE_THREAD;
} else if (scope == pthreads_worker_entry) {
detection |= PTHREADS_SCOPE_WORKER;
} else if (scope == pthreads_stackable_entry) {
detection |= PTHREADS_SCOPE_STACKABLE;
}
} while((scope=scope->parent)!=NULL);
if ((thread != NULL) && (thread->std.ce == candidate)) {
detection |= PTHREADS_SCOPE_CONNECTION;
}
return detection;
} /* }}} */
/* {{{ 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_IS_CREATOR(t) (t->cid == pthreads_self()) /* }}} */
/* {{{ 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);
/* }}} */
/* {{{ default mutex attributes */
pthread_mutexattr_t defmutex; /* }}} */
#endif /* }}} */ /* HAVE_PTHREADS_THREAD_H */
pthreads-0.0.36/config.m4 0000644 0000000 0000000 00000001105 12042774354 013624 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])
PHP_NEW_EXTENSION(pthreads, php_pthreads.c \
src/globals.c \
src/prepare.c \
src/synchro.c \
src/state.c \
src/serial.c \
src/modifiers.c\
src/handlers.c \
src/object.c, $ext_shared)
PHP_ADD_BUILD_DIR($ext_builddir/src, 1)
PHP_SUBST(PTHREADS_SHARED_LIBADD)
PHP_ADD_MAKEFILE_FRAGMENT
fi
pthreads-0.0.36/config.w32 0000644 0000000 0000000 00000000553 12042774354 013725 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 serial.c modifiers.c handlers.c object.c", "pthreads"
);
} pthreads-0.0.36/LICENSE 0000644 0000000 0000000 00000006153 12042774354 013132 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.36/php_pthreads.c 0000644 0000000 0000000 00000110715 12042774354 014752 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_SERIAL_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
/* {{{ defmutex setup
Choose the NP type if it exists as it targets the current system */
#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
/* }}} */
#ifndef HAVE_PTHREADS_SERIAL_H
#include
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
#include
#endif
/* {{{ basic */
ZEND_BEGIN_ARG_INFO_EX(Thread_start, 0, 0, 0)
ZEND_ARG_INFO(0, synchronized)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_run, 0, 0, 0)
ZEND_END_ARG_INFO()
/* }}} */
/* {{{ synchronization */
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()
/* }}} */
/* {{{ importing */
ZEND_BEGIN_ARG_INFO_EX(Thread_getThread, 0, 0, 1)
ZEND_ARG_INFO(0, tid)
ZEND_END_ARG_INFO()
/* }}} */
/* {{{ identification */
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()
/* }}} */
/* {{{ state detection */
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()
/* }}} */
/* {{{ stacking */
ZEND_BEGIN_ARG_INFO_EX(Thread_stack, 0, 0, 1)
ZEND_ARG_INFO(0, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_unstack, 0, 0, 0)
ZEND_ARG_INFO(0, work)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getStacked, 0, 0, 0)
ZEND_END_ARG_INFO()
/* }}} */
/* {{{ statics/globals */
ZEND_BEGIN_ARG_INFO_EX(Thread_getCount, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getMax, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(Thread_getPeak, 0, 0, 0)
ZEND_END_ARG_INFO()
/* }}} */
/* {{{ mutex */
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()
/* }}} */
/* {{{ conditions */
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()
/* }}} */
/* {{{ Thread method entries */
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, getThread, Thread_getThread, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL|ZEND_ACC_STATIC)
PHP_ME(Thread, getThreadId, Thread_getThreadId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getCreatorId, Thread_getCreatorId, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getCount, Thread_getCount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getMax, Thread_getMax, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getPeak, Thread_getPeak, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ Worker method entries */
zend_function_entry pthreads_worker_methods[] = {
PHP_ME(Thread, start, Thread_start, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ABSTRACT_ME(Thread, run, Thread_run)
PHP_ME(Thread, join, Thread_join, 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)
PHP_ME(Thread, stack, Thread_stack, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, unstack, Thread_unstack, 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, getStacked, Thread_getStacked, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ Stackable method entries */
zend_function_entry pthreads_stackable_methods[] = {
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, isRunning, Thread_isRunning, 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}
}; /* }}} */
/* {{{ Mutex method entries */
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}
}; /* }}} */
/* {{{ Cond method entries */
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}
}; /* }}} */
/* {{{ pthreads module entry */
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
}; /* }}} */
/* {{{ INI Entries */
PHP_INI_BEGIN()
/* {{{ pthreads.max allows admins some control over how many threads a user can create */
PHP_INI_ENTRY("pthreads.max", "0", PHP_INI_SYSTEM, NULL) /* }}} */
/* {{{ pthreads.importing allows importing threads to be disabled where it poses a security risk */
PHP_INI_ENTRY("pthreads.importing", "1", PHP_INI_SYSTEM, NULL) /* }}} */
PHP_INI_END()
/* }}} */
/* {{{ Brains of the operation */
#ifndef HAVE_PTHREADS_OBJECT_H
# include
#endif /* }}} */
/* {{{ Access modification */
#ifndef HAVE_PTHREADS_MODIFIERS_H
# include
#endif /* }}} */
/* {{{ Friendly Thread Display */
#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 /* }}} */
/* {{{ module initialization */
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_object_thread_ctor;
te.serialize = zend_class_serialize_deny;
te.unserialize = zend_class_unserialize_deny;
pthreads_thread_entry=zend_register_internal_class(&te TSRMLS_CC);
INIT_CLASS_ENTRY(we, "Worker", pthreads_worker_methods);
we.create_object = pthreads_object_worker_ctor;
we.serialize = zend_class_serialize_deny;
we.unserialize = zend_class_unserialize_deny;
pthreads_worker_entry=zend_register_internal_class(&we TSRMLS_CC);
INIT_CLASS_ENTRY(se, "Stackable", pthreads_stackable_methods);
se.create_object = pthreads_object_stackable_ctor;
se.serialize = zend_class_serialize_deny;
se.unserialize = zend_class_unserialize_deny;
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.get_property_ptr_ptr = NULL;
return SUCCESS;
} /* }}} */
/* {{{ module shutdown */
PHP_MSHUTDOWN_FUNCTION(pthreads)
{
UNREGISTER_INI_ENTRIES();
pthread_mutexattr_destroy(
&defmutex
);
return SUCCESS;
} /* }}} */
/* {{{ minfo */
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 Threads", INI_STR("pthreads.max"));
} else php_info_print_table_row(2, "Maximum Threads", "No Limits");
snprintf(numbers, sizeof(numbers), "%d", pthreads_globals_count());
php_info_print_table_row(2, "Current Threads", numbers);
snprintf(numbers, sizeof(numbers), "%d", pthreads_globals_peak());
php_info_print_table_row(2, "Peak Threads", numbers);
php_info_print_table_end();
} /* }}} */
/* {{{ proto boolean Thread::start([boolean sync])
Starts executing your implemented run method in a thread, will return a boolean indication of success
If sync is true, your new thread runs synchronized with the current thread ( causing the current thread to block ) until you call notify from within the new thread or the thread ends
If sync is false or void, the new thread will run asynchronously to the current thread and this call will return as quickly as possible */
PHP_METHOD(Thread, start)
{
PTHREAD thread = PTHREADS_FETCH;
int result = FAILURE;
/*
* See if there are any limits in this environment
*/
if (PTHREADS_G(max) && !(pthreads_globals_count()synchronized);
} else thread->synchronized = 0;
if (!pthreads_state_isset(thread->state, PTHREADS_ST_STARTED TSRMLS_CC)) {
int acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
/*
* Don't allow restarting this object
*/
pthreads_set_state(thread, PTHREADS_ST_STARTED TSRMLS_CC);
/*
* Set running flag and store thread in globals
*/
pthreads_set_state(thread, PTHREADS_ST_RUNNING TSRMLS_CC);
/*
* Attempt to start the thread
*/
if ((result = pthread_create(&thread->thread, NULL, PHP_PTHREAD_ROUTINE, (void*)thread)) == SUCCESS) {
/*
* Wait for notification to continue
*/
pthreads_set_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
/*
* Release thread lock
*/
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else {
/*
* Do not attempt to join failed threads at dtor time
*/
pthreads_unset_state(thread, PTHREADS_ST_RUNNING TSRMLS_CC);
/*
* Release thread lock
*/
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
/*
* Report the error, there's no chance of recovery ...
*/
switch(result) {
case EAGAIN:
zend_error_noreturn(E_WARNING, "pthreads has detected that the %s could not be started, the system lacks the necessary resources or the system-imposed limit would be exceeded", PTHREADS_NAME);
break;
default: zend_error_noreturn(E_WARNING, "pthreads has detected that the %s could not be started because of an unspecified system error", PTHREADS_NAME);
}
}
} else zend_error_noreturn(E_WARNING, "pthreads has experienced an internal error while starting %s", PTHREADS_NAME);
} else zend_error_noreturn(E_WARNING, "pthreads has detected an attempt to start %s (%lu) that has already been started", PTHREADS_FRIENDLY_NAME);
if (result==SUCCESS) {
RETURN_TRUE;
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto int Thread::stack(Stackable $work)
Pushes an item onto the Thread Stack, returns the size of stack */
PHP_METHOD(Thread, stack)
{
PTHREAD thread = PTHREADS_FETCH;
zval *work;
int size;
if (thread) {
if (PTHREADS_IS_NOT_CONNECTION(thread)) {
if (!pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, pthreads_stackable_entry)==SUCCESS) {
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 Thread::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(Thread, 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 Thread::getStacked()
Returns the current size of the stack */
PHP_METHOD(Thread, 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 Thread::isStarted()
Will return true if a Thread has been started */
PHP_METHOD(Thread, isStarted)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_STARTED TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto Thread::isRunning()
Will return true while a thread is executing */
PHP_METHOD(Thread, isRunning)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_RUNNING TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto Thread::isJoined()
Will return true if a Thread has been joined already */
PHP_METHOD(Thread, isJoined)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
} /* }}} */
/* {{{ proto boolean Thread::isWaiting()
Will return true if the referenced thread is waiting for notification */
PHP_METHOD(Thread, isWaiting)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
RETURN_BOOL(pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
} else zend_error(E_ERROR, "pthreads has experienced an internal error while preparing to read the state of a %s and cannot continue", PTHREADS_NAME);
}
/* {{{ proto boolean Thread::wait([long timeout])
Will cause the calling 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 mixed Thread::join()
Will cause the calling thread to block and wait for the exit status of the referenced thread */
PHP_METHOD(Thread, join)
{
PTHREAD thread = PTHREADS_FETCH;
/*
* Check that we are in the correct context
*/
if (!PTHREADS_IN_THREAD(thread) && PTHREADS_IS_CREATOR(thread)) {
/*
* Ensure this thread was started
*/
if (pthreads_state_isset(thread->state, PTHREADS_ST_STARTED TSRMLS_CC)) {
/*
* Ensure this thread wasn't already joined
*/
if (!pthreads_state_isset(thread->state, PTHREADS_ST_JOINED TSRMLS_CC)) {
/*
* Ensure nothing attempts to join this thread again
*/
pthreads_set_state(thread, PTHREADS_ST_JOINED TSRMLS_CC);
/*
* We must force workers to close at this point
*/
{
if (PTHREADS_IS_WORKER(thread)) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC)) {
do {
pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
} while (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC));
}
}
}
/*
* Carry out joining
*/
if (pthread_join(thread->thread, NULL)==SUCCESS) {
RETURN_LONG(*thread->status);
} else {
zend_error(E_WARNING, "pthreads detected failure while joining with %s (%lu)", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
}
} else {
zend_error(E_WARNING, "pthreads has detected that %s (%lu) has already been joined", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
}
} else {
zend_error(E_WARNING, "pthreads has detected an attempt to join with an unstarted %s", PTHREADS_NAME);
RETURN_FALSE;
}
} else {
zend_error(E_WARNING, "pthreads has detected an attempt to join from an incorrect context, only the creating context may join with %s (%lu)", PTHREADS_FRIENDLY_NAME);
RETURN_FALSE;
}
} /* }}} */
/* {{{ proto boolean Thread::getThread(long $tid)
Thread::find shall attempt to import the Thread identified by tid into the current context */
PHP_METHOD(Thread, getThread)
{
PTHREAD found = NULL;
ulong tid = 0L;
if (PTHREADS_G(importing)) {
if (EG(called_scope) == pthreads_thread_entry) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tid)==SUCCESS) {
if (tid && tid >0L) {
if ((found=pthreads_globals_find((ulong)tid))!=NULL) {
if (!PTHREADS_IS_CREATOR(found)) {
if (pthreads_import(found, &return_value TSRMLS_CC)) {
return;
} else zend_error(E_WARNING, "pthreads has detected that Thread::getThread(%lu) has failed", tid);
} else zend_error(E_WARNING, "pthreads has detected that Thread::getThread(%lu) has nothing to import as the requested thread was created in the current", tid);
RETURN_FALSE;
} else zend_error(E_WARNING, "pthreads has detected that Thread::getThread(%lu) has nothing to import as the requested thread is no longer running", tid);
} else zend_error(E_WARNING, "pthreads has detected incorrect use of Thread::getThread, no valid Thread identifier was specified");
}
} else zend_error(E_WARNING, "pthreads has detected incorrect use of Thread::getThread, this method may only be called statically as Thread::getThread");
} else zend_error(E_WARNING, "pthreads has detected an attempt to use a prohibited method (Thread::getThread), importing Threads is disabled in this environment");
RETURN_NULL();
}
/* }}} */
/* {{{ proto long Thread::getThreadId()
Will return the identifier of the referenced Thread
If executed on a Stackable will return the identifier of the Worker executing the Stackable */
PHP_METHOD(Thread, getThreadId)
{
if (getThis()) {
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
ZVAL_LONG(return_value, thread->tid);
} else ZVAL_LONG(return_value, 0L);
} else ZVAL_LONG(return_value, pthreads_self());
} /* }}} */
/* {{{ proto long Thread::getCreatorId()
Will return the identifier of the thread ( or process ) that created the referenced Thread or Worker */
PHP_METHOD(Thread, getCreatorId)
{
if (getThis()) {
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
ZVAL_LONG(return_value, thread->cid);
} else ZVAL_LONG(return_value, 0L);
} else ZVAL_LONG(return_value, 0L);
} /* }}} */
/* {{{ proto long Thread::getCount()
Will return the number of threads currently running */
PHP_METHOD(Thread, getCount)
{
RETURN_LONG(pthreads_globals_count());
} /* }}} */
/* {{{ proto long Thread::getMax()
Will return the maximum number of threads you may create in this environment
@NOTE this setting very much depends on the kind of environment you're executing php in */
PHP_METHOD(Thread, getMax)
{
RETURN_LONG(PTHREADS_G(max));
} /* }}} */
/* {{{ proto long Thread::getPeak()
Will return the peak number of threads executing */
PHP_METHOD(Thread, getPeak)
{
RETURN_LONG(pthreads_globals_peak());
} /* }}} */
/* {{{ 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;
} /* }}} */
/* {{{ 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
pthreads-0.0.36/php_pthreads.h 0000644 0000000 0000000 00000004772 12042774354 014764 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.36"
/* {{{ php internals */
PHP_MINIT_FUNCTION(pthreads);
PHP_MSHUTDOWN_FUNCTION(pthreads);
PHP_MINFO_FUNCTION(pthreads);
/* }}} */
/* {{{ basic */
PHP_METHOD(Thread, start);
/* }}} */
/* {{{ synchronization */
PHP_METHOD(Thread, wait);
PHP_METHOD(Thread, notify);
PHP_METHOD(Thread, join);
/* }}} */
/* {{{ state detection */
PHP_METHOD(Thread, isStarted);
PHP_METHOD(Thread, isRunning);
PHP_METHOD(Thread, isJoined);
PHP_METHOD(Thread, isWaiting);
/* }}} */
/* {{{ stacking */
PHP_METHOD(Thread, stack);
PHP_METHOD(Thread, unstack);
PHP_METHOD(Thread, getStacked);
/* }}} */
/* {{{ importing */
PHP_METHOD(Thread, getThread);
/* }}} */
/* {{{ identification */
PHP_METHOD(Thread, getThreadId);
PHP_METHOD(Thread, getCreatorId);
/* }}} */
/* {{{ globals */
PHP_METHOD(Thread, getCount);
PHP_METHOD(Thread, getMax);
PHP_METHOD(Thread, getPeak);
/* }}} */
/* {{{ mutex */
PHP_METHOD(Mutex, create);
PHP_METHOD(Mutex, lock);
PHP_METHOD(Mutex, trylock);
PHP_METHOD(Mutex, unlock);
PHP_METHOD(Mutex, destroy);
/* }}} */
/* {{{ conditions */
PHP_METHOD(Cond, create);
PHP_METHOD(Cond, signal);
PHP_METHOD(Cond, broadcast);
PHP_METHOD(Cond, wait);
PHP_METHOD(Cond, destroy);
/* }}} */
extern zend_module_entry pthreads_module_entry;
#define phpext_pthreads_ptr &pthreads_module_entry
#endif
pthreads-0.0.36/README.md 0000644 0000000 0000000 00000011120 12042774354 013372 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.