- the functions xbt_os_mutex_lock() and xbt_os_mutex_unlock() are renamed xbt_os_mutex_acquire() and xbt_os_mutex_release() respectively
- the functions xbt_os_sem_wait() and xbt_os_sem_post() are renamed xbt_os_sem_acquire() and xbt_os_sem_release() respectively
This renaming impacts the folowing files :
- xbt_os_thread.h and xbt_os_thread.c
- context.c
- xbt_rl_synchro.c
- run_context.c
In addition the function unschedule() declared an defined in the file context.c is renamed yield().
The prototype of the function xbt_os_sem_init() takes now only one parameter : the initial value of the semaphore.
The second parameter of the function xbt_os_sem_timedacquire() which replace the function xbt_os_sem_timedwait() is now a double (desired timeout in seconds).
To finish, the semaphore interface of the xbt portability layer does not expose the functions xbt_os_sem_open() and xbt_sem_close().
git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@4848
48e7efb5-ca39-0410-a469-
dd3cf9ba447f
typedef struct xbt_os_mutex_ *xbt_os_mutex_t;
XBT_PUBLIC(xbt_os_mutex_t) xbt_os_mutex_init(void);
typedef struct xbt_os_mutex_ *xbt_os_mutex_t;
XBT_PUBLIC(xbt_os_mutex_t) xbt_os_mutex_init(void);
- XBT_PUBLIC(void) xbt_os_mutex_lock(xbt_os_mutex_t mutex);
- XBT_PUBLIC(void) xbt_os_mutex_unlock(xbt_os_mutex_t mutex);
+ XBT_PUBLIC(void) xbt_os_mutex_acquire(xbt_os_mutex_t mutex);
+ XBT_PUBLIC(void) xbt_os_mutex_release(xbt_os_mutex_t mutex);
XBT_PUBLIC(void) xbt_os_mutex_destroy(xbt_os_mutex_t mutex);
XBT_PUBLIC(void) xbt_os_mutex_destroy(xbt_os_mutex_t mutex);
/** \brief Semaphore data type (opaque structure) */
typedef struct xbt_os_sem_* xbt_os_sem_t;
/** \brief Semaphore data type (opaque structure) */
typedef struct xbt_os_sem_* xbt_os_sem_t;
- XBT_PUBLIC(xbt_os_sem_t) xbt_os_sem_init(int pshared, unsigned int value);
- XBT_PUBLIC(xbt_os_sem_t) xbt_os_sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
- XBT_PUBLIC(void) xbt_os_sem_wait(xbt_os_sem_t sem);
- XBT_PUBLIC(void) xbt_os_sem_timedwait(xbt_os_sem_t sem,const struct timespec* abs_timeout);
- XBT_PUBLIC(void) xbt_os_sem_post(xbt_os_sem_t sem);
- XBT_PUBLIC(void) xbt_os_sem_close(xbt_os_sem_t sem);
+ XBT_PUBLIC(xbt_os_sem_t) xbt_os_sem_init(unsigned int value);
+ XBT_PUBLIC(void) xbt_os_sem_acquire(xbt_os_sem_t sem);
+ XBT_PUBLIC(void) xbt_os_sem_timedacquire(xbt_os_sem_t sem,double timeout);
+ XBT_PUBLIC(void) xbt_os_sem_release(xbt_os_sem_t sem);
XBT_PUBLIC(void) xbt_os_sem_destroy(xbt_os_sem_t sem);
XBT_PUBLIC(void) xbt_os_sem_get_value(xbt_os_sem_t sem, int* svalue);
XBT_PUBLIC(void) xbt_os_sem_destroy(xbt_os_sem_t sem);
XBT_PUBLIC(void) xbt_os_sem_get_value(xbt_os_sem_t sem, int* svalue);
schedule(xbt_context_t c);
static void
schedule(xbt_context_t c);
static void
-unschedule(xbt_context_t c);
static void
schedule(xbt_context_t c)
{
static void
schedule(xbt_context_t c)
{
- xbt_os_sem_post(c->begin);
- xbt_os_sem_wait(c->end);
+ xbt_os_sem_release(c->begin);
+ xbt_os_sem_acquire(c->end);
-static void unschedule(xbt_context_t c)
+static void yield(xbt_context_t c)
- xbt_os_sem_post(c->end);
- xbt_os_sem_wait(c->begin);
+ xbt_os_sem_release(c->end);
+ xbt_os_sem_acquire(c->begin);
#ifdef CONTEXT_THREADS
/*
#ifdef CONTEXT_THREADS
/*
- * initialize the semaphores used to schedule/unschedule
+ * initialize the semaphores used to schedule/yield
* the process associated to the newly created context
*/
* the process associated to the newly created context
*/
- res->begin = xbt_os_sem_init(0,0);
- res->end = xbt_os_sem_init(0,0);
+ res->begin = xbt_os_sem_init(0);
+ res->end = xbt_os_sem_init(0);
#else
xbt_assert2(getcontext(&(res->uc)) == 0,
#else
xbt_assert2(getcontext(&(res->uc)) == 0,
/*context->thread = xbt_os_thread_self();*/
/* signal its starting to the maestro and wait to start its job*/
/*context->thread = xbt_os_thread_self();*/
/* signal its starting to the maestro and wait to start its job*/
context->thread = xbt_os_thread_create(context->name,__context_wrapper, context);
/* wait the starting of the newly created process */
context->thread = xbt_os_thread_create(context->name,__context_wrapper, context);
/* wait the starting of the newly created process */
- xbt_os_sem_wait(context->end);
+ xbt_os_sem_acquire(context->end);
#else
makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1, context);
#endif
#else
makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1, context);
#endif
#ifdef CONTEXT_THREADS
/* signal to the maestro that it has finished */
#ifdef CONTEXT_THREADS
/* signal to the maestro that it has finished */
- xbt_os_sem_post(current_context->end);
+ xbt_os_sem_release(current_context->end);
/* exit*/
xbt_os_thread_exit(NULL); /* We should provide return value in case other wants it */
#else
/* exit*/
xbt_os_thread_exit(NULL); /* We should provide return value in case other wants it */
#else
current_context = context;
/* yield itself */
current_context = context;
/* yield itself */
/* restore the current context to the previously saved context */
current_context = self;
/* restore the current context to the previously saved context */
current_context = self;
-void xbt_os_mutex_lock(xbt_os_mutex_t mutex) {
+void xbt_os_mutex_acquire(xbt_os_mutex_t mutex) {
int errcode;
if ((errcode=pthread_mutex_lock(&(mutex->m))))
int errcode;
if ((errcode=pthread_mutex_lock(&(mutex->m))))
mutex, strerror(errcode));
}
mutex, strerror(errcode));
}
-void xbt_os_mutex_unlock(xbt_os_mutex_t mutex) {
+void xbt_os_mutex_release(xbt_os_mutex_t mutex) {
int errcode;
if ((errcode=pthread_mutex_unlock(&(mutex->m))))
int errcode;
if ((errcode=pthread_mutex_unlock(&(mutex->m))))
typedef struct xbt_os_sem_ {
sem_t s;
typedef struct xbt_os_sem_ {
sem_t s;
- int pshared;
- unsigned int value;
- const char* name;
}s_xbt_os_sem_t ;
xbt_os_sem_t
}s_xbt_os_sem_t ;
xbt_os_sem_t
-xbt_os_sem_init(int pshared, unsigned int value)
+xbt_os_sem_init(unsigned int value)
{
xbt_os_sem_t res = xbt_new(s_xbt_os_sem_t,1);
{
xbt_os_sem_t res = xbt_new(s_xbt_os_sem_t,1);
- if(sem_init(&(res->s),pshared,value) < 0)
+ if(sem_init(&(res->s),0,value) < 0)
THROW1(system_error,errno,"sem_init() failed: %s",
strerror(errno));
THROW1(system_error,errno,"sem_init() failed: %s",
strerror(errno));
- res->pshared = pshared;
- res->value = value;
-
-xbt_os_sem_wait(xbt_os_sem_t sem)
+xbt_os_sem_acquire(xbt_os_sem_t sem)
- THROW1(arg_error,EINVAL,"xbt_os_sem_wait() failed: %s",
+ THROW1(arg_error,EINVAL,"xbt_os_sem_acquire() failed: %s",
strerror(EINVAL));
if(sem_wait(&(sem->s)) < 0)
strerror(EINVAL));
if(sem_wait(&(sem->s)) < 0)
-void xbt_os_sem_timedwait(xbt_os_sem_t sem,const struct timespec* abs_timeout)
+void xbt_os_sem_timedacquire(xbt_os_sem_t sem,double timeout)
+ int errcode;
+ struct timespec ts_end;
+ double end = timeout + xbt_os_time();
+
- THROW1(arg_error,EINVAL,"xbt_os_sem_timedwait() failed: %s",
- strerror(EINVAL));
+ THROW1(arg_error,EINVAL,"xbt_os_sem_timedacquire() failed: %s",strerror(EINVAL));
- /* only throw an exception if the global variable errno is different than ETIMEDOUT :
- * (the semaphore could not be locked before the specified timeout expired)
- */
- if((sem_timedwait(&(sem->s),abs_timeout) < 0) && (ETIMEDOUT != errno))
- THROW1(system_error,errno,"sem_wait() failed: %s",
- strerror(errno));
+ if (timeout < 0)
+ {
+ xbt_os_sem_acquire(sem);
+ }
+ else
+ {
+ ts_end.tv_sec = (time_t) floor(end);
+ ts_end.tv_nsec = (long) ( ( end - ts_end.tv_sec) * 1000000000);
+ DEBUG2("sem_timedwait(%p,%p)",&(sem->s),&ts_end);
+
+ switch ((errcode=sem_timedwait(&(sem->s),&ts_end)))
+ {
+ case 0:
+ return;
+
+ case ETIMEDOUT:
+ THROW2(timeout_error,errcode,"semaphore %p wasn't signaled before timeout (%f)",sem,timeout);
+
+ default:
+ THROW3(system_error,errcode,"sem_timedwait(%p,%f) failed: %s",sem,timeout, strerror(errcode));
+ }
+ }
-xbt_os_sem_post(xbt_os_sem_t sem)
+xbt_os_sem_release(xbt_os_sem_t sem)
- THROW1(arg_error,EINVAL,"xbt_os_sem_post() failed: %s",
+ THROW1(arg_error,EINVAL,"xbt_os_sem_release() failed: %s",
strerror(EINVAL));
if(sem_post(&(sem->s)) < 0)
strerror(EINVAL));
if(sem_post(&(sem->s)) < 0)
-void
-xbt_os_sem_close(xbt_os_sem_t sem)
-{
- if(!sem)
- THROW1(arg_error,EINVAL,"xbt_os_sem_close() failed: %s",
- strerror(EINVAL));
-
- if(sem_close(&(sem->s)) < 0)
- THROW1(system_error,errno,"sem_close() failed: %s",
- strerror(errno));
-}
-
-xbt_os_sem_t
-xbt_os_sem_open(const char *name, int oflag, mode_t mode, unsigned int value)
-{
- sem_t* ps;
- xbt_os_sem_t res = xbt_new(s_xbt_os_sem_t,1);
-
- if(SEM_FAILED == (ps = sem_open(name,oflag, mode, value)))
- THROW1(system_error,errno,"sem_open() failed: %s",
- strerror(errno));
-
- res->s = *ps;
- res->value = value;
-
- return res;
-}
-
void
xbt_os_sem_destroy(xbt_os_sem_t sem)
{
void
xbt_os_sem_destroy(xbt_os_sem_t sem)
{
typedef struct xbt_os_thread_ {
char *name;
HANDLE handle; /* the win thread handle */
typedef struct xbt_os_thread_ {
char *name;
HANDLE handle; /* the win thread handle */
-void xbt_os_mutex_lock(xbt_os_mutex_t mutex) {
+void xbt_os_mutex_acquire(xbt_os_mutex_t mutex) {
EnterCriticalSection(& mutex->lock);
}
EnterCriticalSection(& mutex->lock);
}
-void xbt_os_mutex_unlock(xbt_os_mutex_t mutex) {
+void xbt_os_mutex_release(xbt_os_mutex_t mutex) {
LeaveCriticalSection (& mutex->lock);
LeaveCriticalSection (& mutex->lock);
typedef struct xbt_os_sem_ {
HANDLE h;
unsigned int value;
typedef struct xbt_os_sem_ {
HANDLE h;
unsigned int value;
CRITICAL_SECTION value_lock; /* protect access to value of the semaphore */
}s_xbt_os_sem_t ;
xbt_os_sem_t
CRITICAL_SECTION value_lock; /* protect access to value of the semaphore */
}s_xbt_os_sem_t ;
xbt_os_sem_t
-xbt_os_sem_init(int pshared, unsigned int value)
+xbt_os_sem_init(unsigned int value)
- if(0 != pshared)
- THROW1(arg_error,EPERM,"xbt_os_sem_init() failed: %s",
- strerror(EPERM));
-
if(value > INT_MAX)
THROW1(arg_error,EINVAL,"xbt_os_sem_init() failed: %s",
strerror(EINVAL));
if(value > INT_MAX)
THROW1(arg_error,EINVAL,"xbt_os_sem_init() failed: %s",
strerror(EINVAL));
-xbt_os_sem_wait(xbt_os_sem_t sem)
+xbt_os_sem_acquire(xbt_os_sem_t sem)
- THROW1(arg_error,EINVAL,"xbt_os_sem_wait() failed: %s",
+ THROW1(arg_error,EINVAL,"xbt_os_sem_acquire() failed: %s",
strerror(EINVAL));
/* wait failure */
strerror(EINVAL));
/* wait failure */
LeaveCriticalSection(&(sem->value_lock));
}
LeaveCriticalSection(&(sem->value_lock));
}
-void xbt_os_sem_timedwait(xbt_os_sem_t sem,const struct timespec* abs_timeout)
+void xbt_os_sem_timedacquire(xbt_os_sem_t sem, double timeout)
- long timeout;
- struct timeval tv;
+ long seconds;
+ long milliseconds;
+ double end = timeout + xbt_os_time();
- THROW1(arg_error,EINVAL,"xbt_os_sem_timedwait() failed: %s",
+ THROW1(arg_error,EINVAL,"xbt_os_sem_timedacquire() failed: %s",
-
- if(!abs_timeout)
- timeout = INFINITE;
- else
- {
- if(gettimeofday(&tv, NULL) < 0)
- THROW1(system_error,errno,"gettimeofday() failed: %s",
- strerror(errno));
-
- timeout = ((long) (abs_timeout->tv_sec - tv.tv_sec) * 1e3 + (long)((abs_timeout->tv_nsec / 1e3) - tv.tv_usec) / 1e3);
- }
- switch(WaitForSingleObject(sem->h,timeout))
+ if (timeout < 0)
+ {
+ xbt_os_sem_acquire(sem);
+ }
+ else
- case WAIT_OBJECT_0:
- EnterCriticalSection(&(sem->value_lock));
- sem->value--;
- LeaveCriticalSection(&(sem->value_lock));
- return;
- case WAIT_TIMEOUT:
- /* it's not an exception :
- * (semaphore could not be locked before the specified timeout expired)
- */
- return;
+ seconds = (long) floor(end);
+ milliseconds = (long)( ( end - seconds) * 1000);
+ milliseconds += (seconds * 1000);
+ switch(WaitForSingleObject(sem->h,milliseconds))
+ {
+ case WAIT_OBJECT_0:
+ EnterCriticalSection(&(sem->value_lock));
+ sem->value--;
+ LeaveCriticalSection(&(sem->value_lock));
+ return;
+
+ case WAIT_TIMEOUT:
+ THROW2(timeout_error,GetLastError(),"semaphore %p wasn't signaled before timeout (%f)",sem,timeout);
+ return;
+
+ default:
- THROW1(system_error,GetLastError(),"WaitForSingleObject() failed: %s",
- strerror(GetLastError()));
+ THROW3(system_error,GetLastError(),"WaitForSingleObject(%p,%f) failed: %s",sem,timeout, strerror(GetLastError()));
+ }
-xbt_os_sem_post(xbt_os_sem_t sem)
+xbt_os_sem_release(xbt_os_sem_t sem)
{
if(!sem)
THROW1(arg_error,EINVAL,"xbt_os_sem_post() failed: %s",
{
if(!sem)
THROW1(arg_error,EINVAL,"xbt_os_sem_post() failed: %s",
LeaveCriticalSection(&(sem->value_lock));
}
LeaveCriticalSection(&(sem->value_lock));
}
-xbt_os_sem_t
-xbt_os_sem_open(const char *name, int oflag, mode_t mode, unsigned int value)
-{
- THROW_UNIMPLEMENTED;
-}
-
-void
-xbt_os_sem_close(xbt_os_sem_t sem)
-{
- THROW_UNIMPLEMENTED;
-}
-
void
xbt_os_sem_destroy(xbt_os_sem_t sem)
{
void
xbt_os_sem_destroy(xbt_os_sem_t sem)
{
void xbt_mutex_lock(xbt_mutex_t mutex) {
DEBUG1("Lock mutex %p", mutex);
void xbt_mutex_lock(xbt_mutex_t mutex) {
DEBUG1("Lock mutex %p", mutex);
- xbt_os_mutex_lock( (xbt_os_mutex_t)mutex );
+ xbt_os_mutex_acquire( (xbt_os_mutex_t)mutex );
}
void xbt_mutex_unlock(xbt_mutex_t mutex) {
DEBUG1("Unlock mutex %p", mutex);
}
void xbt_mutex_unlock(xbt_mutex_t mutex) {
DEBUG1("Unlock mutex %p", mutex);
- xbt_os_mutex_unlock( (xbt_os_mutex_t)mutex );
+ xbt_os_mutex_release( (xbt_os_mutex_t)mutex );
}
void xbt_mutex_destroy(xbt_mutex_t mutex) {
}
void xbt_mutex_destroy(xbt_mutex_t mutex) {
rctx_t rctx;
DEBUG2("Armageddon request by <%s> (exit=%d)",initiator->filepos,exitcode);
rctx_t rctx;
DEBUG2("Armageddon request by <%s> (exit=%d)",initiator->filepos,exitcode);
- xbt_os_mutex_lock(armageddon_mutex);
+ xbt_os_mutex_acquire(armageddon_mutex);
if (armageddon_initiator != NULL) {
VERB0("Armageddon already started. Let it go");
if (armageddon_initiator != NULL) {
VERB0("Armageddon already started. Let it go");
- xbt_os_mutex_unlock(initiator->interruption);
- xbt_os_mutex_unlock(armageddon_mutex);
+ xbt_os_mutex_release(initiator->interruption);
+ xbt_os_mutex_release(armageddon_mutex);
return;
}
DEBUG1("Armageddon request by <%s> got the lock. Let's go amok",initiator->filepos);
armageddon_initiator = initiator;
return;
}
DEBUG1("Armageddon request by <%s> got the lock. Let's go amok",initiator->filepos);
armageddon_initiator = initiator;
- xbt_os_mutex_unlock(armageddon_mutex);
+ xbt_os_mutex_release(armageddon_mutex);
/* Kill any background commands */
while (xbt_dynar_length(bg_jobs)) {
xbt_dynar_pop(bg_jobs,&rctx);
if (rctx != initiator) {
INFO2("Kill <%s> because <%s> failed",rctx->filepos,initiator->filepos);
/* Kill any background commands */
while (xbt_dynar_length(bg_jobs)) {
xbt_dynar_pop(bg_jobs,&rctx);
if (rctx != initiator) {
INFO2("Kill <%s> because <%s> failed",rctx->filepos,initiator->filepos);
- xbt_os_mutex_lock(rctx->interruption);
+ xbt_os_mutex_acquire(rctx->interruption);
- xbt_os_mutex_unlock(rctx->interruption);
+ xbt_os_mutex_release(rctx->interruption);
if (!rctx->reader_done) {
kill(rctx->pid,SIGTERM);
usleep(100);
if (!rctx->reader_done) {
kill(rctx->pid,SIGTERM);
usleep(100);
- xbt_os_mutex_lock(rctx->interruption);
+ xbt_os_mutex_acquire(rctx->interruption);
if (!rctx->interrupted && rctx->end_time > 0 && rctx->end_time < now) {
INFO1("<%s> timeouted. Kill the process.",rctx->filepos);
rctx->timeout = 1;
if (!rctx->interrupted && rctx->end_time > 0 && rctx->end_time < now) {
INFO1("<%s> timeouted. Kill the process.",rctx->filepos);
rctx->timeout = 1;
xbt_os_thread_join(rctx->writer,NULL);
xbt_os_thread_join(rctx->reader,NULL);
xbt_os_thread_join(rctx->writer,NULL);
xbt_os_thread_join(rctx->reader,NULL);
- /* xbt_os_mutex_unlock(rctx->interruption);
+ /* xbt_os_mutex_release(rctx->interruption);
if (rctx->interrupted)
return NULL;
if (rctx->interrupted)
return NULL;
- xbt_os_mutex_lock(rctx->interruption);*/
+ xbt_os_mutex_acquire(rctx->interruption);*/
xbt_strbuff_chomp(rctx->output_got);
xbt_strbuff_chomp(rctx->output_wanted);
xbt_strbuff_chomp(rctx->output_got);
xbt_strbuff_chomp(rctx->output_wanted);
- xbt_os_mutex_unlock(rctx->interruption);
+ xbt_os_mutex_release(rctx->interruption);