processes_arrived_sofar--;
if (!processes_arrived_sofar) {
- simcall_cond_destroy(cond);
- simcall_mutex_destroy(mutex);
+ SIMIX_cond_destroy(cond);
+ SIMIX_mutex_destroy(mutex);
mutex = NULL;
}
}
/************************** Synchro simcalls **********************************/
XBT_PUBLIC(smx_mutex_t) simcall_mutex_init(void);
-XBT_PUBLIC(void) simcall_mutex_destroy(smx_mutex_t mutex);
+XBT_PUBLIC(void) SIMIX_mutex_destroy(smx_mutex_t mutex);
XBT_PUBLIC(void) simcall_mutex_lock(smx_mutex_t mutex);
XBT_PUBLIC(int) simcall_mutex_trylock(smx_mutex_t mutex);
XBT_PUBLIC(void) simcall_mutex_unlock(smx_mutex_t mutex);
XBT_PUBLIC(smx_cond_t) simcall_cond_init(void);
-XBT_PUBLIC(void) simcall_cond_destroy(smx_cond_t cond);
+XBT_PUBLIC(void) SIMIX_cond_destroy(smx_cond_t cond);
XBT_PUBLIC(void) simcall_cond_signal(smx_cond_t cond);
XBT_PUBLIC(void) simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex);
XBT_PUBLIC(void) simcall_cond_wait_timeout(smx_cond_t cond,
XBT_PUBLIC(void) simcall_cond_broadcast(smx_cond_t cond);
XBT_PUBLIC(smx_sem_t) simcall_sem_init(int capacity);
-XBT_PUBLIC(void) simcall_sem_destroy(smx_sem_t sem);
+XBT_PUBLIC(void) SIMIX_sem_destroy(smx_sem_t sem);
XBT_PUBLIC(void) simcall_sem_release(smx_sem_t sem);
XBT_PUBLIC(int) simcall_sem_would_block(smx_sem_t sem);
XBT_PUBLIC(void) simcall_sem_acquire(smx_sem_t sem);
}
void MSG_sem_destroy(msg_sem_t sem) {
- simcall_sem_destroy(sem);
+ SIMIX_sem_destroy(sem);
}
/** @brief returns a boolean indicating if this semaphore would block at this very specific time
*
return simcall_BODY_mutex_init();
}
-/**
- * \ingroup simix_synchro_management
- *
- */
-void simcall_mutex_destroy(smx_mutex_t mutex)
-{
- simcall_BODY_mutex_destroy(mutex);
-}
-
/**
* \ingroup simix_synchro_management
*
return simcall_BODY_cond_init();
}
-/**
- * \ingroup simix_synchro_management
- *
- */
-void simcall_cond_destroy(smx_cond_t cond)
-{
- simcall_BODY_cond_destroy(cond);
-}
-
/**
* \ingroup simix_synchro_management
*
return simcall_BODY_sem_init(capacity);
}
-/**
- * \ingroup simix_synchro_management
- *
- */
-void simcall_sem_destroy(smx_sem_t sem)
-{
- simcall_BODY_sem_destroy(sem);
-}
-
/**
* \ingroup simix_synchro_management
*
simcall->result.dp = result;
}
-static inline smx_mutex_t simcall_mutex_destroy__get__mutex(smx_simcall_t simcall) {
- return (smx_mutex_t) simcall->args[0].dp;
-}
-static inline void simcall_mutex_destroy__set__mutex(smx_simcall_t simcall, void* arg) {
- simcall->args[0].dp = arg;
-}
-
static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall) {
return (smx_mutex_t) simcall->args[0].dp;
}
simcall->result.dp = result;
}
-static inline smx_cond_t simcall_cond_destroy__get__cond(smx_simcall_t simcall) {
- return (smx_cond_t) simcall->args[0].dp;
-}
-static inline void simcall_cond_destroy__set__cond(smx_simcall_t simcall, void* arg) {
- simcall->args[0].dp = arg;
-}
-
static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall) {
return (smx_cond_t) simcall->args[0].dp;
}
simcall->result.dp = result;
}
-static inline smx_sem_t simcall_sem_destroy__get__sem(smx_simcall_t simcall) {
- return (smx_sem_t) simcall->args[0].dp;
-}
-static inline void simcall_sem_destroy__set__sem(smx_simcall_t simcall, void* arg) {
- simcall->args[0].dp = arg;
-}
-
static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall) {
return (smx_sem_t) simcall->args[0].dp;
}
return (smx_mutex_t) self->simcall.result.dp;
}
-inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
- smx_process_t self = SIMIX_process_self();
-
- /* Go to that function to follow the code flow through the simcall barrier */
- if (0) SIMIX_mutex_destroy(mutex);
- /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
-
- self->simcall.call = SIMCALL_MUTEX_DESTROY;
- memset(&self->simcall.result, 0, sizeof(self->simcall.result));
- memset(self->simcall.args, 0, sizeof(self->simcall.args));
- self->simcall.args[0].dp = (void*) mutex;
- if (self != simix_global->maestro_process) {
- XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
- SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
- SIMIX_process_yield(self);
- } else {
- SIMIX_simcall_handle(&self->simcall, 0);
- }
-
- }
-
inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
smx_process_t self = SIMIX_process_self();
return (smx_cond_t) self->simcall.result.dp;
}
-inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
- smx_process_t self = SIMIX_process_self();
-
- /* Go to that function to follow the code flow through the simcall barrier */
- if (0) SIMIX_cond_destroy(cond);
- /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
-
- self->simcall.call = SIMCALL_COND_DESTROY;
- memset(&self->simcall.result, 0, sizeof(self->simcall.result));
- memset(self->simcall.args, 0, sizeof(self->simcall.args));
- self->simcall.args[0].dp = (void*) cond;
- if (self != simix_global->maestro_process) {
- XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
- SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
- SIMIX_process_yield(self);
- } else {
- SIMIX_simcall_handle(&self->simcall, 0);
- }
-
- }
-
inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
smx_process_t self = SIMIX_process_self();
return (smx_sem_t) self->simcall.result.dp;
}
-inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
- smx_process_t self = SIMIX_process_self();
-
- /* Go to that function to follow the code flow through the simcall barrier */
- if (0) SIMIX_sem_destroy(sem);
- /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
-
- self->simcall.call = SIMCALL_SEM_DESTROY;
- memset(&self->simcall.result, 0, sizeof(self->simcall.result));
- memset(self->simcall.args, 0, sizeof(self->simcall.args));
- self->simcall.args[0].dp = (void*) sem;
- if (self != simix_global->maestro_process) {
- XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
- SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
- SIMIX_process_yield(self);
- } else {
- SIMIX_simcall_handle(&self->simcall, 0);
- }
-
- }
-
inline static void simcall_BODY_sem_release(smx_sem_t sem) {
smx_process_t self = SIMIX_process_self();
SIMCALL_COMM_GET_SRC_PROC,
SIMCALL_COMM_GET_DST_PROC,
SIMCALL_MUTEX_INIT,
- SIMCALL_MUTEX_DESTROY,
SIMCALL_MUTEX_LOCK,
SIMCALL_MUTEX_TRYLOCK,
SIMCALL_MUTEX_UNLOCK,
SIMCALL_COND_INIT,
- SIMCALL_COND_DESTROY,
SIMCALL_COND_SIGNAL,
SIMCALL_COND_WAIT,
SIMCALL_COND_WAIT_TIMEOUT,
SIMCALL_COND_BROADCAST,
SIMCALL_SEM_INIT,
- SIMCALL_SEM_DESTROY,
SIMCALL_SEM_RELEASE,
SIMCALL_SEM_WOULD_BLOCK,
SIMCALL_SEM_ACQUIRE,
"SIMCALL_COMM_GET_SRC_PROC",
"SIMCALL_COMM_GET_DST_PROC",
"SIMCALL_MUTEX_INIT",
- "SIMCALL_MUTEX_DESTROY",
"SIMCALL_MUTEX_LOCK",
"SIMCALL_MUTEX_TRYLOCK",
"SIMCALL_MUTEX_UNLOCK",
"SIMCALL_COND_INIT",
- "SIMCALL_COND_DESTROY",
"SIMCALL_COND_SIGNAL",
"SIMCALL_COND_WAIT",
"SIMCALL_COND_WAIT_TIMEOUT",
"SIMCALL_COND_BROADCAST",
"SIMCALL_SEM_INIT",
- "SIMCALL_SEM_DESTROY",
"SIMCALL_SEM_RELEASE",
"SIMCALL_SEM_WOULD_BLOCK",
"SIMCALL_SEM_ACQUIRE",
SIMIX_simcall_answer(simcall);
break;
-case SIMCALL_MUTEX_DESTROY:
- SIMIX_mutex_destroy((smx_mutex_t) simcall->args[0].dp);
- SIMIX_simcall_answer(simcall);
- break;
-
case SIMCALL_MUTEX_LOCK:
simcall_HANDLER_mutex_lock(simcall , (smx_mutex_t) simcall->args[0].dp);
break;
SIMIX_simcall_answer(simcall);
break;
-case SIMCALL_COND_DESTROY:
- SIMIX_cond_destroy((smx_cond_t) simcall->args[0].dp);
- SIMIX_simcall_answer(simcall);
- break;
-
case SIMCALL_COND_SIGNAL:
SIMIX_cond_signal((smx_cond_t) simcall->args[0].dp);
SIMIX_simcall_answer(simcall);
SIMIX_simcall_answer(simcall);
break;
-case SIMCALL_SEM_DESTROY:
- SIMIX_sem_destroy((smx_sem_t) simcall->args[0].dp);
- SIMIX_simcall_answer(simcall);
- break;
-
case SIMCALL_SEM_RELEASE:
simcall_HANDLER_sem_release(simcall , (smx_sem_t) simcall->args[0].dp);
SIMIX_simcall_answer(simcall);
Func - comm_get_dst_proc (void*, smx_process_t) (comm, void*, smx_synchro_t)
Func H mutex_init (void*, smx_mutex_t)
-Proc - mutex_destroy (void) (mutex, void*, smx_mutex_t)
Blck H mutex_lock (void) (mutex, void*, smx_mutex_t)
Func H mutex_trylock (int) (mutex, void*, smx_mutex_t)
Proc H mutex_unlock (void) (mutex, void*, smx_mutex_t)
Func - cond_init (void*, smx_cond_t)
-Proc - cond_destroy (void) (cond, void*, smx_cond_t)
Proc - cond_signal (void) (cond, void*, smx_cond_t)
Blck H cond_wait (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t)
Blck H cond_wait_timeout (void) (cond, void*, smx_cond_t) (mutex, void*, smx_mutex_t) (timeout, double)
Proc - cond_broadcast (void) (cond, void*, smx_cond_t)
Func - sem_init (void*, smx_sem_t) (capacity, unsigned int)
-Proc - sem_destroy (void) (sem, void*, smx_sem_t)
Proc H sem_release (void) (sem, void*, smx_sem_t)
Func H sem_would_block (int) (sem, void*, smx_sem_t)
Blck H sem_acquire (void) (sem, void*, smx_sem_t)
XBT_PRIVATE void SIMIX_synchro_destroy(smx_synchro_t synchro);
XBT_PRIVATE smx_mutex_t SIMIX_mutex_init(void);
-XBT_PRIVATE void SIMIX_mutex_destroy(smx_mutex_t mutex);
XBT_PRIVATE int SIMIX_mutex_trylock(smx_mutex_t mutex, smx_process_t issuer);
XBT_PRIVATE void SIMIX_mutex_unlock(smx_mutex_t mutex, smx_process_t issuer);
XBT_PRIVATE smx_cond_t SIMIX_cond_init(void);
-XBT_PRIVATE void SIMIX_cond_destroy(smx_cond_t cond);
XBT_PRIVATE void SIMIX_cond_broadcast(smx_cond_t cond);
XBT_PRIVATE void SIMIX_cond_signal(smx_cond_t cond);
-XBT_PRIVATE void SIMIX_sem_destroy(smx_sem_t sem);
XBT_PRIVATE XBT_PRIVATE smx_sem_t SIMIX_sem_init(unsigned int value);
XBT_PRIVATE void SIMIX_sem_release(smx_sem_t sem);
XBT_PRIVATE int SIMIX_sem_would_block(smx_sem_t sem);
void xbt_mutex_destroy(xbt_mutex_t mutex)
{
- simcall_mutex_destroy((smx_mutex_t) mutex);
+ SIMIX_mutex_destroy((smx_mutex_t) mutex);
}
/***** condition related functions *****/
void xbt_cond_destroy(xbt_cond_t cond)
{
- simcall_cond_destroy((smx_cond_t) cond);
+ SIMIX_cond_destroy((smx_cond_t) cond);
}
/***** barrier related functions *****/