X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/88fad0aaff9eb463f048bfdfe4ad6218aba44ddb..ea74f5d95928a521a588737e81f1de94eef25d19:/src/kernel/activity/MutexImpl.cpp diff --git a/src/kernel/activity/MutexImpl.cpp b/src/kernel/activity/MutexImpl.cpp index 7d90c8a7aa..660d77cfe4 100644 --- a/src/kernel/activity/MutexImpl.cpp +++ b/src/kernel/activity/MutexImpl.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2022. 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. */ @@ -6,130 +6,102 @@ #include "src/kernel/activity/MutexImpl.hpp" #include "src/kernel/activity/SynchroRaw.hpp" -#include "src/simix/smx_private.hpp" +#if SIMGRID_HAVE_MC +#include "simgrid/modelchecker.h" +#include "src/mc/mc_safety.hpp" +#define MC_CHECK_NO_DPOR() \ + xbt_assert(not MC_is_active() || mc::reduction_mode != mc::ReductionMode::dpor, \ + "Mutex is currently not supported with DPOR, use --cfg=model-check/reduction:none") +#else +#define MC_CHECK_NO_DPOR() (void)0 +#endif -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_mutex, simix_synchro, "Mutex kernel-space implementation"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_mutex, ker_synchro, "Mutex kernel-space implementation"); namespace simgrid { namespace kernel { namespace activity { -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) +void MutexImpl::lock(actor::ActorImpl* issuer) { XBT_IN("(%p; %p)", this, issuer); - /* FIXME: check where to validate the arguments */ - smx_activity_t synchro = nullptr; + MC_CHECK_NO_DPOR(); - if (this->locked) { + if (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); + RawImplPtr synchro(new RawImpl([this, issuer]() { this->remove_sleeping_actor(*issuer); })); + (*synchro).set_host(issuer->get_host()).start(); + synchro->register_simcall(&issuer->simcall_); + sleeping_.push_back(*issuer); } else { /* mutex free */ - this->locked = true; - this->owner = issuer; - SIMIX_simcall_answer(&issuer->simcall); + locked_ = true; + owner_ = issuer; + issuer->simcall_answer(); } XBT_OUT(); } -/** Tries to lock the mutex for a process +/** Tries to lock the mutex for a actor * - * \param issuer the process that tries to acquire the mutex - * \return whether we managed to lock the mutex + * @param issuer the actor that tries to acquire the mutex + * @return whether we managed to lock the mutex */ -bool MutexImpl::try_lock(smx_actor_t issuer) +bool MutexImpl::try_lock(actor::ActorImpl* issuer) { XBT_IN("(%p, %p)", this, issuer); - if (this->locked) { + MC_CHECK_NO_DPOR(); + if (locked_) { XBT_OUT(); return false; } - this->locked = true; - this->owner = issuer; + locked_ = true; + owner_ = issuer; XBT_OUT(); return true; } -/** Unlock a mutex for a process +/** Unlock a mutex for a actor * - * Unlocks the mutex and gives it to a process waiting for it. + * Unlocks the mutex and gives it to a actor 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. + * If there are no actor waiting, it sets the mutex as free. */ -void MutexImpl::unlock(smx_actor_t issuer) +void MutexImpl::unlock(actor::ActorImpl* 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:%ld), 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); + xbt_assert(locked_, "Cannot release that mutex: it was not locked."); + xbt_assert(issuer == owner_, "Cannot release that mutex: it was locked by %s (pid:%ld), not by you.", + owner_->get_cname(), owner_->get_pid()); + + if (not sleeping_.empty()) { + /* Give the ownership to the first waiting actor */ + owner_ = &sleeping_.front(); + sleeping_.pop_front(); + owner_->waiting_synchro_ = nullptr; + owner_->simcall_answer(); } else { /* nobody to wake up */ - this->locked = false; - this->owner = nullptr; + locked_ = false; + owner_ = nullptr; } XBT_OUT(); } -} -} -} - /** Increase the refcount for this mutex */ -smx_mutex_t SIMIX_mutex_ref(smx_mutex_t mutex) +MutexImpl* MutexImpl::ref() { - if (mutex != nullptr) - intrusive_ptr_add_ref(mutex); - return mutex; + intrusive_ptr_add_ref(this); + return this; } /** 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) +void MutexImpl::unref() { - mutex->lock(simcall->issuer); + intrusive_ptr_release(this); } -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); -} +} // namespace activity +} // namespace kernel +} // namespace simgrid