X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5979fe52092423ac8915b118cff1e161e57d1ecb..a78605066e144a5398e2f4be801f4f7d3161181e:/src/simix/smx_synchro.c diff --git a/src/simix/smx_synchro.c b/src/simix/smx_synchro.c index c14e550ab2..aec653b19c 100644 --- a/src/simix/smx_synchro.c +++ b/src/simix/smx_synchro.c @@ -17,6 +17,13 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_synchro, simix, /****************************** Synchronization *******************************/ /*********************************** Mutex ************************************/ + +/** + * \brief Initialize a mutex. + * + * Allocs and creates the data for the mutex. It have to be called before the utilisation of the mutex. + * \return A mutex + */ smx_mutex_t SIMIX_mutex_init() { smx_mutex_t m = xbt_new0(s_smx_mutex_t,1); @@ -27,24 +34,31 @@ smx_mutex_t SIMIX_mutex_init() return m; } +/** + * \brief Locks a mutex. + * + * Tries to lock a mutex, if the mutex isn't used yet, the process can continue its execution, else it'll be blocked here. You have to call #SIMIX_mutex_unlock to free the mutex. + * \param mutex The mutex + */ void SIMIX_mutex_lock(smx_mutex_t mutex) { smx_process_t self = SIMIX_process_self(); - xbt_assert0((mutex != NULL), "Invalid parameters"); + if (mutex->using) { /* somebody using the mutex, block */ xbt_swag_insert(self, mutex->sleeping); self->simdata->mutex = mutex; /* wait for some process make the unlock and wake up me from mutex->sleeping */ xbt_context_yield(); + self->simdata->mutex = NULL; + /* verify if the process was suspended */ while (self->simdata->suspended) { xbt_context_yield(); } - self->simdata->mutex = NULL; mutex->using = 1; } else { @@ -54,7 +68,13 @@ void SIMIX_mutex_lock(smx_mutex_t mutex) return; } -/* return 1 if the process got the mutex, else 0. */ +/** + * \brief Tries to lock a mutex. + * + * Tries to lock a mutex, return 1 if the mutex is free, 0 else. This function does not block the process if the mutex is used. + * \param mutex The mutex + * \return 1 - mutex free, 0 - mutex used + */ int SIMIX_mutex_trylock(smx_mutex_t mutex) { xbt_assert0((mutex != NULL), "Invalid parameters"); @@ -67,12 +87,18 @@ int SIMIX_mutex_trylock(smx_mutex_t mutex) } } +/** + * \brief Unlocks a mutex. + * + * Unlocks the mutex and wakes up a process blocked on it. If there are no process sleeping, only sets the mutex as free. + * \param mutex The mutex + */ void SIMIX_mutex_unlock(smx_mutex_t mutex) { smx_process_t p; /*process to wake up */ - + xbt_assert0((mutex != NULL), "Invalid parameters"); - + if (xbt_swag_size(mutex->sleeping) > 0) { p = xbt_swag_extract(mutex->sleeping); mutex->using = 0; @@ -85,6 +111,12 @@ void SIMIX_mutex_unlock(smx_mutex_t mutex) return; } +/** + * \brief Destroys a mutex. + * + * Destroys and frees the mutex's memory. + * \param mutex A mutex + */ void SIMIX_mutex_destroy(smx_mutex_t mutex) { if ( mutex == NULL ) @@ -97,6 +129,13 @@ void SIMIX_mutex_destroy(smx_mutex_t mutex) } /******************************** Conditional *********************************/ + +/** + * \brief Initialize a condition. + * + * Allocs and creates the data for the condition. It have to be called before the utilisation of the condition. + * \return A condition + */ smx_cond_t SIMIX_cond_init() { smx_cond_t cond = xbt_new0(s_smx_cond_t,1); @@ -108,8 +147,15 @@ smx_cond_t SIMIX_cond_init() return cond; } +/** + * \brief Signalizes a condition. + * + * Signalizes a condition and wakes up a sleping process. If there are no process sleeping, no action is done. + * \param cond A condition + */ void SIMIX_cond_signal(smx_cond_t cond) { + DEBUG1("Signal condition %p",cond); xbt_assert0((cond != NULL), "Invalid parameters"); smx_process_t proc = NULL; @@ -121,32 +167,55 @@ void SIMIX_cond_signal(smx_cond_t cond) return; } +/** + * \brief Waits on a condition. + * + * Blocks a process until the signal is called. This functions frees the mutex associated and locks it after its execution. + * \param cond A condition + * \param mutex A mutex + */ void SIMIX_cond_wait(smx_cond_t cond,smx_mutex_t mutex) { - smx_process_t self = SIMIX_process_self(); + smx_action_t act_sleep; xbt_assert0((mutex != NULL), "Invalid parameters"); + DEBUG1("Wait condition %p",cond); cond->mutex = mutex; SIMIX_mutex_unlock(mutex); - __SIMIX_cond_wait(cond); + /* create an action null only if there are no actions already on the condition, usefull if the host crashs */ + if (xbt_fifo_size(cond->actions) ==0 ) { + act_sleep = SIMIX_action_sleep(SIMIX_host_self(), -1); + SIMIX_register_action_to_condition(act_sleep,cond); + SIMIX_register_condition_to_action(act_sleep,cond); + __SIMIX_cond_wait(cond); + xbt_fifo_pop(act_sleep->cond_list); + SIMIX_action_destroy(act_sleep); + } + else { + __SIMIX_cond_wait(cond); + } /* get the mutex again */ - self->simdata->mutex = cond->mutex; SIMIX_mutex_lock(cond->mutex); return; } +xbt_fifo_t SIMIX_cond_get_actions(smx_cond_t cond) +{ + xbt_assert0((cond != NULL), "Invalid parameters"); + return cond->actions; +} + void __SIMIX_cond_wait(smx_cond_t cond) { smx_process_t self = SIMIX_process_self(); xbt_assert0((cond != NULL), "Invalid parameters"); /* process status */ - self->simdata->cond = cond; + self->simdata->cond = cond; xbt_swag_insert(self, cond->sleeping); - xbt_context_yield(); self->simdata->cond = NULL; while (self->simdata->suspended) { @@ -156,12 +225,20 @@ void __SIMIX_cond_wait(smx_cond_t cond) } +/** + * \brief Waits on a condition with timeout. + * + * Same behavior of #SIMIX_cond_wait, but waits a maximum time and throws an timeout_error if it happens. + * \param cond A condition + * \param mutex A mutex + * \param max_duration Timeout time + */ void SIMIX_cond_wait_timeout(smx_cond_t cond,smx_mutex_t mutex, double max_duration) { - smx_process_t self = SIMIX_process_self(); xbt_assert0((mutex != NULL), "Invalid parameters"); smx_action_t act_sleep; + DEBUG1("Timed wait condition %p",cond); cond->mutex = mutex; SIMIX_mutex_unlock(mutex); @@ -169,22 +246,39 @@ void SIMIX_cond_wait_timeout(smx_cond_t cond,smx_mutex_t mutex, double max_durat act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration); SIMIX_register_action_to_condition(act_sleep,cond); SIMIX_register_condition_to_action(act_sleep,cond); + __SIMIX_cond_wait(cond); + xbt_fifo_remove(act_sleep->cond_list,cond); + if ( SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) { + SIMIX_action_destroy(act_sleep); + THROW0(timeout_error,0,"Condition timeout"); + } + else { + SIMIX_action_destroy(act_sleep); + } + } - __SIMIX_cond_wait(cond); + else + __SIMIX_cond_wait(cond); /* get the mutex again */ - self->simdata->mutex = cond->mutex; SIMIX_mutex_lock(cond->mutex); return; } +/** + * \brief Broadcasts a condition. + * + * Signalizes a condition and wakes up ALL sleping process. If there are no process sleeping, no action is done. + * \param cond A condition + */ void SIMIX_cond_broadcast(smx_cond_t cond) { xbt_assert0((cond != NULL), "Invalid parameters"); smx_process_t proc = NULL; smx_process_t proc_next = NULL; + DEBUG1("Broadcast condition %p",cond); xbt_swag_foreach_safe(proc,proc_next,cond->sleeping) { xbt_swag_remove(proc,cond->sleeping); xbt_swag_insert(proc, simix_global->process_to_run); @@ -193,14 +287,20 @@ void SIMIX_cond_broadcast(smx_cond_t cond) return; } +/** + * \brief Destroys a contidion. + * + * Destroys and frees the condition's memory. + * \param cond A condition + */ void SIMIX_cond_destroy(smx_cond_t cond) { - + DEBUG1("Destroy condition %p",cond); + xbt_backtrace_display_current(); if ( cond == NULL ) return ; else { - xbt_assert0( xbt_swag_size(cond->sleeping) == 0 , "Cannot destroy conditional"); - + xbt_assert0( xbt_swag_size(cond->sleeping) == 0 , "Cannot destroy conditional since someone is still using it"); xbt_swag_free(cond->sleeping); xbt_fifo_free(cond->actions); xbt_free(cond); @@ -208,11 +308,19 @@ void SIMIX_cond_destroy(smx_cond_t cond) } } +/** + * \brief Set a condition to an action + * + * Creates the "link" between an action and a condition. You have to call this function when you create an action and want to wait its ending. + * \param action SIMIX action + * \param cond SIMIX cond + */ void SIMIX_register_condition_to_action(smx_action_t action, smx_cond_t cond) { xbt_assert0( (action != NULL) && (cond != NULL), "Invalid parameters"); - xbt_fifo_push(action->simdata->cond_list,cond); + DEBUG2("Register condition %p to action %p",cond,action); + xbt_fifo_push(action->cond_list,cond); }