package.xml 0000644 0000000 0000000 00000007401 12034302053 011663 0 ustar root root
pthreadspecl.php.netThreading APIA compatible Threading API for PHP5.3+Joe Watkinskrakjoepthreads@pthreads.orgyes2012-10-070.0.350.0.35betabetaPHP License
The package with version 0.0.34 contains an error and will not build without debug enabled
5.3.01.4.0b1pthreads
pthreads-0.0.35/examples/AdvancedSynchronization.php 0000644 0000000 0000000 00000003130 12034302053 021252 0 ustar root root my = "data";
printf("%s: %lu running\n", __CLASS__, $this->getThreadId());
printf("%s: %lu notified: %d\n", __CLASS__, $this->getThreadId(), $this->wait());
$this->my = strrev($this->my);
}
}
class ScopeTest2 extends Thread {
public function __construct($other){
$this->other = $other;
}
public function run(){
printf("%s: %lu running\n", __CLASS__, $this->getThreadId());
if (($other = Thread::getThread($this->other))) {
printf("%s: %lu working ... %s\n", __CLASS__, $this->getThreadId(), $other->my);
usleep(1000000); /* simulate some work */
if ($other->isWaiting())
printf("%s: %lu notifying %lu: %d\n", __CLASS__, $this->getThreadId(), $this->other, $other->notify());
$other->join();
printf("%s: %lu testing again ... %s\n", __CLASS__, $this->getThreadId(), $other->my);
} else {
printf("%s: %lu failed to find %lu\n", __CLASS__, $this->getThreadId(), $this->other);
}
printf("%s: %lu notified: %d\n", __CLASS__, $this->getThreadId(), $this->wait());
}
}
printf("Process: running\n");
$test = new ScopeTest();
$test->start();
$test2 = new ScopeTest2($test->getThreadId());
$test2->start();
printf("Process: notifying %lu: %d\n", $test2->getThreadId(), $test2->notify());
if ($test->isWaiting()) {
/*
* If importing has been disabled then the responsability to notify the waiting thread must fall back to the Process to avoid deadlock
*/
printf("Process: notifying %lu: %d\n", $test->getThreadId(), $test->notify());
}
?> pthreads-0.0.35/examples/CallAnyFunction.php 0000644 0000000 0000000 00000004246 12034302053 017465 0 ustar root root method = $method;
$this->params = $params;
}
/**
* The smallest thread in the world
* @NOTE: the function you're calling had better had serializable results
**/
public function run(){ return call_user_func_array($this->method, $this->params); }
/**
* 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 **/
}
/**
* You could join the result, or if you know the response is a string then do the following:
**/
public function __toString(){
if(!$this->result)
$this->result = $this->join();
return (string) $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->join(); */
/* 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.35/examples/Mutexes.php 0000644 0000000 0000000 00000003206 12034302053 016061 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.35/examples/Fetch.php 0000644 0000000 0000000 00000004076 12034302053 015466 0 ustar root root sym = 10245;
$this->arr = array(
"1", "2", "3"
);
/*
* objects supported at join time ( when it's finished with, and no concern for the thread safety of the underlying object is required )
*/
$this->obj = new stdClass();
$this->obj->val = "testval";
/*
* serialized objects supported all the time
*/
$this->objs = serialize($this->obj);
/*
* resources never supported
*/
$this->res = fopen("php://stdout", "w");
/*
* tell the waiting process we have created symbols and fetch will succeed
*/
$this->notify();
/*
* wait for waiting process to fetch symbols
*/
$this->wait();
}
}
$thread = new Fetching();
$thread->start(true);
/*
* we just got notified that there are symbols waiting
*/
foreach(array("sym", "arr", "obj", "objs", "res") as $symbol){
printf("Thread::fetch(%s): ", $symbol);
$fetched = $thread->$symbol;
if ($fetched) {
switch($symbol){
/*
* we need to manually serialize objects here
*/
case "objs":
print_r(unserialize($fetched));
break;
default: var_dump($fetched);
}
}
}
/*
* Tell the thread it can continue
*/
$thread->notify();
/*
* Join the thread ( and it's symbols )
*/
$thread->join();
/*
* Show thread structure after join ( will contain all symbols created in the thread )
* @NOTE members of a user declared class should be available in both contexts, else joining symbols will fail ( gracefully )
*/
print_r($thread);
?> pthreads-0.0.35/examples/Notifications.php 0000644 0000000 0000000 00000002454 12034302053 017244 0 ustar root root notify());
fflush($stdout);
printf("Process Waiting ...\n");
fflush($stdout);
printf("Thread Notifying Process 2: %d\n", $this->notify());
fflush($stdout);
$this->wait();
printf("Thread exiting ...");
}
}
$t = new ExampleThread();
if ($t->start(true)) {
printf("Process Working ... then ...\n");
echo "WHAT ...";
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.35/examples/ObjectsAsParameters.php 0000644 0000000 0000000 00000003073 12034302053 020332 0 ustar root root response = $request;
}
/*
* You must include the user declared class here
*/
public function __prepare() {
include(sprintf(
"%s/Request.inc.php", dirname(__FILE__)
));
if(class_exists("Request")){
printf("Prepared Thread #%lu\n", $this->getThreadId());
} else printf("Cannot Prepare Thread #%lu\n", $this->getThreadId());
return true;
}
/*
* Manipulate the object and return it as the result so the parent can have it back
*/
public function run(){
printf("Running Thread #%lu\n", $this->getThreadId());
if($this->response){
if($this->response->url){
$this->response->setStart(microtime(true));
$this->response->setData(file_get_contents($this->response->url));
$this->response->setFinish(microtime(true));
}
}
return $this->response->getLength();
}
}
/* include your declared class */
include(sprintf(
"%s/Request.inc.php", dirname(__FILE__)
));
/* keeping a reference is a bit pointless ... though you could and replace it */
$request = new OOWebRequest(new Request("http://www.google.com"));
/* go */
if($request->start()){
/* do some heavy lifting here perhaps in the current thread */
while($request->isBusy()) {
echo ".";
usleep(100);
}
/* then join to get the result */
if($request->join()){
printf("\nGot %d bytes from %s in %f seconds\n", $request->response->getLength(), $request->response->getUrl(), $request->response->getDuration());
}
}
?>
pthreads-0.0.35/examples/Request.inc.php 0000644 0000000 0000000 00000002525 12034302053 016632 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; }
}
?> pthreads-0.0.35/examples/SimpleWebRequest.php 0000644 0000000 0000000 00000001646 12034302053 017675 0 ustar root root url = $url;
$this->data = null;
}
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->isBusy()){
echo ".";
usleep(500);
}
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.35/examples/Stacking.php 0000644 0000000 0000000 00000001024 12034302053 016166 0 ustar root root attempt>1)
usleep(rand(1000, 3000));
printf("%s: %lu running: %d/%d ...\n", __CLASS__, $this->getThreadId(), $this->attempt++, $this->getStacked());
return $this->attempt;
}
}
$work = new MyWorker;
while($i++<10){
printf(
"Stacking: %d/%d\n", $i, $work->stack($work)
);
}
$work->start();
usleep(10000);
while($i++<20){
printf(
"Stacking: %d/%d\n", $i, $work->stack($work)
);
}
printf("Result: %d/%d\n", $work->join(), $work->getStacked());
?> pthreads-0.0.35/examples/Synchronizing.php 0000644 0000000 0000000 00000003570 12034302053 017277 0 ustar root root lock = $lock;
}
/*
The run method shall first attempt to acquire the lock.
Because the mutex passed is owned by the parent it cannot continue until
the parent unlocks the mutex
It does it's work and holds onto the lock until it's ready to return
(pending a flush, which in the real world isn't required)
So the parent doesn't need to unlock the mutex before destruction
*/
public function run(){
/* see, first lock mutex */
printf("Running(%d) %f\n", Mutex::lock($this->lock), microtime(true));
/* print some stuff to standard output */
$stdout = fopen("php://stdout", "w");
while(++$ilock), microtime(true));
fflush($stdout);
/* you should close resources, or not, whatever; I'm not your mother ... */
return null;
}
}
/* create a mutex and acquire lock */
$lock = Mutex::create(true);
/* create new thread, passing the lock as parameter */
$thread = new Syncrhonizing($lock);
/* start executing the child ... */
$thread->start();
/* the child will block until you release the mutex */
printf("Allow(%d): %f\n", Mutex::unlock($lock), microtime(true));
/* ... continue normal not thread related stuff ... */
/* and then: */
$thread->join();
/*
another option would be to lock the mutex and unlock it and let the thread destroy itgetThreadId without calling join,
when this is stable that will definitely be an option but right now I suggest you join everything you create somewhere
*/
printf("Cleaup(%d): %f\n", Mutex::destroy($lock), microtime(true));
?> pthreads-0.0.35/tests/mutex.phpt 0000644 0000000 0000000 00000000555 12034302053 015305 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.35/tests/oomethods.phpt 0000644 0000000 0000000 00000000653 12034302053 016143 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.35/tests/staticmethods.phpt 0000644 0000000 0000000 00000000740 12034302053 017012 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.35/tests/thread.phpt 0000644 0000000 0000000 00000000533 12034302053 015406 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.35/tests/wait.phpt 0000644 0000000 0000000 00000000533 12034302053 015103 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--
bool(true) pthreads-0.0.35/config.m4 0000644 0000000 0000000 00000000736 12034302053 013614 0 ustar root root PHP_ARG_ENABLE(pthreads, whether to enable pthreads extension, [ --enable-pthreads Enable pthreads extension])
if test "$PHP_PTHREADS" != "no"; then
PHP_EVAL_INCLINE("-D_GNU_SOURCE", PTHREADS_CFLAGS)
PHP_EVAL_LIBLINE("-lpthread", PTHREADS_SHARED_LIBADD)
AC_DEFINE(HAVE_PTHREADS, 1, [Wether you have pthreads support])
PHP_NEW_EXTENSION(pthreads, php_pthreads.c, $ext_shared, \\$(PTHREADS_CFLAGS))
PHP_SUBST(PTHREADS_CFLAGS)
PHP_SUBST(PTHREADS_SHARED_LIBADD)
fi
pthreads-0.0.35/config.w32 0000644 0000000 0000000 00000000271 12034302053 013701 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");
} pthreads-0.0.35/LICENSE 0000644 0000000 0000000 00000006153 12034302053 013111 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.35/php_pthreads.c 0000644 0000000 0000000 00000115611 12034302053 014731 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_THREADS
#define HAVE_PHP_THREADS
#include "php_pthreads.h"
#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
zend_class_entry *pthreads_class_entry = NULL;
zend_class_entry *pthreads_import_entry = NULL;
zend_class_entry *pthreads_mutex_class_entry = NULL;
zend_class_entry *pthreads_condition_class_entry = NULL;
zend_object_handlers *zsh = NULL;
zend_object_handlers poh;
/* {{{ defmutex setup
Choose the NP type if it exists as it targets the current system */
pthread_mutexattr_t defmutex;
#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_COMPAT_H
#include "pthreads_compat.h"
#endif
#ifndef HAVE_PTHREADS_SERIAL_H
#include "pthreads_serial.h"
#endif
#ifndef HAVE_PTHREADS_GLOBALS_H
#include "pthreads_globals.h"
#endif
/* {{{ arginfo */
/* {{{ Thread arginfo */
/* {{{ 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()
/* }}} */
/* {{{ advanced */
ZEND_BEGIN_ARG_INFO_EX(Thread_yield, 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()
/* }}} */
/* {{{ 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()
ZEND_BEGIN_ARG_INFO_EX(Thread_isBusy, 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 arginfo */
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()
/* }}} */
/* {{{ Cond arginfo */
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()
/* }}} */
/* }}} */
/* {{{ method entries */
/* {{{ Thread method entries */
zend_function_entry pthreads_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, isBusy, Thread_isBusy, 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, getStacked, Thread_getStacked, 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, 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)
PHP_ME(Thread, yield, Thread_yield, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ Import method entries */
zend_function_entry pthreads_import_methods[] = {
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, isBusy, Thread_isBusy, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(Thread, getStacked, Thread_getStacked, 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()
/* }}} */
#ifndef HAVE_PTHREADS_OBJECT_H
# include "pthreads_object.h"
#endif
/* {{{ module initialization */
PHP_MINIT_FUNCTION(pthreads)
{
zend_class_entry te;
zend_class_entry ie;
zend_class_entry me;
zend_class_entry ce;
REGISTER_INI_ENTRIES();
INIT_CLASS_ENTRY(te, "Thread", pthreads_methods);
te.create_object = pthreads_attach_to_instance;
te.serialize = zend_class_serialize_deny;
te.unserialize = zend_class_unserialize_deny;
pthreads_class_entry=zend_register_internal_class(&te TSRMLS_CC);
if (INI_INT("pthreads.importing")) {
INIT_CLASS_ENTRY(ie, "ImportedThread", pthreads_import_methods);
ie.create_object = pthreads_attach_to_import;
ie.serialize = zend_class_serialize_deny;
ie.unserialize = zend_class_unserialize_deny;
pthreads_import_entry=zend_register_internal_class(&ie TSRMLS_CC);
}
INIT_CLASS_ENTRY(me, "Mutex", pthreads_mutex_methods);
me.serialize = zend_class_serialize_deny;
me.unserialize = zend_class_unserialize_deny;
pthreads_mutex_class_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_class_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
}
if (!PTHREADS_G(init))
PTHREADS_G_INIT();
/*
* Setup standard and pthreads object handlers
*/
zsh = zend_get_std_object_handlers();
memcpy(&poh, zsh, sizeof(zend_object_handlers));
poh.read_property = pthreads_read_property;
poh.write_property = pthreads_write_property;
poh.has_property = pthreads_has_property;
poh.unset_property = pthreads_unset_property;
poh.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 (INI_INT("pthreads.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_G_COUNT());
php_info_print_table_row(2, "Current Threads", numbers);
snprintf(numbers, sizeof(numbers), "%d", PTHREADS_G_PEAK());
php_info_print_table_row(2, "Peak Threads", numbers);
php_info_print_table_end();
} /* }}} */
/* {{{ Thread methods */
/* {{{ 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 = -1;
zval *props;
/*
* Ensure we are in the correct context
*/
if (!PTHREADS_IS_SELF(thread)) {
/*
* See if there are any limits in this environment
*/
if (INI_INT("pthreads.max") && !(PTHREADS_G_COUNT()synchronized);
} else thread->synchronized = 0;
/*
* Stop multiple starts from occuring
*/
if (!PTHREADS_IS_STARTED(thread)) {
PTHREADS_SET_STARTED(thread);
/*
* Serializing here keeps the heap happy, so here is where we'll do it ...
* @NOTE Verification
* I still feel that some kind of verification is needed before we attempt to run the thread as it will help those new to threading
*/
ALLOC_INIT_ZVAL(props);
Z_TYPE_P(props)=IS_ARRAY;
Z_ARRVAL_P(props)=thread->std.properties;
thread->serial = pthreads_serialize(props TSRMLS_CC);
FREE_ZVAL(props);
/* even null serializes, so if we get a NULL pointer then the serialzation failed and we should not continue */
if (thread->serial == NULL) {
zend_error(E_ERROR, "pthreads detected unsupported symbols in your thread, please amend your parameters");
RETURN_FALSE;
}
/*
* Set appropriate flags
*/
PTHREADS_SET_RUNNING(thread);
/*
* Acquire Thread Lock
*/
PTHREADS_LOCK(thread);
/*
* Create the thread
*/
if ((result = pthread_create(&thread->thread, NULL, PHP_PTHREAD_ROUTINE, (void*)thread)) == SUCCESS) {
/*
* Release Thread Lock
*/
PTHREADS_UNLOCK(thread);
/*
* Wait for appropriate event
*/
PTHREADS_WAIT(thread);
} else {
/*
* Do not attempt to join failed threads at dtor time
*/
PTHREADS_UNSET_RUNNING(thread);
zend_error(E_ERROR, "pthreads detected an internal error while creating thread (%d)", result);
}
} else zend_error(E_WARNING, "pthreads detected that this thread has already been started and it cannot reuse the Thread");
} else zend_error(E_WARNING, "pthreads detected an attempt to call an external method, do not attempt to start in this context");
if (result==SUCCESS) {
RETURN_TRUE;
}
RETURN_FALSE;
} /* }}} */
/* {{{ proto int Thread::stack(Thread $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_SELF(thread)) {
if (!PTHREADS_IS_JOINED(thread)) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, thread->std.ce)==SUCCESS) {
size = PTHREADS_PUSH(thread, PTHREADS_FETCH_FROM(work));
if (size) {
RETURN_LONG(size);
}
}
} else zend_error(E_ERROR, "pthreads has detected an attempt to stack onto a joined Thread (%lu)", thread->tid);
} else zend_error(E_ERROR, "pthreads has detected an attempt to call and external method on %lu, you cannot stack in this context", thread->tid);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
RETURN_FALSE;
} /* }}} */
/* {{{ proto int Thread::unstack([Thread $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_SELF(thread)) {
if (ZEND_NUM_ARGS() > 0) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &work, thread->std.ce)==SUCCESS) {
RETURN_LONG(PTHREADS_POP_EX(thread, PTHREADS_FETCH_FROM(work) TSRMLS_CC));
}
} else RETURN_LONG(PTHREADS_POP_EX(thread, NULL TSRMLS_CC));
} else zend_error(E_WARNING, "pthreads has detected an attempt to call an external method, you cannot unstack in this context");
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
RETURN_FALSE;
}
/* {{{ proto int Thread::getStacked()
Returns the current size of the stack */
PHP_METHOD(Thread, getStacked)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_SELF(thread) || PTHREADS_IS_IMPORT(thread)) {
RETURN_LONG(PTHREADS_GET_STACKED(thread->sig));
} else RETURN_LONG(PTHREADS_GET_STACKED(thread));
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
RETURN_FALSE;
}
/* {{{ proto Thread::isStarted()
Will return true if a Thread has been started */
PHP_METHOD(Thread, isStarted)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_IMPORT(thread)){
RETURN_BOOL(PTHREADS_IS_STARTED(thread->sig));
} else if (!PTHREADS_IS_SELF(thread)) {
RETURN_BOOL(PTHREADS_IS_STARTED(thread));
} else zend_error(E_WARNING, "pthreads has detected an attempt to use Thread::isStarted from the a Thread");
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
} /* }}} */
/* {{{ proto Thread::isRunning()
Will return true while a thread is executing */
PHP_METHOD(Thread, isRunning)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_IMPORT(thread)) {
RETURN_BOOL(PTHREADS_IS_RUNNING(thread->sig));
} else if (!PTHREADS_IS_SELF(thread)) {
RETURN_BOOL(PTHREADS_IS_RUNNING(thread));
} else zend_error(E_WARNING, "pthreads has detected an attempt to use Thread::isRunning from a Thread");
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
} /* }}} */
/* {{{ proto Thread::isJoined()
Will return true if a Thread has been joined already */
PHP_METHOD(Thread, isJoined)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_IMPORT(thread)) {
RETURN_BOOL(PTHREADS_IS_JOINED(thread->sig));
} else if (!PTHREADS_IS_SELF(thread)) {
RETURN_BOOL(PTHREADS_IS_JOINED(thread));
} else zend_error(E_WARNING, "pthreads has detected an attempt to use Thread::isJoined from a Thread");
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
} /* }}} */
/* {{{ proto Thread::isBusy()
Will return true if a Thread has been started and is running but hasn't yet been joined */
PHP_METHOD(Thread, isBusy)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_IMPORT(thread)) {
PTHREADS_LOCK(thread->sig);
if (PTHREADS_IN_STATE(thread->sig, PTHREADS_ST_STARTED)) {
if (!PTHREADS_IN_STATE(thread->sig, PTHREADS_ST_JOINED)) {
ZVAL_BOOL(return_value, PTHREADS_IN_STATE(thread->sig, PTHREADS_ST_RUNNING));
} else ZVAL_BOOL(return_value, 0);
} else ZVAL_BOOL(return_value, 0);
PTHREADS_UNLOCK(thread->sig);
} else if (!PTHREADS_IS_SELF(thread)) {
PTHREADS_LOCK(thread);
if (PTHREADS_IN_STATE(thread, PTHREADS_ST_STARTED)) {
if (!PTHREADS_IN_STATE(thread, PTHREADS_ST_JOINED)) {
ZVAL_BOOL(return_value, PTHREADS_IN_STATE(thread, PTHREADS_ST_RUNNING));
} else ZVAL_BOOL(return_value, 0);
} else ZVAL_BOOL(return_value, 0);
PTHREADS_UNLOCK(thread);
} else zend_error(E_WARNING, "pthreads has detected an attempt to use Thread::isBusy from a Thread");
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
} /* }}} */
/* {{{ 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) {
if (PTHREADS_IS_IMPORT(thread)){
PTHREADS_LOCK(thread->sig);
ZVAL_BOOL(return_value, PTHREADS_IN_STATE(thread->sig, PTHREADS_ST_WAITING));
PTHREADS_UNLOCK(thread->sig);
} else if (!PTHREADS_IS_SELF(thread)){
PTHREADS_LOCK(thread);
ZVAL_BOOL(return_value, PTHREADS_IN_STATE(thread, PTHREADS_ST_WAITING));
PTHREADS_UNLOCK(thread);
} else zend_error(E_WARNING, "pthreads has detected an attempt to use Thread::isWaiting from a Thread");
} else zend_error(E_ERROR, "pthreads has expereinced an internal error and cannot continue");
}
/* {{{ 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) {
if (!PTHREADS_IS_SELF(thread) && !PTHREADS_IS_IMPORT(thread)) {
RETURN_BOOL(PTHREADS_WAIT_EX(thread, timeout)>0);
} else RETURN_BOOL(PTHREADS_WAIT_EX(thread->sig, timeout)>0);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
} /* }}} */
/* {{{ proto boolean Thread::notify()
Notify anyone waiting that they can continue
A call to Thread::notify when no one is waiting will cause the thread or process that called it to block until someone waits
Will return a boolean indication of success
@TODO make this handle imported threads */
PHP_METHOD(Thread, notify)
{
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
if (PTHREADS_IS_SELF(thread)||PTHREADS_IS_IMPORT(thread)) {
RETURN_BOOL(PTHREADS_NOTIFY(thread->sig)>0);
} else RETURN_BOOL(PTHREADS_NOTIFY(thread)>0);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
RETURN_FALSE;
} /* }}} */
/* {{{ proto mixed Thread::join([boolean discard])
Will cause the calling thread to block and wait for the output of the referenced thread
If discard is void or false, properties set in the threading context during runtime will replace the properties of the referenced thread in the current context */
PHP_METHOD(Thread, join)
{
PTHREAD thread = PTHREADS_FETCH;
PTHREAD selected = NULL;
zval *symbols = NULL;
char *result = NULL;
zend_bool discard = 0;
/*
* Check for discard argument
*/
if (ZEND_NUM_ARGS())
zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &discard);
if (thread) {
/*
* Select the appropriate way to join the thread with the calling context
*/
if ((selected=(!PTHREADS_IS_SELF(thread) && !PTHREADS_IS_IMPORT(thread)) ? thread : (PTHREADS_IS_IMPORT(thread) && !PTHREADS_IS_SELF(thread)) ? thread->sig : NULL) != NULL) {
/*
* Ensure this thread was started
*/
if (PTHREADS_IS_STARTED(selected)) {
/*
* Ensure this thread wasn't already joined
*/
if (!PTHREADS_IS_JOINED(selected)) {
/*
* We must force threads to wake at this point
*/
if (PTHREADS_IS_BLOCKING(selected)) {
if (!PTHREADS_IS_WORKER(selected)) {
zend_error(E_WARNING, "pthreads has avoided a deadlock, the referenced thread was waiting for notification");
}
do {
PTHREADS_NOTIFY(selected);
} while(PTHREADS_IS_BLOCKING(selected));
}
/*
* Ensure nothing attempts to join this thread again
*/
PTHREADS_SET_JOINED(selected);
/*
* Carry out joining and deserialize result
*/
if (pthread_join(selected->thread, (void**)&result)==SUCCESS) {
if (result) {
pthreads_unserialize_into(result, return_value TSRMLS_CC);
free(result);
}
/*
* Replace symbol tables
*/
if (selected->serial) {
if (!discard) {
if (!PTHREADS_IS_IMPORT(thread)) {
if ((symbols=pthreads_unserialize(selected->serial TSRMLS_CC))!=NULL){
if (selected->std.properties) {
zend_hash_destroy(selected->std.properties);
FREE_HASHTABLE(selected->std.properties);
}
selected->std.properties = Z_ARRVAL_P(symbols);
FREE_ZVAL(symbols);
}
} else if (!PTHREADS_ST_CHECK(thread->state, PTHREADS_ST_JOINED)) {
if ((symbols=pthreads_unserialize(selected->serial TSRMLS_CC))!=NULL){
if (thread->std.properties) {
zend_hash_destroy(thread->std.properties);
FREE_HASHTABLE(thread->std.properties);
}
thread->std.properties = Z_ARRVAL_P(symbols);
FREE_ZVAL(symbols);
}
thread->state |= PTHREADS_ST_JOINED;
}
} else {
/*
* Discarding in any context affects all contexts and provides an easy way to release resources that aren't going to be used
*/
free(selected->serial);
selected->serial = NULL;
}
}
} else {
zend_error(E_WARNING, "pthreads detected failure while joining with the referenced Thread (%lu)", thread->tid);
RETURN_FALSE;
}
} else {
zend_error(E_WARNING, "pthreads has detected that the referenced Thread (%lu) has already been joined", thread->tid);
RETURN_TRUE;
}
} else {
zend_error(E_WARNING, "pthreads has detected an attempt to join a thread that is not yet started");
}
} else {
zend_error(E_ERROR, "pthreads detected a call to an external method, do not attempt to join in the this context");
}
} else {
zend_error(E_ERROR, "pthreads has expereinced an internal error and cannot continue");
RETURN_FALSE;
}
} /* }}} */
/* {{{ proto boolean Thread::getThread([long $tid])
Thread::find shall attempt to import the Thread identified by tid into the current context, for the purposes of synchronization */
PHP_METHOD(Thread, getThread)
{
PTHREAD found = NULL;
unsigned long tid = 0L;
if (pthreads_import_entry != NULL) {
if (EG(called_scope) == pthreads_class_entry) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tid)==SUCCESS) {
if (tid && tid >0L) {
if ((found=PTHREADS_FIND((unsigned long)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 */
PHP_METHOD(Thread, getThreadId)
{
if (getThis()) {
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
ZVAL_LONG(return_value, thread->tid);
} else ZVAL_LONG(return_value, 0);
} else ZVAL_LONG(return_value, 0);
} /* }}} */
/* {{{ proto long Thread::getCount()
Will return the number of threads currently running */
PHP_METHOD(Thread, getCount)
{
RETURN_LONG(PTHREADS_G_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(INI_INT("pthreads.max"));
} /* }}} */
/* {{{ proto long Thread::getPeak()
Will return the peak number of threads executing */
PHP_METHOD(Thread, getPeak)
{
RETURN_LONG(PTHREADS_G_PEAK());
} /* }}} */
/* {{{ proto long Thread::yield()
Will cause the calling thread to yield */
PHP_METHOD(Thread, yield)
{
#ifndef _WIN32
pthread_yield();
#endif
} /* }}} */
/* }}} */
/* {{{ Mutex methods */
/* {{{ 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;
} /* }}} */
/* }}} */
/* {{{ Cond Methods */
/* {{{ 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.35/php_pthreads.h 0000644 0000000 0000000 00000007720 12034302053 014737 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.34"
#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
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
PHP_MINIT_FUNCTION(pthreads);
PHP_MSHUTDOWN_FUNCTION(pthreads);
PHP_MINFO_FUNCTION(pthreads);
/* {{{ basic */
PHP_METHOD(Thread, start);
/* }}} */
/* {{{ advanced */
PHP_METHOD(Thread, yield);
/* }}} */
/* {{{ 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);
PHP_METHOD(Thread, isBusy);
/* }}} */
/* {{{ stacking */
PHP_METHOD(Thread, stack);
PHP_METHOD(Thread, unstack);
PHP_METHOD(Thread, getStacked);
/* }}} */
/* {{{ importing */
PHP_METHOD(Thread, getThread);
/* }}} */
/* {{{ identification */
PHP_METHOD(Thread, getThreadId);
/* }}} */
/* {{{ instance 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 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*)
#define phpext_pthreads_ptr &pthreads_module_entry
#endif
pthreads-0.0.35/pthreads_compat.h 0000644 0000000 0000000 00000007104 12034302053 015427 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_COMPAT_H
#define HAVE_PTHREADS_COMPAT_H
/*
* NOTES
* The only difference between pthreads_method_del_ref and zend_function_dtor in 5.4.6 is we free the run_time_cache if there are no more references to it and the release version free's it regardless
* Unsure of what this affects and how ...
*
* TODO
* Look into the run_time_cache issue in 5.4
*/
#ifdef _WIN32
#endif
#if PHP_VERSION_ID > 50399
static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->op_array_dtor) {
extension->op_array_dtor(op_array);
}
}
static void pthreads_method_del_ref(zend_function *function);
static void pthreads_method_del_ref(zend_function *function){
if (function && function->type == ZEND_USER_FUNCTION ) {
TSRMLS_FETCH();
zend_op_array *op_array = (zend_op_array*) function;
if (op_array) {
zend_literal *literal = op_array->literals;
zend_literal *end;
zend_uint i;
if (op_array->static_variables) {
zend_hash_destroy(op_array->static_variables);
FREE_HASHTABLE(op_array->static_variables);
}
if (--(*op_array->refcount)>0) {
return;
}
if (op_array->run_time_cache) {
free(
op_array->run_time_cache
);
}
free(op_array->refcount);
if (op_array->vars) {
i = op_array->last_var;
while (i > 0) {
i--;
str_free(op_array->vars[i].name);
}
free(op_array->vars);
}
if (literal) {
end = literal + op_array->last_literal;
while (literal < end) {
zval_dtor(&literal->constant);
literal++;
}
free(op_array->literals);
}
free(op_array->opcodes);
if (op_array->function_name) {
free((char*)op_array->function_name);
}
if (op_array->doc_comment) {
free((char*)op_array->doc_comment);
}
if (op_array->brk_cont_array) {
free(op_array->brk_cont_array);
}
if (op_array->try_catch_array) {
free(op_array->try_catch_array);
}
if (op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) {
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_dtor_handler, op_array TSRMLS_CC);
}
if (op_array->arg_info) {
for (i=0; inum_args; i++) {
str_free(op_array->arg_info[i].name);
if (op_array->arg_info[i].class_name) {
str_free(op_array->arg_info[i].class_name);
}
}
free(op_array->arg_info);
}
}
}
}
#endif /* PHP_VERSION_ID > 50399 */
#endif /* HAVE_PTHREADS_COMPAT_H */
pthreads-0.0.35/pthreads_globals.h 0000644 0000000 0000000 00000012702 12034302053 015567 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. look into the possibility of providing persistent threads that survive across SAPI requests
* 2. test read/write lock speed vs mutex
* 3. make errors more meaningful
*/
/* {{{ thread structure and functions */
#ifndef HAVE_PTHREADS_THREAD_H
# include "pthreads_thread.h"
#endif /* }}} */
/* {{{ default mutex type */
extern pthread_mutexattr_t defmutex;
/* }}} */
/* {{{ pthreads_globals */
struct {
/*
* Initialized flag
* @NOTE the first MINIT of an instance will cause this flag to be set
*/
zend_bool init;
/*
* Globals Mutex
*/
pthread_mutex_t lock;
/*
* Peak Number of Running Threads
*/
size_t peak;
/*
* Running Thread List
*/
zend_llist threads;
} pthreads_globals; /* }}} */
/* {{{ PTHREADS_G */
#define PTHREADS_G(v) pthreads_globals.v
/* }}} */
/* {{{ PTHREADS_G_INIT */
static inline void pthreads_globals_init(){
if (!PTHREADS_G(init)) {
PTHREADS_G(init)=1;
PTHREADS_G(peak)=0;
pthread_mutex_init(&PTHREADS_G(lock), &defmutex);
zend_llist_init(&PTHREADS_G(threads), sizeof(void**), NULL, 1);
}
} /* }}} */
#define PTHREADS_G_INIT pthreads_globals_init
/* {{{ PTHREADS_G_LOCK */
static inline int pthreads_globals_lock(){
switch (pthread_mutex_lock(&PTHREADS_G(lock))) {
case SUCCESS:
case EDEADLK:
return 1;
break;
default: return 0;
}
} /* }}} */
#define PTHREADS_G_LOCK pthreads_globals_lock
/* {{{ PTHREADS_G_UNLOCK */
static inline void pthreads_globals_unlock() {
if (!PTHREADS_G(init)) {
zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
}
pthread_mutex_unlock(&PTHREADS_G(lock));
} /* }}} */
#define PTHREADS_G_UNLOCK pthreads_globals_unlock
/* {{{ PTHREADS_G_COUNT */
static inline long pthreads_globals_count() {
long result = 0L;
if (PTHREADS_G_LOCK()) {
result = PTHREADS_G(threads).count;
PTHREADS_G_UNLOCK();
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
return result;
} /* }}} */
#define PTHREADS_G_COUNT pthreads_globals_count
/* {{{ PTHREADS_G_ADD */
static inline void pthreads_globals_add(PTHREAD thread) {
if (PTHREADS_G_LOCK()) {
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_G_UNLOCK();
}
if (found) {
return search;
} else return NULL;
} /* }}} */
#define PTHREADS_FIND(tid) pthreads_find(tid)
#endif /* HAVE_PTHREADS_GLOBAL_H */
pthreads-0.0.35/pthreads_handlers.h 0000644 0000000 0000000 00000020061 12034302053 015741 0 ustar root root /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins |
+----------------------------------------------------------------------+
*/
/*
* These handlers are mutex aware for safer operation in multi-threaded applications
*/
#ifndef HAVE_PTHREADS_HANDLERS_H
#define HAVE_PTHREADS_HANDLERS_H
extern zend_object_handlers * zsh;
/* {{{ 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
#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
#endif /* }}} */
zval * pthreads_read_property(PTHREADS_READ_PROPERTY_PASSTHRU_D);
void pthreads_write_property(PTHREADS_WRITE_PROPERTY_PASSTHRU_D);
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D);
void pthreads_unset_property(PTHREADS_UNSET_PROPERTY_PASSTHRU_D);
/* {{ read_property */
zval * pthreads_read_property (PTHREADS_READ_PROPERTY_PASSTHRU_D) {
PTHREAD thread = PTHREADS_FETCH_FROM(object);
int acquire = 0;
int oacquire = 0;
zval **lookup = NULL;
zval *property = NULL;
char *serial = NULL;
if (thread) {
acquire = pthread_mutex_lock(PTHREADS_IS_IMPORT(thread) ? thread->sig->lock : thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
if (!PTHREADS_IS_SELF(thread) && !PTHREADS_IS_IMPORT(thread)) {
if (!PTHREADS_IS_JOINED(thread->sig)) {
oacquire = pthread_mutex_lock(thread->sig->lock);
if (oacquire == SUCCESS || oacquire == EDEADLK) {
if (zend_hash_find(thread->sig->std.properties, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void**)&lookup)==SUCCESS) {
switch(Z_TYPE_PP(lookup)){
case IS_LONG:
case IS_BOOL:
case IS_STRING:
case IS_NULL:
case IS_ARRAY:
serial = pthreads_serialize(*lookup TSRMLS_CC);
if (serial) {
if ((property = pthreads_unserialize(serial TSRMLS_CC)) != NULL)
Z_SET_REFCOUNT_P(property, 0);
free(serial);
}
break;
/* it's possible to allow access to an object, however I feel it's unsafe and too heavy */
/* objects will become available when the thread is joined and we know for sure the object is no longer being manipulated by another context */
case IS_OBJECT:
case IS_RESOURCE:
zend_error(E_WARNING, "pthreads detected an attempt to fetch an unsupported symbol (%s)", Z_STRVAL_P(member));
break;
}
}
if (oacquire != EDEADLK)
pthread_mutex_unlock(thread->sig->lock);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
} else if (PTHREADS_IS_IMPORT(thread)) {
oacquire = pthread_mutex_lock(thread->sig->sig->lock);
if (oacquire == SUCCESS || oacquire == EDEADLK) {
if (!PTHREADS_ST_CHECK(thread->state, PTHREADS_ST_JOINED)) {
if (zend_hash_find(thread->sig->sig->std.properties, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void**)&lookup)==SUCCESS) {
switch(Z_TYPE_PP(lookup)){
case IS_LONG:
case IS_BOOL:
case IS_STRING:
case IS_NULL:
case IS_ARRAY:
serial = pthreads_serialize(*lookup TSRMLS_CC);
if (serial) {
if ((property = pthreads_unserialize(serial TSRMLS_CC)) != NULL)
Z_SET_REFCOUNT_P(property, 0);
free(serial);
}
break;
/* it's possible to allow access to an object, however I feel it's unsafe and too heavy */
/* objects will become available when the thread is joined and we know for sure the object is no longer being manipulated by another context */
case IS_OBJECT:
case IS_RESOURCE:
zend_error(E_WARNING, "pthreads detected an attempt to fetch an unsupported symbol (%s)", Z_STRVAL_P(member));
break;
}
}
}
if (oacquire != EDEADLK)
pthread_mutex_unlock(thread->sig->sig->lock);
}
}
if (property == NULL)
property = zsh->read_property(PTHREADS_READ_PROPERTY_PASSTHRU_C);
if (acquire != EDEADLK)
pthread_mutex_unlock(PTHREADS_IS_IMPORT(thread) ? thread->sig->lock : thread->lock);
} else zend_error(E_ERROR, "pthreads has experienced an internal error and cannot continue");
}
return property;
} /* }}} */
/* {{{ write_property */
void pthreads_write_property(PTHREADS_WRITE_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) {
zsh->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");
}
} /* }}} */
/* {{{ has_property */
int pthreads_has_property(PTHREADS_HAS_PROPERTY_PASSTHRU_D) {
PTHREAD thread = PTHREADS_FETCH_FROM(object);
int acquire = 0;
int result = 0;
if (thread) {
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
result = zsh->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_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) {
zsh->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");
}
} /* }}} */
#endif
pthreads-0.0.35/pthreads_object.h 0000644 0000000 0000000 00000073661 12034302053 015425 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
/*
* NOTES
* 1. Not happy with inability to detect scope properly in Threads, too many annoyances to be acceptable
* 2. Private/Protected Members in user declared Threads not working properly as a result of the above
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* {{{ state constants */
#define PTHREADS_ST_STARTED 1
#define PTHREADS_ST_RUNNING 2
#define PTHREADS_ST_JOINED 4
#define PTHREADS_ST_WAITING 8
#define PTHREADS_ST_CHECK(state, bits) ((state & bits)==bits)
/* }}} */
/* {{{ THREAD structure */
#ifndef HAVE_PTHREADS_THREAD_H
# include "pthreads_thread.h"
#endif
/* }}} */
/* {{{ Empty method entries */
zend_function_entry pthreads_empty_methods[] = {
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ prototypes */
zend_object_value pthreads_attach_to_instance(zend_class_entry *entry TSRMLS_DC);
zend_object_value pthreads_attach_to_import(zend_class_entry *entry TSRMLS_DC);
void pthreads_detach_from_instance(void * child TSRMLS_DC);
void * PHP_PTHREAD_ROUTINE(void *);
/* }}} */
/* {{{ macros */
/* {{{ inline static prototypes support macros */
static inline int pthreads_is_worker(PTHREAD thread);
static inline int pthreads_set_worker(PTHREAD thread, zend_bool flag);
static inline int pthreads_get_state(PTHREAD thread);
static inline int pthreads_set_state_ex(PTHREAD thread, int state, long timeout);
static inline int pthreads_set_state(PTHREAD thread, int state);
static inline int pthreads_unset_state(PTHREAD thread, int state);
static inline int pthreads_import(PTHREAD thread, zval **return_value TSRMLS_DC);
static inline int pthreads_pop(PTHREAD thread, zval *this_ptr TSRMLS_DC);
static inline int pthreads_pop_ex(PTHREAD thread, PTHREAD work TSRMLS_DC);
static inline int pthreads_push(PTHREAD thread, PTHREAD work);
static inline int pthreads_get_stacked(PTHREAD thread);
/* }}} */
/* {{{ 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) /* }}} */
/* {{{ tell if a referenced PTHREAD is threading version of the users object */
#define PTHREADS_IS_SELF(t) (t->self) /* }}} */
/* {{{ tell if the current thread created referenced PTHREAD */
#define PTHREADS_IS_CREATOR(t) (t->cid == pthreads_self()) /* }}} */
/* {{{ get the import flag on a PTHREAD */
#define PTHREADS_IS_IMPORT(t) t->import /* }}} */
/* {{{ set the worker flag on a PTHREAD */
#define PTHREADS_SET_WORKER pthreads_set_worker /* }}} */
/* {{{ get the worker flag for a PTHREAD */
#define PTHREADS_IS_WORKER pthreads_is_worker /* }}} */
/* {{{ get state from a PTHREAD */
#define PTHREADS_ST(t) pthreads_get_state(t) /* }}} */
/* {{{ tell if a PTHREAD is blocking */
#define PTHREADS_IS_BLOCKING(t) ((PTHREADS_ST(t) & PTHREADS_ST_WAITING)==PTHREADS_ST_WAITING) /* }}} */
/* {{{ set the joined state on the referenced PTHREAD */
#define PTHREADS_SET_JOINED(t) pthreads_set_state(t, PTHREADS_ST_JOINED) /* }}} */
/* {{{ set the running state on the referenced PTHREAD */
#define PTHREADS_SET_RUNNING(t) pthreads_set_state(t, PTHREADS_ST_RUNNING) /* }}} */
/* {{{ unset the running state on the referenced PTHREAD */
#define PTHREADS_UNSET_RUNNING(t) pthreads_unset_state(t, PTHREADS_ST_RUNNING) /* }}} */
/* {{{ set the joined state on the referenced PTHREAD */
#define PTHREADS_IS_JOINED(t) ((PTHREADS_ST(t) & PTHREADS_ST_JOINED)==PTHREADS_ST_JOINED) /* }}} */
/* {{{ set the started state on the referenced PTHREAD */
#define PTHREADS_IS_STARTED(t) ((PTHREADS_ST(t) & PTHREADS_ST_STARTED)==PTHREADS_ST_STARTED) /* }}} */
/* {{{ tell if the referenced PTHREAD is in the running state */
#define PTHREADS_IS_RUNNING(t) ((PTHREADS_ST(t) & PTHREADS_ST_RUNNING)==PTHREADS_ST_RUNNING) /* }}} */
/* {{{ tell if the referenced PTHREAD has been started */
#define PTHREADS_SET_STARTED(t) pthreads_set_state(t, PTHREADS_ST_STARTED) /* }}} */
/* {{{ wait on the referenced PTHREAD monitor to be notified */
#define PTHREADS_WAIT(t) pthreads_set_state(t, PTHREADS_ST_WAITING) /* }}} */
/* {{{ wait on the referenced PTHREAD monitor for a specific amount of time */
#define PTHREADS_WAIT_EX(t, l) pthreads_set_state_ex(t, PTHREADS_ST_WAITING, l) /* }}} */
/* {{{ notify the referenced PTHREAD monitor */
#define PTHREADS_NOTIFY(t) pthreads_unset_state(t, PTHREADS_ST_WAITING) /* }}} */
/* {{{ lock a threads state */
#define PTHREADS_LOCK(t) pthread_mutex_lock(t->lock) /* }}} */
/* {{{ unlock a threads state */
#define PTHREADS_UNLOCK(t) pthread_mutex_unlock(t->lock) /* }}} */
/* {{{ setup reference to self using from as the threading version of $this */
#define PTHREADS_SET_SELF(from) do{\
self = PTHREADS_FETCH_FROM(from);\
self->self = 1;\
self->tid = thread->tid;\
self->cid = thread->cid;\
self->state = PTHREADS_ST_STARTED|PTHREADS_ST_RUNNING;\
self->sig = thread;\
thread->sig = self;\
}while(0) /* }}} */
/* {{{ check for state, assumes you have the mutex for thread */
#define PTHREADS_IN_STATE(t, s) PTHREADS_ST_CHECK(t->state, s) /* }}} */
/* {{{ import a thread from another context */
#define PTHREADS_IMPORT pthreads_import /* }}} */
/* {{{ pop the next item from the work buffer onto the current stack */
#define PTHREADS_POP pthreads_pop /* }}} */
/* {{{ pop a specific item or all items from the stack and discard */
#define PTHREADS_POP_EX pthreads_pop_ex /* }}} */
/* {{{ push an item onto the work stack for a thread */
#define PTHREADS_PUSH pthreads_push /* }}} */
/* {{{ get the number of items on the stack */
#define PTHREADS_GET_STACKED pthreads_get_stacked /* }}} */
/* {{{ handlers included here for access to macros above */
#ifndef HAVE_PTHREADS_HANDLERS_H
# include "pthreads_handlers.h"
#endif /* }}} */
/*{{{ inline statics declarations */
/* {{{ set worker flag on PTHREAD */
static inline int pthreads_set_worker(PTHREAD thread, zend_bool flag) {
int acquire = pthread_mutex_lock(thread->lock);
int result = 0;
if (acquire == SUCCESS || acquire == EDEADLK) {
thread->worker = flag;
result = 1;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else result = 0;
return result;
} /* }}} */
/* {{{ get worker flag on PTHREAD */
static inline int pthreads_is_worker(PTHREAD thread) {
int result;
int acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
result = thread->worker;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else result = -1;
return result;
} /* }}} */
/* {{{ get thread state mask */
static inline int pthreads_get_state(PTHREAD thread){
int result = -1;
int acquire = pthread_mutex_lock(thread->lock);
if (acquire==SUCCESS || acquire == EDEADLK) {
result = thread->state;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
}
return result;
} /* }}} */
/* {{{ set state bits on a thread, timeout where appropriate/required */
static inline int pthreads_set_state_ex(PTHREAD thread, int state, long timeout){
int result = -1;
struct timeval now;
struct timespec until;
int acquire;
int wacquire;
int timed = 0;
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;
}
timed=1;
}
}
if (PTHREADS_ST_CHECK(state, PTHREADS_ST_WAITING)) {
wacquire = pthread_mutex_lock(thread->wait);
}
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
thread->state |= state;
switch(state) {
case PTHREADS_ST_WAITING: do {
if (timed) {
result=!pthread_cond_timedwait(thread->sync, thread->lock, &until);
} else pthread_cond_wait(thread->sync, thread->lock);
} while(PTHREADS_IN_STATE(thread, PTHREADS_ST_WAITING));
break;
case PTHREADS_ST_RUNNING: PTHREADS_G_ADD(thread); break;
}
if (PTHREADS_ST_CHECK(state, PTHREADS_ST_WAITING)) {
if (result == -1)
result = thread->state;
}
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 (PTHREADS_ST_CHECK(state, PTHREADS_ST_WAITING)) {
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->wait);
}
return result;
} /* }}} */
/* {{{ set state bits on a thread */
static inline int pthreads_set_state(PTHREAD thread, int state) {
return pthreads_set_state_ex(thread, state, 0L);
} /* }}} */
/* {{{ unset state bits on a thread */
static inline int pthreads_unset_state(PTHREAD thread, int state){
int result = -1;
int acquire = 0;
check:
switch (state) {
case PTHREADS_ST_WAITING:
if (!PTHREADS_IS_BLOCKING(thread)) {
#if _WIN32
Sleep(10);
#else
usleep(100000);
#endif
goto check;
}
break;
}
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
thread->state &= ~state;
switch (state) {
case PTHREADS_ST_WAITING: pthread_cond_broadcast(thread->sync); break;
case PTHREADS_ST_RUNNING: PTHREADS_G_DEL(thread); break;
}
result = thread->state;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
return ((result & state) != state);
} /* }}} */
/* {{{ pop for php */
static inline int pthreads_pop_ex(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 zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
return remain;
} /* }}} */
/* {{{ pop the next item from the work buffer */
static inline int pthreads_pop(PTHREAD thread, zval *this_ptr TSRMLS_DC) {
PTHREAD *work = NULL;
PTHREAD current = NULL;
int acquire = 0;
int remain = -1;
int bubble = 0;
zval *that_ptr;
zend_class_entry ce;
zend_class_entry *pce;
zend_function *run;
burst:
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
bubble = thread->worker;
if (thread->stack.count > 0) {
work = zend_llist_get_first(&thread->stack);
if (work && (current = *work) && current) {
bubble = 0;
/*
* We create another class entry for the work
*/
INIT_CLASS_ENTRY(
ce,
current->std.ce->name,
pthreads_empty_methods
);
pce=zend_register_internal_class(&ce TSRMLS_CC);
/*
* Allocate a $that
*/
ALLOC_ZVAL(that_ptr);
/*
* Initialize it with the new entry
*/
object_init_ex(that_ptr, pce);
/*
* Copy user declared methods
*/
zend_hash_copy(
&Z_OBJCE_P(that_ptr)->function_table,
¤t->std.ce->function_table,
(copy_ctor_func_t) function_add_ref,
&run, sizeof(zend_function)
);
/*
* Setup the executor again
*/
if (zend_hash_find(&Z_OBJCE_P(that_ptr)->function_table, "run", sizeof("run"), (void**) &run)==SUCCESS) {
#if PHP_VERSION_ID > 50399
/*
* Versions above 5.4 have run_time_cache to contend with, handled in compat for now
* @NOTE 5.4 still leaks executing workers, zend catches it MUST find a soltuion
*/
Z_OBJCE_P(that_ptr)->function_table.pDestructor = (dtor_func_t) pthreads_method_del_ref;
#endif
/*
* Set next op array
*/
PTHREADS_EG(thread->ls, active_op_array)=(zend_op_array*)run;
/*
* Return what is left on stack
*/
remain = thread->stack.count;
}
/*
* Cleanup List
*/
zend_llist_del_element(&thread->stack, work, (int (*)(void *, void *)) pthreads_equal_func);
}
}
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 (bubble && remain < 0 && !PTHREADS_IS_JOINED(thread)) {
if (PTHREADS_WAIT(thread) > 0) {
remain = -1;
goto burst;
}
}
return remain;
} /* }}} */
/* {{{ push an item onto the work buffer */
static inline int pthreads_push(PTHREAD thread, PTHREAD work) {
int acquire = 0;
int counted = -1;
int notify = 0;
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
thread->worker = 1;
zend_llist_add_element(&thread->stack, &work);
counted = thread->stack.count;
notify = PTHREADS_IN_STATE(thread, PTHREADS_ST_WAITING);
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
if (counted && notify) {
PTHREADS_NOTIFY(thread);
}
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
return counted;
} /* }}} */
/* {{{ return the number of items currently stacked */
static inline int pthreads_get_stacked(PTHREAD thread) {
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 zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue");
return counted;
} /* }}} */
/* {{{ import a thread created in another context into the current context */
static inline int pthreads_import(PTHREAD thread, zval** return_value TSRMLS_DC){
if (!PTHREADS_IS_CREATOR(thread)) {
/*
* Initialize the thread in the current context
*/
if (object_init_ex(*return_value, pthreads_import_entry)==SUCCESS) {
PTHREAD imported = PTHREADS_FETCH_FROM(*return_value);
if (imported) {
/*
* Block all changes to state while we setup
*/
PTHREADS_LOCK(thread);
/*
* The Thread identifier of the imported thread
*/
imported->tid = thread->tid;
/*
* Set creator to the importing thread
*/
imported->cid = pthreads_self();
/*
* These objects are treated differently so must set import flag
*/
imported->import = 1;
/*
* These objects do not require a sync or lock or state of their own
*/
imported->wait = NULL;
imported->sync = NULL;
imported->lock = NULL;
imported->state = 0L;
/*
* Set the imports significant other
*/
imported->sig = thread;
/*
* Unlock the thread we've imported
*/
PTHREADS_UNLOCK(thread);
return 1;
} else zend_error_noreturn(E_WARNING, "pthreads has detected a failure while importing Thread %lu from Thread %lu", thread->tid, thread->cid);
} else zend_error_noreturn(E_WARNING, "pthreads has detected a failure while trying to initialize imported Thread %lu", thread->tid);
} else zend_error_noreturn(E_WARNING, "pthreads has detected an attempt to import a thread that was created in the current context");
return 0;
} /* }}} */
/* }}} */
/* {{{ this constructor is used to build the original PTHREAD in the creating context */
zend_object_value pthreads_attach_to_instance(zend_class_entry *entry TSRMLS_DC){
#if PHP_VERSION_ID < 50399
zval *temp;
#endif
zend_object_value attach;
/*
* Allocate an initialize thread object for storage
*/
PTHREAD thread = calloc(1, sizeof(*thread));
thread->synchronized = 0;
thread->self = 0;
thread->pls = tsrm_ls;
thread->ls = NULL;
thread->sig = NULL;
thread->tid = 0L;
thread->cid = pthreads_self();
/*
* State Initialization
*/
thread->lock = (pthread_mutex_t*) calloc(1, sizeof(pthread_mutex_t));
if (thread->lock) {
pthread_mutex_init(thread->lock, &defmutex);
thread->state = 0;
thread->wait = (pthread_mutex_t*) calloc(1, sizeof(pthread_mutex_t));
if (thread->wait) {
pthread_mutex_init(thread->wait, &defmutex);
}
}
/*
* Sync Initialization
*/
thread->sync = (pthread_cond_t*) calloc(1, sizeof(pthread_cond_t));
if (thread->sync)
pthread_cond_init(thread->sync, NULL);
/*
* Initialize Work buffer
*/
zend_llist_init(&thread->stack, sizeof(void**), NULL, 1);
/*
* Initialize standard entry
*/
zend_object_std_init(&thread->std, entry TSRMLS_CC);
/*
* Initialize instance properties
*/
#if PHP_VERSION_ID < 50399
{
zend_hash_copy(
thread->std.properties,
&entry->default_properties,
ZVAL_COPY_CTOR,
&temp, sizeof(zval*)
);
}
#else
object_properties_init(&(thread->std), entry);
#endif
/*
* Store the object
*/
attach.handle = zend_objects_store_put(
thread,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
pthreads_detach_from_instance,
NULL TSRMLS_CC
);
/*
* Mutex aware handlers
*/
attach.handlers = &poh;
return attach;
}
/* }}} */
/* {{{ this constructor is used to build a PTHREAD skeleton for use as a base object to represent an imported thread */
zend_object_value pthreads_attach_to_import(zend_class_entry *entry TSRMLS_DC){
#if PHP_VERSION_ID < 50399
zval *temp;
#endif
zend_object_value attach;
/*
* Allocate an initialize thread object for storage
*/
PTHREAD import = calloc(1, sizeof(*import));
import->synchronized = 0;
import->self = 0;
import->ls = tsrm_ls;
import->pls = NULL;
import->sig = NULL;
import->tid = 0L;
import->cid = pthreads_self();
import->lock = NULL;
import->sync = NULL;
import->state = 0;
/*
* Standard Entry Initialization
*/
zend_object_std_init(&import->std, entry TSRMLS_CC);
/*
* Initialize instance properties
*/
#if PHP_VERSION_ID < 50399
{
zend_hash_copy(
import->std.properties,
&entry->default_properties,
ZVAL_COPY_CTOR,
&temp, sizeof(zval*)
);
}
#else
object_properties_init(&(import->std), entry);
#endif
/*
* Store the object
*/
attach.handle = zend_objects_store_put(
import,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
pthreads_detach_from_instance,
NULL TSRMLS_CC
);
/*
* Attach pthreads handlers
*/
attach.handlers = &poh;
return attach;
}
/* }}} */
/* {{{ this destructor handles all types of PTHREAD gracefully */
void pthreads_detach_from_instance(void * arg TSRMLS_DC){
/*
* We must check for a result even when it's ignored
*/
char *result;
PTHREAD thread = (PTHREAD) arg;
int acquire = EDEADLK;
if (thread) {
if (!PTHREADS_IS_SELF(thread) && !PTHREADS_IS_IMPORT(thread)) {
/*
* If the thread is running we must attempt to join
*/
if (PTHREADS_IS_STARTED(thread)) {
if (!PTHREADS_IS_JOINED(thread)) {
/*
* Here we force blocking threads to wake and warn users of the deadlock
*/
if (PTHREADS_IS_BLOCKING(thread)) {
zend_error(E_WARNING, "pthreads has avoided a deadlock, thread #%lu was waiting for notification", thread->tid);
PTHREADS_NOTIFY(thread);
}
pthread_join(thread->thread, (void*) &result);
PTHREADS_SET_JOINED(thread);
/*
* Free the result for the thread
*/
if (result)
free(result);
}
}
/*
* Free whatever is found in the serial buffer
*/
if (thread->serial)
free(thread->serial);
}
/*
* Deal with properties in a safe manner by requiring the lock
*/
{
if (!PTHREADS_IS_IMPORT(thread)) {
acquire = pthread_mutex_lock(thread->lock);
}
/*
* Destroy object properties
*/
if (thread->std.properties) {
zend_hash_destroy(thread->std.properties);
FREE_HASHTABLE(thread->std.properties);
}
if (acquire != EDEADLK) {
pthread_mutex_unlock(thread->lock);
}
}
#if PHP_VERSION_ID > 50399
/*
* 5.4+ requires that you free default properties seperately
*/
if (thread->std.ce->default_properties_count > 0 && thread->std.properties_table) {
int i=0;
for (;istd.ce->default_properties_count;i++){
if (thread->std.properties_table[i]) {
zval_ptr_dtor(&thread->std.properties_table[i]);
}
}
efree(thread->std.properties_table);
}
#endif
if (!PTHREADS_IS_IMPORT(thread)) {
/*
* Destroy Wait Lock
*/
if (thread->wait) {
pthread_mutex_destroy(thread->wait);
free(thread->wait);
}
/*
* Destroy State Lock
*/
if (thread->lock) {
pthread_mutex_destroy(thread->lock);
free(thread->lock);
}
/*
* Destroy Sync
*/
if (thread->sync) {
pthread_cond_destroy(thread->sync);
free(thread->sync);
}
/*
* Destroy Stack
*/
zend_llist_destroy(&thread->stack);
}
/*
* Finally free the thread object
*/
free(thread);
}
}
/* }}} */
/* {{{ this is aptly named ... */
void * PHP_PTHREAD_ROUTINE(void *arg){
/*
* The thread in the context where it was created
*/
PTHREAD thread = (PTHREAD) arg;
/*
* The thread in this context
*/
PTHREAD self = NULL;
/*
* A pointer to the exit value of the thread
*/
char *result = NULL;
/*
* Allocating a new string for the thread class entry in this context ensures a clean, error free shutdown
*/
char *rename = NULL;
/*
* The interpreter context for this thread
*/
void ***ctx;
if (thread) {
/*
* Allocate and Initialize an interpreter context for this Thread
*/
PTHREADS_G_LOCK();
ctx = thread->ls = tsrm_new_interpreter_context();
PTHREADS_G_UNLOCK();
{
/*
* As always, a pointer to $this
*/
zval *this_ptr;
/*
* As always, the return value pointer
*/
zval *return_value = NULL;
/*
* Thread safe property store
*/
zval *symbols = NULL;
/*
* Reference to original properties
*/
HashTable *properties = NULL;
/*
* Class Entry for the Thread in this context
*/
zend_class_entry ce;
/*
* Temporary function pointer
*/
zend_function *tf;
/*
* Will signify if the user has declared __prepare magic
*/
int preparation = 0;
/*
* Pointer to __prepare megic implementation
*/
zend_function *prepare;
/*
* Pointer to run implementation
*/
zend_function *run;
/*
* Set Context/TSRMLS
*/
tsrm_set_interpreter_context(ctx); {
TSRMLS_FETCH_FROM_CTX(ctx);
/*
* Set Thread Identifier
*/
thread->tid = pthreads_self();
/*
* Activate Zend
*/
#if COMPILE_DL_PTHREADS
/*
* Same server context as parent
*/
SG(server_context)=PTHREADS_SG(thread->pls, 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
/*
* A new reference to $this for the current context
*/
MAKE_STD_ZVAL(this_ptr);
zend_first_try {
/*
* First some basic executor setup, using zend_first_try sets a sensible bailout address incase of error
*/
EG(in_execution) = 1;
EG(current_execute_data)=NULL;
EG(current_module)=&pthreads_module_entry;
CG(compiled_filename)=rename;
/*
* Get a copy of the name of the users implementation of Thread
*/
rename = (char*) calloc(1, thread->std.ce->name_length+1);
if (rename) {
memcpy(
rename,
thread->std.ce->name,
thread->std.ce->name_length
);
}
/*
* Initialize the thread in the current context
*/
INIT_CLASS_ENTRY_EX(
ce,
rename,
thread->std.ce->name_length,
pthreads_empty_methods
);
ce.create_object = pthreads_attach_to_instance;
ce.serialize = zend_class_serialize_deny;
ce.unserialize = zend_class_unserialize_deny;
object_init_ex(this_ptr, zend_register_internal_class(
&ce TSRMLS_CC
));
/*
* Fetches a reference to thread from the current context
*/
PTHREADS_SET_SELF(getThis());
/*
* We can now set the executor and scope to reference a thread safe version of $this
*/
EG(called_scope) = Z_OBJCE_P(getThis());
EG(scope) = Z_OBJCE_P(getThis());
EG(This) = getThis();
/*
* Import the users object definition
*/
zend_hash_copy(
&Z_OBJCE_P(getThis())->function_table,
&thread->std.ce->function_table,
(copy_ctor_func_t) function_add_ref,
&tf, sizeof(zend_function)
);
/*
* Allow the creating thread to continue where appropriate
*/
if (!thread->synchronized)
PTHREADS_NOTIFY(thread);
/*
* Find methods for execution
*/
if(zend_hash_find(
&Z_OBJCE_P(getThis())->function_table,
"__prepare", sizeof("__prepare"),
(void**) &prepare
)==SUCCESS) {
preparation=1;
}
zend_hash_find(
&Z_OBJCE_P(getThis())->function_table,
"run", sizeof("run"),
(void**) &run
);
#if PHP_VERSION_ID > 50399
/*
* Versions above 5.4 have run_time_cache to contend with, handled in compat for now
*/
Z_OBJCE_P(getThis())->function_table.pDestructor = (dtor_func_t) pthreads_method_del_ref;
#endif
/*
* Even if the user does not supply symbols, they may create some
*/
if (!EG(active_symbol_table)) {
EG(active_symbol_table)=&EG(symbol_table);
}
/*
* Test for a preparation method
*/
if (preparation) {
/*
* Preparation is run out of context and the return value is ignored
*/
zval *discard;
EG(return_value_ptr_ptr)=&discard;
EG(active_op_array)=(zend_op_array*)prepare;
EG(active_op_array)->filename = rename;
zend_try {
zend_execute(EG(active_op_array) TSRMLS_CC);
} zend_end_try();
if (discard && Z_TYPE_P(discard) != IS_NULL) {
zval_ptr_dtor(&discard);
}
}
/*
* Setting these here makes deserialization errors sensible
*/
EG(return_value_ptr_ptr)=&return_value;
EG(active_op_array)=(zend_op_array*)run;
EG(active_op_array)->filename = rename;
/*
* Unserialize symbols from parent context
*/
if (thread->serial) {
symbols = pthreads_unserialize(thread->serial TSRMLS_CC);
if (symbols) {
/*
* Point the properties of the runnable at the thread safe symbols
*/
properties = self->std.properties;
self->std.properties=Z_ARRVAL_P(
symbols
);
}
/*
* Safe to free, no longer required
*/
free(thread->serial);
/*
* Avoid double free
*/
thread->serial = NULL;
}
/*
* Now time to execute Thread::run
*/
zend_try {
do {
if (EG(active_op_array)) {
EG(active_op_array)->filename = rename;
zend_execute(
EG(active_op_array) TSRMLS_CC
);
}
} while(pthreads_pop(thread, getThis() TSRMLS_CC)>-1);
} zend_end_try();
/*
* Serialize and destroy return value
*/
if (return_value && Z_TYPE_P(return_value) != IS_NULL) {
result = pthreads_serialize(
return_value TSRMLS_CC
);
zval_ptr_dtor(&return_value);
}
/*
* Serialize and destroy symbols
*/
if (symbols && Z_TYPE_P(symbols) != IS_NULL) {
thread->serial = pthreads_serialize(
symbols TSRMLS_CC
);
zval_ptr_dtor(&symbols);
}
/*
* Free zval allocated for $this
*/
FREE_ZVAL(this_ptr);
} zend_catch {
if (symbols && Z_TYPE_P(symbols) != IS_NULL) {
zval_ptr_dtor(&symbols);
}
if (return_value && Z_TYPE_P(return_value) != IS_NULL){
zval_ptr_dtor(&return_value);
}
FREE_ZVAL(this_ptr);
} zend_end_try();
/*
* Restoring the pointer to original property table ensures they are free'd
*/
if (self)
self->std.properties = properties;
/*
* Free the name of the thread
*/
if (rename) {
free(rename);
}
/*
* Deactivate Zend
*/
#if COMPILE_DL_PTHREADS
php_request_shutdown(TSRMLS_C);
#else
zend_deactivate_modules(TSRMLS_C);
zend_deactivate(TSRMLS_C);
#endif
}
/*
* Free Context
*/
PTHREADS_G_LOCK();
tsrm_free_interpreter_context(ctx);
PTHREADS_G_UNLOCK();
}
}
PTHREADS_UNSET_RUNNING(thread);
/*
* Passing serialized symbols back to thread
*/
pthread_exit((void*)result);
#ifdef _WIN32
/*
* Silence MSVC Compiler
*/
return NULL;
#endif
}
/* }}} */
#endif /* HAVE_PTHREADS_OBJECT_H */
pthreads-0.0.35/pthreads_serial.h 0000644 0000000 0000000 00000006076 12034302053 015432 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
/* {{{ prototypes */
char * pthreads_serialize(zval *unserial TSRMLS_DC);
zval * pthreads_unserialize(char *serial TSRMLS_DC);
int pthreads_unserialize_into(char *serial, zval *result TSRMLS_DC);
/* }}} */
/* {{{ Will serialize the zval into a newly allocated buffer which must be free'd by the caller */
char * pthreads_serialize(zval *unserial TSRMLS_DC){
char *result = NULL;
if (unserial && Z_TYPE_P(unserial) != IS_NULL) {
smart_str *output;
php_serialize_data_t vars;
PHP_VAR_SERIALIZE_INIT(vars);
output = (smart_str*) calloc(1, sizeof(smart_str));
php_var_serialize(
output,
&unserial,
&vars TSRMLS_CC
);
PHP_VAR_SERIALIZE_DESTROY(vars);
result = (char*) calloc(1, output->len+1);
memcpy(result, output->c, output->len);
smart_str_free(output);
free(output);
}
return result;
}
/* }}} */
/* {{{ Will unserialize data into the allocated zval passed */
int pthreads_unserialize_into(char *serial, zval *result TSRMLS_DC){
if (serial) {
const unsigned char *pointer = (const unsigned char *)serial;
php_unserialize_data_t vars;
PHP_VAR_UNSERIALIZE_INIT(vars);
if (!php_var_unserialize(&result, &pointer, pointer+strlen(serial), &vars TSRMLS_CC)) {
PHP_VAR_UNSERIALIZE_DESTROY(vars);
zval_dtor(result);
zend_error(E_WARNING, "The thread attempted to declare properties (%ld bytes of %s) that do not support serialization", strlen(serial), serial);
return FAILURE;
} else {
PHP_VAR_UNSERIALIZE_DESTROY(vars);
}
return SUCCESS;
} else return SUCCESS;
}
/* }}} */
/* {{{ Will unserialze data into a newly allocated buffer which must be free'd by the caller */
zval * pthreads_unserialize(char *serial TSRMLS_DC){
zval *result;
ALLOC_ZVAL(result);
if (pthreads_unserialize_into(serial, result TSRMLS_CC)==SUCCESS) {
return result;
} else return NULL;
}
/* }}} */
#endif
pthreads-0.0.35/pthreads_thread.h 0000644 0000000 0000000 00000006473 12034302053 015423 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
/* {{{ thread structure */
typedef struct _pthread_construct {
/*
* Standard Entry
*/
zend_object std;
/*
* The Thread
*/
pthread_t thread;
/*
* The Thread Identifier
*/
unsigned long tid;
/*
* The Thread Identifier of Creator
*/
unsigned long cid;
/*
* Thread Safe Local Storage
*/
void ***ls;
void ***pls;
/*
* State Management
*/
pthread_cond_t *sync;
pthread_mutex_t *lock;
pthread_mutex_t *wait;
int state;
/*
* Flags, safe but no locking
*/
zend_bool self;
zend_bool synchronized;
zend_bool import;
/*
* Requires a thread lock for access
*/
zend_bool worker;
/*
* Serial Buffer
*/
char *serial;
/*
* Work Buffer
*/
zend_llist stack;
/*
* Significant Other
*/
struct _pthread_construct *sig;
} THREAD, *PTHREAD;
/* {{{ comparison function */
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;
} /* }}} */
/* {{{ pthread_self wrapper */
ulong pthreads_self() {
#ifdef _WIN32
return (ulong) GetCurrentThreadId();
#else
return (ulong) pthread_self();
#endif
} /* }}} */
/* {{{ 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);
/* }}} */
#endif /* }}} */ /* HAVE_PTHREADS_THREAD_H */
pthreads-0.0.35/README.md 0000644 0000000 0000000 00000011120 12034302053 013351 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.