From b8dc7c0693d2606e9cb9f21bcced90a5174bd503 Mon Sep 17 00:00:00 2001 From: Martin Quinson Date: Tue, 13 Aug 2019 11:47:52 +0200 Subject: [PATCH] obey our coding standards, and snake_case some parts of MC --- src/kernel/activity/ActivityImpl.cpp | 2 +- src/kernel/activity/CommImpl.cpp | 86 +-- src/kernel/activity/ConditionVariableImpl.cpp | 12 +- src/kernel/activity/ExecImpl.cpp | 38 +- src/kernel/activity/IoImpl.cpp | 10 +- src/kernel/activity/MutexImpl.cpp | 6 +- src/kernel/activity/SemaphoreImpl.cpp | 4 +- src/kernel/activity/SleepImpl.cpp | 10 +- src/kernel/activity/SynchroRaw.cpp | 22 +- src/kernel/actor/ActorImpl.cpp | 8 +- src/mc/ModelChecker.cpp | 4 +- src/mc/Transition.hpp | 4 +- src/mc/VisitedState.cpp | 4 +- .../CommunicationDeterminismChecker.cpp | 38 +- src/mc/checker/LivenessChecker.cpp | 26 +- src/mc/checker/SafetyChecker.cpp | 76 ++- src/mc/mc_base.cpp | 20 +- src/mc/mc_comm_pattern.cpp | 12 +- src/mc/mc_comm_pattern.hpp | 2 +- src/mc/mc_record.cpp | 20 +- src/mc/mc_request.cpp | 549 +++++++++--------- src/mc/mc_smx.cpp | 2 +- src/mc/mc_state.cpp | 144 ++--- src/mc/mc_state.hpp | 30 +- src/simix/libsmx.cpp | 4 +- src/simix/popping_accessors.hpp | 480 +++++++-------- src/simix/popping_bodies.cpp | 6 +- src/simix/popping_generated.cpp | 104 +++- src/simix/popping_private.hpp | 28 +- src/simix/smx_global.cpp | 2 +- src/smpi/plugins/sampi_loadbalancer.cpp | 2 +- 31 files changed, 902 insertions(+), 853 deletions(-) diff --git a/src/kernel/activity/ActivityImpl.cpp b/src/kernel/activity/ActivityImpl.cpp index c5f3524539..30278792ec 100644 --- a/src/kernel/activity/ActivityImpl.cpp +++ b/src/kernel/activity/ActivityImpl.cpp @@ -21,7 +21,7 @@ ActivityImpl::~ActivityImpl() void ActivityImpl::register_simcall(smx_simcall_t simcall) { simcalls_.push_back(simcall); - simcall->issuer->waiting_synchro = this; + simcall->issuer_->waiting_synchro = this; } void ActivityImpl::clean_action() diff --git a/src/kernel/activity/CommImpl.cpp b/src/kernel/activity/CommImpl.cpp index 28c30e9282..8e95559b08 100644 --- a/src/kernel/activity/CommImpl.cpp +++ b/src/kernel/activity/CommImpl.cpp @@ -200,7 +200,7 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity: if (timeout < 0.0) THROW_IMPOSSIBLE; - if (comm->src_actor_ == simcall->issuer) + if (comm->src_actor_ == simcall->issuer_) comm->state_ = SIMIX_SRC_TIMEOUT; else comm->state_ = SIMIX_DST_TIMEOUT; @@ -215,10 +215,10 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity: if (comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING) { comm->finish(); } else { /* we need a sleep action (even when there is no timeout) to be notified of host failures */ - simgrid::kernel::resource::Action* sleep = simcall->issuer->get_host()->pimpl_cpu->sleep(timeout); + simgrid::kernel::resource::Action* sleep = simcall->issuer_->get_host()->pimpl_cpu->sleep(timeout); sleep->set_activity(comm); - if (simcall->issuer == comm->src_actor_) + if (simcall->issuer_ == comm->src_actor_) comm->src_timeout_ = sleep; else comm->dst_timeout_ = sleep; @@ -242,7 +242,7 @@ void simcall_HANDLER_comm_test(smx_simcall_t simcall, simgrid::kernel::activity: comm->simcalls_.push_back(simcall); comm->finish(); } else { - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); } } @@ -255,7 +255,7 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi if (MC_is_active() || MC_record_replay_is_active()) { int idx = SIMCALL_GET_MC_VALUE(*simcall); if (idx == -1) { - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); } else { simgrid::kernel::activity::CommImpl* comm = comms[idx]; simcall_comm_testany__set__result(simcall, idx); @@ -275,7 +275,7 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi return; } } - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); } static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall) @@ -307,12 +307,12 @@ void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activi } if (timeout < 0.0) { - simcall->timeout_cb = NULL; + simcall->timeout_cb_ = NULL; } else { - simcall->timeout_cb = simgrid::simix::Timer::set(SIMIX_get_clock() + timeout, [simcall]() { + simcall->timeout_cb_ = simgrid::simix::Timer::set(SIMIX_get_clock() + timeout, [simcall]() { SIMIX_waitany_remove_simcall_from_actions(simcall); simcall_comm_waitany__set__result(simcall, -1); - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); }); } @@ -580,13 +580,13 @@ void CommImpl::finish() * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the * simcall */ - if (simcall->call == SIMCALL_NONE) // FIXME: maybe a better way to handle this case + if (simcall->call_ == SIMCALL_NONE) // FIXME: maybe a better way to handle this case continue; // if process handling comm is killed - if (simcall->call == SIMCALL_COMM_WAITANY) { + if (simcall->call_ == SIMCALL_COMM_WAITANY) { SIMIX_waitany_remove_simcall_from_actions(simcall); - if (simcall->timeout_cb) { - simcall->timeout_cb->remove(); - simcall->timeout_cb = nullptr; + if (simcall->timeout_cb_) { + simcall->timeout_cb_->remove(); + simcall->timeout_cb_ = nullptr; } if (not MC_is_active() && not MC_record_replay_is_active()) { CommImpl** comms = simcall_comm_waitany__get__comms(simcall); @@ -605,8 +605,8 @@ void CommImpl::finish() /* Check out for errors */ - if (not simcall->issuer->get_host()->is_on()) { - simcall->issuer->context_->iwannadie = true; + if (not simcall->issuer_->get_host()->is_on()) { + simcall->issuer_->context_->iwannadie = true; } else { switch (state_) { @@ -616,28 +616,28 @@ void CommImpl::finish() break; case SIMIX_SRC_TIMEOUT: - simcall->issuer->exception_ = std::make_exception_ptr( + simcall->issuer_->exception_ = std::make_exception_ptr( simgrid::TimeoutException(XBT_THROW_POINT, "Communication timeouted because of the sender")); break; case SIMIX_DST_TIMEOUT: - simcall->issuer->exception_ = std::make_exception_ptr( + simcall->issuer_->exception_ = std::make_exception_ptr( simgrid::TimeoutException(XBT_THROW_POINT, "Communication timeouted because of the receiver")); break; case SIMIX_SRC_HOST_FAILURE: - if (simcall->issuer == src_actor_) - simcall->issuer->context_->iwannadie = true; + if (simcall->issuer_ == src_actor_) + simcall->issuer_->context_->iwannadie = true; else - simcall->issuer->exception_ = + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::NetworkFailureException(XBT_THROW_POINT, "Remote peer failed")); break; case SIMIX_DST_HOST_FAILURE: - if (simcall->issuer == dst_actor_) - simcall->issuer->context_->iwannadie = true; + if (simcall->issuer_ == dst_actor_) + simcall->issuer_->context_->iwannadie = true; else - simcall->issuer->exception_ = + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::NetworkFailureException(XBT_THROW_POINT, "Remote peer failed")); break; @@ -645,25 +645,25 @@ void CommImpl::finish() XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) " "detached:%d", this, src_actor_ ? src_actor_->get_host()->get_cname() : nullptr, - dst_actor_ ? dst_actor_->get_host()->get_cname() : nullptr, simcall->issuer->get_cname(), - simcall->issuer, detached_); - if (src_actor_ == simcall->issuer) { + dst_actor_ ? dst_actor_->get_host()->get_cname() : nullptr, simcall->issuer_->get_cname(), + simcall->issuer_, detached_); + if (src_actor_ == simcall->issuer_) { XBT_DEBUG("I'm source"); - } else if (dst_actor_ == simcall->issuer) { + } else if (dst_actor_ == simcall->issuer_) { XBT_DEBUG("I'm dest"); } else { XBT_DEBUG("I'm neither source nor dest"); } - simcall->issuer->throw_exception( + simcall->issuer_->throw_exception( std::make_exception_ptr(simgrid::NetworkFailureException(XBT_THROW_POINT, "Link failure"))); break; case SIMIX_CANCELED: - if (simcall->issuer == dst_actor_) - simcall->issuer->exception_ = std::make_exception_ptr( + if (simcall->issuer_ == dst_actor_) + simcall->issuer_->exception_ = std::make_exception_ptr( simgrid::CancelException(XBT_THROW_POINT, "Communication canceled by the sender")); else - simcall->issuer->exception_ = std::make_exception_ptr( + simcall->issuer_->exception_ = std::make_exception_ptr( simgrid::CancelException(XBT_THROW_POINT, "Communication canceled by the receiver")); break; @@ -672,12 +672,12 @@ void CommImpl::finish() } } /* if there is an exception during a waitany or a testany, indicate the position of the failed communication */ - if (simcall->issuer->exception_ && - (simcall->call == SIMCALL_COMM_WAITANY || simcall->call == SIMCALL_COMM_TESTANY)) { + if (simcall->issuer_->exception_ && + (simcall->call_ == SIMCALL_COMM_WAITANY || simcall->call_ == SIMCALL_COMM_TESTANY)) { // First retrieve the rank of our failing synchro CommImpl** comms; size_t count; - if (simcall->call == SIMCALL_COMM_WAITANY) { + if (simcall->call_ == SIMCALL_COMM_WAITANY) { comms = simcall_comm_waitany__get__comms(simcall); count = simcall_comm_waitany__get__count(simcall); } else { @@ -690,19 +690,19 @@ void CommImpl::finish() // In order to modify the exception we have to rethrow it: try { - std::rethrow_exception(simcall->issuer->exception_); + std::rethrow_exception(simcall->issuer_->exception_); } catch (simgrid::Exception& e) { e.value = rank; } } - simcall->issuer->waiting_synchro = nullptr; - simcall->issuer->comms.remove(this); + simcall->issuer_->waiting_synchro = nullptr; + simcall->issuer_->comms.remove(this); if (detached_) { - if (simcall->issuer == src_actor_) { + if (simcall->issuer_ == src_actor_) { if (dst_actor_) dst_actor_->comms.remove(this); - } else if (simcall->issuer == dst_actor_) { + } else if (simcall->issuer_ == dst_actor_) { if (src_actor_) src_actor_->comms.remove(this); } else { @@ -711,10 +711,10 @@ void CommImpl::finish() } } - if (simcall->issuer->get_host()->is_on()) - simcall->issuer->simcall_answer(); + if (simcall->issuer_->get_host()->is_on()) + simcall->issuer_->simcall_answer(); else - simcall->issuer->context_->iwannadie = true; + simcall->issuer_->context_->iwannadie = true; } } diff --git a/src/kernel/activity/ConditionVariableImpl.cpp b/src/kernel/activity/ConditionVariableImpl.cpp index c29e907ec1..fd84ce5853 100644 --- a/src/kernel/activity/ConditionVariableImpl.cpp +++ b/src/kernel/activity/ConditionVariableImpl.cpp @@ -16,7 +16,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ConditionVariable, simix_synchro, "Condition var 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; + smx_actor_t issuer = simcall->issuer_; cond->wait(mutex, -1, issuer, simcall); XBT_OUT(); @@ -26,7 +26,7 @@ void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex 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; + smx_actor_t issuer = simcall->issuer_; simcall_cond_wait_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout cond->wait(mutex, timeout, issuer, simcall); XBT_OUT(); @@ -61,13 +61,13 @@ void ConditionVariableImpl::signal() /* Now transform the cond wait simcall into a mutex lock one */ smx_simcall_t simcall = &proc.simcall; MutexImpl* simcall_mutex; - if (simcall->call == SIMCALL_COND_WAIT) + if (simcall->call_ == SIMCALL_COND_WAIT) simcall_mutex = simcall_cond_wait__get__mutex(simcall); else simcall_mutex = simcall_cond_wait_timeout__get__mutex(simcall); - simcall->call = SIMCALL_MUTEX_LOCK; + simcall->call_ = SIMCALL_MUTEX_LOCK; - simcall_mutex->lock(simcall->issuer); + simcall_mutex->lock(simcall->issuer_); } XBT_OUT(); } @@ -102,7 +102,7 @@ void ConditionVariableImpl::wait(smx_mutex_t mutex, double timeout, actor::Actor (*synchro).set_host(issuer->get_host()).set_timeout(timeout).start(); synchro->simcalls_.push_front(simcall); issuer->waiting_synchro = std::move(synchro); - sleeping_.push_back(*simcall->issuer); + sleeping_.push_back(*simcall->issuer_); } // boost::intrusive_ptr support: diff --git a/src/kernel/activity/ExecImpl.cpp b/src/kernel/activity/ExecImpl.cpp index cfdf73e8e1..ea1159d295 100644 --- a/src/kernel/activity/ExecImpl.cpp +++ b/src/kernel/activity/ExecImpl.cpp @@ -43,7 +43,7 @@ void simcall_HANDLER_execution_test(smx_simcall_t simcall, simgrid::kernel::acti synchro->simcalls_.push_back(simcall); synchro->finish(); } else { - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); } simcall_execution_test__set__result(simcall, res); } @@ -52,9 +52,9 @@ void simcall_HANDLER_execution_waitany_for(smx_simcall_t simcall, simgrid::kerne size_t count, double timeout) { if (timeout < 0.0) { - simcall->timeout_cb = nullptr; + simcall->timeout_cb_ = nullptr; } else { - simcall->timeout_cb = simgrid::simix::Timer::set(SIMIX_get_clock() + timeout, [simcall, execs, count]() { + simcall->timeout_cb_ = simgrid::simix::Timer::set(SIMIX_get_clock() + timeout, [simcall, execs, count]() { for (size_t i = 0; i < count; i++) { // Remove the first occurence of simcall: auto* exec = execs[i]; @@ -63,7 +63,7 @@ void simcall_HANDLER_execution_waitany_for(smx_simcall_t simcall, simgrid::kerne exec->simcalls_.erase(j); } simcall_execution_waitany_for__set__result(simcall, -1); - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); }); } @@ -219,9 +219,9 @@ void ExecImpl::finish() * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the * simcall */ - if (simcall->call == SIMCALL_NONE) // FIXME: maybe a better way to handle this case + if (simcall->call_ == SIMCALL_NONE) // FIXME: maybe a better way to handle this case continue; // if process handling comm is killed - if (simcall->call == SIMCALL_EXECUTION_WAITANY_FOR) { + if (simcall->call_ == SIMCALL_EXECUTION_WAITANY_FOR) { simgrid::kernel::activity::ExecImpl** execs = simcall_execution_waitany_for__get__execs(simcall); size_t count = simcall_execution_waitany_for__get__count(simcall); @@ -232,9 +232,9 @@ void ExecImpl::finish() if (j != exec->simcalls_.end()) exec->simcalls_.erase(j); - if (simcall->timeout_cb) { - simcall->timeout_cb->remove(); - simcall->timeout_cb = nullptr; + if (simcall->timeout_cb_) { + simcall->timeout_cb_->remove(); + simcall->timeout_cb_ = nullptr; } } @@ -253,35 +253,35 @@ void ExecImpl::finish() break; case SIMIX_FAILED: - XBT_DEBUG("ExecImpl::finish(): host '%s' failed", simcall->issuer->get_host()->get_cname()); - simcall->issuer->context_->iwannadie = true; - if (simcall->issuer->get_host()->is_on()) - simcall->issuer->exception_ = + XBT_DEBUG("ExecImpl::finish(): host '%s' failed", simcall->issuer_->get_host()->get_cname()); + simcall->issuer_->context_->iwannadie = true; + if (simcall->issuer_->get_host()->is_on()) + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::HostFailureException(XBT_THROW_POINT, "Host failed")); /* else, the actor will be killed with no possibility to survive */ break; case SIMIX_CANCELED: XBT_DEBUG("ExecImpl::finish(): execution canceled"); - simcall->issuer->exception_ = + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::CancelException(XBT_THROW_POINT, "Execution Canceled")); break; case SIMIX_TIMEOUT: XBT_DEBUG("ExecImpl::finish(): execution timeouted"); - simcall->issuer->exception_ = std::make_exception_ptr(simgrid::TimeoutException(XBT_THROW_POINT, "Timeouted")); + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::TimeoutException(XBT_THROW_POINT, "Timeouted")); break; default: xbt_die("Internal error in ExecImpl::finish(): unexpected synchro state %d", static_cast(state_)); } - simcall->issuer->waiting_synchro = nullptr; + simcall->issuer_->waiting_synchro = nullptr; /* Fail the process if the host is down */ - if (simcall->issuer->get_host()->is_on()) - simcall->issuer->simcall_answer(); + if (simcall->issuer_->get_host()->is_on()) + simcall->issuer_->simcall_answer(); else - simcall->issuer->context_->iwannadie = true; + simcall->issuer_->context_->iwannadie = true; } } diff --git a/src/kernel/activity/IoImpl.cpp b/src/kernel/activity/IoImpl.cpp index a4c845b958..ba69f5f326 100644 --- a/src/kernel/activity/IoImpl.cpp +++ b/src/kernel/activity/IoImpl.cpp @@ -88,19 +88,19 @@ void IoImpl::finish() /* do nothing, synchro done */ break; case SIMIX_FAILED: - simcall->issuer->context_->iwannadie = true; - simcall->issuer->exception_ = + simcall->issuer_->context_->iwannadie = true; + simcall->issuer_->exception_ = std::make_exception_ptr(StorageFailureException(XBT_THROW_POINT, "Storage failed")); break; case SIMIX_CANCELED: - simcall->issuer->exception_ = std::make_exception_ptr(CancelException(XBT_THROW_POINT, "I/O Canceled")); + simcall->issuer_->exception_ = std::make_exception_ptr(CancelException(XBT_THROW_POINT, "I/O Canceled")); break; default: xbt_die("Internal error in IoImpl::finish(): unexpected synchro state %d", static_cast(state_)); } - simcall->issuer->waiting_synchro = nullptr; - simcall->issuer->simcall_answer(); + simcall->issuer_->waiting_synchro = nullptr; + simcall->issuer_->simcall_answer(); } } diff --git a/src/kernel/activity/MutexImpl.cpp b/src/kernel/activity/MutexImpl.cpp index 9269c91f6e..9274c47766 100644 --- a/src/kernel/activity/MutexImpl.cpp +++ b/src/kernel/activity/MutexImpl.cpp @@ -101,15 +101,15 @@ void MutexImpl::unref() void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex) { - mutex->lock(simcall->issuer); + mutex->lock(simcall->issuer_); } int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex) { - return mutex->try_lock(simcall->issuer); + return mutex->try_lock(simcall->issuer_); } void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex) { - mutex->unlock(simcall->issuer); + mutex->unlock(simcall->issuer_); } diff --git a/src/kernel/activity/SemaphoreImpl.cpp b/src/kernel/activity/SemaphoreImpl.cpp index 05dc8d79a3..4848f27bf7 100644 --- a/src/kernel/activity/SemaphoreImpl.cpp +++ b/src/kernel/activity/SemaphoreImpl.cpp @@ -52,7 +52,7 @@ void SemaphoreImpl::release() */ void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem) { - sem->acquire(simcall->issuer, -1); + sem->acquire(simcall->issuer_, -1); } /** @@ -61,5 +61,5 @@ void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem) void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout) { simcall_sem_acquire_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout - sem->acquire(simcall->issuer, timeout); + sem->acquire(simcall->issuer_, timeout); } diff --git a/src/kernel/activity/SleepImpl.cpp b/src/kernel/activity/SleepImpl.cpp index f80692be18..09f5e1408c 100644 --- a/src/kernel/activity/SleepImpl.cpp +++ b/src/kernel/activity/SleepImpl.cpp @@ -57,13 +57,13 @@ void SleepImpl::finish() smx_simcall_t simcall = simcalls_.front(); simcalls_.pop_front(); - simcall->issuer->waiting_synchro = nullptr; - if (simcall->issuer->is_suspended()) { + simcall->issuer_->waiting_synchro = nullptr; + if (simcall->issuer_->is_suspended()) { XBT_DEBUG("Wait! This process is suspended and can't wake up now."); - simcall->issuer->suspended_ = false; - simcall->issuer->suspend(simcall->issuer); + simcall->issuer_->suspended_ = false; + simcall->issuer_->suspend(simcall->issuer_); } else { - simcall->issuer->simcall_answer(); + simcall->issuer_->simcall_answer(); } } diff --git a/src/kernel/activity/SynchroRaw.cpp b/src/kernel/activity/SynchroRaw.cpp index b98ab926cf..62c12314e4 100644 --- a/src/kernel/activity/SynchroRaw.cpp +++ b/src/kernel/activity/SynchroRaw.cpp @@ -70,42 +70,42 @@ void RawImpl::finish() simcalls_.pop_front(); if (state_ == SIMIX_FAILED) { - XBT_DEBUG("RawImpl::finish(): host '%s' failed", simcall->issuer->get_host()->get_cname()); - simcall->issuer->context_->iwannadie = true; - simcall->issuer->exception_ = std::make_exception_ptr(HostFailureException(XBT_THROW_POINT, "Host failed")); + XBT_DEBUG("RawImpl::finish(): host '%s' failed", simcall->issuer_->get_host()->get_cname()); + simcall->issuer_->context_->iwannadie = true; + simcall->issuer_->exception_ = std::make_exception_ptr(HostFailureException(XBT_THROW_POINT, "Host failed")); } else if (state_ != SIMIX_SRC_TIMEOUT) { xbt_die("Internal error in RawImpl::finish() unexpected synchro state %d", static_cast(state_)); } - switch (simcall->call) { + switch (simcall->call_) { case SIMCALL_MUTEX_LOCK: - simgrid::xbt::intrusive_erase(simcall_mutex_lock__get__mutex(simcall)->sleeping_, *simcall->issuer); + simgrid::xbt::intrusive_erase(simcall_mutex_lock__get__mutex(simcall)->sleeping_, *simcall->issuer_); break; case SIMCALL_COND_WAIT: - simgrid::xbt::intrusive_erase(simcall_cond_wait__get__cond(simcall)->sleeping_, *simcall->issuer); + simgrid::xbt::intrusive_erase(simcall_cond_wait__get__cond(simcall)->sleeping_, *simcall->issuer_); break; case SIMCALL_COND_WAIT_TIMEOUT: - simgrid::xbt::intrusive_erase(simcall_cond_wait_timeout__get__cond(simcall)->sleeping_, *simcall->issuer); + simgrid::xbt::intrusive_erase(simcall_cond_wait_timeout__get__cond(simcall)->sleeping_, *simcall->issuer_); simcall_cond_wait_timeout__set__result(simcall, 1); // signal a timeout break; case SIMCALL_SEM_ACQUIRE: - simgrid::xbt::intrusive_erase(simcall_sem_acquire__get__sem(simcall)->sleeping_, *simcall->issuer); + simgrid::xbt::intrusive_erase(simcall_sem_acquire__get__sem(simcall)->sleeping_, *simcall->issuer_); break; case SIMCALL_SEM_ACQUIRE_TIMEOUT: - simgrid::xbt::intrusive_erase(simcall_sem_acquire_timeout__get__sem(simcall)->sleeping_, *simcall->issuer); + simgrid::xbt::intrusive_erase(simcall_sem_acquire_timeout__get__sem(simcall)->sleeping_, *simcall->issuer_); simcall_sem_acquire_timeout__set__result(simcall, 1); // signal a timeout break; default: THROW_IMPOSSIBLE; } - simcall->issuer->waiting_synchro = nullptr; - simcall->issuer->simcall_answer(); + simcall->issuer_->waiting_synchro = nullptr; + simcall->issuer_->simcall_answer(); } } // namespace activity diff --git a/src/kernel/actor/ActorImpl.cpp b/src/kernel/actor/ActorImpl.cpp index 8cd4120470..161321033c 100644 --- a/src/kernel/actor/ActorImpl.cpp +++ b/src/kernel/actor/ActorImpl.cpp @@ -60,7 +60,7 @@ int get_maxpid() ActorImpl::ActorImpl(const simgrid::xbt::string& name, s4u::Host* host) : host_(host), name_(name), piface_(this) { pid_ = maxpid++; - simcall.issuer = this; + simcall.issuer_ = this; } ActorImpl::~ActorImpl() @@ -440,9 +440,9 @@ void ActorImpl::throw_exception(std::exception_ptr e) void ActorImpl::simcall_answer() { if (this != simix_global->maestro_process){ - XBT_DEBUG("Answer simcall %s (%d) issued by %s (%p)", SIMIX_simcall_name(simcall.call), (int)simcall.call, + XBT_DEBUG("Answer simcall %s (%d) issued by %s (%p)", SIMIX_simcall_name(simcall.call_), (int)simcall.call_, get_cname(), this); - simcall.call = SIMCALL_NONE; + simcall.call_ = SIMCALL_NONE; xbt_assert(not XBT_LOG_ISENABLED(simix_process, xbt_log_priority_debug) || std::find(begin(simix_global->actors_to_run), end(simix_global->actors_to_run), this) == end(simix_global->actors_to_run), @@ -531,7 +531,7 @@ void create_maestro(const std::function& code) maestro->context_.reset(simix_global->context_factory->create_maestro(simix::ActorCode(code), maestro)); } - maestro->simcall.issuer = maestro; + maestro->simcall.issuer_ = maestro; simix_global->maestro_process = maestro; } diff --git a/src/mc/ModelChecker.cpp b/src/mc/ModelChecker.cpp index 0bd8683d1e..2b1d6d980c 100644 --- a/src/mc/ModelChecker.cpp +++ b/src/mc/ModelChecker.cpp @@ -367,8 +367,8 @@ void ModelChecker::handle_simcall(Transition const& transition) s_mc_message_simcall_handle_t m; memset(&m, 0, sizeof(m)); m.type = MC_MESSAGE_SIMCALL_HANDLE; - m.pid = transition.pid; - m.value = transition.argument; + m.pid = transition.pid_; + m.value = transition.argument_; this->process_->get_channel().send(m); this->process_->clear_cache(); if (this->process_->running()) diff --git a/src/mc/Transition.hpp b/src/mc/Transition.hpp index d956ac110f..39f8a83673 100644 --- a/src/mc/Transition.hpp +++ b/src/mc/Transition.hpp @@ -20,7 +20,7 @@ namespace mc { */ class Transition { public: - int pid = 0; + int pid_ = 0; /* Which transition was executed for this simcall * @@ -30,7 +30,7 @@ public: * * * random can produce different values. */ - int argument = 0; + int argument_ = 0; }; } diff --git a/src/mc/VisitedState.cpp b/src/mc/VisitedState.cpp index 73bbb6493a..24e3c5c5c6 100644 --- a/src/mc/VisitedState.cpp +++ b/src/mc/VisitedState.cpp @@ -52,8 +52,8 @@ VisitedStates::addVisitedState(unsigned long state_number, simgrid::mc::State* g std::unique_ptr new_state = std::unique_ptr(new VisitedState(state_number)); graph_state->system_state = new_state->system_state; - XBT_DEBUG("Snapshot %p of visited state %d (exploration stack state %d)", - new_state->system_state.get(), new_state->num, graph_state->num); + XBT_DEBUG("Snapshot %p of visited state %d (exploration stack state %d)", new_state->system_state.get(), + new_state->num, graph_state->num_); auto range = boost::range::equal_range(states_, new_state.get(), simgrid::mc::DerefAndCompareByActorsCountAndUsedHeap()); diff --git a/src/mc/checker/CommunicationDeterminismChecker.cpp b/src/mc/checker/CommunicationDeterminismChecker.cpp index fd11be1840..a4b48c9926 100644 --- a/src/mc/checker/CommunicationDeterminismChecker.cpp +++ b/src/mc/checker/CommunicationDeterminismChecker.cpp @@ -290,7 +290,7 @@ RecordTrace CommunicationDeterminismChecker::get_record_trace() // override { RecordTrace res; for (auto const& state : stack_) - res.push_back(state->getTransition()); + res.push_back(state->get_transition()); return res; } @@ -298,10 +298,10 @@ std::vector CommunicationDeterminismChecker::get_textual_trace() // { std::vector trace; for (auto const& state : stack_) { - smx_simcall_t req = &state->executed_req; + smx_simcall_t req = &state->executed_req_; if (req) trace.push_back( - simgrid::mc::request_to_string(req, state->transition.argument, simgrid::mc::RequestType::executed)); + simgrid::mc::request_to_string(req, state->transition_.argument_, simgrid::mc::RequestType::executed)); } return trace; } @@ -344,7 +344,7 @@ void CommunicationDeterminismChecker::prepare() /* Get an enabled actor and insert it in the interleave set of the initial state */ for (auto& actor : mc_model_checker->process().actors()) if (simgrid::mc::actor_is_enabled(actor.copy.get_buffer())) - initial_state->addInterleavingSet(actor.copy.get_buffer()); + initial_state->add_interleaving_set(actor.copy.get_buffer()); stack_.push_back(std::move(initial_state)); } @@ -386,8 +386,8 @@ void CommunicationDeterminismChecker::restoreState() if (state == stack_.back()) break; - int req_num = state->transition.argument; - smx_simcall_t saved_req = &state->executed_req; + int req_num = state->transition_.argument_; + smx_simcall_t saved_req = &state->executed_req_; xbt_assert(saved_req); /* because we got a copy of the executed request, we have to fetch the @@ -398,7 +398,7 @@ void CommunicationDeterminismChecker::restoreState() /* TODO : handle test and testany simcalls */ e_mc_call_type_t call = MC_get_call_type(req); - mc_model_checker->handle_simcall(state->transition); + mc_model_checker->handle_simcall(state->transition_); MC_handle_comm_pattern(call, req, req_num, 1); mc_model_checker->wait_for_requests(); @@ -418,8 +418,8 @@ void CommunicationDeterminismChecker::real_run() simgrid::mc::State* cur_state = stack_.back().get(); XBT_DEBUG("**************************************************"); - XBT_DEBUG("Exploration depth = %zu (state = %d, interleaved processes = %zu)", stack_.size(), cur_state->num, - cur_state->interleaveSize()); + XBT_DEBUG("Exploration depth = %zu (state = %d, interleaved processes = %zu)", stack_.size(), cur_state->num_, + cur_state->interleave_size()); /* Update statistics */ mc_model_checker->visited_states++; @@ -431,7 +431,7 @@ void CommunicationDeterminismChecker::real_run() if (req != nullptr && visited_state == nullptr) { - int req_num = cur_state->transition.argument; + int req_num = cur_state->transition_.argument_; XBT_DEBUG("Execute: %s", simgrid::mc::request_to_string(req, req_num, simgrid::mc::RequestType::simix).c_str()); @@ -447,7 +447,7 @@ void CommunicationDeterminismChecker::real_run() call = MC_get_call_type(req); /* Answer the request */ - mc_model_checker->handle_simcall(cur_state->transition); + mc_model_checker->handle_simcall(cur_state->transition_); /* After this call req is no longer useful */ MC_handle_comm_pattern(call, req, req_num, 0); @@ -473,13 +473,13 @@ void CommunicationDeterminismChecker::real_run() /* Get enabled actors and insert them in the interleave set of the next state */ for (auto& actor : mc_model_checker->process().actors()) if (simgrid::mc::actor_is_enabled(actor.copy.get_buffer())) - next_state->addInterleavingSet(actor.copy.get_buffer()); + next_state->add_interleaving_set(actor.copy.get_buffer()); if (dot_output != nullptr) - fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num, next_state->num, req_str.c_str()); + fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num_, next_state->num_, req_str.c_str()); } else if (dot_output != nullptr) - fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num, + fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num_, visited_state->original_num == -1 ? visited_state->num : visited_state->original_num, req_str.c_str()); stack_.push_back(std::move(next_state)); @@ -497,7 +497,7 @@ void CommunicationDeterminismChecker::real_run() this->initial_communications_pattern_done = true; /* Trash the current state, no longer needed */ - XBT_DEBUG("Delete state %d at depth %zu", cur_state->num, stack_.size()); + XBT_DEBUG("Delete state %d at depth %zu", cur_state->num_, stack_.size()); stack_.pop_back(); visited_state = nullptr; @@ -511,18 +511,18 @@ void CommunicationDeterminismChecker::real_run() while (not stack_.empty()) { std::unique_ptr state(std::move(stack_.back())); stack_.pop_back(); - if (state->interleaveSize() && stack_.size() < (std::size_t)_sg_mc_max_depth) { + if (state->interleave_size() && stack_.size() < (std::size_t)_sg_mc_max_depth) { /* We found a back-tracking point, let's loop */ - XBT_DEBUG("Back-tracking to state %d at depth %zu", state->num, stack_.size() + 1); + XBT_DEBUG("Back-tracking to state %d at depth %zu", state->num_, stack_.size() + 1); stack_.push_back(std::move(state)); this->restoreState(); - XBT_DEBUG("Back-tracking to state %d at depth %zu done", stack_.back()->num, stack_.size()); + XBT_DEBUG("Back-tracking to state %d at depth %zu done", stack_.back()->num_, stack_.size()); break; } else { - XBT_DEBUG("Delete state %d at depth %zu", state->num, stack_.size() + 1); + XBT_DEBUG("Delete state %d at depth %zu", state->num_, stack_.size() + 1); } } } diff --git a/src/mc/checker/LivenessChecker.cpp b/src/mc/checker/LivenessChecker.cpp index 2ed9954b8c..4f6000f09d 100644 --- a/src/mc/checker/LivenessChecker.cpp +++ b/src/mc/checker/LivenessChecker.cpp @@ -142,8 +142,8 @@ void LivenessChecker::replay() if (pair->exploration_started) { - int req_num = state->transition.argument; - smx_simcall_t saved_req = &state->executed_req; + int req_num = state->transition_.argument_; + smx_simcall_t saved_req = &state->executed_req_; smx_simcall_t req = nullptr; @@ -161,7 +161,7 @@ void LivenessChecker::replay() state.get()); } - this->get_session().execute(state->transition); + this->get_session().execute(state->transition_); } /* Update statistics */ @@ -232,7 +232,7 @@ RecordTrace LivenessChecker::get_record_trace() // override { RecordTrace res; for (std::shared_ptr const& pair : exploration_stack_) - res.push_back(pair->graph_state->getTransition()); + res.push_back(pair->graph_state->get_transition()); return res; } @@ -260,9 +260,9 @@ std::vector LivenessChecker::get_textual_trace() // override { std::vector trace; for (std::shared_ptr const& pair : exploration_stack_) { - int req_num = pair->graph_state->transition.argument; - smx_simcall_t req = &pair->graph_state->executed_req; - if (req && req->call != SIMCALL_NONE) + int req_num = pair->graph_state->transition_.argument_; + smx_simcall_t req = &pair->graph_state->executed_req_; + if (req && req->call_ != SIMCALL_NONE) trace.push_back(simgrid::mc::request_to_string( req, req_num, simgrid::mc::RequestType::executed)); } @@ -284,8 +284,8 @@ std::shared_ptr LivenessChecker::create_pair(Pair* current_pair, xbt_autom /* Get enabled actors and insert them in the interleave set of the next graph_state */ for (auto& actor : mc_model_checker->process().actors()) if (simgrid::mc::actor_is_enabled(actor.copy.get_buffer())) - next_pair->graph_state->addInterleavingSet(actor.copy.get_buffer()); - next_pair->requests = next_pair->graph_state->interleaveSize(); + next_pair->graph_state->add_interleaving_set(actor.copy.get_buffer()); + next_pair->requests = next_pair->graph_state->interleave_size(); /* FIXME : get search_cycle value for each accepting state */ if (next_pair->automaton_state->type == 1 || (current_pair && current_pair->search_cycle)) next_pair->search_cycle = true; @@ -346,8 +346,8 @@ void LivenessChecker::run() XBT_DEBUG( "********************* ( Depth = %d, search_cycle = %d, interleave size = %zu, pair_num = %d, requests = %d)", - current_pair->depth, current_pair->search_cycle, current_pair->graph_state->interleaveSize(), current_pair->num, - current_pair->requests); + current_pair->depth, current_pair->search_cycle, current_pair->graph_state->interleave_size(), + current_pair->num, current_pair->requests); if (current_pair->requests == 0) { this->backtrack(); @@ -380,7 +380,7 @@ void LivenessChecker::run() } smx_simcall_t req = MC_state_get_request(current_pair->graph_state.get()); - int req_num = current_pair->graph_state->transition.argument; + int req_num = current_pair->graph_state->transition_.argument_; if (dot_output != nullptr) { if (this->previous_pair_ != 0 && this->previous_pair_ != current_pair->num) { @@ -405,7 +405,7 @@ void LivenessChecker::run() visited_pairs_count_++; /* Answer the request */ - mc_model_checker->handle_simcall(current_pair->graph_state->transition); + mc_model_checker->handle_simcall(current_pair->graph_state->transition_); /* Wait for requests (schedules processes) */ mc_model_checker->wait_for_requests(); diff --git a/src/mc/checker/SafetyChecker.cpp b/src/mc/checker/SafetyChecker.cpp index df92ccde5f..f827c1f8dc 100644 --- a/src/mc/checker/SafetyChecker.cpp +++ b/src/mc/checker/SafetyChecker.cpp @@ -35,7 +35,7 @@ void SafetyChecker::check_non_termination(simgrid::mc::State* current_state) { for (auto state = stack_.rbegin(); state != stack_.rend(); ++state) if (snapshot_equal((*state)->system_state.get(), current_state->system_state.get())) { - XBT_INFO("Non-progressive cycle: state %d -> state %d", (*state)->num, current_state->num); + XBT_INFO("Non-progressive cycle: state %d -> state %d", (*state)->num_, current_state->num_); XBT_INFO("******************************************"); XBT_INFO("*** NON-PROGRESSIVE CYCLE DETECTED ***"); XBT_INFO("******************************************"); @@ -53,7 +53,7 @@ RecordTrace SafetyChecker::get_record_trace() // override { RecordTrace res; for (auto const& state : stack_) - res.push_back(state->getTransition()); + res.push_back(state->get_transition()); return res; } @@ -61,8 +61,8 @@ std::vector SafetyChecker::get_textual_trace() // override { std::vector trace; for (auto const& state : stack_) { - int value = state->transition.argument; - smx_simcall_t req = &state->executed_req; + int value = state->transition_.argument_; + smx_simcall_t req = &state->executed_req_; if (req) trace.push_back(simgrid::mc::request_to_string( req, value, simgrid::mc::RequestType::executed)); @@ -89,8 +89,8 @@ void SafetyChecker::run() simgrid::mc::State* state = stack_.back().get(); XBT_DEBUG("**************************************************"); - XBT_VERB("Exploration depth=%zu (state=%p, num %d)(%zu interleave)", stack_.size(), state, state->num, - state->interleaveSize()); + XBT_VERB("Exploration depth=%zu (state=%p, num %d)(%zu interleave)", stack_.size(), state, state->num_, + state->interleave_size()); mc_model_checker->visited_states++; @@ -125,18 +125,18 @@ void SafetyChecker::run() // If there are processes to interleave and the maximum depth has not been // reached then perform one step of the exploration algorithm. - XBT_DEBUG("Execute: %s", - simgrid::mc::request_to_string( - req, state->transition.argument, simgrid::mc::RequestType::simix).c_str()); + XBT_DEBUG( + "Execute: %s", + simgrid::mc::request_to_string(req, state->transition_.argument_, simgrid::mc::RequestType::simix).c_str()); std::string req_str; if (dot_output != nullptr) - req_str = simgrid::mc::request_get_dot_output(req, state->transition.argument); + req_str = simgrid::mc::request_get_dot_output(req, state->transition_.argument_); mc_model_checker->executed_transitions++; /* Actually answer the request: let execute the selected request (MCed does one step) */ - this->get_session().execute(state->transition); + this->get_session().execute(state->transition_); /* Create the new expanded state (copy the state of MCed into our MCer data) */ std::unique_ptr next_state = @@ -156,18 +156,17 @@ void SafetyChecker::run() for (auto& remoteActor : mc_model_checker->process().actors()) { auto actor = remoteActor.copy.get_buffer(); if (simgrid::mc::actor_is_enabled(actor)) { - next_state->addInterleavingSet(actor); + next_state->add_interleaving_set(actor); if (reductionMode_ == simgrid::mc::ReductionMode::dpor) break; // With DPOR, we take the first enabled transition } } if (dot_output != nullptr) - std::fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", - state->num, next_state->num, req_str.c_str()); + std::fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num_, next_state->num_, req_str.c_str()); } else if (dot_output != nullptr) - std::fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num, + std::fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num_, visited_state_->original_num == -1 ? visited_state_->num : visited_state_->original_num, req_str.c_str()); @@ -200,7 +199,7 @@ void SafetyChecker::backtrack() stack_.pop_back(); if (reductionMode_ == simgrid::mc::ReductionMode::dpor) { smx_simcall_t req = &state->internal_req; - if (req->call == SIMCALL_MUTEX_LOCK || req->call == SIMCALL_MUTEX_TRYLOCK) + if (req->call_ == SIMCALL_MUTEX_LOCK || req->call_ == SIMCALL_MUTEX_TRYLOCK) xbt_die("Mutex is currently not supported with DPOR, use --cfg=model-check/reduction:none"); const smx_actor_t issuer = MC_smx_simcall_get_issuer(req); @@ -209,52 +208,49 @@ void SafetyChecker::backtrack() if (simgrid::mc::request_depend(req, &prev_state->internal_req)) { if (XBT_LOG_ISENABLED(mc_safety, xbt_log_priority_debug)) { XBT_DEBUG("Dependent Transitions:"); - int value = prev_state->transition.argument; - smx_simcall_t prev_req = &prev_state->executed_req; + int value = prev_state->transition_.argument_; + smx_simcall_t prev_req = &prev_state->executed_req_; XBT_DEBUG("%s (state=%d)", - simgrid::mc::request_to_string( - prev_req, value, simgrid::mc::RequestType::internal).c_str(), - prev_state->num); - value = state->transition.argument; - prev_req = &state->executed_req; + simgrid::mc::request_to_string(prev_req, value, simgrid::mc::RequestType::internal).c_str(), + prev_state->num_); + value = state->transition_.argument_; + prev_req = &state->executed_req_; XBT_DEBUG("%s (state=%d)", - simgrid::mc::request_to_string( - prev_req, value, simgrid::mc::RequestType::executed).c_str(), - state->num); + simgrid::mc::request_to_string(prev_req, value, simgrid::mc::RequestType::executed).c_str(), + state->num_); } - if (not prev_state->actorStates[issuer->get_pid()].isDone()) - prev_state->addInterleavingSet(issuer); + if (not prev_state->actor_states_[issuer->get_pid()].is_done()) + prev_state->add_interleaving_set(issuer); else - XBT_DEBUG("Process %p is in done set", req->issuer); + XBT_DEBUG("Process %p is in done set", req->issuer_); break; - } else if (req->issuer == prev_state->internal_req.issuer) { + } else if (req->issuer_ == prev_state->internal_req.issuer_) { - XBT_DEBUG("Simcall %d and %d with same issuer", req->call, prev_state->internal_req.call); + XBT_DEBUG("Simcall %d and %d with same issuer", req->call_, prev_state->internal_req.call_); break; } else { const smx_actor_t previous_issuer = MC_smx_simcall_get_issuer(&prev_state->internal_req); XBT_DEBUG("Simcall %d, process %ld (state %d) and simcall %d, process %ld (state %d) are independent", - req->call, issuer->get_pid(), state->num, prev_state->internal_req.call, previous_issuer->get_pid(), - prev_state->num); + req->call_, issuer->get_pid(), state->num_, prev_state->internal_req.call_, + previous_issuer->get_pid(), prev_state->num_); } } } - if (state->interleaveSize() - && stack_.size() < (std::size_t) _sg_mc_max_depth) { + if (state->interleave_size() && stack_.size() < (std::size_t)_sg_mc_max_depth) { /* We found a back-tracking point, let's loop */ - XBT_DEBUG("Back-tracking to state %d at depth %zu", state->num, stack_.size() + 1); + XBT_DEBUG("Back-tracking to state %d at depth %zu", state->num_, stack_.size() + 1); stack_.push_back(std::move(state)); this->restore_state(); - XBT_DEBUG("Back-tracking to state %d at depth %zu done", stack_.back()->num, stack_.size()); + XBT_DEBUG("Back-tracking to state %d at depth %zu done", stack_.back()->num_, stack_.size()); break; } else { - XBT_DEBUG("Delete state %d at depth %zu", state->num, stack_.size() + 1); + XBT_DEBUG("Delete state %d at depth %zu", state->num_, stack_.size() + 1); } } } @@ -275,7 +271,7 @@ void SafetyChecker::restore_state() for (std::unique_ptr const& state : stack_) { if (state == stack_.back()) break; - session->execute(state->transition); + session->execute(state->transition_); /* Update statistics */ mc_model_checker->visited_states++; mc_model_checker->executed_transitions++; @@ -309,7 +305,7 @@ SafetyChecker::SafetyChecker(Session& s) : Checker(s) /* Get an enabled actor and insert it in the interleave set of the initial state */ for (auto& actor : mc_model_checker->process().actors()) if (simgrid::mc::actor_is_enabled(actor.copy.get_buffer())) { - initial_state->addInterleavingSet(actor.copy.get_buffer()); + initial_state->add_interleaving_set(actor.copy.get_buffer()); if (reductionMode_ != simgrid::mc::ReductionMode::none) break; } diff --git a/src/mc/mc_base.cpp b/src/mc/mc_base.cpp index 2a6b270e5e..7b6bcc93fa 100644 --- a/src/mc/mc_base.cpp +++ b/src/mc/mc_base.cpp @@ -42,7 +42,7 @@ void wait_for_requests() simix_global->run_all_actors(); for (smx_actor_t const& process : simix_global->actors_that_ran) { smx_simcall_t req = &process->simcall; - if (req->call != SIMCALL_NONE && not simgrid::mc::request_is_visible(req)) + if (req->call_ != SIMCALL_NONE && not simgrid::mc::request_is_visible(req)) process->simcall_handle(0); } } @@ -78,10 +78,10 @@ bool actor_is_enabled(smx_actor_t actor) // Now, we are in the client app, no need for remote memory reading. smx_simcall_t req = &actor->simcall; - if (req->transition != nullptr) - return req->transition->fireable(); + if (req->transition_ != nullptr) + return req->transition_->fireable(); - switch (req->call) { + switch (req->call_) { case SIMCALL_NONE: return false; @@ -119,7 +119,7 @@ bool actor_is_enabled(smx_actor_t actor) if (mutex->owner_ == nullptr) return true; - return mutex->owner_->get_pid() == req->issuer->get_pid(); + return mutex->owner_->get_pid() == req->issuer_->get_pid(); } case SIMCALL_SEM_ACQUIRE: { @@ -153,10 +153,10 @@ bool request_is_visible(smx_simcall_t req) xbt_assert(mc_model_checker == nullptr, "This should be called from the client side"); #endif - return (req->transition != nullptr && req->transition->visible()) || req->call == SIMCALL_COMM_ISEND || - req->call == SIMCALL_COMM_IRECV || req->call == SIMCALL_COMM_WAIT || req->call == SIMCALL_COMM_WAITANY || - req->call == SIMCALL_COMM_TEST || req->call == SIMCALL_COMM_TESTANY || req->call == SIMCALL_MC_RANDOM || - req->call == SIMCALL_MUTEX_LOCK || req->call == SIMCALL_MUTEX_TRYLOCK || req->call == SIMCALL_MUTEX_UNLOCK; + return (req->transition_ != nullptr && req->transition_->visible()) || req->call_ == SIMCALL_COMM_ISEND || + req->call_ == SIMCALL_COMM_IRECV || req->call_ == SIMCALL_COMM_WAIT || req->call_ == SIMCALL_COMM_WAITANY || + req->call_ == SIMCALL_COMM_TEST || req->call_ == SIMCALL_COMM_TESTANY || req->call_ == SIMCALL_MC_RANDOM || + req->call_ == SIMCALL_MUTEX_LOCK || req->call_ == SIMCALL_MUTEX_TRYLOCK || req->call_ == SIMCALL_MUTEX_UNLOCK; } } @@ -169,5 +169,5 @@ int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max) std::uniform_int_distribution prng(min, max); return prng(rnd_engine); } - return simcall->mc_value; + return simcall->mc_value_; } diff --git a/src/mc/mc_comm_pattern.cpp b/src/mc/mc_comm_pattern.cpp index 8182faf6fe..8e4b405ac0 100644 --- a/src/mc/mc_comm_pattern.cpp +++ b/src/mc/mc_comm_pattern.cpp @@ -26,28 +26,28 @@ static void MC_patterns_copy(std::vector& de void MC_restore_communications_pattern(simgrid::mc::State* state) { for (unsigned i = 0; i < initial_communications_pattern.size(); i++) - initial_communications_pattern[i].index_comm = state->communicationIndices[i]; + initial_communications_pattern[i].index_comm = state->communication_indices_[i]; for (unsigned i = 0; i < MC_smx_get_maxpid(); i++) - MC_patterns_copy(incomplete_communications_pattern[i], state->incomplete_comm_pattern[i]); + MC_patterns_copy(incomplete_communications_pattern[i], state->incomplete_comm_pattern_[i]); } void MC_state_copy_incomplete_communications_pattern(simgrid::mc::State* state) { - state->incomplete_comm_pattern.clear(); + state->incomplete_comm_pattern_.clear(); for (unsigned i=0; i < MC_smx_get_maxpid(); i++) { std::vector res; for (auto const& comm : incomplete_communications_pattern[i]) res.push_back(comm->dup()); - state->incomplete_comm_pattern.push_back(std::move(res)); + state->incomplete_comm_pattern_.push_back(std::move(res)); } } void MC_state_copy_index_communications_pattern(simgrid::mc::State* state) { - state->communicationIndices.clear(); + state->communication_indices_.clear(); for (auto const& list_process_comm : initial_communications_pattern) - state->communicationIndices.push_back(list_process_comm.index_comm); + state->communication_indices_.push_back(list_process_comm.index_comm); } void MC_handle_comm_pattern(e_mc_call_type_t call_type, smx_simcall_t req, int value, int backtracking) diff --git a/src/mc/mc_comm_pattern.hpp b/src/mc/mc_comm_pattern.hpp index 15b9a72153..9d55a88136 100644 --- a/src/mc/mc_comm_pattern.hpp +++ b/src/mc/mc_comm_pattern.hpp @@ -45,7 +45,7 @@ enum e_mc_comm_pattern_difference_t { static inline e_mc_call_type_t MC_get_call_type(smx_simcall_t req) { - switch (req->call) { + switch (req->call_) { case SIMCALL_COMM_ISEND: return MC_CALL_TYPE_SEND; case SIMCALL_COMM_IRECV: diff --git a/src/mc/mc_record.cpp b/src/mc/mc_record.cpp index 224eed8527..4ea2c9573c 100644 --- a/src/mc/mc_record.cpp +++ b/src/mc/mc_record.cpp @@ -28,20 +28,20 @@ void replay(RecordTrace const& trace) simgrid::mc::wait_for_requests(); for (simgrid::mc::Transition const& transition : trace) { - XBT_DEBUG("Executing %i$%i", transition.pid, transition.argument); + XBT_DEBUG("Executing %i$%i", transition.pid_, transition.argument_); // Choose a request: - smx_actor_t process = SIMIX_process_from_PID(transition.pid); + smx_actor_t process = SIMIX_process_from_PID(transition.pid_); if (not process) - xbt_die("Unexpected process (pid:%d).", transition.pid); + xbt_die("Unexpected process (pid:%d).", transition.pid_); smx_simcall_t simcall = &(process->simcall); - if (not simcall || simcall->call == SIMCALL_NONE) - xbt_die("No simcall for process %d.", transition.pid); + if (not simcall || simcall->call_ == SIMCALL_NONE) + xbt_die("No simcall for process %d.", transition.pid_); if (not simgrid::mc::request_is_visible(simcall) || not simgrid::mc::actor_is_enabled(process)) xbt_die("Unexpected simcall."); // Execute the request: - simcall->issuer->simcall_handle(transition.argument); + simcall->issuer_->simcall_handle(transition.argument_); simgrid::mc::wait_for_requests(); } } @@ -65,7 +65,7 @@ RecordTrace parseRecordTrace(const char* data) while (*current) { simgrid::mc::Transition item; - int count = sscanf(current, "%d/%d", &item.pid, &item.argument); + int count = sscanf(current, "%d/%d", &item.pid_, &item.argument_); if(count != 2 && count != 1) throw std::invalid_argument("Could not parse record path"); res.push_back(item); @@ -89,9 +89,9 @@ std::string traceToString(simgrid::mc::RecordTrace const& trace) for (auto i = trace.begin(); i != trace.end(); ++i) { if (i != trace.begin()) stream << ';'; - stream << i->pid; - if (i->argument) - stream << '/' << i->argument; + stream << i->pid_; + if (i->argument_) + stream << '/' << i->argument_; } return stream.str(); } diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp index 900a115e2f..539143d711 100644 --- a/src/mc/mc_request.cpp +++ b/src/mc/mc_request.cpp @@ -20,26 +20,26 @@ static char *buff_size_to_string(size_t size); static inline simgrid::kernel::activity::CommImpl* MC_get_comm(smx_simcall_t r) { - switch (r->call ) { - case SIMCALL_COMM_WAIT: - return static_cast(simcall_comm_wait__getraw__comm(r)); - case SIMCALL_COMM_TEST: - return static_cast(simcall_comm_test__getraw__comm(r)); - default: - return nullptr; + switch (r->call_) { + case SIMCALL_COMM_WAIT: + return static_cast(simcall_comm_wait__getraw__comm(r)); + case SIMCALL_COMM_TEST: + return static_cast(simcall_comm_test__getraw__comm(r)); + default: + return nullptr; } } static inline smx_mailbox_t MC_get_mbox(smx_simcall_t r) { - switch(r->call) { - case SIMCALL_COMM_ISEND: - return simcall_comm_isend__get__mbox(r); - case SIMCALL_COMM_IRECV: - return simcall_comm_irecv__get__mbox(r); - default: - return nullptr; + switch (r->call_) { + case SIMCALL_COMM_ISEND: + return simcall_comm_isend__get__mbox(r); + case SIMCALL_COMM_IRECV: + return simcall_comm_irecv__get__mbox(r); + default: + return nullptr; } } @@ -50,10 +50,10 @@ namespace mc { static inline bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) { - if (r1->call == SIMCALL_COMM_ISEND && r2->call == SIMCALL_COMM_IRECV) + if (r1->call_ == SIMCALL_COMM_ISEND && r2->call_ == SIMCALL_COMM_IRECV) return false; - if (r1->call == SIMCALL_COMM_IRECV && r2->call == SIMCALL_COMM_ISEND) + if (r1->call_ == SIMCALL_COMM_IRECV && r2->call_ == SIMCALL_COMM_ISEND) return false; // Those are internal requests, we do not need indirection @@ -61,8 +61,7 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) simgrid::kernel::activity::CommImpl* synchro1 = MC_get_comm(r1); simgrid::kernel::activity::CommImpl* synchro2 = MC_get_comm(r2); - if ((r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV) - && r2->call == SIMCALL_COMM_WAIT) { + if ((r1->call_ == SIMCALL_COMM_ISEND || r1->call_ == SIMCALL_COMM_IRECV) && r2->call_ == SIMCALL_COMM_WAIT) { smx_mailbox_t mbox = MC_get_mbox(r1); @@ -70,15 +69,15 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->issuer != synchro2->src_actor_.get()) && (r1->issuer != synchro2->dst_actor_.get()) && + if ((r1->issuer_ != synchro2->src_actor_.get()) && (r1->issuer_ != synchro2->dst_actor_.get()) && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->call == SIMCALL_COMM_ISEND) && (synchro2->type_ == kernel::activity::CommImpl::Type::SEND) && + if ((r1->call_ == SIMCALL_COMM_ISEND) && (synchro2->type_ == kernel::activity::CommImpl::Type::SEND) && (synchro2->src_buff_ != simcall_comm_isend__get__src_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->call == SIMCALL_COMM_IRECV) && (synchro2->type_ == kernel::activity::CommImpl::Type::RECEIVE) && + if ((r1->call_ == SIMCALL_COMM_IRECV) && (synchro2->type_ == kernel::activity::CommImpl::Type::RECEIVE) && (synchro2->dst_buff_ != simcall_comm_irecv__get__dst_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) return false; } @@ -92,19 +91,19 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) return false; #endif - if (r1->call == SIMCALL_COMM_WAIT && (r2->call == SIMCALL_COMM_WAIT || r2->call == SIMCALL_COMM_TEST) && + if (r1->call_ == SIMCALL_COMM_WAIT && (r2->call_ == SIMCALL_COMM_WAIT || r2->call_ == SIMCALL_COMM_TEST) && (synchro1->src_actor_.get() == nullptr || synchro1->dst_actor_.get() == nullptr)) return false; - if (r1->call == SIMCALL_COMM_TEST && + if (r1->call_ == SIMCALL_COMM_TEST && (simcall_comm_test__get__comm(r1) == nullptr || synchro1->src_buff_ == nullptr || synchro1->dst_buff_ == nullptr)) return false; - if (r1->call == SIMCALL_COMM_TEST && r2->call == SIMCALL_COMM_WAIT && synchro1->src_buff_ == synchro2->src_buff_ && + if (r1->call_ == SIMCALL_COMM_TEST && r2->call_ == SIMCALL_COMM_WAIT && synchro1->src_buff_ == synchro2->src_buff_ && synchro1->dst_buff_ == synchro2->dst_buff_) return false; - if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_TEST && synchro1->src_buff_ != nullptr && + if (r1->call_ == SIMCALL_COMM_WAIT && r2->call_ == SIMCALL_COMM_TEST && synchro1->src_buff_ != nullptr && synchro1->dst_buff_ != nullptr && synchro2->src_buff_ != nullptr && synchro2->dst_buff_ != nullptr && synchro1->dst_buff_ != synchro2->src_buff_ && synchro1->dst_buff_ != synchro2->dst_buff_ && synchro2->dst_buff_ != synchro1->src_buff_) @@ -116,15 +115,15 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) // Those are internal_req bool request_depend(smx_simcall_t req1, smx_simcall_t req2) { - if (req1->issuer == req2->issuer) + if (req1->issuer_ == req2->issuer_) return false; /* Wait with timeout transitions are not considered by the independence theorem, thus we consider them as dependent with all other transitions */ - if ((req1->call == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req1) > 0) || - (req2->call == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req2) > 0)) + if ((req1->call_ == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req1) > 0) || + (req2->call_ == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req2) > 0)) return true; - if (req1->call != req2->call) + if (req1->call_ != req2->call_) return request_depend_asymmetric(req1, req2) && request_depend_asymmetric(req2, req1); // Those are internal requests, we do not need indirection @@ -132,7 +131,7 @@ bool request_depend(smx_simcall_t req1, smx_simcall_t req2) simgrid::kernel::activity::CommImpl* synchro1 = MC_get_comm(req1); simgrid::kernel::activity::CommImpl* synchro2 = MC_get_comm(req2); - switch (req1->call) { + switch (req1->call_) { case SIMCALL_COMM_ISEND: return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2); case SIMCALL_COMM_IRECV: @@ -176,8 +175,8 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid { xbt_assert(mc_model_checker != nullptr, "Must be called from MCer"); - if (req->transition != nullptr) - return req->transition->to_string(); + if (req->transition_ != nullptr) + return req->transition_->to_string(); bool use_remote_comm = true; switch(request_type) { @@ -197,54 +196,77 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid smx_actor_t issuer = MC_smx_simcall_get_issuer(req); - switch (req->call) { - - case SIMCALL_COMM_ISEND: { - type = "iSend"; - char* p = pointer_to_string(simcall_comm_isend__get__src_buff(req)); - char* bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req)); - if (issuer->get_host()) - args = bprintf("src=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer), - MC_smx_actor_get_name(issuer), p, bs); - else - args = bprintf("src=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs); - xbt_free(bs); - xbt_free(p); - break; - } + switch (req->call_) { - case SIMCALL_COMM_IRECV: { - size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req); - size_t size = 0; - if (remote_size) - mc_model_checker->process().read_bytes(&size, sizeof(size), - remote(remote_size)); - - type = "iRecv"; - char* p = pointer_to_string(simcall_comm_irecv__get__dst_buff(req)); - char* bs = buff_size_to_string(size); - if (issuer->get_host()) - args = bprintf("dst=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer), - MC_smx_actor_get_name(issuer), p, bs); - else - args = bprintf("dst=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs); - xbt_free(bs); - xbt_free(p); - break; - } + case SIMCALL_COMM_ISEND: { + type = "iSend"; + char* p = pointer_to_string(simcall_comm_isend__get__src_buff(req)); + char* bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req)); + if (issuer->get_host()) + args = bprintf("src=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer), + MC_smx_actor_get_name(issuer), p, bs); + else + args = bprintf("src=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs); + xbt_free(bs); + xbt_free(p); + break; + } - case SIMCALL_COMM_WAIT: { - simgrid::kernel::activity::CommImpl* remote_act = - static_cast(simcall_comm_wait__getraw__comm(req)); - char* p; - if (value == -1) { - type = "WaitTimeout"; - p = pointer_to_string(remote_act); - args = bprintf("comm=%s", p); - } else { - type = "Wait"; - p = pointer_to_string(remote_act); + case SIMCALL_COMM_IRECV: { + size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req); + size_t size = 0; + if (remote_size) + mc_model_checker->process().read_bytes(&size, sizeof(size), remote(remote_size)); + type = "iRecv"; + char* p = pointer_to_string(simcall_comm_irecv__get__dst_buff(req)); + char* bs = buff_size_to_string(size); + if (issuer->get_host()) + args = bprintf("dst=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer), + MC_smx_actor_get_name(issuer), p, bs); + else + args = bprintf("dst=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs); + xbt_free(bs); + xbt_free(p); + break; + } + + case SIMCALL_COMM_WAIT: { + simgrid::kernel::activity::CommImpl* remote_act = + static_cast(simcall_comm_wait__getraw__comm(req)); + char* p; + if (value == -1) { + type = "WaitTimeout"; + p = pointer_to_string(remote_act); + args = bprintf("comm=%s", p); + } else { + type = "Wait"; + p = pointer_to_string(remote_act); + + simgrid::mc::Remote temp_synchro; + simgrid::kernel::activity::CommImpl* act; + if (use_remote_comm) { + mc_model_checker->process().read(temp_synchro, + remote(static_cast(remote_act))); + act = temp_synchro.get_buffer(); + } else + act = remote_act; + + smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->src_actor_.get())); + smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->dst_actor_.get())); + args = bprintf("comm=%s [(%ld)%s (%s)-> (%ld)%s (%s)]", p, src_proc ? src_proc->get_pid() : 0, + src_proc ? MC_smx_actor_get_host_name(src_proc) : "", + src_proc ? MC_smx_actor_get_name(src_proc) : "", dst_proc ? dst_proc->get_pid() : 0, + dst_proc ? MC_smx_actor_get_host_name(dst_proc) : "", + dst_proc ? MC_smx_actor_get_name(dst_proc) : ""); + } + xbt_free(p); + break; + } + + case SIMCALL_COMM_TEST: { + simgrid::kernel::activity::CommImpl* remote_act = + static_cast(simcall_comm_test__getraw__comm(req)); simgrid::mc::Remote temp_synchro; simgrid::kernel::activity::CommImpl* act; if (use_remote_comm) { @@ -254,104 +276,79 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid } else act = remote_act; - smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->src_actor_.get())); - smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->dst_actor_.get())); - args = - bprintf("comm=%s [(%ld)%s (%s)-> (%ld)%s (%s)]", p, src_proc ? src_proc->get_pid() : 0, - src_proc ? MC_smx_actor_get_host_name(src_proc) : "", src_proc ? MC_smx_actor_get_name(src_proc) : "", - dst_proc ? dst_proc->get_pid() : 0, dst_proc ? MC_smx_actor_get_host_name(dst_proc) : "", - dst_proc ? MC_smx_actor_get_name(dst_proc) : ""); + char* p; + if (act->src_actor_.get() == nullptr || act->dst_actor_.get() == nullptr) { + type = "Test FALSE"; + p = pointer_to_string(remote_act); + args = bprintf("comm=%s", p); + } else { + type = "Test TRUE"; + p = pointer_to_string(remote_act); + + smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->src_actor_.get())); + smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->dst_actor_.get())); + args = bprintf("comm=%s [(%ld)%s (%s) -> (%ld)%s (%s)]", p, src_proc->get_pid(), + MC_smx_actor_get_name(src_proc), MC_smx_actor_get_host_name(src_proc), dst_proc->get_pid(), + MC_smx_actor_get_name(dst_proc), MC_smx_actor_get_host_name(dst_proc)); + } + xbt_free(p); + break; } - xbt_free(p); - break; - } - case SIMCALL_COMM_TEST: { - simgrid::kernel::activity::CommImpl* remote_act = - static_cast(simcall_comm_test__getraw__comm(req)); - simgrid::mc::Remote temp_synchro; - simgrid::kernel::activity::CommImpl* act; - if (use_remote_comm) { - mc_model_checker->process().read(temp_synchro, - remote(static_cast(remote_act))); - act = temp_synchro.get_buffer(); - } else - act = remote_act; - - char* p; - if (act->src_actor_.get() == nullptr || act->dst_actor_.get() == nullptr) { - type = "Test FALSE"; - p = pointer_to_string(remote_act); - args = bprintf("comm=%s", p); - } else { - type = "Test TRUE"; - p = pointer_to_string(remote_act); - - smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->src_actor_.get())); - smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(act->dst_actor_.get())); - args = bprintf("comm=%s [(%ld)%s (%s) -> (%ld)%s (%s)]", p, src_proc->get_pid(), MC_smx_actor_get_name(src_proc), - MC_smx_actor_get_host_name(src_proc), dst_proc->get_pid(), MC_smx_actor_get_name(dst_proc), - MC_smx_actor_get_host_name(dst_proc)); + case SIMCALL_COMM_WAITANY: { + type = "WaitAny"; + size_t count = simcall_comm_waitany__get__count(req); + if (count > 0) { + simgrid::kernel::activity::CommImpl* remote_sync; + remote_sync = mc_model_checker->process().read(remote(simcall_comm_waitany__get__comms(req) + value)); + char* p = pointer_to_string(remote_sync); + args = bprintf("comm=%s (%d of %zu)", p, value + 1, count); + xbt_free(p); + } else + args = bprintf("comm at idx %d", value); + break; } - xbt_free(p); - break; - } - case SIMCALL_COMM_WAITANY: { - type = "WaitAny"; - size_t count = simcall_comm_waitany__get__count(req); - if (count > 0) { - simgrid::kernel::activity::CommImpl* remote_sync; - remote_sync = mc_model_checker->process().read(remote(simcall_comm_waitany__get__comms(req) + value)); - char* p = pointer_to_string(remote_sync); - args = bprintf("comm=%s (%d of %zu)", p, value + 1, count); - xbt_free(p); - } else - args = bprintf("comm at idx %d", value); - break; - } - - case SIMCALL_COMM_TESTANY: - if (value == -1) { - type = "TestAny FALSE"; - args = xbt_strdup("-"); - } else { - type = "TestAny"; - args = - bprintf("(%d of %zu)", value + 1, - simcall_comm_testany__get__count(req)); + case SIMCALL_COMM_TESTANY: + if (value == -1) { + type = "TestAny FALSE"; + args = xbt_strdup("-"); + } else { + type = "TestAny"; + args = bprintf("(%d of %zu)", value + 1, simcall_comm_testany__get__count(req)); + } + break; + + case SIMCALL_MUTEX_TRYLOCK: + case SIMCALL_MUTEX_LOCK: { + if (req->call_ == SIMCALL_MUTEX_LOCK) + type = "Mutex LOCK"; + else + type = "Mutex TRYLOCK"; + + simgrid::mc::Remote mutex; + mc_model_checker->process().read_bytes(mutex.get_buffer(), sizeof(mutex), + remote(req->call_ == SIMCALL_MUTEX_LOCK + ? simcall_mutex_lock__get__mutex(req) + : simcall_mutex_trylock__get__mutex(req))); + args = bprintf("locked = %d, owner = %d, sleeping = n/a", mutex.get_buffer()->is_locked(), + mutex.get_buffer()->owner_ != nullptr + ? (int)mc_model_checker->process() + .resolve_actor(simgrid::mc::remote(mutex.get_buffer()->owner_)) + ->get_pid() + : -1); + break; } - break; - - case SIMCALL_MUTEX_TRYLOCK: - case SIMCALL_MUTEX_LOCK: { - if (req->call == SIMCALL_MUTEX_LOCK) - type = "Mutex LOCK"; - else - type = "Mutex TRYLOCK"; - - simgrid::mc::Remote mutex; - mc_model_checker->process().read_bytes(mutex.get_buffer(), sizeof(mutex), - remote(req->call == SIMCALL_MUTEX_LOCK - ? simcall_mutex_lock__get__mutex(req) - : simcall_mutex_trylock__get__mutex(req))); - args = bprintf( - "locked = %d, owner = %d, sleeping = n/a", mutex.get_buffer()->is_locked(), - mutex.get_buffer()->owner_ != nullptr - ? (int)mc_model_checker->process().resolve_actor(simgrid::mc::remote(mutex.get_buffer()->owner_))->get_pid() - : -1); - break; - } - case SIMCALL_MC_RANDOM: - type = "MC_RANDOM"; - args = bprintf("%d", value); - break; + case SIMCALL_MC_RANDOM: + type = "MC_RANDOM"; + args = bprintf("%d", value); + break; - default: - type = SIMIX_simcall_name(req->call); - args = bprintf("??"); - break; + default: + type = SIMIX_simcall_name(req->call_); + args = bprintf("??"); + break; } std::string str; @@ -371,23 +368,23 @@ namespace mc { bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx) { simgrid::kernel::activity::CommImpl* remote_act = nullptr; - switch (req->call) { + switch (req->call_) { - case SIMCALL_COMM_WAIT: - /* FIXME: check also that src and dst processes are not suspended */ - remote_act = simcall_comm_wait__getraw__comm(req); - break; + case SIMCALL_COMM_WAIT: + /* FIXME: check also that src and dst processes are not suspended */ + remote_act = simcall_comm_wait__getraw__comm(req); + break; - case SIMCALL_COMM_WAITANY: - remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + idx)); - break; + case SIMCALL_COMM_WAITANY: + remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + idx)); + break; - case SIMCALL_COMM_TESTANY: - remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + idx)); - break; + case SIMCALL_COMM_TESTANY: + remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + idx)); + break; - default: - return true; + default: + return true; } simgrid::mc::Remote temp_comm; @@ -423,121 +420,121 @@ std::string request_get_dot_output(smx_simcall_t req, int value) const smx_actor_t issuer = MC_smx_simcall_get_issuer(req); const char* color = get_color(issuer->get_pid() - 1); - if (req->transition != nullptr) + if (req->transition_ != nullptr) return simgrid::xbt::string_printf("label = \"%s\", color = %s, fontcolor = %s", - req->transition->dot_label().c_str(), color, color); + req->transition_->dot_label().c_str(), color, color); std::string label; + switch (req->call_) { + case SIMCALL_COMM_ISEND: + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] iSend", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); + else + label = bprintf("[(%ld)] iSend", issuer->get_pid()); + break; - switch (req->call) { - case SIMCALL_COMM_ISEND: - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] iSend", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); - else - label = bprintf("[(%ld)] iSend", issuer->get_pid()); - break; - - case SIMCALL_COMM_IRECV: - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] iRecv", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); - else - label = simgrid::xbt::string_printf("[(%ld)] iRecv", issuer->get_pid()); - break; - - case SIMCALL_COMM_WAIT: - if (value == -1) { + case SIMCALL_COMM_IRECV: if (issuer->get_host()) - label = - simgrid::xbt::string_printf("[(%ld)%s] WaitTimeout", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); + label = simgrid::xbt::string_printf("[(%ld)%s] iRecv", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); else - label = simgrid::xbt::string_printf("[(%ld)] WaitTimeout", issuer->get_pid()); - } else { - simgrid::kernel::activity::ActivityImpl* remote_act = simcall_comm_wait__getraw__comm(req); + label = simgrid::xbt::string_printf("[(%ld)] iRecv", issuer->get_pid()); + break; + + case SIMCALL_COMM_WAIT: + if (value == -1) { + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] WaitTimeout", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer)); + else + label = simgrid::xbt::string_printf("[(%ld)] WaitTimeout", issuer->get_pid()); + } else { + simgrid::kernel::activity::ActivityImpl* remote_act = simcall_comm_wait__getraw__comm(req); + simgrid::mc::Remote temp_comm; + mc_model_checker->process().read(temp_comm, + remote(static_cast(remote_act))); + simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer(); + + smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(comm->src_actor_.get())); + smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(comm->dst_actor_.get())); + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] Wait [(%ld)->(%ld)]", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer), src_proc ? src_proc->get_pid() : 0, + dst_proc ? dst_proc->get_pid() : 0); + else + label = simgrid::xbt::string_printf("[(%ld)] Wait [(%ld)->(%ld)]", issuer->get_pid(), + src_proc ? src_proc->get_pid() : 0, dst_proc ? dst_proc->get_pid() : 0); + } + break; + + case SIMCALL_COMM_TEST: { + simgrid::kernel::activity::ActivityImpl* remote_act = simcall_comm_test__getraw__comm(req); simgrid::mc::Remote temp_comm; mc_model_checker->process().read(temp_comm, remote(static_cast(remote_act))); simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer(); - - smx_actor_t src_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(comm->src_actor_.get())); - smx_actor_t dst_proc = mc_model_checker->process().resolve_actor(simgrid::mc::remote(comm->dst_actor_.get())); - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] Wait [(%ld)->(%ld)]", issuer->get_pid(), - MC_smx_actor_get_host_name(issuer), src_proc ? src_proc->get_pid() : 0, - dst_proc ? dst_proc->get_pid() : 0); - else - label = simgrid::xbt::string_printf("[(%ld)] Wait [(%ld)->(%ld)]", issuer->get_pid(), - src_proc ? src_proc->get_pid() : 0, dst_proc ? dst_proc->get_pid() : 0); + if (comm->src_actor_.get() == nullptr || comm->dst_actor_.get() == nullptr) { + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] Test FALSE", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer)); + else + label = bprintf("[(%ld)] Test FALSE", issuer->get_pid()); + } else { + if (issuer->get_host()) + label = + simgrid::xbt::string_printf("[(%ld)%s] Test TRUE", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); + else + label = simgrid::xbt::string_printf("[(%ld)] Test TRUE", issuer->get_pid()); + } + break; } - break; - case SIMCALL_COMM_TEST: { - simgrid::kernel::activity::ActivityImpl* remote_act = simcall_comm_test__getraw__comm(req); - simgrid::mc::Remote temp_comm; - mc_model_checker->process().read(temp_comm, remote(static_cast(remote_act))); - simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer(); - if (comm->src_actor_.get() == nullptr || comm->dst_actor_.get() == nullptr) { - if (issuer->get_host()) - label = - simgrid::xbt::string_printf("[(%ld)%s] Test FALSE", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); - else - label = bprintf("[(%ld)] Test FALSE", issuer->get_pid()); - } else { + case SIMCALL_COMM_WAITANY: { + size_t comms_size = simcall_comm_waitany__get__count(req); if (issuer->get_host()) - label = - simgrid::xbt::string_printf("[(%ld)%s] Test TRUE", issuer->get_pid(), MC_smx_actor_get_host_name(issuer)); + label = simgrid::xbt::string_printf("[(%ld)%s] WaitAny [%d of %zu]", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer), value + 1, comms_size); else - label = simgrid::xbt::string_printf("[(%ld)] Test TRUE", issuer->get_pid()); + label = simgrid::xbt::string_printf("[(%ld)] WaitAny [%d of %zu]", issuer->get_pid(), value + 1, comms_size); + break; } - break; - } - case SIMCALL_COMM_WAITANY: { - size_t comms_size = simcall_comm_waitany__get__count(req); - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] WaitAny [%d of %zu]", issuer->get_pid(), - MC_smx_actor_get_host_name(issuer), value + 1, comms_size); - else - label = simgrid::xbt::string_printf("[(%ld)] WaitAny [%d of %zu]", issuer->get_pid(), value + 1, comms_size); - break; - } - - case SIMCALL_COMM_TESTANY: - if (value == -1) { - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] TestAny FALSE", issuer->get_pid(), - MC_smx_actor_get_host_name(issuer)); - else - label = simgrid::xbt::string_printf("[(%ld)] TestAny FALSE", issuer->get_pid()); - } else { + case SIMCALL_COMM_TESTANY: + if (value == -1) { + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] TestAny FALSE", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer)); + else + label = simgrid::xbt::string_printf("[(%ld)] TestAny FALSE", issuer->get_pid()); + } else { + if (issuer->get_host()) + label = simgrid::xbt::string_printf("[(%ld)%s] TestAny TRUE [%d of %lu]", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer), value + 1, + simcall_comm_testany__get__count(req)); + else + label = simgrid::xbt::string_printf("[(%ld)] TestAny TRUE [%d of %lu]", issuer->get_pid(), value + 1, + simcall_comm_testany__get__count(req)); + } + break; + + case SIMCALL_MUTEX_TRYLOCK: + label = simgrid::xbt::string_printf("[(%ld)] Mutex TRYLOCK", issuer->get_pid()); + break; + + case SIMCALL_MUTEX_LOCK: + label = simgrid::xbt::string_printf("[(%ld)] Mutex LOCK", issuer->get_pid()); + break; + + case SIMCALL_MC_RANDOM: if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] TestAny TRUE [%d of %lu]", issuer->get_pid(), - MC_smx_actor_get_host_name(issuer), value + 1, - simcall_comm_testany__get__count(req)); + label = simgrid::xbt::string_printf("[(%ld)%s] MC_RANDOM (%d)", issuer->get_pid(), + MC_smx_actor_get_host_name(issuer), value); else - label = simgrid::xbt::string_printf("[(%ld)] TestAny TRUE [%d of %lu]", issuer->get_pid(), value + 1, - simcall_comm_testany__get__count(req)); - } - break; - - case SIMCALL_MUTEX_TRYLOCK: - label = simgrid::xbt::string_printf("[(%ld)] Mutex TRYLOCK", issuer->get_pid()); - break; - - case SIMCALL_MUTEX_LOCK: - label = simgrid::xbt::string_printf("[(%ld)] Mutex LOCK", issuer->get_pid()); - break; - - case SIMCALL_MC_RANDOM: - if (issuer->get_host()) - label = simgrid::xbt::string_printf("[(%ld)%s] MC_RANDOM (%d)", issuer->get_pid(), - MC_smx_actor_get_host_name(issuer), value); - else - label = simgrid::xbt::string_printf("[(%ld)] MC_RANDOM (%d)", issuer->get_pid(), value); - break; + label = simgrid::xbt::string_printf("[(%ld)] MC_RANDOM (%d)", issuer->get_pid(), value); + break; - default: - THROW_UNIMPLEMENTED; + default: + THROW_UNIMPLEMENTED; } return simgrid::xbt::string_printf( diff --git a/src/mc/mc_smx.cpp b/src/mc/mc_smx.cpp index 54e9ba964a..3570f8eb4e 100644 --- a/src/mc/mc_smx.cpp +++ b/src/mc/mc_smx.cpp @@ -101,7 +101,7 @@ smx_actor_t MC_smx_simcall_get_issuer(s_smx_simcall const* req) xbt_assert(mc_model_checker != nullptr); // This is the address of the smx_actor in the MCed process: - auto address = simgrid::mc::remote(req->issuer); + auto address = simgrid::mc::remote(req->issuer_); // Lookup by address: for (auto& actor : mc_model_checker->process().actors()) diff --git a/src/mc/mc_state.cpp b/src/mc/mc_state.cpp index 542163b1e8..9ded2f19c8 100644 --- a/src/mc/mc_state.cpp +++ b/src/mc/mc_state.cpp @@ -18,16 +18,16 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_state, mc, "Logging specific to MC (state)"); namespace simgrid { namespace mc { -State::State(unsigned long state_number) : num(state_number) +State::State(unsigned long state_number) : num_(state_number) { this->internal_comm.clear(); std::memset(&this->internal_req, 0, sizeof(this->internal_req)); - std::memset(&this->executed_req, 0, sizeof(this->executed_req)); + std::memset(&this->executed_req_, 0, sizeof(this->executed_req_)); - actorStates.resize(MC_smx_get_maxpid()); + actor_states_.resize(MC_smx_get_maxpid()); /* Stateful model checking */ if ((_sg_mc_checkpoint > 0 && (state_number % _sg_mc_checkpoint == 0)) || _sg_mc_termination) { - system_state = std::make_shared(num); + system_state = std::make_shared(num_); if (_sg_mc_comms_determinism || _sg_mc_send_determinism) { MC_state_copy_incomplete_communications_pattern(this); MC_state_copy_index_communications_pattern(this); @@ -35,14 +35,14 @@ State::State(unsigned long state_number) : num(state_number) } } -std::size_t State::interleaveSize() const +std::size_t State::interleave_size() const { - return boost::range::count_if(this->actorStates, [](simgrid::mc::ProcessState const& p) { return p.isTodo(); }); + return boost::range::count_if(this->actor_states_, [](simgrid::mc::ProcessState const& p) { return p.is_todo(); }); } -Transition State::getTransition() const +Transition State::get_transition() const { - return this->transition; + return this->transition_; } } @@ -63,21 +63,21 @@ Transition State::getTransition() const static inline smx_simcall_t MC_state_get_request_for_process(simgrid::mc::State* state, smx_actor_t actor) { /* reset the outgoing transition */ - simgrid::mc::ProcessState* procstate = &state->actorStates[actor->get_pid()]; - state->transition.pid = -1; - state->transition.argument = -1; - state->executed_req.call = SIMCALL_NONE; + simgrid::mc::ProcessState* procstate = &state->actor_states_[actor->get_pid()]; + state->transition_.pid_ = -1; + state->transition_.argument_ = -1; + state->executed_req_.call_ = SIMCALL_NONE; if (not simgrid::mc::actor_is_enabled(actor)) return nullptr; // Not executable in the application smx_simcall_t req = nullptr; - switch (actor->simcall.call) { + switch (actor->simcall.call_) { case SIMCALL_COMM_WAITANY: - state->transition.argument = -1; + state->transition_.argument_ = -1; while (procstate->times_considered < simcall_comm_waitany__get__count(&actor->simcall)) { if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall, procstate->times_considered)) { - state->transition.argument = procstate->times_considered; + state->transition_.argument_ = procstate->times_considered; ++procstate->times_considered; break; } @@ -85,17 +85,17 @@ static inline smx_simcall_t MC_state_get_request_for_process(simgrid::mc::State* } if (procstate->times_considered >= simcall_comm_waitany__get__count(&actor->simcall)) - procstate->setDone(); - if (state->transition.argument != -1) + procstate->set_done(); + if (state->transition_.argument_ != -1) req = &actor->simcall; break; case SIMCALL_COMM_TESTANY: { unsigned start_count = procstate->times_considered; - state->transition.argument = -1; + state->transition_.argument_ = -1; while (procstate->times_considered < simcall_comm_testany__get__count(&actor->simcall)) { if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall, procstate->times_considered)) { - state->transition.argument = procstate->times_considered; + state->transition_.argument_ = procstate->times_considered; ++procstate->times_considered; break; } @@ -103,9 +103,9 @@ static inline smx_simcall_t MC_state_get_request_for_process(simgrid::mc::State* } if (procstate->times_considered >= simcall_comm_testany__get__count(&actor->simcall)) - procstate->setDone(); + procstate->set_done(); - if (state->transition.argument != -1 || start_count == 0) + if (state->transition_.argument_ != -1 || start_count == 0) req = &actor->simcall; break; @@ -118,85 +118,85 @@ static inline smx_simcall_t MC_state_get_request_for_process(simgrid::mc::State* mc_model_checker->process().read(temp_act, remote_act); simgrid::kernel::activity::CommImpl* act = temp_act.get_buffer(); if (act->src_actor_.get() && act->dst_actor_.get()) - state->transition.argument = 0; + state->transition_.argument_ = 0; else if (act->src_actor_.get() == nullptr && act->type_ == simgrid::kernel::activity::CommImpl::Type::READY && act->detached()) - state->transition.argument = 0; + state->transition_.argument_ = 0; else - state->transition.argument = -1; - procstate->setDone(); + state->transition_.argument_ = -1; + procstate->set_done(); req = &actor->simcall; break; } case SIMCALL_MC_RANDOM: { int min_value = simcall_mc_random__get__min(&actor->simcall); - state->transition.argument = procstate->times_considered + min_value; + state->transition_.argument_ = procstate->times_considered + min_value; procstate->times_considered++; - if (state->transition.argument == simcall_mc_random__get__max(&actor->simcall)) - procstate->setDone(); + if (state->transition_.argument_ == simcall_mc_random__get__max(&actor->simcall)) + procstate->set_done(); req = &actor->simcall; break; } default: - procstate->setDone(); - state->transition.argument = 0; + procstate->set_done(); + state->transition_.argument_ = 0; req = &actor->simcall; break; } if (not req) return nullptr; - state->transition.pid = actor->get_pid(); - state->executed_req = *req; + state->transition_.pid_ = actor->get_pid(); + state->executed_req_ = *req; // Fetch the data of the request and translate it: state->internal_req = *req; /* The waitany and testany request are transformed into a wait or test request over the corresponding communication * action so it can be treated later by the dependence function. */ - switch (req->call) { - case SIMCALL_COMM_WAITANY: { - state->internal_req.call = SIMCALL_COMM_WAIT; - simgrid::kernel::activity::CommImpl* remote_comm; - remote_comm = - mc_model_checker->process().read(remote(simcall_comm_waitany__get__comms(req) + state->transition.argument)); - mc_model_checker->process().read(state->internal_comm, remote(remote_comm)); - simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.get_buffer()); - simcall_comm_wait__set__timeout(&state->internal_req, 0); - break; - } - - case SIMCALL_COMM_TESTANY: - state->internal_req.call = SIMCALL_COMM_TEST; - - if (state->transition.argument > 0) { - simgrid::kernel::activity::CommImpl* remote_comm = - mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + state->transition.argument)); + switch (req->call_) { + case SIMCALL_COMM_WAITANY: { + state->internal_req.call_ = SIMCALL_COMM_WAIT; + simgrid::kernel::activity::CommImpl* remote_comm; + remote_comm = mc_model_checker->process().read( + remote(simcall_comm_waitany__get__comms(req) + state->transition_.argument_)); mc_model_checker->process().read(state->internal_comm, remote(remote_comm)); + simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.get_buffer()); + simcall_comm_wait__set__timeout(&state->internal_req, 0); + break; } - simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.get_buffer()); - simcall_comm_test__set__result(&state->internal_req, state->transition.argument); - break; - - case SIMCALL_COMM_WAIT: - mc_model_checker->process().read_bytes(&state->internal_comm, sizeof(state->internal_comm), - remote(simcall_comm_wait__getraw__comm(req))); - simcall_comm_wait__set__comm(&state->executed_req, state->internal_comm.get_buffer()); - simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.get_buffer()); - break; - - case SIMCALL_COMM_TEST: - mc_model_checker->process().read_bytes(&state->internal_comm, sizeof(state->internal_comm), - remote(simcall_comm_test__getraw__comm(req))); - simcall_comm_test__set__comm(&state->executed_req, state->internal_comm.get_buffer()); - simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.get_buffer()); - break; - - default: - /* No translation needed */ - break; + case SIMCALL_COMM_TESTANY: + state->internal_req.call_ = SIMCALL_COMM_TEST; + + if (state->transition_.argument_ > 0) { + simgrid::kernel::activity::CommImpl* remote_comm = mc_model_checker->process().read( + remote(simcall_comm_testany__get__comms(req) + state->transition_.argument_)); + mc_model_checker->process().read(state->internal_comm, remote(remote_comm)); + } + + simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.get_buffer()); + simcall_comm_test__set__result(&state->internal_req, state->transition_.argument_); + break; + + case SIMCALL_COMM_WAIT: + mc_model_checker->process().read_bytes(&state->internal_comm, sizeof(state->internal_comm), + remote(simcall_comm_wait__getraw__comm(req))); + simcall_comm_wait__set__comm(&state->executed_req_, state->internal_comm.get_buffer()); + simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.get_buffer()); + break; + + case SIMCALL_COMM_TEST: + mc_model_checker->process().read_bytes(&state->internal_comm, sizeof(state->internal_comm), + remote(simcall_comm_test__getraw__comm(req))); + simcall_comm_test__set__comm(&state->executed_req_, state->internal_comm.get_buffer()); + simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.get_buffer()); + break; + + default: + /* No translation needed */ + break; } return req; @@ -206,7 +206,7 @@ smx_simcall_t MC_state_get_request(simgrid::mc::State* state) { for (auto& actor : mc_model_checker->process().actors()) { /* Only consider the actors that were marked as interleaving by the checker algorithm */ - if (not state->actorStates[actor.copy.get_buffer()->get_pid()].isTodo()) + if (not state->actor_states_[actor.copy.get_buffer()->get_pid()].is_todo()) continue; smx_simcall_t res = MC_state_get_request_for_process(state, actor.copy.get_buffer()); diff --git a/src/mc/mc_state.hpp b/src/mc/mc_state.hpp index 480bdea388..6d66849184 100644 --- a/src/mc/mc_state.hpp +++ b/src/mc/mc_state.hpp @@ -62,9 +62,9 @@ class ProcessState { * Either the checker did not consider the transition, or it was considered and to do, or considered and done. */ enum class InterleavingType { - /** This process transition is not considered by the checker (yet?) */ + /** This actor transition is not considered by the checker (yet?) */ disabled = 0, - /** The checker algorithm decided that this process transitions should be done at some point */ + /** The checker algorithm decided that this actor transitions should be done at some point */ todo, /** The checker algorithm decided that this should be done, but it was done in the meanwhile */ done, @@ -78,16 +78,16 @@ public: // TODO, make this private unsigned int times_considered = 0; - bool isDisabled() const { return this->state == InterleavingType::disabled; } - bool isDone() const { return this->state == InterleavingType::done; } - bool isTodo() const { return this->state == InterleavingType::todo; } + bool is_disabled() const { return this->state == InterleavingType::disabled; } + bool is_done() const { return this->state == InterleavingType::done; } + bool is_todo() const { return this->state == InterleavingType::todo; } /** Mark that we should try executing this process at some point in the future of the checker algorithm */ void consider() { this->state = InterleavingType::todo; this->times_considered = 0; } - void setDone() { this->state = InterleavingType::done; } + void set_done() { this->state = InterleavingType::done; } }; /* A node in the exploration graph (kind-of) @@ -95,15 +95,15 @@ public: class XBT_PRIVATE State { public: /** Sequential state number (used for debugging) */ - int num = 0; + int num_ = 0; /** State's exploration status by process */ - std::vector actorStates; + std::vector actor_states_; - Transition transition; + Transition transition_; /** The simcall which was executed, going out of that state */ - s_smx_simcall executed_req; + s_smx_simcall executed_req_; /* Internal translation of the executed_req simcall * @@ -119,14 +119,14 @@ public: std::shared_ptr system_state; // For CommunicationDeterminismChecker - std::vector> incomplete_comm_pattern; - std::vector communicationIndices; + std::vector> incomplete_comm_pattern_; + std::vector communication_indices_; explicit State(unsigned long state_number); - std::size_t interleaveSize() const; - void addInterleavingSet(smx_actor_t actor) { this->actorStates[actor->get_pid()].consider(); } - Transition getTransition() const; + std::size_t interleave_size() const; + void add_interleaving_set(smx_actor_t actor) { this->actor_states_[actor->get_pid()].consider(); } + Transition get_transition() const; }; } } diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp index c8470a43b8..134f4171d6 100644 --- a/src/simix/libsmx.cpp +++ b/src/simix/libsmx.cpp @@ -309,13 +309,13 @@ e_smx_state_t simcall_io_wait(const smx_activity_t& io) void simcall_run_kernel(std::function const& code, simgrid::kernel::actor::Transition* t) { - SIMIX_process_self()->simcall.transition = t; + SIMIX_process_self()->simcall.transition_ = t; simcall_BODY_run_kernel(&code); } void simcall_run_blocking(std::function const& code, simgrid::kernel::actor::Transition* t = nullptr) { - SIMIX_process_self()->simcall.transition = t; + SIMIX_process_self()->simcall.transition_ = t; simcall_BODY_run_blocking(&code); } diff --git a/src/simix/popping_accessors.hpp b/src/simix/popping_accessors.hpp index 9843aaea86..066b3edc43 100644 --- a/src/simix/popping_accessors.hpp +++ b/src/simix/popping_accessors.hpp @@ -17,984 +17,984 @@ #include "src/simix/popping_private.hpp" static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__get__execution(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline int simcall_execution_wait__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline simgrid::kernel::activity::ExecImpl** simcall_execution_waitany_for__get__execs(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::ExecImpl** simcall_execution_waitany_for__getraw__execs(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_execution_waitany_for__set__execs(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl** arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline size_t simcall_execution_waitany_for__get__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline size_t simcall_execution_waitany_for__getraw__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_execution_waitany_for__set__count(smx_simcall_t simcall, size_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline double simcall_execution_waitany_for__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline double simcall_execution_waitany_for__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_execution_waitany_for__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline int simcall_execution_waitany_for__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_execution_waitany_for__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_execution_waitany_for__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline simgrid::kernel::activity::ExecImpl* simcall_execution_test__get__execution(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::ExecImpl* simcall_execution_test__getraw__execution(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_execution_test__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline bool simcall_execution_test__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline bool simcall_execution_test__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_execution_test__set__result(smx_simcall_t simcall, bool result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline double simcall_comm_send__get__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[3]); + return simgrid::simix::unmarshal(simcall->args_[3]); } static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[3]); + return simgrid::simix::unmarshal_raw(simcall->args_[3]); } static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[3], arg); + simgrid::simix::marshal(simcall->args_[3], arg); } static inline unsigned char* simcall_comm_send__get__src_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[4]); + return simgrid::simix::unmarshal(simcall->args_[4]); } static inline unsigned char* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[4]); + return simgrid::simix::unmarshal_raw(simcall->args_[4]); } static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, unsigned char* arg) { - simgrid::simix::marshal(simcall->args[4], arg); + simgrid::simix::marshal(simcall->args_[4], arg); } static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[5]); + return simgrid::simix::unmarshal(simcall->args_[5]); } static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[5]); + return simgrid::simix::unmarshal_raw(simcall->args_[5]); } static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg) { - simgrid::simix::marshal(simcall->args[5], arg); + simgrid::simix::marshal(simcall->args_[5], arg); } static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[6]); + return simgrid::simix::unmarshal(simcall->args_[6]); } static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[6]); + return simgrid::simix::unmarshal_raw(simcall->args_[6]); } static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) { - simgrid::simix::marshal(simcall->args[6], arg); + simgrid::simix::marshal(simcall->args_[6], arg); } static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[7]); + return simgrid::simix::unmarshal(simcall->args_[7]); } static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[7]); + return simgrid::simix::unmarshal_raw(simcall->args_[7]); } static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) { - simgrid::simix::marshal(simcall->args[7], arg); + simgrid::simix::marshal(simcall->args_[7], arg); } static inline void* simcall_comm_send__get__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[8]); + return simgrid::simix::unmarshal(simcall->args_[8]); } static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[8]); + return simgrid::simix::unmarshal_raw(simcall->args_[8]); } static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg) { - simgrid::simix::marshal(simcall->args[8], arg); + simgrid::simix::marshal(simcall->args_[8], arg); } static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[9]); + return simgrid::simix::unmarshal(simcall->args_[9]); } static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[9]); + return simgrid::simix::unmarshal_raw(simcall->args_[9]); } static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[9], arg); + simgrid::simix::marshal(simcall->args_[9], arg); } static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[3]); + return simgrid::simix::unmarshal(simcall->args_[3]); } static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[3]); + return simgrid::simix::unmarshal_raw(simcall->args_[3]); } static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[3], arg); + simgrid::simix::marshal(simcall->args_[3], arg); } static inline unsigned char* simcall_comm_isend__get__src_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[4]); + return simgrid::simix::unmarshal(simcall->args_[4]); } static inline unsigned char* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[4]); + return simgrid::simix::unmarshal_raw(simcall->args_[4]); } static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, unsigned char* arg) { - simgrid::simix::marshal(simcall->args[4], arg); + simgrid::simix::marshal(simcall->args_[4], arg); } static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[5]); + return simgrid::simix::unmarshal(simcall->args_[5]); } static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[5]); + return simgrid::simix::unmarshal_raw(simcall->args_[5]); } static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg) { - simgrid::simix::marshal(simcall->args[5], arg); + simgrid::simix::marshal(simcall->args_[5], arg); } static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[6]); + return simgrid::simix::unmarshal(simcall->args_[6]); } static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[6]); + return simgrid::simix::unmarshal_raw(simcall->args_[6]); } static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) { - simgrid::simix::marshal(simcall->args[6], arg); + simgrid::simix::marshal(simcall->args_[6], arg); } static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[7]); + return simgrid::simix::unmarshal(simcall->args_[7]); } static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[7]); + return simgrid::simix::unmarshal_raw(simcall->args_[7]); } static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg) { - simgrid::simix::marshal(simcall->args[7], arg); + simgrid::simix::marshal(simcall->args_[7], arg); } static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[8]); + return simgrid::simix::unmarshal(simcall->args_[8]); } static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[8]); + return simgrid::simix::unmarshal_raw(simcall->args_[8]); } static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) { - simgrid::simix::marshal(simcall->args[8], arg); + simgrid::simix::marshal(simcall->args_[8], arg); } static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[9]); + return simgrid::simix::unmarshal(simcall->args_[9]); } static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[9]); + return simgrid::simix::unmarshal_raw(simcall->args_[9]); } static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg) { - simgrid::simix::marshal(simcall->args[9], arg); + simgrid::simix::marshal(simcall->args_[9], arg); } static inline bool simcall_comm_isend__get__detached(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[10]); + return simgrid::simix::unmarshal(simcall->args_[10]); } static inline bool simcall_comm_isend__getraw__detached(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[10]); + return simgrid::simix::unmarshal_raw(simcall->args_[10]); } static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, bool arg) { - simgrid::simix::marshal(simcall->args[10], arg); + simgrid::simix::marshal(simcall->args_[10], arg); } static inline boost::intrusive_ptr simcall_comm_isend__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal>(simcall->result); + return simgrid::simix::unmarshal>(simcall->result_); } static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr result) { - simgrid::simix::marshal>(simcall->result, result); + simgrid::simix::marshal>(simcall->result_, result); } static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline unsigned char* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline unsigned char* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, unsigned char* arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[3]); + return simgrid::simix::unmarshal(simcall->args_[3]); } static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[3]); + return simgrid::simix::unmarshal_raw(simcall->args_[3]); } static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg) { - simgrid::simix::marshal(simcall->args[3], arg); + simgrid::simix::marshal(simcall->args_[3], arg); } static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[4]); + return simgrid::simix::unmarshal(simcall->args_[4]); } static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[4]); + return simgrid::simix::unmarshal_raw(simcall->args_[4]); } static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) { - simgrid::simix::marshal(simcall->args[4], arg); + simgrid::simix::marshal(simcall->args_[4], arg); } static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[5]); + return simgrid::simix::unmarshal(simcall->args_[5]); } static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[5]); + return simgrid::simix::unmarshal_raw(simcall->args_[5]); } static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) { - simgrid::simix::marshal(simcall->args[5], arg); + simgrid::simix::marshal(simcall->args_[5], arg); } static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[6]); + return simgrid::simix::unmarshal(simcall->args_[6]); } static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[6]); + return simgrid::simix::unmarshal_raw(simcall->args_[6]); } static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg) { - simgrid::simix::marshal(simcall->args[6], arg); + simgrid::simix::marshal(simcall->args_[6], arg); } static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[7]); + return simgrid::simix::unmarshal(simcall->args_[7]); } static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[7]); + return simgrid::simix::unmarshal_raw(simcall->args_[7]); } static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[7], arg); + simgrid::simix::marshal(simcall->args_[7], arg); } static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[8]); + return simgrid::simix::unmarshal(simcall->args_[8]); } static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[8]); + return simgrid::simix::unmarshal_raw(simcall->args_[8]); } static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[8], arg); + simgrid::simix::marshal(simcall->args_[8], arg); } static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline unsigned char* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline unsigned char* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, unsigned char* arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[3]); + return simgrid::simix::unmarshal(simcall->args_[3]); } static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[3]); + return simgrid::simix::unmarshal_raw(simcall->args_[3]); } static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg) { - simgrid::simix::marshal(simcall->args[3], arg); + simgrid::simix::marshal(simcall->args_[3], arg); } static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[4]); + return simgrid::simix::unmarshal(simcall->args_[4]); } static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[4]); + return simgrid::simix::unmarshal_raw(simcall->args_[4]); } static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) { - simgrid::simix::marshal(simcall->args[4], arg); + simgrid::simix::marshal(simcall->args_[4], arg); } static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[5]); + return simgrid::simix::unmarshal(simcall->args_[5]); } static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[5]); + return simgrid::simix::unmarshal_raw(simcall->args_[5]); } static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) { - simgrid::simix::marshal(simcall->args[5], arg); + simgrid::simix::marshal(simcall->args_[5], arg); } static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[6]); + return simgrid::simix::unmarshal(simcall->args_[6]); } static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[6]); + return simgrid::simix::unmarshal_raw(simcall->args_[6]); } static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg) { - simgrid::simix::marshal(simcall->args[6], arg); + simgrid::simix::marshal(simcall->args_[6], arg); } static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[7]); + return simgrid::simix::unmarshal(simcall->args_[7]); } static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[7]); + return simgrid::simix::unmarshal_raw(simcall->args_[7]); } static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[7], arg); + simgrid::simix::marshal(simcall->args_[7], arg); } static inline boost::intrusive_ptr simcall_comm_irecv__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal>(simcall->result); + return simgrid::simix::unmarshal>(simcall->result_); } static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr result) { - simgrid::simix::marshal>(simcall->result, result); + simgrid::simix::marshal>(simcall->result_, result); } static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__get__comms(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__getraw__comms(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline size_t simcall_comm_waitany__get__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline size_t simcall_comm_waitany__getraw__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_waitany__set__count(smx_simcall_t simcall, size_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__get__comm(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__get__comm(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline bool simcall_comm_test__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline bool simcall_comm_test__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_comm_test__set__result(smx_simcall_t simcall, bool result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__get__comms(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline int simcall_comm_testany__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[2]); + return simgrid::simix::unmarshal(simcall->args_[2]); } static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[2]); + return simgrid::simix::unmarshal_raw(simcall->args_[2]); } static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[2], arg); + simgrid::simix::marshal(simcall->args_[2], arg); } static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__get__io(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__getraw__io(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_io_wait__set__io(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline sg_size_t simcall_io_wait__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline sg_size_t simcall_io_wait__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_io_wait__set__result(smx_simcall_t simcall, sg_size_t result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline int simcall_mc_random__get__min(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[0]); + return simgrid::simix::unmarshal(simcall->args_[0]); } static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[0]); + return simgrid::simix::unmarshal_raw(simcall->args_[0]); } static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg) { - simgrid::simix::marshal(simcall->args[0], arg); + simgrid::simix::marshal(simcall->args_[0], arg); } static inline int simcall_mc_random__get__max(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->args[1]); + return simgrid::simix::unmarshal(simcall->args_[1]); } static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->args[1]); + return simgrid::simix::unmarshal_raw(simcall->args_[1]); } static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg) { - simgrid::simix::marshal(simcall->args[1], arg); + simgrid::simix::marshal(simcall->args_[1], arg); } static inline int simcall_mc_random__get__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal(simcall->result); + return simgrid::simix::unmarshal(simcall->result_); } static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw(simcall->result); + return simgrid::simix::unmarshal_raw(simcall->result_); } static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result) { - simgrid::simix::marshal(simcall->result, result); + simgrid::simix::marshal(simcall->result_, result); } static inline std::function const* simcall_run_kernel__get__code(smx_simcall_t simcall) { - return simgrid::simix::unmarshal const*>(simcall->args[0]); + return simgrid::simix::unmarshal const*>(simcall->args_[0]); } static inline std::function const* simcall_run_kernel__getraw__code(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw const*>(simcall->args[0]); + return simgrid::simix::unmarshal_raw const*>(simcall->args_[0]); } static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function const* arg) { - simgrid::simix::marshal const*>(simcall->args[0], arg); + simgrid::simix::marshal const*>(simcall->args_[0], arg); } static inline std::function const* simcall_run_blocking__get__code(smx_simcall_t simcall) { - return simgrid::simix::unmarshal const*>(simcall->args[0]); + return simgrid::simix::unmarshal const*>(simcall->args_[0]); } static inline std::function const* simcall_run_blocking__getraw__code(smx_simcall_t simcall) { - return simgrid::simix::unmarshal_raw const*>(simcall->args[0]); + return simgrid::simix::unmarshal_raw const*>(simcall->args_[0]); } static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function const* arg) { - simgrid::simix::marshal const*>(simcall->args[0], arg); + simgrid::simix::marshal const*>(simcall->args_[0], arg); } /* The prototype of all simcall handlers, automatically generated for you */ diff --git a/src/simix/popping_bodies.cpp b/src/simix/popping_bodies.cpp index 40a802fcd1..fcb408dace 100644 --- a/src/simix/popping_bodies.cpp +++ b/src/simix/popping_bodies.cpp @@ -30,13 +30,13 @@ inline static R simcall(e_smx_simcall_t call, T const&... t) smx_actor_t self = SIMIX_process_self(); simgrid::simix::marshal(&self->simcall, call, t...); if (self != simix_global->maestro_process) { - XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->get_cname(), SIMIX_simcall_name(self->simcall.call), - (int)self->simcall.call); + XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->get_cname(), SIMIX_simcall_name(self->simcall.call_), + (int)self->simcall.call_); self->yield(); } else { self->simcall_handle(0); } - return simgrid::simix::unmarshal(self->simcall.result); + return simgrid::simix::unmarshal(self->simcall.result_); } inline static int simcall_BODY_execution_wait(simgrid::kernel::activity::ExecImpl* execution) diff --git a/src/simix/popping_generated.cpp b/src/simix/popping_generated.cpp index 880712d9cf..706e64e125 100644 --- a/src/simix/popping_generated.cpp +++ b/src/simix/popping_generated.cpp @@ -56,103 +56,159 @@ const char* simcall_names[] = { * This function is generated from src/simix/simcalls.in */ void simgrid::kernel::actor::ActorImpl::simcall_handle(int value) { - XBT_DEBUG("Handling simcall %p: %s", &simcall, SIMIX_simcall_name(simcall.call)); + XBT_DEBUG("Handling simcall %p: %s", &simcall, SIMIX_simcall_name(simcall.call_)); SIMCALL_SET_MC_VALUE(simcall, value); if (context_->iwannadie) return; - switch (simcall.call) { + switch (simcall.call_) { case SIMCALL_EXECUTION_WAIT: - simcall_HANDLER_execution_wait(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_execution_wait(&simcall, + simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_EXECUTION_WAITANY_FOR: - simcall_HANDLER_execution_waitany_for(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2])); + simcall_HANDLER_execution_waitany_for( + &simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), simgrid::simix::unmarshal(simcall.args_[2])); break; case SIMCALL_EXECUTION_TEST: - simcall_HANDLER_execution_test(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_execution_test(&simcall, + simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_COMM_SEND: - simcall_HANDLER_comm_send(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2]), simgrid::simix::unmarshal(simcall.args[3]), simgrid::simix::unmarshal(simcall.args[4]), simgrid::simix::unmarshal(simcall.args[5]), simgrid::simix::unmarshal(simcall.args[6]), simgrid::simix::unmarshal(simcall.args[7]), simgrid::simix::unmarshal(simcall.args[8]), simgrid::simix::unmarshal(simcall.args[9])); + simcall_HANDLER_comm_send( + &simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), + simgrid::simix::unmarshal(simcall.args_[2]), simgrid::simix::unmarshal(simcall.args_[3]), + simgrid::simix::unmarshal(simcall.args_[4]), + simgrid::simix::unmarshal(simcall.args_[5]), + simgrid::simix::unmarshal(simcall.args_[6]), + simgrid::simix::unmarshal(simcall.args_[7]), + simgrid::simix::unmarshal(simcall.args_[8]), simgrid::simix::unmarshal(simcall.args_[9])); break; case SIMCALL_COMM_ISEND: - simgrid::simix::marshal>(simcall.result, simcall_HANDLER_comm_isend(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2]), simgrid::simix::unmarshal(simcall.args[3]), simgrid::simix::unmarshal(simcall.args[4]), simgrid::simix::unmarshal(simcall.args[5]), simgrid::simix::unmarshal(simcall.args[6]), simgrid::simix::unmarshal(simcall.args[7]), simgrid::simix::unmarshal(simcall.args[8]), simgrid::simix::unmarshal(simcall.args[9]), simgrid::simix::unmarshal(simcall.args[10]))); + simgrid::simix::marshal>( + simcall.result_, + simcall_HANDLER_comm_isend( + &simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), + simgrid::simix::unmarshal(simcall.args_[2]), simgrid::simix::unmarshal(simcall.args_[3]), + simgrid::simix::unmarshal(simcall.args_[4]), + simgrid::simix::unmarshal(simcall.args_[5]), + simgrid::simix::unmarshal(simcall.args_[6]), + simgrid::simix::unmarshal(simcall.args_[7]), + simgrid::simix::unmarshal(simcall.args_[8]), + simgrid::simix::unmarshal(simcall.args_[9]), simgrid::simix::unmarshal(simcall.args_[10]))); simcall_answer(); break; case SIMCALL_COMM_RECV: - simcall_HANDLER_comm_recv(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2]), simgrid::simix::unmarshal(simcall.args[3]), simgrid::simix::unmarshal(simcall.args[4]), simgrid::simix::unmarshal(simcall.args[5]), simgrid::simix::unmarshal(simcall.args[6]), simgrid::simix::unmarshal(simcall.args[7]), simgrid::simix::unmarshal(simcall.args[8])); + simcall_HANDLER_comm_recv(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), + simgrid::simix::unmarshal(simcall.args_[2]), + simgrid::simix::unmarshal(simcall.args_[3]), + simgrid::simix::unmarshal(simcall.args_[4]), + simgrid::simix::unmarshal(simcall.args_[5]), + simgrid::simix::unmarshal(simcall.args_[6]), + simgrid::simix::unmarshal(simcall.args_[7]), + simgrid::simix::unmarshal(simcall.args_[8])); break; case SIMCALL_COMM_IRECV: - simgrid::simix::marshal>(simcall.result, simcall_HANDLER_comm_irecv(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2]), simgrid::simix::unmarshal(simcall.args[3]), simgrid::simix::unmarshal(simcall.args[4]), simgrid::simix::unmarshal(simcall.args[5]), simgrid::simix::unmarshal(simcall.args[6]), simgrid::simix::unmarshal(simcall.args[7]))); + simgrid::simix::marshal>( + simcall.result_, + simcall_HANDLER_comm_irecv(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), + simgrid::simix::unmarshal(simcall.args_[2]), + simgrid::simix::unmarshal(simcall.args_[3]), + simgrid::simix::unmarshal(simcall.args_[4]), + simgrid::simix::unmarshal(simcall.args_[5]), + simgrid::simix::unmarshal(simcall.args_[6]), + simgrid::simix::unmarshal(simcall.args_[7]))); simcall_answer(); break; case SIMCALL_COMM_WAITANY: - simcall_HANDLER_comm_waitany(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2])); + simcall_HANDLER_comm_waitany( + &simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), simgrid::simix::unmarshal(simcall.args_[2])); break; case SIMCALL_COMM_WAIT: - simcall_HANDLER_comm_wait(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1])); + simcall_HANDLER_comm_wait(&simcall, + simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1])); break; case SIMCALL_COMM_TEST: - simcall_HANDLER_comm_test(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_comm_test(&simcall, + simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_COMM_TESTANY: - simcall_HANDLER_comm_testany(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1])); + simcall_HANDLER_comm_testany(&simcall, + simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1])); break; case SIMCALL_MUTEX_LOCK: - simcall_HANDLER_mutex_lock(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_mutex_lock(&simcall, simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_MUTEX_TRYLOCK: - simgrid::simix::marshal(simcall.result, simcall_HANDLER_mutex_trylock(&simcall, simgrid::simix::unmarshal(simcall.args[0]))); + simgrid::simix::marshal( + simcall.result_, + simcall_HANDLER_mutex_trylock(&simcall, simgrid::simix::unmarshal(simcall.args_[0]))); simcall_answer(); break; case SIMCALL_MUTEX_UNLOCK: - simcall_HANDLER_mutex_unlock(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_mutex_unlock(&simcall, simgrid::simix::unmarshal(simcall.args_[0])); simcall_answer(); break; case SIMCALL_COND_WAIT: - simcall_HANDLER_cond_wait(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1])); + simcall_HANDLER_cond_wait(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1])); break; case SIMCALL_COND_WAIT_TIMEOUT: - simcall_HANDLER_cond_wait_timeout(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]), simgrid::simix::unmarshal(simcall.args[2])); + simcall_HANDLER_cond_wait_timeout(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]), + simgrid::simix::unmarshal(simcall.args_[2])); break; case SIMCALL_SEM_ACQUIRE: - simcall_HANDLER_sem_acquire(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_sem_acquire(&simcall, simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_SEM_ACQUIRE_TIMEOUT: - simcall_HANDLER_sem_acquire_timeout(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1])); + simcall_HANDLER_sem_acquire_timeout(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1])); break; case SIMCALL_IO_WAIT: - simcall_HANDLER_io_wait(&simcall, simgrid::simix::unmarshal(simcall.args[0])); + simcall_HANDLER_io_wait(&simcall, + simgrid::simix::unmarshal(simcall.args_[0])); break; case SIMCALL_MC_RANDOM: - simgrid::simix::marshal(simcall.result, simcall_HANDLER_mc_random(&simcall, simgrid::simix::unmarshal(simcall.args[0]), simgrid::simix::unmarshal(simcall.args[1]))); + simgrid::simix::marshal(simcall.result_, + simcall_HANDLER_mc_random(&simcall, simgrid::simix::unmarshal(simcall.args_[0]), + simgrid::simix::unmarshal(simcall.args_[1]))); simcall_answer(); break; case SIMCALL_RUN_KERNEL: - SIMIX_run_kernel(simgrid::simix::unmarshal const*>(simcall.args[0])); + SIMIX_run_kernel(simgrid::simix::unmarshal const*>(simcall.args_[0])); simcall_answer(); break; case SIMCALL_RUN_BLOCKING: - SIMIX_run_blocking(simgrid::simix::unmarshal const*>(simcall.args[0])); + SIMIX_run_blocking(simgrid::simix::unmarshal const*>(simcall.args_[0])); break; case NUM_SIMCALLS: diff --git a/src/simix/popping_private.hpp b/src/simix/popping_private.hpp index f0c6cce8b1..00d77e2dc2 100644 --- a/src/simix/popping_private.hpp +++ b/src/simix/popping_private.hpp @@ -43,17 +43,17 @@ union u_smx_scalar { * @brief Represents a simcall to the kernel. */ struct s_smx_simcall { - e_smx_simcall_t call; - smx_actor_t issuer; - smx_timer_t timeout_cb; // Callback to timeouts - simgrid::kernel::actor::Transition* transition = nullptr; - int mc_value; - u_smx_scalar args[11]; - u_smx_scalar result; + e_smx_simcall_t call_; + smx_actor_t issuer_; + smx_timer_t timeout_cb_; // Callback to timeouts + simgrid::kernel::actor::Transition* transition_ = nullptr; + int mc_value_; + u_smx_scalar args_[11]; + u_smx_scalar result_; }; -#define SIMCALL_SET_MC_VALUE(simcall, value) ((simcall).mc_value = (value)) -#define SIMCALL_GET_MC_VALUE(simcall) ((simcall).mc_value) +#define SIMCALL_SET_MC_VALUE(simcall, value) ((simcall).mc_value_ = (value)) +#define SIMCALL_GET_MC_VALUE(simcall) ((simcall).mc_value_) /******************************** General *************************************/ @@ -184,21 +184,21 @@ template inline void marshal_args(smx_simcall_t simcall) template inline void marshal_args(smx_simcall_t simcall, A const& a) { - marshal(simcall->args[I], a); + marshal(simcall->args_[I], a); } template inline void marshal_args(smx_simcall_t simcall, A const& a, B const&... b) { - marshal(simcall->args[I], a); + marshal(simcall->args_[I], a); marshal_args(simcall, b...); } /** Initialize the simcall */ template inline void marshal(smx_simcall_t simcall, e_smx_simcall_t call, A const&... a) { - simcall->call = call; - memset(&simcall->result, 0, sizeof(simcall->result)); - memset(simcall->args, 0, sizeof(simcall->args)); + simcall->call_ = call; + memset(&simcall->result_, 0, sizeof(simcall->result_)); + memset(simcall->args_, 0, sizeof(simcall->args_)); marshal_args<0>(simcall, a...); } } diff --git a/src/simix/smx_global.cpp b/src/simix/smx_global.cpp index 2662ebaa24..25ce05455f 100644 --- a/src/simix/smx_global.cpp +++ b/src/simix/smx_global.cpp @@ -467,7 +467,7 @@ void SIMIX_run() */ for (smx_actor_t const& process : simix_global->actors_that_ran) { - if (process->simcall.call != SIMCALL_NONE) { + if (process->simcall.call_ != SIMCALL_NONE) { process->simcall_handle(0); } } diff --git a/src/smpi/plugins/sampi_loadbalancer.cpp b/src/smpi/plugins/sampi_loadbalancer.cpp index dc5dfaa68d..59f5914af9 100644 --- a/src/smpi/plugins/sampi_loadbalancer.cpp +++ b/src/smpi/plugins/sampi_loadbalancer.cpp @@ -137,7 +137,7 @@ void sg_load_balancer_plugin_init() if (!done) { done = true; simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImpl const& activity) { - simgrid::smpi::plugin::lb.record_actor_computation(activity.simcalls_.front()->issuer->iface(), + simgrid::smpi::plugin::lb.record_actor_computation(activity.simcalls_.front()->issuer_->iface(), activity.surf_action_->get_cost()); }); -- 2.20.1