X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/bbfde1ef5427e4e7e84ca8d38aff13507947c194..2f391a5ab078df821362ea4d82338e4259028630:/src/simix/smx_network.c

diff --git a/src/simix/smx_network.c b/src/simix/smx_network.c
index 0802fb7233..923173b5d7 100644
--- a/src/simix/smx_network.c
+++ b/src/simix/smx_network.c
@@ -54,7 +54,7 @@ void SIMIX_rdv_destroy(smx_rdv_t rdv)
  *  \param rdv The rendez-vous point
  *  \param comm The communication request
  */
-static inline void SIMIX_rdv_push(smx_rdv_t rdv, smx_comm_t comm)
+static XBT_INLINE void SIMIX_rdv_push(smx_rdv_t rdv, smx_comm_t comm)
 {
   xbt_fifo_push(rdv->comm_fifo, comm);
   comm->rdv = rdv;
@@ -65,7 +65,7 @@ static inline void SIMIX_rdv_push(smx_rdv_t rdv, smx_comm_t comm)
  *  \param rdv The rendez-vous point
  *  \param comm The communication request
  */
-static inline void SIMIX_rdv_remove(smx_rdv_t rdv, smx_comm_t comm)
+static XBT_INLINE void SIMIX_rdv_remove(smx_rdv_t rdv, smx_comm_t comm)
 {
   xbt_fifo_remove(rdv->comm_fifo, comm);
   comm->rdv = NULL;
@@ -159,6 +159,7 @@ smx_comm_t SIMIX_communication_new(smx_comm_type_t type)
  */
 void SIMIX_communication_destroy(smx_comm_t comm)
 {
+  VERB2("Destroy communication %p; refcount initially %d",comm,comm->refcount);
   comm->refcount--;
   if(comm->refcount > 0)
     return;
@@ -194,7 +195,7 @@ void SIMIX_communication_destroy(smx_comm_t comm)
  *  maybe is in use by others.
  *  \
  */
-static inline void SIMIX_communication_use(smx_comm_t comm)
+static XBT_INLINE void SIMIX_communication_use(smx_comm_t comm)
 {
   comm->refcount++;
 }
@@ -203,7 +204,7 @@ static inline void SIMIX_communication_use(smx_comm_t comm)
  *  \brief Start the simulation of a communication request
  *  \param comm The communication request
  */
-static inline void SIMIX_communication_start(smx_comm_t comm)
+static XBT_INLINE void SIMIX_communication_start(smx_comm_t comm)
 {
   /* If both the sender and the receiver are already there, start the communication */
   if(comm->src_proc && comm->dst_proc){
@@ -233,7 +234,44 @@ static inline void SIMIX_communication_start(smx_comm_t comm)
 }
 
 /**
- *  \brief Waits for communication completion and performs error checking
+ * \brief Performs error checking and cleanup
+ * \param comm The communication
+ */
+static XBT_INLINE void SIMIX_communication_cleanup(smx_comm_t comm)
+{
+  DEBUG1("Checking errors and cleaning communication %p", comm);
+
+  /* Make sure that everyone sleeping on that semaphore is awake, and that nobody will ever block on it */
+  SIMIX_sem_release_forever(comm->sem);
+  
+  /* Check for errors other than timeouts */
+  if (!SIMIX_host_get_state(SIMIX_host_self())){
+    if(comm->rdv)
+      SIMIX_rdv_remove(comm->rdv, comm);
+    SIMIX_communication_destroy(comm);
+    THROW0(host_error, 0, "Host failed");
+  } else if (SIMIX_action_get_state(comm->act) == SURF_ACTION_FAILED){
+    SIMIX_communication_destroy(comm);
+    THROW0(network_error, 0, "Link failure");
+  } else if (!SIMIX_host_get_state(SIMIX_process_get_host(comm->dst_proc)) ||
+      !SIMIX_host_get_state(SIMIX_process_get_host(comm->src_proc))) {
+    /* We test both src&dst because we dunno who we are today, and we already tested myself above.
+     *    So, at the end, we test the remote peer only
+     * Moreover, we have to test it because if the remote peer fails, the action comm->act is not done nor failed.
+     *    In that case, we got awaken by the little endless actions created in the SIMIX_sem_acquire(comm->sem)
+     *    at the beginning of this function. */
+    SIMIX_communication_destroy(comm);
+    THROW0(network_error, 0, "Remote peer failed");
+
+  }
+  /* Copy network data */
+  SIMIX_network_copy_data(comm);  
+
+  SIMIX_communication_destroy(comm);
+}
+
+/**
+ *  \brief Waits for communication completion
  *  \param comm The communication
  *  \param timeout The max amount of time to wait for the communication to finish
  *
@@ -242,7 +280,7 @@ static inline void SIMIX_communication_start(smx_comm_t comm)
  *   - timeout_error if communication reached the timeout specified (either because of local peer or remote peer)
  *   - network_error if network failed or remote peer failed
  */
-static inline void SIMIX_communication_wait_for_completion(smx_comm_t comm, double timeout)
+static XBT_INLINE void SIMIX_communication_wait_for_completion(smx_comm_t comm, double timeout)
 {
   smx_action_t act_sleep = NULL;
   int src_timeout = 0;
@@ -285,35 +323,8 @@ static inline void SIMIX_communication_wait_for_completion(smx_comm_t comm, doub
     THROW1(timeout_error, 0, "Communication timeouted because of %s",src_timeout?"the source":"the destination");
   }
 
-  DEBUG1("Communication %p complete! Let's check for errors", comm);
-
-  /* Make sure that everyone sleeping on that semaphore is awake, and that nobody will ever block on it */
-  SIMIX_sem_release_forever(comm->sem);
-  
-  /* Check for errors other than timeouts (they are catched above) */
-  if (!SIMIX_host_get_state(SIMIX_host_self())){
-    if(comm->rdv)
-      SIMIX_rdv_remove(comm->rdv, comm);
-    SIMIX_communication_destroy(comm);
-    THROW0(host_error, 0, "Host failed");
-  } else if (SIMIX_action_get_state(comm->act) == SURF_ACTION_FAILED){
-    SIMIX_communication_destroy(comm);
-    THROW0(network_error, 0, "Link failure");
-  } else if (!SIMIX_host_get_state(SIMIX_process_get_host(comm->dst_proc)) ||
-      !SIMIX_host_get_state(SIMIX_process_get_host(comm->src_proc))) {
-    /* We test both src&dst because we dunno who we are today, and we already tested myself above.
-     *    So, at the end, we test the remote peer only
-     * Moreover, we have to test it because if the remote peer fails, the action comm->act is not done nor failed.
-     *    In that case, we got awaken by the little endless actions created in the SIMIX_sem_acquire(comm->sem)
-     *    at the beginning of this function. */
-    SIMIX_communication_destroy(comm);
-    THROW0(network_error, 0, "Remote peer failed");
-
-  }
-  /* Copy network data */
-  SIMIX_network_copy_data(comm);  
-
-  SIMIX_communication_destroy(comm);
+  DEBUG1("Communication %p complete!", comm);
+  SIMIX_communication_cleanup(comm);
 }
 
 /**
@@ -360,7 +371,8 @@ void SIMIX_network_copy_buffer_callback(smx_comm_t comm, size_t buff_size) {
 void SIMIX_network_copy_data(smx_comm_t comm)
 {
   size_t buff_size = comm->src_buff_size;
-
+  uintptr_t casted_size = 0;
+  uintptr_t amount = 0;
   /* If there is no data to be copy then return */
   if(!comm->src_buff || !comm->dst_buff || comm->copied == 1)
     return;
@@ -391,8 +403,8 @@ void SIMIX_network_copy_data(smx_comm_t comm)
   {
     if (msg_sizes == NULL)
       msg_sizes = xbt_dict_new();
-    uintptr_t casted_size = comm->task_size;
-    uintptr_t amount = xbt_dicti_get(msg_sizes, casted_size);
+    casted_size = comm->task_size;
+    amount = xbt_dicti_get(msg_sizes, casted_size);
     amount++;
 
     xbt_dicti_set(msg_sizes,casted_size, amount);
@@ -401,10 +413,13 @@ void SIMIX_network_copy_data(smx_comm_t comm)
 #include "xbt.h"
 /* pimple to display the message sizes */
 void SIMIX_message_sizes_output(const char *filename) {
-  FILE * out = fopen(filename,"w");
-  xbt_assert1(out,"Cannot open file %s",filename);
-  uintptr_t key,data;
+  uintptr_t key = 0;
+  uintptr_t data = 0;
   xbt_dict_cursor_t cursor;
+  FILE * out = NULL;
+  out = fopen(filename,"w");
+  xbt_assert1(out,"Cannot open file %s",filename);
+
   xbt_dict_foreach(msg_sizes,cursor,key,data) {
     fprintf(out,"%zu %zu\n",key,data);
   }
@@ -476,15 +491,11 @@ smx_comm_t SIMIX_network_isend(smx_rdv_t rdv, double task_size, double rate,
 {
   smx_comm_t comm;
 
-  /* If running in model-checking mode then intercept the communication action. 
-   * There can be two situations, this is a replay (back-track process) so no
-   * transition needs to be created, or we are expanding a new state and in 
-   * consecuence a transition needs to be created and added to the set of
-   * transitions associated to the current state.
-   */
-  if (_surf_do_model_check)
-    MC_trans_intercept_isend(rdv);
-  
+  /*If running in model-checking mode then intercept the communication action*/
+	#ifdef HAVE_MC
+	  if (_surf_do_model_check)
+		MC_trans_intercept_isend(rdv);
+	#endif
   /* Look for communication request matching our needs.
      If it is not found then create it and push it into the rendez-vous point */
   comm = SIMIX_rdv_get_request(rdv, comm_recv);
@@ -510,15 +521,11 @@ smx_comm_t SIMIX_network_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_s
 {
   smx_comm_t comm;
 
-  /* If running in model-checking mode then intercept the communication action. 
-   * There can be two situations, this is a replay (back-track process) so no
-   * transition needs to be created, or we are expanding a new state and in 
-   * consecuence a transition needs to be created and added to the set of
-   * transitions associated to the current state.
-   */
+  /*If running in model-checking mode then intercept the communication action*/
+#ifdef HAVE_MC
   if (_surf_do_model_check)
     MC_trans_intercept_irecv(rdv);
-  
+#endif
   /* Look for communication request matching our needs.
    * If it is not found then create it and push it into the rendez-vous point
    */
@@ -541,15 +548,11 @@ smx_comm_t SIMIX_network_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_s
 /** @brief blocks until the communication terminates or the timeout occurs */
 XBT_INLINE void SIMIX_network_wait(smx_comm_t comm, double timeout)
 {
-  /* If running in model-checking mode then intercept the communication action. 
-   * There can be two situations, this is a replay (back-track process) so no
-   * transition needs to be created, or we are expanding a new state and in 
-   * consecuence a transition needs to be created and added to the set of
-   * transitions associated to the current state.
-   */
+  /*If running in model-checking mode then intercept the communication action*/
+#ifdef HAVE_MC
   if (_surf_do_model_check)
     MC_trans_intercept_wait(comm);
-  
+#endif
   /* Wait for communication completion */
   SIMIX_communication_wait_for_completion(comm, timeout);
 }
@@ -557,14 +560,11 @@ XBT_INLINE void SIMIX_network_wait(smx_comm_t comm, double timeout)
 /** @Returns whether the (asynchronous) communication is done yet or not */
 XBT_INLINE int SIMIX_network_test(smx_comm_t comm)
 {
-  /* If running in model-checking mode then intercept the communication action. 
-   * There can be two situations, this is a replay (back-track process) so no
-   * transition needs to be created, or we are expanding a new state and in 
-   * consecuence a transition needs to be created and added to the set of
-   * transitions associated to the current state.
-   */
+  /*If running in model-checking mode then intercept the communication action*/
+#ifdef HAVE_MC
   if (_surf_do_model_check)
     MC_trans_intercept_test(comm);
+#endif
 
   /* Copy data if the communication is done */
   if(comm->sem && !SIMIX_sem_would_block(comm->sem)){
@@ -585,15 +585,11 @@ unsigned int SIMIX_network_waitany(xbt_dynar_t comms)
   unsigned int cursor, found_comm=-1;
   smx_comm_t comm,comm_finished=NULL;
 
-  /* If running in model-checking mode then intercept the communication action. 
-   * There can be two situations, this is a replay (back-track process) so no
-   * transition needs to be created, or we are expanding a new state and in 
-   * consecuence a transition needs to be created and added to the set of
-   * transitions associated to the current state.
-   */
+  /*If running in model-checking mode then intercept the communication action*/
+#ifdef HAVE_MC
   if (_surf_do_model_check)
     MC_trans_intercept_waitany(comms);
-    
+#endif
   xbt_dynar_foreach(comms,cursor,comm)
     xbt_dynar_push(sems,&(comm->sem));
 
@@ -604,7 +600,11 @@ unsigned int SIMIX_network_waitany(xbt_dynar_t comms)
   xbt_assert0(found_comm!=-1,"Cannot find which communication finished");
   xbt_dynar_get_cpy(comms,found_comm,&comm_finished);
 
-  /* Check for errors and cleanup the comm */
-  SIMIX_communication_wait_for_completion(comm_finished,-1);
+  DEBUG2("Communication %p of communication set %p finished", comm_finished, comms);
+
+  /* let the regular code deal with the communication end (errors checking and cleanup).
+   * A bit of useless work will be done, but that's good for source factorization */
+  SIMIX_sem_release_forever(comm_finished->sem);
+  SIMIX_communication_wait_for_completion(comm_finished, -1);
   return found_comm;
-}
\ No newline at end of file
+}