XBT_PUBLIC(void) SIMIX_mutex_unref(smx_mutex_t mutex);
XBT_PUBLIC(void) simcall_mutex_lock(smx_mutex_t mutex);
XBT_PUBLIC(int) simcall_mutex_trylock(smx_mutex_t mutex);
+XBT_PUBLIC(void) simcall_mutex_unlock(smx_mutex_t mutex);
XBT_PUBLIC(smx_cond_t) simcall_cond_init();
XBT_PUBLIC(void) SIMIX_cond_unref(smx_cond_t cond);
#include "src/mc/mc_mmu.h"
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_page_snapshot, mc,
- "Logging specific to mc_page_snapshot");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_page_snapshot, mc, "Logging specific to mc_page_snapshot");
namespace simgrid {
namespace mc {
// ***** snapshot_page_manager
-PageStore::PageStore(size_t size) :
- memory_(nullptr), capacity_(0), top_index_(0)
+PageStore::PageStore(size_t size) : memory_(nullptr), capacity_(size), top_index_(0)
{
- // Using mmap in order to be able to expand the region
- // by relocating it somewhere else in the virtual memory
- // space:
+ // Using mmap in order to be able to expand the region by relocating it somewhere else in the virtual memory space:
void* memory = ::mmap(nullptr, size << xbt_pagebits, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_POPULATE, -1, 0);
if (memory == MAP_FAILED)
xbt_die("Could not mmap initial snapshot pages.");
this->top_index_ = 0;
- this->capacity_ = size;
this->memory_ = memory;
this->page_counts_.resize(size);
}
size_t res = this->free_pages_[this->free_pages_.size() - 1];
this->free_pages_.pop_back();
return res;
-
}
}
{
xbt_assert(top_index_ <= this->capacity_, "top_index is not consistent");
- // First, we check if a page with the same content is already in the page
- // store:
+ // First, we check if a page with the same content is already in the page store:
// 1. compute the hash of the page;
// 2. find pages with the same hash using `hash_index_`;
// 3. find a page with the same content.
const void* snapshot_page = this->get_page(pageno);
if (memcmp(page, snapshot_page, xbt_pagesize) == 0) {
- // If a page with the same content is already in the page store it is
- // reused and its reference count is incremented.
+ // If a page with the same content is already in the page store it's reused and its refcount is incremented.
page_counts_[pageno]++;
return pageno;
}
}
- // Otherwise, a new page is allocated in the page store and the content
- // of the page is `memcpy()`-ed to this new page.
+ // Otherwise, a new page is allocated in the page store and the content of the page is `memcpy()`-ed to this new page.
std::size_t pageno = alloc_page();
xbt_assert(this->page_counts_[pageno]==0, "Allocated page is already used");
void* snapshot_page = (void*) this->get_page(pageno);
xbt_test_add("Init");
std::size_t pagesize = (size_t) getpagesize();
- std::unique_ptr<PageStore> store
- = std::unique_ptr<PageStore>(new simgrid::mc::PageStore(500));
+ std::unique_ptr<PageStore> store = std::unique_ptr<PageStore>(new simgrid::mc::PageStore(500));
void* data = getpage();
xbt_test_assert(store->size()==0, "Bad size");
}
/** @brief Save the current state */
-VisitedState::VisitedState(unsigned long state_number)
+VisitedState::VisitedState(unsigned long state_number) : num(state_number)
{
simgrid::mc::RemoteClient* process = &(mc_model_checker->process());
this->heap_bytes_used = mmalloc_get_bytes_used_remote(
this->actors_count = mc_model_checker->process().actors().size();
this->system_state = simgrid::mc::take_snapshot(state_number);
- this->num = state_number;
this->original_num = -1;
}
-VisitedState::~VisitedState()
-{
-}
-
void VisitedStates::prune()
{
while (states_.size() > (std::size_t)_sg_mc_max_visited_states) {
int original_num = 0; // num field of the VisitedState to which I was declared equal to (used for dot_output)
explicit VisitedState(unsigned long state_number);
- ~VisitedState();
+ ~VisitedState() = default;
};
class XBT_PRIVATE VisitedStates {
namespace simgrid {
namespace mc {
-VisitedPair::VisitedPair(
- int pair_num, xbt_automaton_state_t automaton_state,
- std::shared_ptr<const std::vector<int>> atomic_propositions,
- std::shared_ptr<simgrid::mc::State> graph_state)
+VisitedPair::VisitedPair(int pair_num, xbt_automaton_state_t automaton_state,
+ std::shared_ptr<const std::vector<int>> atomic_propositions,
+ std::shared_ptr<simgrid::mc::State> graph_state)
+ : num(pair_num), automaton_state(automaton_state)
{
simgrid::mc::RemoteClient* process = &(mc_model_checker->process());
this->graph_state = std::move(graph_state);
if(this->graph_state->system_state == nullptr)
this->graph_state->system_state = simgrid::mc::take_snapshot(pair_num);
- this->heap_bytes_used = mmalloc_get_bytes_used_remote(
- process->get_heap()->heaplimit,
- process->get_malloc_info());
+ this->heap_bytes_used = mmalloc_get_bytes_used_remote(process->get_heap()->heaplimit, process->get_malloc_info());
this->actors_count = mc_model_checker->process().actors().size();
- this->automaton_state = automaton_state;
- this->num = pair_num;
this->other_num = -1;
this->atomic_propositions = std::move(atomic_propositions);
}
};
struct XBT_PRIVATE VisitedPair {
- int num = 0;
+ int num;
int other_num = 0; /* Dot output for */
std::shared_ptr<simgrid::mc::State> graph_state = nullptr; /* System state included */
- xbt_automaton_state_t automaton_state = nullptr;
+ xbt_automaton_state_t automaton_state;
std::shared_ptr<const std::vector<int>> atomic_propositions;
std::size_t heap_bytes_used = 0;
int actors_count = 0;
xbt_assert(mc_model_checker == nullptr, "This should be called from the client side");
#endif
- return 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
- ;
+ return 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;
}
}
namespace simgrid {
namespace mc {
-State::State(unsigned long 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));
actorStates.resize(MC_smx_get_maxpid());
- num = state_number;
/* Stateful model checking */
if ((_sg_mc_checkpoint > 0 && (state_number % _sg_mc_checkpoint == 0)) || _sg_mc_termination) {
system_state = simgrid::mc::take_snapshot(num);
std::size_t State::interleaveSize() const
{
- return boost::range::count_if(this->actorStates,
- [](simgrid::mc::ProcessState const& p) { return p.isTodo(); });
+ return boost::range::count_if(this->actorStates, [](simgrid::mc::ProcessState const& p) { return p.isTodo(); });
}
Transition State::getTransition() const
* - which simcall can currently be executed (like a comm where the other partner is already known)
* Once we returned the last enabled transition of a process, it is marked done.
*
- * Things can get muddled with the WAITANY and TESTANY simcalls, that are rewritten
- * on the fly to a bunch of WAIT (resp TEST) transitions using the transition.argument
- * field to remember what was the last returned sub-transition.
+ * Things can get muddled with the WAITANY and TESTANY simcalls, that are rewritten on the fly to a bunch of WAIT
+ * (resp TEST) transitions using the transition.argument field to remember what was the last returned sub-transition.
*/
-static inline smx_simcall_t MC_state_get_request_for_process(
- simgrid::mc::State* state, smx_actor_t actor)
+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->pid];
smx_simcall_t req = nullptr;
switch (actor->simcall.call) {
- case SIMCALL_COMM_WAITANY:
- state->transition.argument = -1;
- while (procstate->times_considered <
- read_length(mc_model_checker->process(),
- remote(simcall_comm_waitany__get__comms(&actor->simcall)))) {
- if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall,
- procstate->times_considered++)) {
- state->transition.argument = procstate->times_considered - 1;
- break;
- }
+ case SIMCALL_COMM_WAITANY:
+ state->transition.argument = -1;
+ while (procstate->times_considered <
+ read_length(mc_model_checker->process(), remote(simcall_comm_waitany__get__comms(&actor->simcall)))) {
+ if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall, procstate->times_considered++)) {
+ state->transition.argument = procstate->times_considered - 1;
+ break;
}
-
- if (procstate->times_considered >=
- simgrid::mc::read_length(mc_model_checker->process(),
- simgrid::mc::remote(simcall_comm_waitany__get__comms(&actor->simcall))))
- procstate->setDone();
- if (state->transition.argument != -1)
- req = &actor->simcall;
- break;
-
- case SIMCALL_COMM_TESTANY: {
- unsigned start_count = procstate->times_considered;
- 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 - 1;
- break;
- }
-
- if (procstate->times_considered >=
- simcall_comm_testany__get__count(&actor->simcall))
- procstate->setDone();
-
- if (state->transition.argument != -1 || start_count == 0)
- req = &actor->simcall;
-
- break;
}
- case SIMCALL_COMM_WAIT: {
- simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> remote_act =
- remote(static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__getraw__comm(&actor->simcall)));
- simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_act;
- mc_model_checker->process().read(temp_act, remote_act);
- simgrid::kernel::activity::CommImpl* act = temp_act.getBuffer();
- if (act->src_proc && act->dst_proc)
- state->transition.argument = 0;
- else if (act->src_proc == nullptr && act->type == SIMIX_COMM_READY
- && act->detached == 1)
- state->transition.argument = 0;
- else
- state->transition.argument = -1;
+ if (procstate->times_considered >=
+ simgrid::mc::read_length(mc_model_checker->process(),
+ simgrid::mc::remote(simcall_comm_waitany__get__comms(&actor->simcall))))
procstate->setDone();
+ if (state->transition.argument != -1)
req = &actor->simcall;
- break;
- }
+ break;
+
+ case SIMCALL_COMM_TESTANY: {
+ unsigned start_count = procstate->times_considered;
+ 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 - 1;
+ break;
+ }
+
+ if (procstate->times_considered >= simcall_comm_testany__get__count(&actor->simcall))
+ procstate->setDone();
- case SIMCALL_MC_RANDOM: {
- int min_value = simcall_mc_random__get__min(&actor->simcall);
- 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 != -1 || start_count == 0)
req = &actor->simcall;
- break;
- }
- default:
- procstate->setDone();
+ break;
+ }
+
+ case SIMCALL_COMM_WAIT: {
+ simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> remote_act =
+ remote(static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_wait__getraw__comm(&actor->simcall)));
+ simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_act;
+ mc_model_checker->process().read(temp_act, remote_act);
+ simgrid::kernel::activity::CommImpl* act = temp_act.getBuffer();
+ if (act->src_proc && act->dst_proc)
state->transition.argument = 0;
- req = &actor->simcall;
- break;
+ else if (act->src_proc == nullptr && act->type == SIMIX_COMM_READY && act->detached == 1)
+ state->transition.argument = 0;
+ else
+ state->transition.argument = -1;
+ procstate->setDone();
+ 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;
+ procstate->times_considered++;
+ if (state->transition.argument == simcall_mc_random__get__max(&actor->simcall))
+ procstate->setDone();
+ req = &actor->simcall;
+ break;
+ }
+
+ default:
+ procstate->setDone();
+ state->transition.argument = 0;
+ req = &actor->simcall;
+ break;
}
if (not req)
return nullptr;
// 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. */
+ /* 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;
*/
void Mutex::unlock()
{
- smx_actor_t self = SIMIX_process_self();
- simgrid::simix::kernelImmediate([this, self] { return mutex_->unlock(self); });
+ simcall_mutex_unlock(mutex_);
}
/** @brief Acquire the mutex if it's free, and return false (without blocking) if not */
return simcall_BODY_mutex_trylock(mutex);
}
+/**
+ * \ingroup simix_synchro_management
+ *
+ */
+void simcall_mutex_unlock(smx_mutex_t mutex)
+{
+ simcall_BODY_mutex_unlock(mutex);
+}
+
/**
* \ingroup simix_synchro_management
*
simgrid::simix::marshal<int>(simcall->result, result);
}
+static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
+}
+static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
+{
+ return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
+}
+static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
+{
+ simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
+}
+
static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
size_t count);
XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
+XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
return simcall<int, smx_mutex_t>(SIMCALL_MUTEX_TRYLOCK, mutex);
}
+inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
+ /* Go to that function to follow the code flow through the simcall barrier */
+ if (0) simcall_HANDLER_mutex_unlock(&SIMIX_process_self()->simcall, mutex);
+ return simcall<void, smx_mutex_t>(SIMCALL_MUTEX_UNLOCK, mutex);
+ }
+
inline static smx_cond_t simcall_BODY_cond_init() {
/* Go to that function to follow the code flow through the simcall barrier */
if (0) SIMIX_cond_init();
SIMCALL_COMM_TESTANY,
SIMCALL_MUTEX_LOCK,
SIMCALL_MUTEX_TRYLOCK,
+ SIMCALL_MUTEX_UNLOCK,
SIMCALL_COND_INIT,
SIMCALL_COND_SIGNAL,
SIMCALL_COND_WAIT,
"SIMCALL_COMM_TESTANY",
"SIMCALL_MUTEX_LOCK",
"SIMCALL_MUTEX_TRYLOCK",
+ "SIMCALL_MUTEX_UNLOCK",
"SIMCALL_COND_INIT",
"SIMCALL_COND_SIGNAL",
"SIMCALL_COND_WAIT",
SIMIX_simcall_answer(simcall);
break;
+case SIMCALL_MUTEX_UNLOCK:
+ simcall_HANDLER_mutex_unlock(simcall, simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]));
+ SIMIX_simcall_answer(simcall);
+ break;
+
case SIMCALL_COND_INIT:
simgrid::simix::marshal<smx_cond_t>(simcall->result, SIMIX_cond_init());
SIMIX_simcall_answer(simcall);
void mutex_lock(smx_mutex_t mutex) [[block]];
int mutex_trylock(smx_mutex_t mutex);
+void mutex_unlock(smx_mutex_t mutex);
smx_cond_t cond_init() [[nohandler]];
void cond_signal(smx_cond_t cond) [[nohandler]];
std::string msg = std::string("Shutting down host, but it's not empty:");
smx_actor_t process = nullptr;
- xbt_swag_foreach(process, process_list) {
- msg = msg + "\n\t" + process->name.c_str();
- }
+ xbt_swag_foreach(process, process_list) msg = msg + "\n\t" + process->name.c_str();
+
SIMIX_display_process_status();
THROWF(arg_error, 0, "%s", msg.c_str());
}
return mutex->try_lock(simcall->issuer);
}
+void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex)
+{
+ mutex->unlock(simcall->issuer);
+}
+
/********************************* Condition **********************************/
/**
#include "xbt/synchro.h"
#include "simgrid/simix.h" /* used implementation */
-#include "src/simix/smx_synchro_private.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync, xbt, "Synchronization mechanism");
void xbt_mutex_release(xbt_mutex_t mutex)
{
- ((smx_mutex_t)mutex)->unlock(SIMIX_process_self());
+ simcall_mutex_unlock((smx_mutex_t)mutex);
}
void xbt_mutex_destroy(xbt_mutex_t mutex)
