Yet another batch of fixes

[simgrid.git] / src / smpi / smpi_comm.cpp

diff --git a/src/smpi/smpi_comm.cpp b/src/smpi/smpi_comm.cpp
index a4f0468..3513ba6 100644 (file)
--- a/src/smpi/smpi_comm.cpp
+++ b/src/smpi/smpi_comm.cpp
@@ -63,7 +63,6 @@ MPI_Comm smpi_comm_new(MPI_Group group, MPI_Topology topo)
 
   comm = xbt_new(s_smpi_mpi_communicator_t, 1);
   comm->group = group;
-  smpi_group_use(comm->group);
   comm->refcount=1;
   comm->topoType = MPI_INVALID_TOPO;
   comm->topo = topo;
@@ -81,7 +80,6 @@ void smpi_comm_destroy(MPI_Comm comm)
 {
   if (comm == MPI_COMM_UNINITIALIZED)
     comm = smpi_process_comm_world();
-  smpi_group_unuse(comm->group);
   smpi_topo_destroy(comm->topo); // there's no use count on topos
   smpi_comm_unuse(comm);
 }
@@ -90,7 +88,8 @@ int smpi_comm_dup(MPI_Comm comm, MPI_Comm* newcomm){
   if(smpi_privatize_global_variables){ //we need to switch as the called function may silently touch global variables
      smpi_switch_data_segment(smpi_process_index());
    }
-  (*newcomm) = smpi_comm_new(smpi_comm_group(comm), smpi_comm_topo(comm));
+  MPI_Group cp=smpi_group_copy(smpi_comm_group(comm));
+  (*newcomm) = smpi_comm_new(cp, smpi_comm_topo(comm));
   int ret = MPI_SUCCESS;
   //todo: faire en sorte que ça fonctionne avec un communicator dupliqué (refaire un init_smp ?)
   
@@ -231,6 +230,7 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key)
   int* recvbuf;
   int* rankmap;
   MPI_Group group, group_root, group_out;
+  MPI_Group* group_snd;
   MPI_Request* requests;
 
   group_root = group_out = NULL;
@@ -250,6 +250,7 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key)
   xbt_free(sendbuf);
   /* Do the actual job */
   if(rank == 0) {
+    group_snd = xbt_new(MPI_Group, size);
     rankmap = xbt_new(int, 2 * size);
     for(i = 0; i < size; i++) {
       if(recvbuf[2 * i] == MPI_UNDEFINED) {
@@ -275,7 +276,6 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key)
         group_root = group_out; /* Save root's group */
       }
       for(j = 0; j < count; j++) {
-        //increment refcounter in order to avoid freeing the group too quick before copy
         index = smpi_group_index(group, rankmap[2 * j]);
         smpi_group_set_mapping(group_out, index, j);
       }
@@ -283,22 +283,24 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key)
       reqs = 0;
       for(j = 0; j < count; j++) {
         if(rankmap[2 * j] != 0) {
-          requests[reqs] = smpi_isend_init(&group_out, 1, MPI_PTR, rankmap[2 * j], system_tag, comm);
+          group_snd[reqs]=smpi_group_copy(group_out);
+          requests[reqs] = smpi_mpi_isend(&(group_snd[reqs]), 1, MPI_PTR, rankmap[2 * j], system_tag, comm);
           reqs++;
         }
       }
-      smpi_mpi_startall(reqs, requests);
+      if(i != 0) {
+        smpi_group_destroy(group_out);
+      }
       smpi_mpi_waitall(reqs, requests, MPI_STATUS_IGNORE);
       xbt_free(requests);
     }
     xbt_free(recvbuf);
+    xbt_free(rankmap);
+    xbt_free(group_snd);
     group_out = group_root; /* exit with root's group */
   } else {
     if(color != MPI_UNDEFINED) {
       smpi_mpi_recv(&group_out, 1, MPI_PTR, 0, system_tag, comm, MPI_STATUS_IGNORE);
-      if(group_out){
-        group_out=smpi_group_copy(group_out);
-      }
     } /* otherwise, exit with group_out == NULL */
   }
   return group_out ? smpi_comm_new(group_out, NULL) : MPI_COMM_NULL;
@@ -307,14 +309,27 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key)
 void smpi_comm_use(MPI_Comm comm){
   if (comm == MPI_COMM_UNINITIALIZED)
     comm = smpi_process_comm_world();
+  smpi_group_use(comm->group);
   comm->refcount++;
 }
 
-void smpi_comm_unuse(MPI_Comm comm){
-  if (comm == MPI_COMM_UNINITIALIZED)
-    comm = smpi_process_comm_world();
-  comm->refcount--;
-  if(comm->refcount==0){
+void smpi_comm_cleanup_attributes(MPI_Comm comm){
+  if(comm->attributes !=NULL){
+    xbt_dict_cursor_t cursor = NULL;
+    int* key;
+    void * value;
+    int flag;
+    xbt_dict_foreach(comm->attributes, cursor, key, value){
+      smpi_comm_key_elem elem =
+         static_cast<smpi_comm_key_elem>(xbt_dict_get_or_null(smpi_comm_keyvals, (const char*)key));
+      if(elem &&  elem->delete_fn)
+        elem->delete_fn(comm, *key, value, &flag);
+    }
+    xbt_dict_free(&comm->attributes);
+  }
+}
+
+void smpi_comm_cleanup_smp(MPI_Comm comm){
     if(comm->intra_comm != MPI_COMM_NULL)
       smpi_comm_unuse(comm->intra_comm);
     if(comm->leaders_comm != MPI_COMM_NULL)
@@ -323,18 +338,17 @@ void smpi_comm_unuse(MPI_Comm comm){
       xbt_free(comm->non_uniform_map);
     if(comm->leaders_map !=NULL)
       xbt_free(comm->leaders_map);
-    if(comm->attributes !=NULL){
-      xbt_dict_cursor_t cursor = NULL;
-      int* key;
-      void * value;
-      int flag;
-      xbt_dict_foreach(comm->attributes, cursor, key, value){
-        smpi_comm_key_elem elem =
-           static_cast<smpi_comm_key_elem>(xbt_dict_get_or_null(smpi_comm_keyvals, (const char*)key));
-        if(elem &&  elem->delete_fn)
-          elem->delete_fn(comm, *key, value, &flag);
-      }
-    }
+}
+
+void smpi_comm_unuse(MPI_Comm comm){
+  if (comm == MPI_COMM_UNINITIALIZED)
+    comm = smpi_process_comm_world();
+  comm->refcount--;
+  smpi_group_unuse(comm->group);
+
+  if(comm->refcount==0){
+    smpi_comm_cleanup_smp(comm);
+    smpi_comm_cleanup_attributes(comm);
     xbt_free(comm);
   }
 }
@@ -462,9 +476,13 @@ void smpi_comm_init_smp(MPI_Comm comm){
     for (i=0; i< leader_group_size;i++)
       smpi_group_set_mapping(leaders_group, leader_list[i], i);
 
-    leader_comm = smpi_comm_new(leaders_group, NULL);
-    if(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL)
+    if(smpi_comm_get_leaders_comm(comm)==MPI_COMM_NULL){
+      leader_comm = smpi_comm_new(leaders_group, NULL);
       smpi_comm_set_leaders_comm(comm, leader_comm);
+    }else{
+      leader_comm=smpi_comm_get_leaders_comm(comm);
+      smpi_group_unuse(leaders_group);
+    }
     smpi_process_set_comm_intra(comm_intra);
   }