X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/96cedde3cdbc0b8ffc3f096a1b65d021b0226f99..2e20b9d63d8a9ca26f8b508b5cab294acc3b608a:/src/kernel/activity/MutexImpl.cpp diff --git a/src/kernel/activity/MutexImpl.cpp b/src/kernel/activity/MutexImpl.cpp index cc82ce65f2..f1e089fbc5 100644 --- a/src/kernel/activity/MutexImpl.cpp +++ b/src/kernel/activity/MutexImpl.cpp @@ -1,134 +1,133 @@ -/* Copyright (c) 2007-2019. 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. */ #include "src/kernel/activity/MutexImpl.hpp" -#include "src/kernel/activity/SynchroRaw.hpp" -#include "src/simix/smx_synchro_private.hpp" +#include "src/kernel/activity/Synchro.hpp" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_mutex, simix_synchro, "Mutex kernel-space implementation"); +#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(ker_mutex, ker_synchro, "Mutex kernel-space implementation"); namespace simgrid { namespace kernel { namespace activity { -MutexImpl::MutexImpl() : piface_(this) +bool MutexAcquisitionImpl::test(actor::ActorImpl*) { - XBT_IN("(%p)", this); - XBT_OUT(); + return mutex_->owner_ == issuer_; } +void MutexAcquisitionImpl::wait_for(actor::ActorImpl* issuer, double timeout) +{ + xbt_assert(mutex_->owner_ != nullptr); // it was locked either by someone else or by me during the lock_async + xbt_assert( + issuer == issuer_, + "Actors can only wait acquisitions that they created themselves while this one was created by actor id %ld.", + issuer_->get_pid()); + xbt_assert(timeout < 0, "Timeouts on mutex acquisitions are not implemented yet."); + + this->register_simcall(&issuer_->simcall_); // Block on that acquisition -MutexImpl::~MutexImpl() + if (mutex_->get_owner() == issuer_) { // I'm the owner + finish(); + } else { + // Already in the queue + } +} +void MutexAcquisitionImpl::finish() { - XBT_IN("(%p)", this); - XBT_OUT(); + xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size()); + smx_simcall_t simcall = simcalls_.front(); + simcalls_.pop_front(); + + simcall->issuer_->waiting_synchro_ = nullptr; + simcall->issuer_->simcall_answer(); } -void MutexImpl::lock(smx_actor_t issuer) +unsigned MutexImpl::next_id_ = 0; + +MutexAcquisitionImplPtr MutexImpl::lock_async(actor::ActorImpl* issuer) { - XBT_IN("(%p; %p)", this, issuer); - /* FIXME: check where to validate the arguments */ - smx_activity_t synchro = nullptr; + auto res = MutexAcquisitionImplPtr(new kernel::activity::MutexAcquisitionImpl(issuer, this), true); - if (this->locked) { + if (owner_ != nullptr) { /* 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); + sleeping_.push_back(res); } else { - /* mutex free */ - this->locked = true; - this->owner = issuer; - SIMIX_simcall_answer(&issuer->simcall); + owner_ = issuer; } - XBT_OUT(); + return res; } -/** 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 + * @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 (owner_ != nullptr) { XBT_OUT(); return false; } - this->locked = true; - this->owner = issuer; + 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->get_cname(), 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(issuer == owner_, "Cannot release that mutex: you're not the owner. %s is (pid:%ld).", + owner_ != nullptr ? owner_->get_cname() : "(nobody)", owner_ != nullptr ? owner_->get_pid() : -1); + + if (not sleeping_.empty()) { + /* Give the ownership to the first waiting actor */ + auto acq = sleeping_.front(); + owner_ = acq->get_issuer(); + + if (acq == owner_->waiting_synchro_) + acq->finish(); + + sleeping_.pop_front(); } else { /* nobody to wake up */ - this->locked = false; - this->owner = nullptr; + 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) +void MutexImpl::unref() { - if (mutex != nullptr) - intrusive_ptr_release(mutex); + intrusive_ptr_release(this); } -// 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); -} +} // namespace activity +} // namespace kernel +} // namespace simgrid