/* 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>
#include "xbt/dict.h"
#include "simgrid/s4u/mailbox.hpp"
-#include "src/simix/SynchroComm.hpp"
+#include "src/kernel/activity/SynchroComm.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix, "SIMIX network-related synchronization");
xbt_assert(name, "Mailboxes must have a name");
/* two processes may have pushed the same mbox_create simcall at the same time */
smx_mailbox_t mbox = (smx_mailbox_t) xbt_dict_get_or_null(mailboxes, name);
-
if (!mbox) {
- mbox = new s_smx_mailbox_t();
- mbox->name = xbt_strdup(name);
- mbox->comm_queue = new std::deque<smx_synchro_t>();
- mbox->done_comm_queue = nullptr; // Allocated on need only
- mbox->permanent_receiver=nullptr;
-
+ mbox = new simgrid::simix::Mailbox(name);
XBT_DEBUG("Creating a mailbox at %p with name %s", mbox, name);
xbt_dict_set(mailboxes, mbox->name, mbox, nullptr);
}
{
XBT_DEBUG("mbox free %p", data);
smx_mailbox_t mbox = (smx_mailbox_t) data;
- xbt_free(mbox->name);
- delete mbox->comm_queue;
- delete mbox->done_comm_queue;
delete mbox;
}
*/
void SIMIX_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t process)
{
- mbox->permanent_receiver=process;
- if (mbox->done_comm_queue == nullptr)
- mbox->done_comm_queue = new std::deque<smx_synchro_t>();
+ mbox->permanent_receiver = process;
}
/**
*/
static inline void SIMIX_mbox_push(smx_mailbox_t mbox, smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
-
- mbox->comm_queue->push_back(comm);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
+ mbox->comm_queue.push_back(comm);
comm->mbox = mbox;
}
*/
void SIMIX_mbox_remove(smx_mailbox_t mbox, smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
comm->mbox = nullptr;
- for (auto it = mbox->comm_queue->begin(); it != mbox->comm_queue->end(); it++)
+ for (auto it = mbox->comm_queue.begin(); it != mbox->comm_queue.end(); it++)
if (*it == comm) {
- mbox->comm_queue->erase(it);
+ mbox->comm_queue. erase(it);
return;
}
- xbt_die("Cannot remove this comm that is not part of the mailbox");
+ xbt_die("Cannot remove the comm %p that is not part of the mailbox %s",comm, mbox->name);
}
/**
for(auto it = deque->begin(); it != deque->end(); it++){
smx_synchro_t synchro = *it;
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (comm->type == SIMIX_COMM_SEND) {
other_user_data = comm->src_data;
XBT_DEBUG("send from %p", mbox);
/* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
- simgrid::simix::Comm* this_synchro = new simgrid::simix::Comm(SIMIX_COMM_SEND);
+ simgrid::kernel::activity::Comm* this_synchro = new simgrid::kernel::activity::Comm(SIMIX_COMM_SEND);
/* Look for communication synchro matching our needs. We also provide a description of
* ourself so that the other side also gets a chance of choosing if it wants to match with us.
*
* If it is not found then push our communication into the rendez-vous point */
smx_synchro_t other_synchro =
- _find_matching_comm(mbox->comm_queue, SIMIX_COMM_RECEIVE, match_fun, data, this_synchro, /*remove_matching*/true);
- simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+ _find_matching_comm(&mbox->comm_queue, SIMIX_COMM_RECEIVE, match_fun, data, this_synchro, /*remove_matching*/true);
+ simgrid::kernel::activity::Comm *other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_synchro);
if (!other_synchro) {
other_synchro = this_synchro;
- other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+ other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_synchro);
if (mbox->permanent_receiver!=nullptr){
//this mailbox is for small messages, which have to be sent right now
other_synchro->state = SIMIX_READY;
other_comm->dst_proc=mbox->permanent_receiver.get();
other_comm->ref();
- mbox->done_comm_queue->push_back(other_synchro);
- other_comm->mbox=mbox;
+ mbox->done_comm_queue.push_back(other_synchro);
XBT_DEBUG("pushing a message into the permanent receive fifo %p, comm %p", mbox, &(other_comm));
}else{
void (*copy_data_fun)(smx_synchro_t, void*, size_t), // used to copy data if not default one
void *data, double rate)
{
- XBT_DEBUG("recv from %p %p", mbox, mbox->comm_queue);
- simgrid::simix::Comm* this_synchro = new simgrid::simix::Comm(SIMIX_COMM_RECEIVE);
+ XBT_DEBUG("recv from %p %p", mbox, &mbox->comm_queue);
+ simgrid::kernel::activity::Comm* this_synchro = new simgrid::kernel::activity::Comm(SIMIX_COMM_RECEIVE);
smx_synchro_t other_synchro;
//communication already done, get it inside the fifo of completed comms
- if (mbox->permanent_receiver && ! mbox->done_comm_queue->empty()) {
+ if (mbox->permanent_receiver != nullptr && ! mbox->done_comm_queue.empty()) {
XBT_DEBUG("We have a comm that has probably already been received, trying to match it, to skip the communication");
//find a match in the already received fifo
- other_synchro = _find_matching_comm(mbox->done_comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,/*remove_matching*/true);
+ other_synchro = _find_matching_comm(&mbox->done_comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,/*remove_matching*/true);
//if not found, assume the receiver came first, register it to the mailbox in the classical way
if (!other_synchro) {
XBT_DEBUG("We have messages in the permanent receive list, but not the one we are looking for, pushing request into fifo");
other_synchro = this_synchro;
SIMIX_mbox_push(mbox, this_synchro);
} else {
- simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+ simgrid::kernel::activity::Comm *other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_synchro);
if(other_comm->surf_comm && other_comm->remains()==0.0) {
XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",other_comm);
other_comm->mbox = nullptr;
}
other_comm->unref();
- static_cast<simgrid::simix::Comm*>(this_synchro)->unref();
+ static_cast<simgrid::kernel::activity::Comm*>(this_synchro)->unref();
}
} else {
/* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
* ourself so that the other side also gets a chance of choosing if it wants to match with us.
*
* If it is not found then push our communication into the rendez-vous point */
- other_synchro = _find_matching_comm(mbox->comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,/*remove_matching*/true);
+ other_synchro = _find_matching_comm(&mbox->comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,/*remove_matching*/true);
if (!other_synchro) {
- XBT_DEBUG("Receive pushed first %zu", mbox->comm_queue->size());
+ XBT_DEBUG("Receive pushed first %zu", mbox->comm_queue.size());
other_synchro = this_synchro;
SIMIX_mbox_push(mbox, this_synchro);
} else {
this_synchro->unref();
- simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+ simgrid::kernel::activity::Comm *other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_synchro);
other_comm->state = SIMIX_READY;
other_comm->type = SIMIX_COMM_READY;
}
/* Setup communication synchro */
- simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+ simgrid::kernel::activity::Comm *other_comm = static_cast<simgrid::kernel::activity::Comm*>(other_synchro);
other_comm->dst_proc = dst_proc;
other_comm->dst_buff = dst_buff;
other_comm->dst_buff_size = dst_buff_size;
smx_synchro_t SIMIX_comm_iprobe(smx_process_t dst_proc, smx_mailbox_t mbox, int type, int src,
int tag, int (*match_fun)(void *, void *, smx_synchro_t), void *data)
{
- XBT_DEBUG("iprobe from %p %p", mbox, mbox->comm_queue);
- simgrid::simix::Comm* this_comm;
+ XBT_DEBUG("iprobe from %p %p", mbox, &mbox->comm_queue);
+ simgrid::kernel::activity::Comm* this_comm;
int smx_type;
if(type == 1){
- this_comm = new simgrid::simix::Comm(SIMIX_COMM_SEND);
+ this_comm = new simgrid::kernel::activity::Comm(SIMIX_COMM_SEND);
smx_type = SIMIX_COMM_RECEIVE;
} else{
- this_comm = new simgrid::simix::Comm(SIMIX_COMM_RECEIVE);
+ this_comm = new simgrid::kernel::activity::Comm(SIMIX_COMM_RECEIVE);
smx_type = SIMIX_COMM_SEND;
}
smx_synchro_t other_synchro=nullptr;
- if(mbox->permanent_receiver && ! mbox->done_comm_queue->empty()){
+ if (mbox->permanent_receiver != nullptr && !mbox->done_comm_queue.empty()) {
XBT_DEBUG("first check in the permanent recv mailbox, to see if we already got something");
- other_synchro =
- _find_matching_comm(mbox->done_comm_queue, (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
+ other_synchro = _find_matching_comm(&mbox->done_comm_queue,
+ (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
}
if (!other_synchro){
XBT_DEBUG("check if we have more luck in the normal mailbox");
- other_synchro = _find_matching_comm(mbox->comm_queue, (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
+ other_synchro = _find_matching_comm(&mbox->comm_queue,
+ (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
}
if(other_synchro)
if (timeout == -1)
THROW_IMPOSSIBLE;
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (comm->src_proc == simcall->issuer)
comm->state = SIMIX_SRC_TIMEOUT;
else
surf_action_t sleep = surf_host_sleep(simcall->issuer->host, timeout);
sleep->setData(synchro);
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (simcall->issuer == comm->src_proc)
comm->src_timeout = sleep;
else
void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (MC_is_active() || MC_record_replay_is_active()){
simcall_comm_test__set__result(simcall, comm->src_proc && comm->dst_proc);
}
}
-void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t synchros)
+void simcall_HANDLER_comm_testany(
+ smx_simcall_t simcall, simgrid::kernel::activity::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::kernel::activity::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::kernel::activity::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;
SIMIX_simcall_answer(simcall);
}
-void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros)
+void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, double timeout)
{
smx_synchro_t synchro;
unsigned int cursor = 0;
if (MC_is_active() || MC_record_replay_is_active()){
+ if (timeout != -1)
+ xbt_die("Timeout not implemented for waitany in the model-checker");
int idx = SIMCALL_GET_MC_VALUE(simcall);
synchro = xbt_dynar_get_as(synchros, idx, smx_synchro_t);
synchro->simcalls.push_back(simcall);
SIMIX_comm_finish(synchro);
return;
}
-
+
+ if (timeout == -1 ){
+ simcall->timer = NULL;
+ } else {
+ simcall->timer = SIMIX_timer_set(timeout, [simcall]() {
+ SIMIX_waitany_remove_simcall_from_actions(simcall);
+ simcall_comm_waitany__set__result(simcall, -1);
+ SIMIX_simcall_answer(simcall);
+ });
+ }
+
xbt_dynar_foreach(synchros, cursor, synchro){
/* associate this simcall to the the synchro */
synchro->simcalls.push_back(simcall);
*/
static inline void SIMIX_comm_start(smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
/* If both the sender and the receiver are already there, start the communication */
if (synchro->state == SIMIX_READY) {
*/
void SIMIX_comm_finish(smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
unsigned int destroy_count = 0;
while (!synchro->simcalls.empty()) {
continue; // if process handling comm is killed
if (simcall->call == SIMCALL_COMM_WAITANY) {
SIMIX_waitany_remove_simcall_from_actions(simcall);
+ if (simcall->timer) {
+ SIMIX_timer_remove(simcall->timer);
+ simcall->timer = nullptr;
+ }
if (!MC_is_active() && !MC_record_replay_is_active())
simcall_comm_waitany__set__result(simcall, xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro));
}
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);
}
}
while (destroy_count-- > 0)
- static_cast<simgrid::simix::Comm*>(synchro)->unref();
+ static_cast<simgrid::kernel::activity::Comm*>(synchro)->unref();
}
/******************************************************************************/
void SIMIX_comm_copy_pointer_callback(smx_synchro_t synchro, void* buff, size_t buff_size)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
xbt_assert((buff_size == sizeof(void *)), "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
*(void **) (comm->dst_buff) = buff;
void SIMIX_comm_copy_buffer_callback(smx_synchro_t synchro, void* buff, size_t buff_size)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
XBT_DEBUG("Copy the data over");
memcpy(comm->dst_buff, buff, buff_size);
*/
void SIMIX_comm_copy_data(smx_synchro_t synchro)
{
- simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+ simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
size_t buff_size = comm->src_buff_size;
/* If there is no data to copy then return */
