X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d2cd6190c7a6ba8f102134cf6ab3043f7df8f77e..7076d70e9205a598bb96f6afca16d5d0456aeeb1:/src/simix/smx_network.cpp

diff --git a/src/simix/smx_network.cpp b/src/simix/smx_network.cpp
index 977fe430bd..ff2dd372bc 100644
--- a/src/simix/smx_network.cpp
+++ b/src/simix/smx_network.cpp
@@ -1,5 +1,4 @@
-/* Copyright (c) 2009-2015. The SimGrid Team.
- * All rights reserved.                                                     */
+/* Copyright (c) 2009-2016. The SimGrid Team.  All rights reserved.         */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -10,30 +9,23 @@
 #include "mc/mc.h"
 #include "src/mc/mc_replay.h"
 #include "xbt/dict.h"
+#include "simgrid/s4u/mailbox.hpp"
+
+#include "src/simix/SynchroComm.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix, "SIMIX network-related synchronization");
 
-static xbt_dict_t mailboxes = NULL;
+static void SIMIX_mbox_free(void *data);
+static xbt_dict_t mailboxes = xbt_dict_new_homogeneous(SIMIX_mbox_free);
 
 static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall);
 static void SIMIX_comm_copy_data(smx_synchro_t comm);
-static smx_synchro_t SIMIX_comm_new(e_smx_comm_type_t type);
 static inline void SIMIX_mbox_push(smx_mailbox_t mbox, smx_synchro_t comm);
-static smx_synchro_t SIMIX_fifo_probe_comm(xbt_fifo_t fifo, e_smx_comm_type_t type,
-                                        int (*match_fun)(void *, void *,smx_synchro_t),
-                                        void *user_data, smx_synchro_t my_synchro);
-static smx_synchro_t SIMIX_fifo_get_comm(xbt_fifo_t fifo, e_smx_comm_type_t type,
-                                        int (*match_fun)(void *, void *,smx_synchro_t),
-                                        void *user_data, smx_synchro_t my_synchro);
-static void SIMIX_mbox_free(void *data);
+static smx_synchro_t _find_matching_comm(std::deque<smx_synchro_t> *deque, e_smx_comm_type_t type,
+    int (*match_fun)(void *, void *,smx_synchro_t), void *user_data, smx_synchro_t my_synchro, bool remove_matching);
 static void SIMIX_comm_start(smx_synchro_t synchro);
 
-void SIMIX_network_init(void)
-{
-  mailboxes = xbt_dict_new_homogeneous(SIMIX_mbox_free);
-}
-
-void SIMIX_network_exit(void)
+void SIMIX_mailbox_exit(void)
 {
   xbt_dict_free(&mailboxes);
 }
@@ -44,37 +36,30 @@ void SIMIX_network_exit(void)
 
 smx_mailbox_t SIMIX_mbox_create(const char *name)
 {
+  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 = name ? (smx_mailbox_t) xbt_dict_get_or_null(mailboxes, name) : NULL;
+  smx_mailbox_t mbox = (smx_mailbox_t) xbt_dict_get_or_null(mailboxes, name);
 
   if (!mbox) {
     mbox = xbt_new0(s_smx_mailbox_t, 1);
-    mbox->name = name ? xbt_strdup(name) : NULL;
-    mbox->comm_fifo = xbt_fifo_new();
-    mbox->done_comm_fifo = xbt_fifo_new();
+    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=NULL;
 
     XBT_DEBUG("Creating a mailbox at %p with name %s", mbox, name);
-
-    if (mbox->name)
-      xbt_dict_set(mailboxes, mbox->name, mbox, NULL);
+    xbt_dict_set(mailboxes, mbox->name, mbox, NULL);
   }
   return mbox;
 }
 
-void SIMIX_mbox_destroy(smx_mailbox_t mbox)
-{
-  if (mbox->name)
-    xbt_dict_remove(mailboxes, mbox->name);
-}
-
 void SIMIX_mbox_free(void *data)
 {
   XBT_DEBUG("mbox free %p", data);
   smx_mailbox_t mbox = (smx_mailbox_t) data;
   xbt_free(mbox->name);
-  xbt_fifo_free(mbox->comm_fifo);
-  xbt_fifo_free(mbox->done_comm_fifo);
+  delete mbox->comm_queue;
+  delete mbox->done_comm_queue;
 
   xbt_free(mbox);
 }
@@ -84,24 +69,9 @@ smx_mailbox_t SIMIX_mbox_get_by_name(const char *name)
   return (smx_mailbox_t) xbt_dict_get_or_null(mailboxes, name);
 }
 
-int SIMIX_mbox_comm_count_by_host(smx_mailbox_t mbox, sg_host_t host)
-{
-  smx_synchro_t comm = NULL;
-  xbt_fifo_item_t item = NULL;
-  int count = 0;
-
-  xbt_fifo_foreach(mbox->comm_fifo, item, comm, smx_synchro_t) {
-    if (comm->comm.src_proc->host == host)
-      count++;
-  }
-
-  return count;
-}
-
 smx_synchro_t SIMIX_mbox_get_head(smx_mailbox_t mbox)
 {
-  return (smx_synchro_t) xbt_fifo_get_item_content(
-    xbt_fifo_get_first_item(mbox->comm_fifo));
+  return mbox->comm_queue->empty()? nullptr:mbox->comm_queue->front();
 }
 
 /**
@@ -122,6 +92,8 @@ smx_process_t SIMIX_mbox_get_receiver(smx_mailbox_t 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>();
 }
 
 /**
@@ -129,10 +101,12 @@ void SIMIX_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t process)
  *  \param mbox The mailbox
  *  \param comm The communication synchro
  */
