XBT_PUBLIC smx_cond_t simcall_cond_init();
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, smx_mutex_t mutex, double max_duration);
+XBT_PUBLIC int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
XBT_PUBLIC void SIMIX_sem_destroy(smx_sem_t sem);
XBT_PUBLIC void simcall_sem_acquire(smx_sem_t sem);
-XBT_PUBLIC void simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
+XBT_PUBLIC int simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
/***************************** Storage **********************************/
XBT_PUBLIC sg_size_t simcall_storage_read(surf_storage_t st, sg_size_t size);
{
XBT_IN("(%p)", simcall);
smx_actor_t issuer = simcall->issuer;
-
+ simcall_cond_wait_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout
_SIMIX_cond_wait(cond, mutex, timeout, issuer, simcall);
XBT_OUT();
}
/** @brief locks on a semaphore object up until the provided timeout expires */
msg_error_t MSG_sem_acquire_timeout(msg_sem_t sem, double timeout) {
- msg_error_t res = MSG_OK;
- try {
- simcall_sem_acquire_timeout(sem,timeout);
- } catch(xbt_ex& e) {
- if (e.category == timeout_error)
- return MSG_TIMEOUT;
- throw;
- }
- return res;
+ return simcall_sem_acquire_timeout(sem, timeout) ? MSG_TIMEOUT : MSG_OK;
}
/** @brief releases the semaphore object */
* \ingroup simix_synchro_management
*
*/
-void simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
+int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
{
xbt_assert(std::isfinite(timeout), "timeout is not finite!");
- simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
+ return simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
}
/**
* \ingroup simix_synchro_management
*
*/
-void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
+int simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
{
xbt_assert(std::isfinite(timeout), "timeout is not finite!");
- simcall_BODY_sem_acquire_timeout(sem, timeout);
+ return simcall_BODY_sem_acquire_timeout(sem, timeout);
}
sg_size_t simcall_storage_read(surf_storage_t st, sg_size_t size)
{
simgrid::simix::marshal<double>(simcall->args[2], arg);
}
+static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal<int>(simcall->result);
+}
+static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal_raw<int>(simcall->result);
+}
+static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result)
+{
+ simgrid::simix::marshal<int>(simcall->result, result);
+}
static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
{
{
simgrid::simix::marshal<double>(simcall->args[1], arg);
}
+static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal<int>(simcall->result);
+}
+static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal_raw<int>(simcall->result);
+}
+static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result)
+{
+ simgrid::simix::marshal<int>(simcall->result, result);
+}
static inline surf_storage_t simcall_storage_read__get__st(smx_simcall_t simcall)
{
return simcall<void, smx_cond_t, smx_mutex_t>(SIMCALL_COND_WAIT, cond, mutex);
}
-inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
+inline static int simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
simcall_HANDLER_cond_wait_timeout(&SIMIX_process_self()->simcall, cond, mutex, timeout);
- return simcall<void, smx_cond_t, smx_mutex_t, double>(SIMCALL_COND_WAIT_TIMEOUT, cond, mutex, timeout);
+ return simcall<int, smx_cond_t, smx_mutex_t, double>(SIMCALL_COND_WAIT_TIMEOUT, cond, mutex, timeout);
}
inline static void simcall_BODY_sem_acquire(smx_sem_t sem)
return simcall<void, smx_sem_t>(SIMCALL_SEM_ACQUIRE, sem);
}
-inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout)
+inline static int simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
simcall_HANDLER_sem_acquire_timeout(&SIMIX_process_self()->simcall, sem, timeout);
- return simcall<void, smx_sem_t, double>(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem, timeout);
+ return simcall<int, smx_sem_t, double>(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem, timeout);
}
inline static sg_size_t simcall_BODY_storage_read(surf_storage_t st, sg_size_t size)
void mutex_unlock(smx_mutex_t mutex);
void cond_wait(smx_cond_t cond, smx_mutex_t mutex) [[block]];
-void cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) [[block]];
+int cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) [[block]];
void sem_acquire(smx_sem_t sem) [[block]];
-void sem_acquire_timeout(smx_sem_t sem, double timeout) [[block]];
+int sem_acquire_timeout(smx_sem_t sem, double timeout) [[block]];
sg_size_t storage_read(surf_storage_t st, sg_size_t size) [[block]];
sg_size_t storage_write(surf_storage_t st, sg_size_t size) [[block]];
case SIMCALL_COND_WAIT_TIMEOUT:
simgrid::xbt::intrusive_erase(simcall_cond_wait_timeout__get__cond(simcall)->sleeping, *process);
+ simcall_cond_wait_timeout__set__result(simcall, 1); // signal a timeout
break;
case SIMCALL_SEM_ACQUIRE:
case SIMCALL_SEM_ACQUIRE_TIMEOUT:
simgrid::xbt::intrusive_erase(simcall_sem_acquire_timeout__get__sem(simcall)->sleeping, *process);
+ simcall_sem_acquire_timeout__set__result(simcall, 1); // signal a timeout
break;
default:
smx_simcall_t simcall = synchro->simcalls.front();
synchro->simcalls.pop_front();
- switch (synchro->state) {
-
- case SIMIX_SRC_TIMEOUT:
- SMX_EXCEPTION(simcall->issuer, timeout_error, 0, "Synchro's wait timeout");
- break;
-
- case SIMIX_FAILED:
- simcall->issuer->context->iwannadie = 1;
- break;
-
- default:
+ if (synchro->state != SIMIX_SRC_TIMEOUT) {
+ if (synchro->state == SIMIX_FAILED)
+ simcall->issuer->context->iwannadie = 1;
+ else
THROW_IMPOSSIBLE;
- break;
}
SIMIX_synchro_stop_waiting(simcall->issuer, simcall);
void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout)
{
XBT_IN("(%p)",simcall);
+ simcall_sem_acquire_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout
_SIMIX_sem_wait(sem, timeout, simcall->issuer, simcall);
XBT_OUT();
}
int xbt_cond_timedwait(xbt_cond_t cond, xbt_mutex_t mutex, double delay)
{
- try {
- simcall_cond_wait_timeout((smx_cond_t)cond, (smx_mutex_t)mutex, delay);
- } catch (xbt_ex& e) {
- if (e.category == timeout_error) {
- return 1;
- } else {
- throw; // rethrow the exceptions that I don't know
- }
- }
- return 0;
+ return simcall_cond_wait_timeout((smx_cond_t)cond, (smx_mutex_t)mutex, delay);
}
void xbt_cond_signal(xbt_cond_t cond)