X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3ba5d4a966c2ac976b2b1656c52145f70189d108..b53d461e4c9810301894b61b449897968082ba49:/src/simix/smx_synchro.cpp diff --git a/src/simix/smx_synchro.cpp b/src/simix/smx_synchro.cpp index c4d9731312..a19b428700 100644 --- a/src/simix/smx_synchro.cpp +++ b/src/simix/smx_synchro.cpp @@ -1,15 +1,15 @@ - -/* Copyright (c) 2007-2015. The SimGrid Team. +/* Copyright (c) 2007-2017. 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.h" +#include "smx_private.hpp" #include "src/surf/cpu_interface.hpp" #include "src/surf/surf_interface.hpp" #include #include +#include #include "src/kernel/activity/SynchroRaw.hpp" @@ -30,7 +30,7 @@ static smx_activity_t SIMIX_synchro_wait(sg_host_t smx_host, double 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); + sync->sleep->setData(sync.get()); XBT_OUT(); return sync; } @@ -41,23 +41,23 @@ void SIMIX_synchro_stop_waiting(smx_actor_t process, smx_simcall_t simcall) switch (simcall->call) { case SIMCALL_MUTEX_LOCK: - xbt_swag_remove(process, simcall_mutex_lock__get__mutex(simcall)->sleeping); + simgrid::xbt::intrusive_erase(simcall_mutex_lock__get__mutex(simcall)->sleeping, *process); break; case SIMCALL_COND_WAIT: - xbt_swag_remove(process, simcall_cond_wait__get__cond(simcall)->sleeping); + simgrid::xbt::intrusive_erase(simcall_cond_wait__get__cond(simcall)->sleeping, *process); break; case SIMCALL_COND_WAIT_TIMEOUT: - xbt_swag_remove(process, simcall_cond_wait_timeout__get__cond(simcall)->sleeping); + simgrid::xbt::intrusive_erase(simcall_cond_wait_timeout__get__cond(simcall)->sleeping, *process); break; case SIMCALL_SEM_ACQUIRE: - xbt_swag_remove(process, simcall_sem_acquire__get__sem(simcall)->sleeping); + simgrid::xbt::intrusive_erase(simcall_sem_acquire__get__sem(simcall)->sleeping, *process); break; case SIMCALL_SEM_ACQUIRE_TIMEOUT: - xbt_swag_remove(process, simcall_sem_acquire_timeout__get__sem(simcall)->sleeping); + simgrid::xbt::intrusive_erase(simcall_sem_acquire_timeout__get__sem(simcall)->sleeping, *process); break; default: @@ -80,7 +80,6 @@ void SIMIX_synchro_finish(smx_activity_t synchro) case SIMIX_FAILED: simcall->issuer->context->iwannadie = 1; -// SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed"); break; default: @@ -101,16 +100,12 @@ namespace simix { MutexImpl::MutexImpl() : mutex_(this) { XBT_IN("(%p)", this); - // Useful to initialize sleeping swag: - simgrid::simix::ActorImpl p; - this->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup)); XBT_OUT(); } MutexImpl::~MutexImpl() { XBT_IN("(%p)", this); - xbt_swag_free(this->sleeping); XBT_OUT(); } @@ -126,7 +121,7 @@ void MutexImpl::lock(smx_actor_t issuer) synchro = SIMIX_synchro_wait(issuer->host, -1); synchro->simcalls.push_back(&issuer->simcall); issuer->waiting_synchro = synchro; - xbt_swag_insert(issuer, this->sleeping); + this->sleeping.push_back(*issuer); } else { /* mutex free */ this->locked = true; @@ -169,12 +164,13 @@ void MutexImpl::unlock(smx_actor_t issuer) /* 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->name.c_str(),this->owner->pid); + 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 (xbt_swag_size(this->sleeping) > 0) { + if (not this->sleeping.empty()) { /*process to wake up */ - smx_actor_t p = (smx_actor_t) xbt_swag_extract(this->sleeping); + smx_actor_t p = &this->sleeping.front(); + this->sleeping.pop_front(); p->waiting_synchro = nullptr; this->owner = p; SIMIX_simcall_answer(&p->simcall); @@ -204,11 +200,6 @@ void SIMIX_mutex_unref(smx_mutex_t mutex) intrusive_ptr_release(mutex); } -smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall) -{ - return new simgrid::simix::MutexImpl(); -} - // Simcall handlers: void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex) @@ -238,9 +229,7 @@ void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex) smx_cond_t SIMIX_cond_init() { XBT_IN("()"); - simgrid::simix::ActorImpl p; - smx_cond_t cond = new s_smx_cond(); - cond->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup)); + smx_cond_t cond = new s_smx_cond_t(); cond->refcount_ = 1; XBT_OUT(); return cond; @@ -292,7 +281,7 @@ static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout, synchro = SIMIX_synchro_wait(issuer->host, timeout); synchro->simcalls.push_front(simcall); issuer->waiting_synchro = synchro; - xbt_swag_insert(simcall->issuer, cond->sleeping); + cond->sleeping.push_back(*simcall->issuer); XBT_OUT(); } @@ -306,21 +295,20 @@ static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout, void SIMIX_cond_signal(smx_cond_t cond) { XBT_IN("(%p)",cond); - smx_actor_t proc = nullptr; - smx_mutex_t mutex = nullptr; - smx_simcall_t simcall = nullptr; - 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 ((proc = (smx_actor_t) xbt_swag_extract(cond->sleeping))) { + if (not cond->sleeping.empty()) { + auto& proc = cond->sleeping.front(); + cond->sleeping.pop_front(); /* Destroy waiter's synchronization */ - proc->waiting_synchro = nullptr; + proc.waiting_synchro = nullptr; /* Now transform the cond wait simcall into a mutex lock one */ - simcall = &proc->simcall; + smx_simcall_t simcall = &proc.simcall; + smx_mutex_t mutex; if(simcall->call == SIMCALL_COND_WAIT) mutex = simcall_cond_wait__get__mutex(simcall); else @@ -345,7 +333,7 @@ void SIMIX_cond_broadcast(smx_cond_t cond) XBT_DEBUG("Broadcast condition %p", cond); /* Signal the condition until nobody is waiting on it */ - while (xbt_swag_size(cond->sleeping)) { + while (not cond->sleeping.empty()) { SIMIX_cond_signal(cond); } XBT_OUT(); @@ -371,17 +359,14 @@ void SIMIX_cond_unref(smx_cond_t cond) void intrusive_ptr_add_ref(s_smx_cond_t *cond) { - auto previous = (cond->refcount_)++; + auto previous = cond->refcount_.fetch_add(1); xbt_assert(previous != 0); } void intrusive_ptr_release(s_smx_cond_t *cond) { - auto count = --(cond->refcount_); - if (count == 0) { - xbt_assert(xbt_swag_size(cond->sleeping) == 0, - "Cannot destroy conditional since someone is still using it"); - xbt_swag_free(cond->sleeping); + if (cond->refcount_.fetch_sub(1) == 1) { + xbt_assert(cond->sleeping.empty(), "Cannot destroy conditional since someone is still using it"); delete cond; } } @@ -391,10 +376,7 @@ void intrusive_ptr_release(s_smx_cond_t *cond) smx_sem_t SIMIX_sem_init(unsigned int value) { XBT_IN("(%u)",value); - simgrid::simix::ActorImpl p; - - smx_sem_t sem = xbt_new0(s_smx_sem_t, 1); - sem->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup)); + smx_sem_t sem = new s_smx_sem_t; sem->value = value; XBT_OUT(); return sem; @@ -406,17 +388,12 @@ void SIMIX_sem_destroy(smx_sem_t sem) XBT_IN("(%p)",sem); XBT_DEBUG("Destroy semaphore %p", sem); if (sem != nullptr) { - xbt_assert(xbt_swag_size(sem->sleeping) == 0, - "Cannot destroy semaphore since someone is still using it"); - xbt_swag_free(sem->sleeping); - xbt_free(sem); + xbt_assert(sem->sleeping.empty(), "Cannot destroy semaphore since someone is still using it"); + delete sem; } XBT_OUT(); } -void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem){ - SIMIX_sem_release(sem); -} /** @brief release the semaphore * * Unlock a process waiting on the semaphore. @@ -425,12 +402,12 @@ void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem){ void SIMIX_sem_release(smx_sem_t sem) { XBT_IN("(%p)",sem); - smx_actor_t proc; - XBT_DEBUG("Sem release semaphore %p", sem); - if ((proc = (smx_actor_t) xbt_swag_extract(sem->sleeping))) { - proc->waiting_synchro = nullptr; - SIMIX_simcall_answer(&proc->simcall); + if (not sem->sleeping.empty()) { + auto& proc = sem->sleeping.front(); + sem->sleeping.pop_front(); + proc.waiting_synchro = nullptr; + SIMIX_simcall_answer(&proc.simcall); } else { sem->value++; } @@ -445,9 +422,6 @@ int SIMIX_sem_would_block(smx_sem_t sem) return (sem->value <= 0); } -int simcall_HANDLER_sem_get_capacity(smx_simcall_t simcall, smx_sem_t sem){ - return SIMIX_sem_get_capacity(sem); -} /** @brief Returns the current capacity of the semaphore */ int SIMIX_sem_get_capacity(smx_sem_t sem) { @@ -467,7 +441,7 @@ static void _SIMIX_sem_wait(smx_sem_t sem, double timeout, smx_actor_t issuer, synchro = SIMIX_synchro_wait(issuer->host, timeout); synchro->simcalls.push_front(simcall); issuer->waiting_synchro = synchro; - xbt_swag_insert(issuer, sem->sleeping); + sem->sleeping.push_back(*issuer); } else { sem->value--; SIMIX_simcall_answer(simcall); @@ -496,6 +470,3 @@ void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, d _SIMIX_sem_wait(sem, timeout, simcall->issuer, simcall); XBT_OUT(); } -int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem) { - return SIMIX_sem_would_block(sem); -}