cflags "-pthread"
ldflags "-pthread"
pkgconfig "bdw-gc"
+ new_annotation threaded
end
#
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 equal(other: NativePthread): Bool `{ return pthread_equal(*recv, *other); `}
+ fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *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 * `}
`}
fun destroy `{
- pthread_attr_destroy(recv);
+ pthread_attr_destroy(self);
`}
# Most features of this class are still TODO
private extern class NativePthreadMutex in "C" `{ pthread_mutex_t * `}
new (attr: NativePthreadMutexAttr) `{
pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
- int res = pthread_mutex_init(mutex, attr);
+ int r = pthread_mutex_init(mutex, attr);
+ if (r != 0) {
+ free(mutex);
+ return NULL;
+ }
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 * `}
new `{
pthread_mutexattr_t *attr = malloc(sizeof(pthread_mutexattr_t));
- int res = pthread_mutexattr_init(attr);
+ int r = pthread_mutexattr_init(attr);
+ if (r != 0) {
+ free(attr);
+ return NULL;
+ }
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
private extern class NativePthreadKey in "C" `{ pthread_key_t * `}
new `{
pthread_key_t *key = malloc(sizeof(pthread_key_t));
- int res = pthread_key_create(key, NULL);
+ int r = pthread_key_create(key, NULL);
+ if (r != 0) {
+ free(key);
+ return NULL;
+ }
return key;
`}
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
return NULL;
`}
- fun destroy `{ pthread_cond_destroy(recv); `}
+ fun destroy `{ pthread_cond_destroy(self); `}
- fun signal `{ pthread_cond_signal(recv); `}
+ fun signal `{ pthread_cond_signal(self); `}
- fun broadcast `{ pthread_cond_broadcast(recv); `}
+ fun broadcast `{ pthread_cond_broadcast(self); `}
- fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(recv, mutex); `}
+ fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(self, mutex); `}
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
# `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
+ return r.as(E)
end
redef fun finalize