X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/17c819afc4ceda4000eec137c8fee35168253b4d..13cf919b6231022290ec292eb1fb48abbb39f8eb:/src/kernel/activity/MutexImpl.cpp diff --git a/src/kernel/activity/MutexImpl.cpp b/src/kernel/activity/MutexImpl.cpp index bd03220da8..1c9235b95c 100644 --- a/src/kernel/activity/MutexImpl.cpp +++ b/src/kernel/activity/MutexImpl.cpp @@ -1,134 +1,112 @@ -/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2023. 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"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_mutex, ker_synchro, "Mutex kernel-space implementation"); -namespace simgrid { -namespace kernel { -namespace activity { +namespace simgrid::kernel::activity { -MutexImpl::MutexImpl() : mutex_(this) +/* -------- Acquisition -------- */ + +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_, "Cannot wait on acquisitions created by another actor (id %ld)", issuer_->get_pid()); + xbt_assert(timeout < 0, "Timeouts on mutex acquisitions are not implemented yet."); -MutexImpl::~MutexImpl() + this->register_simcall(&issuer_->simcall_); // Block on that acquisition + + if (mutex_->get_owner() == issuer_) { // I'm the owner + post(); + } else { + // Already in the queue + } +} +void MutexAcquisitionImpl::post() { - XBT_IN("(%p)", this); - XBT_OUT(); + finish(); } -void MutexImpl::lock(smx_actor_t issuer) +void MutexAcquisitionImpl::finish() { - 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); + xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size()); + actor::Simcall* simcall = simcalls_.front(); + simcalls_.pop_front(); + + simcall->issuer_->waiting_synchro_ = nullptr; + simcall->issuer_->simcall_answer(); +} + +/* -------- Mutex -------- */ + +unsigned MutexImpl::next_id_ = 0; + +MutexAcquisitionImplPtr MutexImpl::lock_async(actor::ActorImpl* issuer) +{ + auto res = MutexAcquisitionImplPtr(new kernel::activity::MutexAcquisitionImpl(issuer, this), true); + + if (owner_ != nullptr) { + /* Somebody is using the mutex; register the acquisition */ + ongoing_acquisitions_.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 - * \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) { + 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 ongoing_acquisitions_.empty()) { + /* Give the ownership to the first waiting actor */ + auto acq = ongoing_acquisitions_.front(); + ongoing_acquisitions_.pop_front(); + + owner_ = acq->get_issuer(); + if (acq == owner_->waiting_synchro_) + acq->post(); + // else, the issuer is not blocked on this acquisition so no need to release it + } 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) -{ - 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); -} +} // namespace simgrid::kernel::activity