-static inline void SIMIX_mbox_push(smx_mailbox_t mbox, smx_synchro_t comm)
+static inline void SIMIX_mbox_push(smx_mailbox_t mbox, smx_synchro_t synchro)
 {
-  xbt_fifo_push(mbox->comm_fifo, comm);
-  comm->comm.mbox = mbox;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  mbox->comm_queue->push_back(comm);
+  comm->mbox = mbox;
 }
 
 /**
@@ -140,172 +114,115 @@ static inline void SIMIX_mbox_push(smx_mailbox_t mbox, smx_synchro_t comm)
  *  \param mbox The rendez-vous point
  *  \param comm The communication synchro
  */
-void SIMIX_mbox_remove(smx_mailbox_t mbox, smx_synchro_t comm)
+void SIMIX_mbox_remove(smx_mailbox_t mbox, smx_synchro_t synchro)
 {
-  xbt_fifo_remove(mbox->comm_fifo, comm);
-  comm->comm.mbox = NULL;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  comm->mbox = NULL;
+  for (auto it = mbox->comm_queue->begin(); it != mbox->comm_queue->end(); it++)
+    if (*it == comm) {
+      mbox->comm_queue->erase(it);
+      return;
+    }
+  xbt_die("Cannot remove this comm that is not part of the mailbox");
 }
 
 /**
- *  \brief Checks if there is a communication synchro queued in a fifo matching our needs
+ *  \brief Checks if there is a communication synchro queued in a deque matching our needs
  *  \param type The type of communication we are looking for (comm_send, comm_recv)
  *  \return The communication synchro if found, NULL otherwise
  */
