X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d105e05a38d60fa6ac512c3158d3af1372f7c75d..89047acf6125582321f8e86f9765b0f57e350e2c:/src/simix/smx_synchro.cpp diff --git a/src/simix/smx_synchro.cpp b/src/simix/smx_synchro.cpp index a19b428700..233f61c331 100644 --- a/src/simix/smx_synchro.cpp +++ b/src/simix/smx_synchro.cpp @@ -1,36 +1,28 @@ -/* Copyright (c) 2007-2017. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2007-2018. 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 "smx_private.hpp" +#include "src/kernel/activity/ConditionVariableImpl.hpp" +#include "src/kernel/activity/MutexImpl.hpp" +#include "src/kernel/activity/SynchroRaw.hpp" +#include "src/simix/smx_synchro_private.hpp" #include "src/surf/cpu_interface.hpp" -#include "src/surf/surf_interface.hpp" #include -#include -#include - -#include "src/kernel/activity/SynchroRaw.hpp" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_synchro, simix, "SIMIX Synchronization (mutex, semaphores and conditions)"); -static smx_activity_t SIMIX_synchro_wait(sg_host_t smx_host, double timeout); -static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout, - smx_actor_t issuer, smx_simcall_t simcall); -static void _SIMIX_sem_wait(smx_sem_t sem, double timeout, smx_actor_t issuer, - smx_simcall_t simcall); - /***************************** Raw synchronization *********************************/ -static smx_activity_t SIMIX_synchro_wait(sg_host_t smx_host, double timeout) +smx_activity_t SIMIX_synchro_wait(sg_host_t smx_host, double timeout) { XBT_IN("(%p, %f)",smx_host,timeout); simgrid::kernel::activity::RawImplPtr sync = simgrid::kernel::activity::RawImplPtr(new simgrid::kernel::activity::RawImpl()); sync->sleep = smx_host->pimpl_cpu->sleep(timeout); - sync->sleep->setData(sync.get()); + sync->sleep->set_data(sync.get()); XBT_OUT(); return sync; } @@ -50,6 +42,7 @@ void SIMIX_synchro_stop_waiting(smx_actor_t process, smx_simcall_t simcall) 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: @@ -58,6 +51,7 @@ void SIMIX_synchro_stop_waiting(smx_actor_t process, smx_simcall_t simcall) 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: @@ -69,22 +63,14 @@ void SIMIX_synchro_stop_waiting(smx_actor_t process, smx_simcall_t simcall) void SIMIX_synchro_finish(smx_activity_t synchro) { XBT_IN("(%p)", synchro.get()); - 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; + smx_simcall_t simcall = synchro->simcalls_.front(); + synchro->simcalls_.pop_front(); - 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); @@ -92,284 +78,6 @@ void SIMIX_synchro_finish(smx_activity_t synchro) SIMIX_simcall_answer(simcall); XBT_OUT(); } -/*********************************** Mutex ************************************/ - -namespace simgrid { -namespace simix { - -MutexImpl::MutexImpl() : mutex_(this) -{ - XBT_IN("(%p)", this); - XBT_OUT(); -} - -MutexImpl::~MutexImpl() -{ - XBT_IN("(%p)", this); - XBT_OUT(); -} - -void MutexImpl::lock(smx_actor_t issuer) -{ - XBT_IN("(%p; %p)", this, issuer); - /* FIXME: check where to validate the arguments */ - smx_activity_t synchro = nullptr; - - if (this->locked) { - /* FIXME: check if the host is active ? */ - /* Somebody using the mutex, use a synchronization to get host failures */ - synchro = SIMIX_synchro_wait(issuer->host, -1); - synchro->simcalls.push_back(&issuer->simcall); - issuer->waiting_synchro = synchro; - this->sleeping.push_back(*issuer); - } else { - /* mutex free */ - this->locked = true; - this->owner = issuer; - SIMIX_simcall_answer(&issuer->simcall); - } - XBT_OUT(); -} - -/** Tries to lock the mutex for a process - * - * \param issuer the process that tries to acquire the mutex - * \return whether we managed to lock the mutex - */ -bool MutexImpl::try_lock(smx_actor_t issuer) -{ - XBT_IN("(%p, %p)", this, issuer); - if (this->locked) { - XBT_OUT(); - return false; - } - - this->locked = true; - this->owner = issuer; - XBT_OUT(); - return true; -} - -/** Unlock a mutex for a process - * - * Unlocks the mutex and gives it to a process waiting for it. - * If the unlocker is not the owner of the mutex nothing happens. - * If there are no process waiting, it sets the mutex as free. - */ -void MutexImpl::unlock(smx_actor_t issuer) -{ - XBT_IN("(%p, %p)", this, issuer); - if (not this->locked) - THROWF(mismatch_error, 0, "Cannot release that mutex: it was not locked."); - - /* If the mutex is not owned by the issuer, that's not good */ - if (issuer != this->owner) - THROWF(mismatch_error, 0, "Cannot release that mutex: it was locked by %s (pid:%lu), not by you.", - this->owner->getCname(), this->owner->pid); - - if (not this->sleeping.empty()) { - /*process to wake up */ - smx_actor_t p = &this->sleeping.front(); - this->sleeping.pop_front(); - p->waiting_synchro = nullptr; - this->owner = p; - SIMIX_simcall_answer(&p->simcall); - } else { - /* nobody to wake up */ - this->locked = false; - this->owner = nullptr; - } - XBT_OUT(); -} - -} -} - -/** Increase the refcount for this mutex */ -smx_mutex_t SIMIX_mutex_ref(smx_mutex_t mutex) -{ - if (mutex != nullptr) - intrusive_ptr_add_ref(mutex); - return mutex; -} - -/** Decrease the refcount for this mutex */ -void SIMIX_mutex_unref(smx_mutex_t mutex) -{ - if (mutex != nullptr) - intrusive_ptr_release(mutex); -} - -// Simcall handlers: - -void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex) -{ - mutex->lock(simcall->issuer); -} - -int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex) -{ - return mutex->try_lock(simcall->issuer); -} - -void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex) -{ - mutex->unlock(simcall->issuer); -} - -/********************************* Condition **********************************/ - -/** - * \brief Initialize a condition. - * - * Allocates and creates the data for the condition. - * It have to be called before the use of the condition. - * \return A condition - */ -smx_cond_t SIMIX_cond_init() -{ - XBT_IN("()"); - smx_cond_t cond = new s_smx_cond_t(); - cond->refcount_ = 1; - XBT_OUT(); - return cond; -} - -/** - * \brief Handle a condition waiting simcall without timeouts - * \param simcall the simcall - */ -void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex) -{ - XBT_IN("(%p)",simcall); - smx_actor_t issuer = simcall->issuer; - - _SIMIX_cond_wait(cond, mutex, -1, issuer, simcall); - XBT_OUT(); -} - -/** - * \brief Handle a condition waiting simcall with timeouts - * \param simcall the simcall - */ -void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, - smx_mutex_t mutex, double timeout) -{ - XBT_IN("(%p)",simcall); - smx_actor_t issuer = simcall->issuer; - - _SIMIX_cond_wait(cond, mutex, timeout, issuer, simcall); - XBT_OUT(); -} - - -static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout, - smx_actor_t issuer, smx_simcall_t simcall) -{ - XBT_IN("(%p, %p, %f, %p,%p)",cond,mutex,timeout,issuer,simcall); - smx_activity_t synchro = nullptr; - - XBT_DEBUG("Wait condition %p", cond); - - /* If there is a mutex unlock it */ - /* FIXME: what happens if the issuer is not the owner of the mutex? */ - if (mutex != nullptr) { - cond->mutex = mutex; - mutex->unlock(issuer); - } - - synchro = SIMIX_synchro_wait(issuer->host, timeout); - synchro->simcalls.push_front(simcall); - issuer->waiting_synchro = synchro; - cond->sleeping.push_back(*simcall->issuer); - XBT_OUT(); -} - -/** - * \brief Signalizes a condition. - * - * Signalizes a condition and wakes up a sleeping process. - * If there are no process sleeping, no action is done. - * \param cond A condition - */ -void SIMIX_cond_signal(smx_cond_t cond) -{ - XBT_IN("(%p)",cond); - XBT_DEBUG("Signal condition %p", cond); - - /* If there are processes waiting for the condition choose one and try - to make it acquire the mutex */ - if (not cond->sleeping.empty()) { - auto& proc = cond->sleeping.front(); - cond->sleeping.pop_front(); - - /* Destroy waiter's synchronization */ - proc.waiting_synchro = nullptr; - - /* Now transform the cond wait simcall into a mutex lock one */ - smx_simcall_t simcall = &proc.simcall; - smx_mutex_t mutex; - if(simcall->call == SIMCALL_COND_WAIT) - mutex = simcall_cond_wait__get__mutex(simcall); - else - mutex = simcall_cond_wait_timeout__get__mutex(simcall); - simcall->call = SIMCALL_MUTEX_LOCK; - - simcall_HANDLER_mutex_lock(simcall, mutex); - } - XBT_OUT(); -} - -/** - * \brief Broadcasts a condition. - * - * Signal ALL processes waiting on a condition. - * If there are no process waiting, no action is done. - * \param cond A condition - */ -void SIMIX_cond_broadcast(smx_cond_t cond) -{ - XBT_IN("(%p)",cond); - XBT_DEBUG("Broadcast condition %p", cond); - - /* Signal the condition until nobody is waiting on it */ - while (not cond->sleeping.empty()) { - SIMIX_cond_signal(cond); - } - XBT_OUT(); -} - -smx_cond_t SIMIX_cond_ref(smx_cond_t cond) -{ - if (cond != nullptr) - intrusive_ptr_add_ref(cond); - return cond; -} - -void SIMIX_cond_unref(smx_cond_t cond) -{ - XBT_IN("(%p)",cond); - XBT_DEBUG("Destroy condition %p", cond); - if (cond != nullptr) { - intrusive_ptr_release(cond); - } - XBT_OUT(); -} - - -void intrusive_ptr_add_ref(s_smx_cond_t *cond) -{ - auto previous = cond->refcount_.fetch_add(1); - xbt_assert(previous != 0); -} - -void intrusive_ptr_release(s_smx_cond_t *cond) -{ - if (cond->refcount_.fetch_sub(1) == 1) { - xbt_assert(cond->sleeping.empty(), "Cannot destroy conditional since someone is still using it"); - delete cond; - } -} /******************************** Semaphores **********************************/ /** @brief Initialize a semaphore */ @@ -439,7 +147,7 @@ static void _SIMIX_sem_wait(smx_sem_t sem, double timeout, smx_actor_t issuer, XBT_DEBUG("Wait semaphore %p (timeout:%f)", sem, timeout); if (sem->value <= 0) { synchro = SIMIX_synchro_wait(issuer->host, timeout); - synchro->simcalls.push_front(simcall); + synchro->simcalls_.push_front(simcall); issuer->waiting_synchro = synchro; sem->sleeping.push_back(*issuer); } else { @@ -451,7 +159,6 @@ static void _SIMIX_sem_wait(smx_sem_t sem, double timeout, smx_actor_t issuer, /** * \brief Handles a sem acquire simcall without timeout. - * \param simcall the simcall */ void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem) { @@ -462,11 +169,11 @@ void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem) /** * \brief Handles a sem acquire simcall with timeout. - * \param simcall the 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(); }