XBT_PUBLIC(unsigned int) simcall_comm_waitany(xbt_dynar_t comms);
XBT_PUBLIC(void) simcall_comm_wait(smx_synchro_t comm, double timeout);
XBT_PUBLIC(int) simcall_comm_test(smx_synchro_t comm);
-XBT_PUBLIC(int) simcall_comm_testany(xbt_dynar_t comms);
+XBT_PUBLIC(int) simcall_comm_testany(smx_synchro_t* comms, size_t count);
/************************** Tracing handling **********************************/
XBT_PUBLIC(void) simcall_set_category(smx_synchro_t synchro, const char *category);
type = "TestAny";
args =
bprintf("(%d of %zu)", value + 1,
- read_length(mc_model_checker->process(),
- simcall_comm_testany__get__comms(req)));
+ simcall_comm_testany__get__count(req));
}
break;
}
break;
- case SIMCALL_COMM_TESTANY: {
- read_element(
- mc_model_checker->process(), &remote_act,
- remote(simcall_comm_testany__get__comms(req)),
- idx, sizeof(remote_act));
- }
+ case SIMCALL_COMM_TESTANY:
+ remote_act = mc_model_checker->process().read(remote(
+ simcall_comm_testany__get__comms(req) + idx));
break;
default:
label = simgrid::xbt::string_printf("[(%lu)%s] TestAny TRUE [%d of %lu]",
issuer->pid,
MC_smx_process_get_host_name(issuer), value + 1,
- xbt_dynar_length(simcall_comm_testany__get__comms(req)));
+ simcall_comm_testany__get__count(req));
else
label = simgrid::xbt::string_printf("[(%lu)] TestAny TRUE [%d of %lu]",
issuer->pid,
value + 1,
- xbt_dynar_length(simcall_comm_testany__get__comms(req)));
+ simcall_comm_testany__get__count(req));
}
break;
unsigned start_count = procstate->interleave_count;
state->transition.argument = -1;
while (procstate->interleave_count <
- read_length(mc_model_checker->process(),
- remote(simcall_comm_testany__get__comms(&process->simcall))))
+ simcall_comm_testany__get__count(&process->simcall))
if (simgrid::mc::request_is_enabled_by_idx(&process->simcall,
procstate->interleave_count++)) {
state->transition.argument = procstate->interleave_count - 1;
}
if (procstate->interleave_count >=
- read_length(mc_model_checker->process(),
- remote(simcall_comm_testany__get__comms(&process->simcall))))
+ simcall_comm_testany__get__count(&process->simcall))
procstate->setDone();
if (state->transition.argument != -1 || start_count == 0)
state->internal_req.issuer = req->issuer;
if (state->transition.argument > 0) {
- smx_synchro_t remote_comm;
- read_element(mc_model_checker->process(),
- &remote_comm, remote(simcall_comm_testany__get__comms(req)),
- state->transition.argument, sizeof(remote_comm));
+ smx_synchro_t 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(
static_cast<simgrid::simix::Comm*>(remote_comm)));
}
{
int finished_index = -1;
- /* create the equivalent dynar with SIMIX objects */
- xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), nullptr);
+ /* Create the equivalent array with SIMIX objects: */
+ std::vector<simgrid::simix::Synchro*> s_comms;
+ s_comms.reserve(xbt_dynar_length(comms));
msg_comm_t comm;
unsigned int cursor;
xbt_dynar_foreach(comms, cursor, comm) {
- xbt_dynar_push(s_comms, &comm->s_comm);
+ s_comms.push_back(comm->s_comm);
}
msg_error_t status = MSG_OK;
try {
- finished_index = simcall_comm_testany(s_comms);
+ finished_index = simcall_comm_testany(s_comms.data(), s_comms.size());
}
catch (xbt_ex& e) {
switch (e.category) {
throw;
}
}
- xbt_dynar_free(&s_comms);
if (finished_index != -1) {
comm = xbt_dynar_get_as(comms, finished_index, msg_comm_t);
/**
* \ingroup simix_comm_management
*/
-int simcall_comm_testany(xbt_dynar_t comms)
+int simcall_comm_testany(smx_synchro_t* comms, size_t count)
{
- if (xbt_dynar_is_empty(comms))
+ if (count == 0)
return -1;
- return simcall_BODY_comm_testany(comms);
+ return simcall_BODY_comm_testany(comms, count);
}
/**
simgrid::simix::marshal<int>(simcall->result, result);
}
-static inline xbt_dynar_t simcall_comm_testany__get__comms(smx_simcall_t simcall) {
- return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
+static inline smx_synchro_t* simcall_comm_testany__get__comms(smx_simcall_t simcall) {
+ return simgrid::simix::unmarshal<smx_synchro_t*>(simcall->args[0]);
}
-static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg) {
- simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
+static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, smx_synchro_t* arg) {
+ simgrid::simix::marshal<smx_synchro_t*>(simcall->args[0], arg);
+}
+static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall) {
+ return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
+}
+static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg) {
+ simgrid::simix::marshal<size_t>(simcall->args[1], arg);
}
static inline int simcall_comm_testany__get__result(smx_simcall_t simcall){
return simgrid::simix::unmarshal<int>(simcall->result);
XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms);
XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t comm, double timeout);
XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t comm);
-XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t comms);
+XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, smx_synchro_t* comms, size_t count);
XBT_PRIVATE smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
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);
return simcall<int, smx_synchro_t>(SIMCALL_COMM_TEST, comm);
}
-inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
+inline static int simcall_BODY_comm_testany(smx_synchro_t* comms, size_t count) {
/* Go to that function to follow the code flow through the simcall barrier */
- if (0) simcall_HANDLER_comm_testany(&SIMIX_process_self()->simcall, comms);
- return simcall<int, xbt_dynar_t>(SIMCALL_COMM_TESTANY, comms);
+ if (0) simcall_HANDLER_comm_testany(&SIMIX_process_self()->simcall, comms, count);
+ return simcall<int, smx_synchro_t*, size_t>(SIMCALL_COMM_TESTANY, comms, count);
}
inline static smx_mutex_t simcall_BODY_mutex_init() {
break;
case SIMCALL_COMM_TESTANY:
- simcall_HANDLER_comm_testany(simcall, simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]));
+ simcall_HANDLER_comm_testany(simcall, simgrid::simix::unmarshal<smx_synchro_t*>(simcall->args[0]), simgrid::simix::unmarshal<size_t>(simcall->args[1]));
break;
case SIMCALL_MUTEX_INIT:
int comm_waitany(xbt_dynar_t comms) [[block]];
void comm_wait(smx_synchro_t comm, double timeout) [[block]];
int comm_test(smx_synchro_t comm) [[block]];
-int comm_testany(xbt_dynar_t comms) [[block]];
+int comm_testany(smx_synchro_t* comms, size_t count) [[block]];
smx_mutex_t mutex_init();
void mutex_lock(smx_mutex_t mutex) [[block]];
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include <algorithm>
+
#include <boost/range/algorithm.hpp>
#include <xbt/ex.hpp>
}
}
-void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t synchros)
+void simcall_HANDLER_comm_testany(
+ smx_simcall_t simcall, simgrid::simix::Synchro* comms[], size_t count)
{
- unsigned int cursor;
- smx_synchro_t synchro;
// The default result is -1 -- this means, "nothing is ready".
// It can be changed below, but only if something matches.
simcall_comm_testany__set__result(simcall, -1);
if(idx == -1){
SIMIX_simcall_answer(simcall);
}else{
- synchro = xbt_dynar_get_as(synchros, idx, smx_synchro_t);
+ simgrid::simix::Synchro* synchro = comms[idx];
simcall_comm_testany__set__result(simcall, idx);
synchro->simcalls.push_back(simcall);
synchro->state = SIMIX_DONE;
return;
}
- xbt_dynar_foreach(simcall_comm_testany__get__comms(simcall), cursor,synchro) {
+ for (std::size_t i = 0; i != count; ++i) {
+ simgrid::simix::Synchro* synchro = comms[i];
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
- simcall_comm_testany__set__result(simcall, cursor);
+ simcall_comm_testany__set__result(simcall, i);
synchro->simcalls.push_back(simcall);
SIMIX_comm_finish(synchro);
return;
e.value = xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro);
}
else if (simcall->call == SIMCALL_COMM_TESTANY) {
- e.value = xbt_dynar_search(simcall_comm_testany__get__comms(simcall), &synchro);
+ e.value = -1;
+ auto comms = simcall_comm_testany__get__comms(simcall);
+ auto count = simcall_comm_testany__get__count(simcall);
+ auto element = std::find(comms, comms + count, synchro);
+ if (element == comms + count)
+ e.value = -1;
+ else
+ e.value = element - comms;
}
simcall->issuer->exception = std::make_exception_ptr(e);
}
int smpi_mpi_testany(int count, MPI_Request requests[], int *index, MPI_Status * status)
{
- xbt_dynar_t comms;
+ std::vector<simgrid::simix::Synchro*> comms;
+ comms.reserve(count);
+
int i;
int flag = 0;
*index = MPI_UNDEFINED;
- comms = xbt_dynar_new(sizeof(smx_synchro_t), nullptr);
+
std::vector<int> map; /** Maps all matching comms back to their location in requests **/
for(i = 0; i < count; i++) {
if ((requests[i] != MPI_REQUEST_NULL) && requests[i]->action && !(requests[i]->flags & PREPARED)) {
- xbt_dynar_push(comms, &requests[i]->action);
+ comms.push_back(requests[i]->action);
map.push_back(i);
}
}
if(smpi_test_sleep > 0)
simcall_process_sleep(nsleeps*smpi_test_sleep);
- i = simcall_comm_testany(comms); // The i-th element in comms matches!
+ i = simcall_comm_testany(comms.data(), comms.size()); // The i-th element in comms matches!
if (i != -1) { // -1 is not MPI_UNDEFINED but a SIMIX return code. (nothing matches)
*index = map[i];
finish_wait(&requests[*index], status);
flag = 1;
smpi_empty_status(status);
}
- xbt_dynar_free(&comms);
return flag;
}