X-Git-Url: http://nitlanguage.org diff --git a/lib/pthreads/pthreads.nit b/lib/pthreads/pthreads.nit index 1e76e28..900063f 100644 --- a/lib/pthreads/pthreads.nit +++ b/lib/pthreads/pthreads.nit @@ -16,8 +16,10 @@ # Main POSIX threads support and intro the classes `Thread`, `Mutex` and `Barrier` module pthreads is - c_compiler_option("-pthread") - c_linker_option("-pthread") + cflags "-pthread" + ldflags "-pthread" + pkgconfig "bdw-gc" + new_annotation threaded end # @@ -34,9 +36,10 @@ in "C" `{ // TODO protect with: #ifdef WITH_LIBGC // We might have to add the next line to gc_chooser.c too, especially // if we get an error like "thread not registered with GC". + #ifndef ANDROID #define GC_THREADS #include - //#endif + #endif `} redef class Sys @@ -109,24 +112,14 @@ private extern class NativePthread in "C" `{ pthread_t * `} fun join: nullable Object `{ void *thread_return; - pthread_join(*recv, &thread_return); + pthread_join(*self, &thread_return); if(thread_return == NULL) thread_return = null_Object(); return (nullable_Object)thread_return; `} - fun cancel: Bool `{ - return pthread_cancel(*recv); - `} - - fun attr: NativePthreadAttr `{ - pthread_attr_t *pattr = malloc(sizeof(pthread_attr_t)); - pthread_getattr_np(*recv, pattr); - return pattr; - `} + fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *other); `} - fun equal(other: NativePthread): Bool `{ pthread_equal(*recv, *other); `} - - fun kill(signal: Int) `{ pthread_kill(*recv, signal); `} + fun kill(signal: Int) `{ pthread_kill(*self, signal); `} end private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `} @@ -142,7 +135,7 @@ private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `} `} fun destroy `{ - pthread_attr_destroy(recv); + pthread_attr_destroy(self); `} # Most features of this class are still TODO @@ -166,11 +159,11 @@ private extern class NativePthreadMutex in "C" `{ pthread_mutex_t * `} return mutex; `} - fun destroy `{ pthread_mutex_destroy(recv); `} + fun destroy `{ pthread_mutex_destroy(self); `} - fun lock `{ pthread_mutex_lock(recv); `} - fun try_lock: Bool `{ return pthread_mutex_trylock(recv); `} - fun unlock `{ pthread_mutex_unlock(recv); `} + fun lock `{ pthread_mutex_lock(self); `} + fun try_lock: Bool `{ return pthread_mutex_trylock(self); `} + fun unlock `{ pthread_mutex_unlock(self); `} end private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `} @@ -180,11 +173,11 @@ private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `} return attr; `} - fun destroy `{ pthread_mutexattr_destroy(recv); `} + fun destroy `{ pthread_mutexattr_destroy(self); `} - fun set_type_normal `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_NORMAL); `} - fun set_type_recursive `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_RECURSIVE); `} - fun set_type_errorcheck `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_ERRORCHECK); `} + fun set_type_normal `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_NORMAL); `} + fun set_type_recursive `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_RECURSIVE); `} + fun set_type_errorcheck `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_ERRORCHECK); `} # pthread_mutexattr_setpshared # pthread_mutexattr_setprotocol @@ -192,18 +185,6 @@ private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `} # pthread_mutexattr_setrobust_np end -private extern class NativePthreadBarrier in "C" `{ pthread_barrier_t * `} - new(count: Int) `{ - pthread_barrier_t *barrier = malloc(sizeof(pthread_barrier_t)); - int res = pthread_barrier_init(barrier, NULL, count); - return barrier; - `} - - fun destroy `{ pthread_barrier_destroy(recv); `} - - fun wait `{ pthread_barrier_wait(recv); `} -end - private extern class NativePthreadKey in "C" `{ pthread_key_t * `} new `{ pthread_key_t *key = malloc(sizeof(pthread_key_t)); @@ -212,16 +193,37 @@ private extern class NativePthreadKey in "C" `{ pthread_key_t * `} `} fun get: nullable Object `{ - void *val = pthread_getspecific(*recv); + void *val = pthread_getspecific(*self); if (val == NULL) val = null_Object(); return val; `} fun set(val: nullable Object) `{ - pthread_setspecific(*recv, val); + pthread_setspecific(*self, val); `} end +private extern class NativePthreadCond in "C" `{ pthread_cond_t * `} + new `{ + pthread_cond_t cond; + int r = pthread_cond_init(&cond, NULL); + if (r == 0) { + pthread_cond_t *pcond = malloc(sizeof(pthread_cond_t)); + memmove(pcond, &cond, sizeof(pthread_cond_t)); + return pcond; + } + return NULL; + `} + + fun destroy `{ pthread_cond_destroy(self); `} + + fun signal `{ pthread_cond_signal(self); `} + + fun broadcast `{ pthread_cond_broadcast(self); `} + + fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(self, mutex); `} +end + # ## Nity part # @@ -234,19 +236,26 @@ end abstract class Thread super Finalizable + # Type returned by `main` + type E : nullable Object + private var native: nullable NativePthread = null + # Is this thread finished ? True when main returned + var is_done = false + # Main method of this thread # # The returned valued is passed to the caller of `join`. - fun main: nullable Object do return null + fun main: E do return null - private fun main_intern: nullable Object + private fun main_intern: E do # Register thread local data sys.self_thread_key.set self - - return main + var r = main + self.is_done = true + return r end # Start executing this thread @@ -264,20 +273,12 @@ abstract class Thread # `Sys::thread_exit`. Returns the object returned from the other thread. # # Stats the thread if now already done by a call to `start`. - fun join: nullable Object + fun join: E do if native == null then start var r = native.join native = null - return r - end - - # Cancel the execution of the thread - fun cancel - do - if native == null then return - native.cancel - native = null + return r.as(E) end redef fun finalize @@ -298,9 +299,6 @@ end # Exit current thread and return `value` to caller of `Thread::join` fun exit_thread(value: nullable Object) `{ pthread_exit(value); `} -# Does not return if the running thread is to be cancelled -fun test_cancel `{ pthread_testcancel(); `} - # Returns the handle to the running `Thread` fun thread: Thread do @@ -364,24 +362,36 @@ end class Barrier super Finalizable + private var mutex = new Mutex + private var cond: nullable NativePthreadCond = new NativePthreadCond + # Number of threads that must be waiting for `wait` to unblock var count: Int - private var native: nullable NativePthreadBarrier is noinit - - init do native = new NativePthreadBarrier(count) + private var threads_waiting = 0 # Wait at this barrier and block until there are a `count` threads waiting - fun wait do native.wait + fun wait + do + mutex.lock + threads_waiting += 1 + if threads_waiting == count then + threads_waiting = 0 + cond.broadcast + else + cond.wait(mutex.native.as(not null)) + end + mutex.unlock + end redef fun finalize do - var native = self.native - if native != null then - native.destroy - native.free + var cond = self.cond + if cond != null then + cond.destroy + cond.free end - self.native = null + self.cond = null end end