-smx_synchro_t SIMIX_fifo_get_comm(xbt_fifo_t fifo, e_smx_comm_type_t type,
-                                 int (*match_fun)(void *, void *,smx_synchro_t),
-                                 void *this_user_data, smx_synchro_t my_synchro)
+static smx_synchro_t _find_matching_comm(std::deque<smx_synchro_t> *deque, e_smx_comm_type_t type,
+    int (*match_fun)(void *, void *,smx_synchro_t), void *this_user_data, smx_synchro_t my_synchro, bool remove_matching)
 {
-  smx_synchro_t synchro;
-  xbt_fifo_item_t item;
   void* other_user_data = NULL;
 
-  xbt_fifo_foreach(fifo, item, synchro, smx_synchro_t) {
-    if (synchro->comm.type == SIMIX_COMM_SEND) {
-      other_user_data = synchro->comm.src_data;
-    } else if (synchro->comm.type == SIMIX_COMM_RECEIVE) {
-      other_user_data = synchro->comm.dst_data;
+  for(auto it = deque->begin(); it != deque->end(); it++){
+    smx_synchro_t synchro = *it;
+    simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+    if (comm->type == SIMIX_COMM_SEND) {
+      other_user_data = comm->src_data;
+    } else if (comm->type == SIMIX_COMM_RECEIVE) {
+      other_user_data = comm->dst_data;
     }
-    if (synchro->comm.type == type &&
-        (!match_fun              ||              match_fun(this_user_data,  other_user_data, synchro)) &&
-        (!synchro->comm.match_fun || synchro->comm.match_fun(other_user_data, this_user_data,  my_synchro))) {
-      XBT_DEBUG("Found a matching communication synchro %p", synchro);
-      xbt_fifo_remove_item(fifo, item);
-      xbt_fifo_free_item(item);
-      synchro->comm.refcount++;
+    if (comm->type == type &&
+        (!      match_fun ||       match_fun(this_user_data,  other_user_data, synchro)) &&
+        (!comm->match_fun || comm->match_fun(other_user_data, this_user_data,  my_synchro))) {
+      XBT_DEBUG("Found a matching communication synchro %p", comm);
+      if (remove_matching)
+        deque->erase(it);
+      comm->refcount++;
 #if HAVE_MC
-      synchro->comm.mbox_cpy = synchro->comm.mbox;
+      comm->mbox_cpy = comm->mbox;
 #endif
-      synchro->comm.mbox = NULL;
-      return synchro;
+      comm->mbox = NULL;
+      return comm;
     }
     XBT_DEBUG("Sorry, communication synchro %p does not match our needs:"
               " its type is %d but we are looking for a comm of type %d (or maybe the filtering didn't match)",
-              synchro, (int)synchro->comm.type, (int)type);
+              comm, (int)comm->type, (int)type);
   }
   XBT_DEBUG("No matching communication synchro found");
   return NULL;
 }
 
-
-/**
- *  \brief Checks if there is a communication synchro queued in a fifo matching our needs, but leave it there
- *  \param type The type of communication we are looking for (comm_send, comm_recv)
- *  \return The communication synchro if found, NULL otherwise
- */
-smx_synchro_t SIMIX_fifo_probe_comm(xbt_fifo_t fifo, e_smx_comm_type_t type,
-                                 int (*match_fun)(void *, void *,smx_synchro_t),
-                                 void *this_user_data, smx_synchro_t my_synchro)
-{
-  smx_synchro_t synchro;
-  xbt_fifo_item_t item;
-  void* other_user_data = NULL;
-
-  xbt_fifo_foreach(fifo, item, synchro, smx_synchro_t) {
-    if (synchro->comm.type == SIMIX_COMM_SEND) {
-      other_user_data = synchro->comm.src_data;
-    } else if (synchro->comm.type == SIMIX_COMM_RECEIVE) {
-      other_user_data = synchro->comm.dst_data;
-    }
-    if (synchro->comm.type == type &&
-        (!match_fun              ||              match_fun(this_user_data,  other_user_data, synchro)) &&
-        (!synchro->comm.match_fun || synchro->comm.match_fun(other_user_data, this_user_data,  my_synchro))) {
-      XBT_DEBUG("Found a matching communication synchro %p", synchro);
-      synchro->comm.refcount++;
-
-      return synchro;
-    }
-    XBT_DEBUG("Sorry, communication synchro %p does not match our needs:"
-              " its type is %d but we are looking for a comm of type %d (or maybe the filtering didn't match)",
-              synchro, (int)synchro->comm.type, (int)type);
-  }
-  XBT_DEBUG("No matching communication synchro found");
-  return NULL;
-}
 /******************************************************************************/
 /*                          Communication synchros                            */
 /******************************************************************************/
 
-/**
- *  \brief Creates a new communicate synchro
- *  \param type The direction of communication (comm_send, comm_recv)
- *  \return The new communicate synchro
- */
-smx_synchro_t SIMIX_comm_new(e_smx_comm_type_t type)
-{
-  smx_synchro_t synchro;
-
-  /* alloc structures */
-  synchro = (smx_synchro_t) xbt_mallocator_get(simix_global->synchro_mallocator);
-
-  synchro->type = SIMIX_SYNC_COMMUNICATE;
-  synchro->state = SIMIX_WAITING;
-
-  /* set communication */
-  synchro->comm.type = type;
-  synchro->comm.refcount = 1;
-  synchro->comm.src_data=NULL;
-  synchro->comm.dst_data=NULL;
-
-  synchro->category = NULL;
-
-  XBT_DEBUG("Create communicate synchro %p", synchro);
-
-  return synchro;
-}
-
 /**
  *  \brief Destroy a communicate synchro
  *  \param synchro The communicate synchro to be destroyed
  */
 void SIMIX_comm_destroy(smx_synchro_t synchro)
 {
-  XBT_DEBUG("Destroy synchro %p (refcount: %d), state: %d",
-            synchro, synchro->comm.refcount, (int)synchro->state);
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  XBT_DEBUG("Destroy synchro %p (refcount: %d), state: %d", comm, comm->refcount, (int)comm->state);
 
-  if (synchro->comm.refcount <= 0) {
+  if (comm->refcount <= 0) {
     xbt_backtrace_display_current();
-    xbt_die("The refcount of comm %p is already 0 before decreasing it. "
-            "That's a bug! If you didn't test and/or wait the same communication twice in your code, then the bug is SimGrid's...", synchro);
+    xbt_die("This comm has a negative refcount! You must not call test() or wait() more than once on a given communication.");
   }
-  synchro->comm.refcount--;
-  if (synchro->comm.refcount > 0)
+  comm->refcount--;
+  if (comm->refcount > 0)
       return;
-  XBT_DEBUG("Really free communication %p; refcount is now %d", synchro,
-      synchro->comm.refcount);
+  XBT_DEBUG("Really free communication %p; refcount is now %d", comm, comm->refcount);
 
-  xbt_free(synchro->name);
   SIMIX_comm_destroy_internal_actions(synchro);
 
-  if (synchro->comm.detached && synchro->state != SIMIX_DONE) {
+  if (comm->detached && comm->state != SIMIX_DONE) {
     /* the communication has failed and was detached:
      * we have to free the buffer */
-    if (synchro->comm.clean_fun) {
-      synchro->comm.clean_fun(synchro->comm.src_buff);
+    if (comm->clean_fun) {
+      comm->clean_fun(comm->src_buff);
     }
-    synchro->comm.src_buff = NULL;
+    comm->src_buff = NULL;
   }
 
-  if(synchro->comm.mbox)
-    SIMIX_mbox_remove(synchro->comm.mbox, synchro);
+  if(comm->mbox)
+    SIMIX_mbox_remove(comm->mbox, comm);
 
-  xbt_mallocator_release(simix_global->synchro_mallocator, synchro);
+  delete comm;
 }
 
 void SIMIX_comm_destroy_internal_actions(smx_synchro_t synchro)
 {
-  if (synchro->comm.surf_comm){
-    synchro->comm.surf_comm->unref();
-    synchro->comm.surf_comm = NULL;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+  if (comm->surf_comm){
+    comm->surf_comm->unref();
+    comm->surf_comm = NULL;
   }
 
-  if (synchro->comm.src_timeout){
-    synchro->comm.src_timeout->unref();
-    synchro->comm.src_timeout = NULL;
+  if (comm->src_timeout){
+    comm->src_timeout->unref();
+    comm->src_timeout = NULL;
   }
 
-  if (synchro->comm.dst_timeout){
-    synchro->comm.dst_timeout->unref();
-    synchro->comm.dst_timeout = NULL;
+  if (comm->dst_timeout){
+    comm->dst_timeout->unref();
+    comm->dst_timeout = NULL;
   }
 }
 
@@ -332,25 +249,29 @@ smx_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_process_t sr
   XBT_DEBUG("send from %p", mbox);
 
   /* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
-  smx_synchro_t this_synchro = SIMIX_comm_new(SIMIX_COMM_SEND);
+  smx_synchro_t this_synchro = new simgrid::simix::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 = SIMIX_fifo_get_comm(mbox->comm_fifo, SIMIX_COMM_RECEIVE, match_fun, data, this_synchro);
+  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);
+
 
   if (!other_synchro) {
     other_synchro = this_synchro;
+    other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
 
     if (mbox->permanent_receiver!=NULL){
       //this mailbox is for small messages, which have to be sent right now
       other_synchro->state = SIMIX_READY;
-      other_synchro->comm.dst_proc=mbox->permanent_receiver;
-      other_synchro->comm.refcount++;
-      xbt_fifo_push(mbox->done_comm_fifo,other_synchro);
-      other_synchro->comm.mbox=mbox;
-      XBT_DEBUG("pushing a message into the permanent receive fifo %p, comm %p", mbox, &(other_synchro->comm));
+      other_comm->dst_proc=mbox->permanent_receiver;
+      other_comm->refcount++;
+      mbox->done_comm_queue->push_back(other_synchro);
+      other_comm->mbox=mbox;
+      XBT_DEBUG("pushing a message into the permanent receive fifo %p, comm %p", mbox, &(other_comm));
 
     }else{
       SIMIX_mbox_push(mbox, this_synchro);
@@ -360,8 +281,8 @@ smx_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_process_t sr
 
     SIMIX_comm_destroy(this_synchro);
 
-    other_synchro->state = SIMIX_READY;
-    other_synchro->comm.type = SIMIX_COMM_READY;
+    other_comm->state = SIMIX_READY;
+    other_comm->type = SIMIX_COMM_READY;
 
   }
   xbt_fifo_push(src_proc->comms, other_synchro);
@@ -369,32 +290,32 @@ smx_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_process_t sr
   /* if the communication synchro is detached then decrease the refcount
    * by one, so it will be eliminated by the receiver's destroy call */
   if (detached) {
-    other_synchro->comm.detached = 1;
-    other_synchro->comm.refcount--;
-    other_synchro->comm.clean_fun = clean_fun;
+    other_comm->detached = 1;
+    other_comm->refcount--;
+    other_comm->clean_fun = clean_fun;
   } else {
-    other_synchro->comm.clean_fun = NULL;
+    other_comm->clean_fun = NULL;
   }
 
   /* Setup the communication synchro */
-  other_synchro->comm.src_proc = src_proc;
-  other_synchro->comm.task_size = task_size;
-  other_synchro->comm.rate = rate;
-  other_synchro->comm.src_buff = src_buff;
-  other_synchro->comm.src_buff_size = src_buff_size;
-  other_synchro->comm.src_data = data;
+  other_comm->src_proc = src_proc;
+  other_comm->task_size = task_size;
+  other_comm->rate = rate;
+  other_comm->src_buff = src_buff;
+  other_comm->src_buff_size = src_buff_size;
+  other_comm->src_data = data;
 
-  other_synchro->comm.match_fun = match_fun;
-  other_synchro->comm.copy_data_fun = copy_data_fun;
+  other_comm->match_fun = match_fun;
+  other_comm->copy_data_fun = copy_data_fun;
 
 
   if (MC_is_active() || MC_record_replay_is_active()) {
-    other_synchro->state = SIMIX_RUNNING;
-    return (detached ? NULL : other_synchro);
+    other_comm->state = SIMIX_RUNNING;
+    return (detached ? NULL : other_comm);
   }
 
-  SIMIX_comm_start(other_synchro);
-  return (detached ? NULL : other_synchro);
+  SIMIX_comm_start(other_comm);
+  return (detached ? NULL : other_comm);
 }
 
 void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_process_t receiver, smx_mailbox_t mbox,
@@ -403,8 +324,7 @@ void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_process_t receiver, sm
                          void (*copy_data_fun)(smx_synchro_t, void*, size_t),
                          void *data, double timeout, double rate)
 {
-  smx_synchro_t comm = SIMIX_comm_irecv(receiver, mbox, dst_buff,
-                           dst_buff_size, match_fun, copy_data_fun, data, rate);
+  smx_synchro_t comm = SIMIX_comm_irecv(receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
   SIMCALL_SET_MC_VALUE(simcall, 0);
   simcall_HANDLER_comm_wait(simcall, comm, timeout);
 }
@@ -423,29 +343,31 @@ smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_mailbox_t mbox, void
     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_fifo);
-  smx_synchro_t this_synchro = SIMIX_comm_new(SIMIX_COMM_RECEIVE);
+  XBT_DEBUG("recv from %p %p", mbox, mbox->comm_queue);
+  smx_synchro_t this_synchro = new simgrid::simix::Comm(SIMIX_COMM_RECEIVE);
 
   smx_synchro_t other_synchro;
   //communication already done, get it inside the fifo of completed comms
-  if (mbox->permanent_receiver && xbt_fifo_size(mbox->done_comm_fifo)!=0) {
+  if (mbox->permanent_receiver && ! 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 = SIMIX_fifo_get_comm(mbox->done_comm_fifo, SIMIX_COMM_SEND, match_fun, data, this_synchro);
+    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 {
-      if(other_synchro->comm.surf_comm && SIMIX_comm_get_remains(other_synchro)==0.0) {
-        XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",&(other_synchro->comm));
-        other_synchro->state = SIMIX_DONE;
-        other_synchro->comm.type = SIMIX_COMM_DONE;
-        other_synchro->comm.mbox = NULL;
+      simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+
+      if(other_comm->surf_comm && SIMIX_comm_get_remains(other_comm)==0.0) {
+        XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",other_comm);
+        other_comm->state = SIMIX_DONE;
+        other_comm->type = SIMIX_COMM_DONE;
+        other_comm->mbox = NULL;
       }
-      other_synchro->comm.refcount--;
+      other_comm->refcount--;
       SIMIX_comm_destroy(this_synchro);
     }
   } else {
@@ -455,32 +377,34 @@ smx_synchro_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_mailbox_t mbox, void
      * 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 = SIMIX_fifo_get_comm(mbox->comm_fifo, SIMIX_COMM_SEND, match_fun, data, this_synchro);
+    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 %d", xbt_fifo_size(mbox->comm_fifo));
+      XBT_DEBUG("Receive pushed first %zu", mbox->comm_queue->size());
       other_synchro = this_synchro;
       SIMIX_mbox_push(mbox, this_synchro);
     } else {
       SIMIX_comm_destroy(this_synchro);
-      other_synchro->state = SIMIX_READY;
-      other_synchro->comm.type = SIMIX_COMM_READY;
-      //other_synchro->comm.refcount--;
+      simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+
+      other_comm->state = SIMIX_READY;
+      other_comm->type = SIMIX_COMM_READY;
     }
     xbt_fifo_push(dst_proc->comms, other_synchro);
   }
 
   /* Setup communication synchro */
-  other_synchro->comm.dst_proc = dst_proc;
-  other_synchro->comm.dst_buff = dst_buff;
-  other_synchro->comm.dst_buff_size = dst_buff_size;
-  other_synchro->comm.dst_data = data;
+  simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+  other_comm->dst_proc = dst_proc;
+  other_comm->dst_buff = dst_buff;
+  other_comm->dst_buff_size = dst_buff_size;
+  other_comm->dst_data = data;
 
-  if (rate != -1.0 && (other_synchro->comm.rate == -1.0 || rate < other_synchro->comm.rate))
-    other_synchro->comm.rate = rate;
+  if (rate != -1.0 && (other_comm->rate == -1.0 || rate < other_comm->rate))
+    other_comm->rate = rate;
 
-  other_synchro->comm.match_fun = match_fun;
-  other_synchro->comm.copy_data_fun = copy_data_fun;
+  other_comm->match_fun = match_fun;
+  other_comm->copy_data_fun = copy_data_fun;
 
   if (MC_is_active() || MC_record_replay_is_active()) {
     other_synchro->state = SIMIX_RUNNING;
@@ -501,34 +425,31 @@ smx_synchro_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t m
 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_fifo);
+  XBT_DEBUG("iprobe from %p %p", mbox, mbox->comm_queue);
   smx_synchro_t this_synchro;
   int smx_type;
   if(type == 1){
-    this_synchro=SIMIX_comm_new(SIMIX_COMM_SEND);
+    this_synchro = new simgrid::simix::Comm(SIMIX_COMM_SEND);
     smx_type = SIMIX_COMM_RECEIVE;
   } else{
-    this_synchro=SIMIX_comm_new(SIMIX_COMM_RECEIVE);
+    this_synchro = new simgrid::simix::Comm(SIMIX_COMM_RECEIVE);
     smx_type = SIMIX_COMM_SEND;
   } 
   smx_synchro_t other_synchro=NULL;
-  if(mbox->permanent_receiver && xbt_fifo_size(mbox->done_comm_fifo)!=0){
-    //find a match in the already received fifo
-      XBT_DEBUG("first try in the perm recv mailbox");
+  if(mbox->permanent_receiver && ! 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_synchro,/*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_synchro,/*remove_matching*/false);
+  }
 
-    other_synchro = SIMIX_fifo_probe_comm(
-      mbox->done_comm_fifo, (e_smx_comm_type_t) smx_type,
-      match_fun, data, this_synchro);
+  if(other_synchro) {
+    simgrid::simix::Comm *other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
+    other_comm->refcount--;
   }
- // }else{
-    if(!other_synchro){
-        XBT_DEBUG("try in the normal mailbox");
-        other_synchro = SIMIX_fifo_probe_comm(
-          mbox->comm_fifo, (e_smx_comm_type_t) smx_type,
-          match_fun, data, this_synchro);
-    }
-//  }
-  if(other_synchro)other_synchro->comm.refcount--;
 
   SIMIX_comm_destroy(this_synchro);
   return other_synchro;
@@ -555,10 +476,11 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t synchro, dou
       if (timeout == -1)
         THROW_IMPOSSIBLE;
 
-      if (synchro->comm.src_proc == simcall->issuer)
-        synchro->state = SIMIX_SRC_TIMEOUT;
+      simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+      if (comm->src_proc == simcall->issuer)
+        comm->state = SIMIX_SRC_TIMEOUT;
       else
-        synchro->state = SIMIX_DST_TIMEOUT;
+        comm->state = SIMIX_DST_TIMEOUT;
     }
 
     SIMIX_comm_finish(synchro);
@@ -573,22 +495,25 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t synchro, dou
     sleep = surf_host_sleep(simcall->issuer->host, timeout);
     sleep->setData(synchro);
 
-    if (simcall->issuer == synchro->comm.src_proc)
-      synchro->comm.src_timeout = sleep;
+    simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+    if (simcall->issuer == comm->src_proc)
+      comm->src_timeout = sleep;
     else
-      synchro->comm.dst_timeout = sleep;
+      comm->dst_timeout = sleep;
   }
 }
 
 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t synchro)
 {
-  if(MC_is_active() || MC_record_replay_is_active()){
-    simcall_comm_test__set__result(simcall, synchro->comm.src_proc && synchro->comm.dst_proc);
-    if(simcall_comm_test__get__result(simcall)){
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  if (MC_is_active() || MC_record_replay_is_active()){
+    simcall_comm_test__set__result(simcall, comm->src_proc && comm->dst_proc);
+    if (simcall_comm_test__get__result(simcall)){
       synchro->state = SIMIX_DONE;
       xbt_fifo_push(synchro->simcalls, simcall);
       SIMIX_comm_finish(synchro);
-    }else{
+    } else {
       SIMIX_simcall_answer(simcall);
     }
     return;
@@ -667,9 +592,8 @@ void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall)
   unsigned int cursor = 0;
   xbt_dynar_t synchros = simcall_comm_waitany__get__comms(simcall);
 
-  xbt_dynar_foreach(synchros, cursor, synchro) {
+  xbt_dynar_foreach(synchros, cursor, synchro)
     xbt_fifo_remove(synchro->simcalls, simcall);
-  }
 }
 
 /**
@@ -678,46 +602,42 @@ void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall)
  */
 static inline void SIMIX_comm_start(smx_synchro_t synchro)
 {
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
   /* If both the sender and the receiver are already there, start the communication */
   if (synchro->state == SIMIX_READY) {
 
-    sg_host_t sender = synchro->comm.src_proc->host;
-    sg_host_t receiver = synchro->comm.dst_proc->host;
-
-    XBT_DEBUG("Starting communication %p from '%s' to '%s'", synchro,
-              sg_host_get_name(sender), sg_host_get_name(receiver));
-
-    synchro->comm.surf_comm = surf_network_model_communicate(surf_network_model,
-                                                            sender, receiver,
-                                                            synchro->comm.task_size, synchro->comm.rate);
+    sg_host_t sender   = comm->src_proc->host;
+    sg_host_t receiver = comm->dst_proc->host;
 
-    synchro->comm.surf_comm->setData(synchro);
+    XBT_DEBUG("Starting communication %p from '%s' to '%s'", synchro, sg_host_get_name(sender), sg_host_get_name(receiver));
 
-    synchro->state = SIMIX_RUNNING;
+    comm->surf_comm = surf_network_model_communicate(surf_network_model, sender, receiver, comm->task_size, comm->rate);
+    comm->surf_comm->setData(synchro);
+    comm->state = SIMIX_RUNNING;
 
     /* If a link is failed, detect it immediately */
-    if (synchro->comm.surf_comm->getState() == simgrid::surf::Action::State::failed) {
+    if (comm->surf_comm->getState() == simgrid::surf::Action::State::failed) {
       XBT_DEBUG("Communication from '%s' to '%s' failed to start because of a link failure",
                 sg_host_get_name(sender), sg_host_get_name(receiver));
-      synchro->state = SIMIX_LINK_FAILURE;
+      comm->state = SIMIX_LINK_FAILURE;
       SIMIX_comm_destroy_internal_actions(synchro);
     }
 
     /* If any of the process is suspend, create the synchro but stop its execution,
        it will be restarted when the sender process resume */
-    if (SIMIX_process_is_suspended(synchro->comm.src_proc) ||
-        SIMIX_process_is_suspended(synchro->comm.dst_proc)) {
+    if (SIMIX_process_is_suspended(comm->src_proc) ||
+        SIMIX_process_is_suspended(comm->dst_proc)) {
       /* FIXME: check what should happen with the synchro state */
 
-      if (SIMIX_process_is_suspended(synchro->comm.src_proc))
+      if (SIMIX_process_is_suspended(comm->src_proc))
         XBT_DEBUG("The communication is suspended on startup because src (%s:%s) were suspended since it initiated the communication",
-                  sg_host_get_name(synchro->comm.src_proc->host), synchro->comm.src_proc->name);
+                  sg_host_get_name(comm->src_proc->host), comm->src_proc->name);
       else
         XBT_DEBUG("The communication is suspended on startup because dst (%s:%s) were suspended since it initiated the communication",
-                  sg_host_get_name(synchro->comm.dst_proc->host), synchro->comm.dst_proc->name);
-
-      synchro->comm.surf_comm->suspend();
+                  sg_host_get_name(comm->dst_proc->host), comm->dst_proc->name);
 
+      comm->surf_comm->suspend();
     }
   }
 }
@@ -728,6 +648,7 @@ static inline void SIMIX_comm_start(smx_synchro_t synchro)
  */
 void SIMIX_comm_finish(smx_synchro_t synchro)
 {
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
   unsigned int destroy_count = 0;
   smx_simcall_t simcall;
 
@@ -747,8 +668,8 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
     }
 
     /* If the synchro is still in a rendez-vous point then remove from it */
-    if (synchro->comm.mbox)
-      SIMIX_mbox_remove(synchro->comm.mbox, synchro);
+    if (comm->mbox)
+      SIMIX_mbox_remove(comm->mbox, synchro);
 
     XBT_DEBUG("SIMIX_comm_finish: synchro state = %d", (int)synchro->state);
 
@@ -767,17 +688,15 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
       break;
 
     case SIMIX_SRC_TIMEOUT:
-      SMX_EXCEPTION(simcall->issuer, timeout_error, 0,
-                    "Communication timeouted because of sender");
+      SMX_EXCEPTION(simcall->issuer, timeout_error, 0, "Communication timeouted because of sender");
       break;
 
     case SIMIX_DST_TIMEOUT:
-      SMX_EXCEPTION(simcall->issuer, timeout_error, 0,
-                    "Communication timeouted because of receiver");
+      SMX_EXCEPTION(simcall->issuer, timeout_error, 0, "Communication timeouted because of receiver");
       break;
 
     case SIMIX_SRC_HOST_FAILURE:
-      if (simcall->issuer == synchro->comm.src_proc)
+      if (simcall->issuer == comm->src_proc)
         simcall->issuer->context->iwannadie = 1;
 //          SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
       else
@@ -785,7 +704,7 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
       break;
 
     case SIMIX_DST_HOST_FAILURE:
-      if (simcall->issuer == synchro->comm.dst_proc)
+      if (simcall->issuer == comm->dst_proc)
         simcall->issuer->context->iwannadie = 1;
 //          SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
       else
@@ -796,12 +715,12 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
 
       XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) detached:%d",
                 synchro,
-                synchro->comm.src_proc ? sg_host_get_name(synchro->comm.src_proc->host) : NULL,
-                synchro->comm.dst_proc ? sg_host_get_name(synchro->comm.dst_proc->host) : NULL,
-                simcall->issuer->name, simcall->issuer, synchro->comm.detached);
-      if (synchro->comm.src_proc == simcall->issuer) {
+                comm->src_proc ? sg_host_get_name(comm->src_proc->host) : NULL,
+                comm->dst_proc ? sg_host_get_name(comm->dst_proc->host) : NULL,
+                simcall->issuer->name, simcall->issuer, comm->detached);
+      if (comm->src_proc == simcall->issuer) {
         XBT_DEBUG("I'm source");
-      } else if (synchro->comm.dst_proc == simcall->issuer) {
+      } else if (comm->dst_proc == simcall->issuer) {
         XBT_DEBUG("I'm dest");
       } else {
         XBT_DEBUG("I'm neither source nor dest");
@@ -810,12 +729,10 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
       break;
 
     case SIMIX_CANCELED:
-      if (simcall->issuer == synchro->comm.dst_proc)
-        SMX_EXCEPTION(simcall->issuer, cancel_error, 0,
-                      "Communication canceled by the sender");
+      if (simcall->issuer == comm->dst_proc)
+        SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Communication canceled by the sender");
       else
-        SMX_EXCEPTION(simcall->issuer, cancel_error, 0,
-                      "Communication canceled by the receiver");
+        SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Communication canceled by the receiver");
       break;
 
     default:
@@ -838,14 +755,14 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
 
     simcall->issuer->waiting_synchro = NULL;
     xbt_fifo_remove(simcall->issuer->comms, synchro);
-    if(synchro->comm.detached){
-      if(simcall->issuer == synchro->comm.src_proc){
-        if(synchro->comm.dst_proc)
-          xbt_fifo_remove(synchro->comm.dst_proc->comms, synchro);
+    if(comm->detached){
+      if(simcall->issuer == comm->src_proc){
+        if(comm->dst_proc)
+          xbt_fifo_remove(comm->dst_proc->comms, synchro);
       }
-      if(simcall->issuer == synchro->comm.dst_proc){
-        if(synchro->comm.src_proc)
-          xbt_fifo_remove(synchro->comm.src_proc->comms, synchro);
+      if(simcall->issuer == comm->dst_proc){
+        if(comm->src_proc)
+          xbt_fifo_remove(comm->src_proc->comms, synchro);
       }
     }
     SIMIX_simcall_answer(simcall);
@@ -862,71 +779,39 @@ void SIMIX_comm_finish(smx_synchro_t synchro)
  */
 void SIMIX_post_comm(smx_synchro_t synchro)
 {
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
   /* Update synchro state */
-  if (synchro->comm.src_timeout &&
-      synchro->comm.src_timeout->getState() == simgrid::surf::Action::State::done)
+  if (comm->src_timeout &&
+      comm->src_timeout->getState() == simgrid::surf::Action::State::done)
     synchro->state = SIMIX_SRC_TIMEOUT;
-  else if (synchro->comm.dst_timeout &&
-    synchro->comm.dst_timeout->getState() == simgrid::surf::Action::State::done)
+  else if (comm->dst_timeout &&
+    comm->dst_timeout->getState() == simgrid::surf::Action::State::done)
     synchro->state = SIMIX_DST_TIMEOUT;
-  else if (synchro->comm.src_timeout &&
-    synchro->comm.src_timeout->getState() == simgrid::surf::Action::State::failed)
+  else if (comm->src_timeout &&
+    comm->src_timeout->getState() == simgrid::surf::Action::State::failed)
     synchro->state = SIMIX_SRC_HOST_FAILURE;
-  else if (synchro->comm.dst_timeout &&
-      synchro->comm.dst_timeout->getState() == simgrid::surf::Action::State::failed)
+  else if (comm->dst_timeout &&
+      comm->dst_timeout->getState() == simgrid::surf::Action::State::failed)
     synchro->state = SIMIX_DST_HOST_FAILURE;
-  else if (synchro->comm.surf_comm &&
-    synchro->comm.surf_comm->getState() == simgrid::surf::Action::State::failed) {
-    XBT_DEBUG("Puta madre. Surf says that the link broke");
+  else if (comm->surf_comm &&
+    comm->surf_comm->getState() == simgrid::surf::Action::State::failed) {
     synchro->state = SIMIX_LINK_FAILURE;
   } else
     synchro->state = SIMIX_DONE;
 
   XBT_DEBUG("SIMIX_post_comm: comm %p, state %d, src_proc %p, dst_proc %p, detached: %d",
-            synchro, (int)synchro->state, synchro->comm.src_proc, synchro->comm.dst_proc, synchro->comm.detached);
+            comm, (int)comm->state, comm->src_proc, comm->dst_proc, comm->detached);
 
   /* destroy the surf actions associated with the Simix communication */
-  SIMIX_comm_destroy_internal_actions(synchro);
+  SIMIX_comm_destroy_internal_actions(comm);
 
   /* if there are simcalls associated with the synchro, then answer them */
   if (xbt_fifo_size(synchro->simcalls)) {
-    SIMIX_comm_finish(synchro);
+    SIMIX_comm_finish(comm);
   }
 }
 
-void SIMIX_comm_cancel(smx_synchro_t synchro)
-{
-  /* if the synchro is a waiting state means that it is still in a mbox */
-  /* so remove from it and delete it */
-  if (synchro->state == SIMIX_WAITING) {
-    SIMIX_mbox_remove(synchro->comm.mbox, synchro);
-    synchro->state = SIMIX_CANCELED;
-  }
-  else if (!MC_is_active() /* when running the MC there are no surf actions */
-           && !MC_record_replay_is_active()
-           && (synchro->state == SIMIX_READY || synchro->state == SIMIX_RUNNING)) {
-
-    synchro->comm.surf_comm->cancel();
-  }
-}
-
-void SIMIX_comm_suspend(smx_synchro_t synchro)
-{
-  /*FIXME: shall we suspend also the timeout synchro? */
-  if (synchro->comm.surf_comm)
-    synchro->comm.surf_comm->suspend();
-  /* in the other case, the action will be suspended on creation, in SIMIX_comm_start() */
-}
-
-void SIMIX_comm_resume(smx_synchro_t synchro)
-{
-  /*FIXME: check what happen with the timeouts */
-  if (synchro->comm.surf_comm)
-    synchro->comm.surf_comm->resume();
-  /* in the other case, the synchro were not really suspended yet, see SIMIX_comm_suspend() and SIMIX_comm_start() */
-}
-
-
 /************* synchro Getters **************/
 
 /**
@@ -935,16 +820,15 @@ void SIMIX_comm_resume(smx_synchro_t synchro)
  */
 double SIMIX_comm_get_remains(smx_synchro_t synchro)
 {
-  double remains;
-
-  if(!synchro){
+  if(!synchro)
     return 0;
-  }
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
 
+  double remains;
   switch (synchro->state) {
 
   case SIMIX_RUNNING:
-    remains = synchro->comm.surf_comm->getRemains();
+    remains = comm->surf_comm->getRemains();
     break;
 
   case SIMIX_WAITING:
@@ -959,11 +843,6 @@ double SIMIX_comm_get_remains(smx_synchro_t synchro)
   return remains;
 }
 
-e_smx_state_t SIMIX_comm_get_state(smx_synchro_t synchro)
-{
-  return synchro->state;
-}
-
 /**
  *  \brief Return the user data associated to the sender of the communication
  *  \param synchro The communication
@@ -971,7 +850,9 @@ e_smx_state_t SIMIX_comm_get_state(smx_synchro_t synchro)
  */
 void* SIMIX_comm_get_src_data(smx_synchro_t synchro)
 {
-  return synchro->comm.src_data;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  return comm->src_data;
 }
 
 /**
@@ -981,45 +862,52 @@ void* SIMIX_comm_get_src_data(smx_synchro_t synchro)
  */
 void* SIMIX_comm_get_dst_data(smx_synchro_t synchro)
 {
-  return synchro->comm.dst_data;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  return comm->dst_data;
 }
 
 smx_process_t SIMIX_comm_get_src_proc(smx_synchro_t synchro)
 {
-  return synchro->comm.src_proc;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  return comm->src_proc;
 }
 
 smx_process_t SIMIX_comm_get_dst_proc(smx_synchro_t synchro)
 {
-  return synchro->comm.dst_proc;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  return comm->dst_proc;
 }
 
 /******************************************************************************/
 /*                    SIMIX_comm_copy_data callbacks                       */
 /******************************************************************************/
-static void (*SIMIX_comm_copy_data_callback) (smx_synchro_t, void*, size_t) =
-  &SIMIX_comm_copy_pointer_callback;
+static void (*SIMIX_comm_copy_data_callback) (smx_synchro_t, void*, size_t) = &SIMIX_comm_copy_pointer_callback;
 
-void
-SIMIX_comm_set_copy_data_callback(void (*callback) (smx_synchro_t, void*, size_t))
+void SIMIX_comm_set_copy_data_callback(void (*callback) (smx_synchro_t, void*, size_t))
 {
   SIMIX_comm_copy_data_callback = callback;
 }
 
-void SIMIX_comm_copy_pointer_callback(smx_synchro_t comm, void* buff, size_t buff_size)
+void SIMIX_comm_copy_pointer_callback(smx_synchro_t synchro, void* buff, size_t buff_size)
 {
-  xbt_assert((buff_size == sizeof(void *)),
-             "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
-  *(void **) (comm->comm.dst_buff) = buff;
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::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 comm, void* buff, size_t buff_size)
+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);
+
   XBT_DEBUG("Copy the data over");
-  memcpy(comm->comm.dst_buff, buff, buff_size);
-  if (comm->comm.detached) { // if this is a detached send, the source buffer was duplicated by SMPI sender to make the original buffer available to the application ASAP
+  memcpy(comm->dst_buff, buff, buff_size);
+  if (comm->detached) { // if this is a detached send, the source buffer was duplicated by SMPI sender to make the original buffer available to the application ASAP
     xbt_free(buff);
-    comm->comm.src_buff = NULL;
+    comm->src_buff = NULL;
   }
 }
 
@@ -1028,37 +916,39 @@ void SIMIX_comm_copy_buffer_callback(smx_synchro_t comm, void* buff, size_t buff
  *  \brief Copy the communication data from the sender's buffer to the receiver's one
  *  \param comm The communication
  */
-void SIMIX_comm_copy_data(smx_synchro_t comm)
+void SIMIX_comm_copy_data(smx_synchro_t synchro)
 {
-  size_t buff_size = comm->comm.src_buff_size;
-  /* If there is no data to be copy then return */
-  if (!comm->comm.src_buff || !comm->comm.dst_buff || comm->comm.copied)
+  simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
+
+  size_t buff_size = comm->src_buff_size;
+  /* If there is no data to copy then return */
+  if (!comm->src_buff || !comm->dst_buff || comm->copied)
     return;
 
   XBT_DEBUG("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)",
             comm,
-            comm->comm.src_proc ? sg_host_get_name(comm->comm.src_proc->host) : "a finished process",
-            comm->comm.src_buff,
-            comm->comm.dst_proc ? sg_host_get_name(comm->comm.dst_proc->host) : "a finished process",
-            comm->comm.dst_buff, buff_size);
+            comm->src_proc ? sg_host_get_name(comm->src_proc->host) : "a finished process",
+            comm->src_buff,
+            comm->dst_proc ? sg_host_get_name(comm->dst_proc->host) : "a finished process",
+            comm->dst_buff, buff_size);
 
   /* Copy at most dst_buff_size bytes of the message to receiver's buffer */
-  if (comm->comm.dst_buff_size)
-    buff_size = MIN(buff_size, *(comm->comm.dst_buff_size));
+  if (comm->dst_buff_size)
+    buff_size = MIN(buff_size, *(comm->dst_buff_size));
 
   /* Update the receiver's buffer size to the copied amount */
-  if (comm->comm.dst_buff_size)
-    *comm->comm.dst_buff_size = buff_size;
+  if (comm->dst_buff_size)
+    *comm->dst_buff_size = buff_size;
 
   if (buff_size > 0){
-      if(comm->comm.copy_data_fun)
-        comm->comm.copy_data_fun (comm, comm->comm.src_buff, buff_size);
+      if(comm->copy_data_fun)
+        comm->copy_data_fun (comm, comm->src_buff, buff_size);
       else
-        SIMIX_comm_copy_data_callback (comm, comm->comm.src_buff, buff_size);
+        SIMIX_comm_copy_data_callback (comm, comm->src_buff, buff_size);
   }
 
 
   /* Set the copied flag so we copy data only once */
   /* (this function might be called from both communication ends) */
-  comm->comm.copied = 1;
+  comm->copied = 1;
 }