/* Used in RL to get win/lin portability, and in SG when CONTEXT_THREAD */
/* in SG, when using CONTEXT_UCONTEXT, xbt_os_thread_stub is used instead */
-/* Copyright 2006,2007 Malek Cherier, Martin Quinson
- * All right reserved. */
+/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+ * All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "gras_config.h"
#include "xbt/sysdep.h"
#include "xbt/ex.h"
#include "xbt/ex_interface.h" /* We play crude games with exceptions */
char *name;
void *param;
pvoid_f_pvoid_t start_routine;
- ex_ctx_t *exception;
+ xbt_running_ctx_t *running_ctx;
+ void *extra_data;
} s_xbt_os_thread_t;
static xbt_os_thread_t main_thread = NULL;
}
/* callback: context fetching */
-static ex_ctx_t *_os_thread_ex_ctx(void)
+static xbt_running_ctx_t *_os_thread_get_running_ctx(void)
{
- return xbt_os_thread_self()->exception;
+ return xbt_os_thread_self()->running_ctx;
}
/* callback: termination */
/* FIXME: there should be a configuration variable to choose to kill everyone or only this one */
}
-void xbt_os_thread_mod_init(void)
+void xbt_os_thread_mod_preinit(void)
{
int errcode;
if ((errcode = pthread_key_create(&xbt_self_thread_key, NULL)))
THROW0(system_error, errcode,
"pthread_key_create failed for xbt_self_thread_key");
-
+
main_thread = xbt_new(s_xbt_os_thread_t, 1);
main_thread->name = (char *) "main";
main_thread->start_routine = NULL;
main_thread->param = NULL;
- main_thread->exception = xbt_new(ex_ctx_t, 1);
- XBT_CTX_INITIALIZE(main_thread->exception);
+ main_thread->running_ctx = xbt_new(xbt_running_ctx_t, 1);
+ XBT_RUNNING_CTX_INITIALIZE(main_thread->running_ctx);
- __xbt_ex_ctx = _os_thread_ex_ctx;
+ if ((errcode = pthread_setspecific(xbt_self_thread_key, main_thread)))
+ THROW0(system_error, errcode,
+ "pthread_setspecific failed for xbt_self_thread_key");
+
+
+ __xbt_running_ctx_fetch = _os_thread_get_running_ctx;
__xbt_ex_terminate = _os_thread_ex_terminate;
thread_mod_inited = 1;
-#ifndef HAVE_SEM_WAIT
+#ifndef HAVE_SEM_INIT
next_sem_ID_lock = xbt_os_mutex_init();
#endif
}
-void xbt_os_thread_mod_exit(void)
+void xbt_os_thread_mod_postexit(void)
{
/* FIXME: don't try to free our key on shutdown.
Valgrind detects no leak if we don't, and whine if we try to */
// if ((errcode=pthread_key_delete(xbt_self_thread_key)))
// THROW0(system_error,errcode,"pthread_key_delete failed for xbt_self_thread_key");
- free(main_thread->exception);
+ free(main_thread->running_ctx);
free(main_thread);
main_thread = NULL;
thread_mod_inited = 0;
-#ifndef HAVE_SEM_WAIT
+#ifndef HAVE_SEM_INIT
xbt_os_mutex_destroy(next_sem_ID_lock);
#endif
/* Restore the default exception setup */
- __xbt_ex_ctx = &__xbt_ex_ctx_default;
+ __xbt_running_ctx_fetch = &__xbt_ex_ctx_default;
__xbt_ex_terminate = &__xbt_ex_terminate_default;
}
+int xbt_os_thread_atfork(void (*prepare)(void),
+ void (*parent)(void), void (*child)(void))
+{
+ return pthread_atfork(prepare, parent, child);
+}
+
static void *wrapper_start_routine(void *s)
{
xbt_os_thread_t t = s;
xbt_os_thread_t xbt_os_thread_create(const char *name,
pvoid_f_pvoid_t start_routine,
- void *param)
+ void *param,
+ void *extra_data)
{
int errcode;
res_thread->name = xbt_strdup(name);
res_thread->start_routine = start_routine;
res_thread->param = param;
- res_thread->exception = xbt_new(ex_ctx_t, 1);
- XBT_CTX_INITIALIZE(res_thread->exception);
-
+ res_thread->running_ctx = xbt_new(xbt_running_ctx_t, 1);
+ XBT_RUNNING_CTX_INITIALIZE(res_thread->running_ctx);
+ res_thread->extra_data = extra_data;
+
if ((errcode = pthread_create(&(res_thread->t), NULL,
wrapper_start_routine, res_thread)))
THROW1(system_error, errcode,
const char *xbt_os_thread_self_name(void)
{
- xbt_os_thread_t self = xbt_os_thread_self();
- return self ? self->name : "main";
+ xbt_os_thread_t me = xbt_os_thread_self();
+ return me ? me->name : "main";
+}
+
+void xbt_os_thread_set_extra_data(void *data)
+{
+ xbt_os_thread_self()->extra_data = data;
+}
+
+void *xbt_os_thread_get_extra_data(void)
+{
+ return xbt_os_thread_self()->extra_data;
}
void xbt_os_thread_join(xbt_os_thread_t thread, void **thread_return)
if ((errcode = pthread_join(thread->t, thread_return)))
THROW1(system_error, errcode, "pthread_join failed: %s",
strerror(errcode));
- if (thread->exception)
- free(thread->exception);
+ if (thread->running_ctx)
+ free(thread->running_ctx);
if (thread->name)
free(thread->name);
return NULL;
res = pthread_getspecific(xbt_self_thread_key);
- if (!res)
- res = main_thread;
return res;
}
+void xbt_os_thread_detach(xbt_os_thread_t thread)
+{
+ pthread_detach(thread->t);
+}
+
#include <sched.h>
void xbt_os_thread_yield(void)
{
case ETIMEDOUT:
THROW1(timeout_error, 0, "mutex %p not ready", mutex);
default:
- THROW2(system_error, errcode, "xbt_mutex_timedacquire(%p) failed: %s",
- mutex, strerror(errcode));
+ THROW2(system_error, errcode,
+ "xbt_mutex_timedacquire(%p) failed: %s", mutex,
+ strerror(errcode));
}
errcode = pthread_mutex_timedlock(&(mutex->m), &ts_end);
-#else /* Well, let's reimplement it since those lazy libc dudes didn't */
+#else /* Well, let's reimplement it since those lazy libc dudes didn't */
double start = xbt_os_time();
do {
errcode = pthread_mutex_trylock(&(mutex->m));
if (errcode == EBUSY)
errcode = ETIMEDOUT;
-#endif /* HAVE_MUTEX_TIMEDLOCK */
+#endif /* HAVE_MUTEX_TIMEDLOCK */
switch (errcode) {
case 0:
THROW1(system_error, errno, "sem_init() failed: %s", strerror(errno));
res->ps = &(res->s);
-#else /* damn, no sem_init(). Reimplement it */
+#else /* damn, no sem_init(). Reimplement it */
xbt_os_mutex_acquire(next_sem_ID_lock);
- res->name = bprintf("/%d.%d", (*xbt_getpid) (), ++next_sem_ID);
+ res->name = bprintf("/%d", ++next_sem_ID);
xbt_os_mutex_release(next_sem_ID_lock);
res->ps = sem_open(res->name, O_CREAT, 0644, value);
/* Remove the name from the semaphore namespace: we never join on it */
if (sem_unlink(res->name) < 0)
- THROW1(system_error, errno, "sem_unlink() failed: %s", strerror(errno));
+ THROW1(system_error, errno, "sem_unlink() failed: %s",
+ strerror(errno));
#endif
case ETIMEDOUT:
THROW1(timeout_error, 0, "semaphore %p not ready", sem);
default:
- THROW2(system_error, errcode, "xbt_os_sem_timedacquire(%p) failed: %s",
- sem, strerror(errcode));
+ THROW2(system_error, errcode,
+ "xbt_os_sem_timedacquire(%p) failed: %s", sem,
+ strerror(errcode));
}
} else {
DEBUG2("sem_timedwait(%p,%p)", sem->ps, &ts_end);
errcode = sem_timedwait(sem->s, &ts_end);
-#else /* Okay, reimplement this function then */
+#else /* Okay, reimplement this function then */
double start = xbt_os_time();
do {
errcode = sem_trywait(sem->ps);
case ETIMEDOUT:
THROW2(timeout_error, delay,
- "semaphore %p wasn't signaled before timeout (%f)", sem, delay);
+ "semaphore %p wasn't signaled before timeout (%f)", sem,
+ delay);
default:
THROW3(system_error, errcode, "sem_timedwait(%p,%f) failed: %s", sem,
THROW0(arg_error, EINVAL, "Cannot destroy the NULL sempahore");
#ifdef HAVE_SEM_INIT
- if (sem_destroy(sem->ps))
- <0)
- THROW1(system_error, errno, "sem_destroy() failed: %s",
- strerror(errno));
+ if (sem_destroy(sem->ps) < 0)
+ THROW1(system_error, errno, "sem_destroy() failed: %s",
+ strerror(errno));
#else
if (sem_close(sem->ps) < 0)
THROW1(system_error, errno, "sem_close() failed: %s", strerror(errno));
void xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue)
{
if (!sem)
- THROW0(arg_error, EINVAL, "Cannot get the value of the NULL semaphore");
+ THROW0(arg_error, EINVAL,
+ "Cannot get the value of the NULL semaphore");
if (sem_getvalue(&(sem->s), svalue) < 0)
- THROW1(system_error, errno, "sem_getvalue() failed: %s", strerror(errno));
+ THROW1(system_error, errno, "sem_getvalue() failed: %s",
+ strerror(errno));
}
/* ********************************* WINDOWS IMPLEMENTATION ************************************ */
-#elif defined(WIN32)
+#elif defined(_XBT_WIN32)
#include <math.h>
/* key to the TLS containing the xbt_os_thread_t structure */
static unsigned long xbt_self_thread_key;
-void xbt_os_thread_mod_init(void)
+void xbt_os_thread_mod_preinit(void)
{
xbt_self_thread_key = TlsAlloc();
}
-void xbt_os_thread_mod_exit(void)
+void xbt_os_thread_mod_postexit(void)
{
if (!TlsFree(xbt_self_thread_key))
"TlsFree() failed to cleanup the thread submodule");
}
+int xbt_os_thread_atfork(void (*prepare)(void),
+ void (*parent)(void), void (*child)(void))
+{
+ return 0;
+}
+
static DWORD WINAPI wrapper_start_routine(void *s)
{
xbt_os_thread_t t = (xbt_os_thread_t) s;
{
if (WAIT_OBJECT_0 != WaitForSingleObject(thread->handle, INFINITE))
- THROW0(system_error, (int) GetLastError(), "WaitForSingleObject failed");
+ THROW0(system_error, (int) GetLastError(),
+ "WaitForSingleObject failed");
if (thread_return) {
if (!GetExitCodeThread(thread->handle, (DWORD *) (*thread_return)))
- THROW0(system_error, (int) GetLastError(), "GetExitCodeThread failed");
+ THROW0(system_error, (int) GetLastError(),
+ "GetExitCodeThread failed");
}
CloseHandle(thread->handle);
ExitThread(0);
}
+void xbt_os_thread_detach(xbt_os_thread_t thread)
+{
+ THROW_UNIMPLEMENTED;
+}
+
+
xbt_os_thread_t xbt_os_thread_self(void)
{
return TlsGetValue(xbt_self_thread_key);
if (delay < 0) {
xbt_os_cond_wait(cond, mutex);
} else {
- DEBUG3("xbt_cond_timedwait(%p,%p,%lu)", &(cond->events), &(mutex->lock),
- end);
+ DEBUG3("xbt_cond_timedwait(%p,%p,%lu)", &(cond->events),
+ &(mutex->lock), end);
/* lock the threads counter and increment it */
EnterCriticalSection(&cond->waiters_count_lock);
/* wait failure */
if (WAIT_OBJECT_0 != WaitForSingleObject(sem->h, INFINITE))
- THROW1(system_error, GetLastError(), "WaitForSingleObject() failed: %s",
- strerror(GetLastError()));
+ THROW1(system_error, GetLastError(),
+ "WaitForSingleObject() failed: %s", strerror(GetLastError()));
EnterCriticalSection(&(sem->value_lock));
sem->value--;
LeaveCriticalSection(&(sem->value_lock));
void xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue)
{
if (!sem)
- THROW0(arg_error, EINVAL, "Cannot get the value of the NULL semaphore");
+ THROW0(arg_error, EINVAL,
+ "Cannot get the value of the NULL semaphore");
EnterCriticalSection(&(sem->value_lock));
*svalue = sem->value;
