X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/611d822b02f836d7abe031cced6adc4281ef4356..a521b79fb5f8fc07b3f9102cec6de074186fe5c1:/src/smpi/colls/bcast/bcast-ompi-split-bintree.cpp?ds=sidebyside

diff --git a/src/smpi/colls/bcast/bcast-ompi-split-bintree.cpp b/src/smpi/colls/bcast/bcast-ompi-split-bintree.cpp
index 41a70e1f09..e91c7680cc 100644
--- a/src/smpi/colls/bcast/bcast-ompi-split-bintree.cpp
+++ b/src/smpi/colls/bcast/bcast-ompi-split-bintree.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2018. The SimGrid Team.
+/* Copyright (c) 2013-2020. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -58,22 +58,21 @@
 #include "../coll_tuned_topo.hpp"
 #include "../colls_private.hpp"
 #define MAXTREEFANOUT 32
-namespace simgrid{
-namespace smpi{
-
-int
-Coll_bcast_ompi_split_bintree::bcast ( void* buffer,
-                                            int count,
-                                            MPI_Datatype datatype,
-                                            int root,
-                                            MPI_Comm comm)
+namespace simgrid {
+namespace smpi {
+
+int bcast__ompi_split_bintree( void* buffer,
+                               int count,
+                               MPI_Datatype datatype,
+                               int root,
+                               MPI_Comm comm)
 {
     unsigned int segsize ;
     int rank, size;
     int segindex, i, lr, pair;
     int segcount[2];       /* Number ompi_request_wait_allof elements sent with each segment */
     uint32_t counts[2];
-    int num_segments[2];   /* Number of segmenets */
+    int num_segments[2];   /* Number of segments */
     int sendcount[2];      /* the same like segcount, except for the last segment */
     size_t realsegsize[2];
     char *tmpbuf[2];
@@ -136,8 +135,7 @@ Coll_bcast_ompi_split_bintree::bcast ( void* buffer,
         (segsize > counts[0] * type_size) ||
         (segsize > counts[1] * type_size) ) {
         /* call linear version here ! */
-        return (Coll_bcast_SMP_linear::bcast ( buffer, count, datatype,
-                                                    root, comm));
+        return bcast__SMP_linear( buffer, count, datatype, root, comm);
     }
     type_extent = datatype->get_extent();
 
@@ -185,43 +183,38 @@ Coll_bcast_ompi_split_bintree::bcast ( void* buffer,
 
     /* intermediate nodes code */
     else if( tree->tree_nextsize > 0 ) {
-        /* Intermediate nodes:
-         * It will receive segments only from one half of the data.
-         * Which one is determined by whether the node belongs to the "left" or "right"
-         * subtree. Topoloby building function builds binary tree such that
-         * odd "shifted ranks" ((rank + size - root)%size) are on the left subtree,
-         * and even on the right subtree.
-         *
-         * Create the pipeline. We first post the first receive, then in the loop we
-         * post the next receive and after that wait for the previous receive to complete
-         * and we disseminating the data to all children.
-         */
-        sendcount[lr] = segcount[lr];
-        base_req=Request::irecv(tmpbuf[lr], sendcount[lr], datatype,
-                           tree->tree_prev, COLL_TAG_BCAST,
-                           comm);
+      /* Intermediate nodes:
+       * It will receive segments only from one half of the data.
+       * Which one is determined by whether the node belongs to the "left" or "right"
+       * subtree. Topology building function builds binary tree such that
+       * odd "shifted ranks" ((rank + size - root)%size) are on the left subtree,
+       * and even on the right subtree.
+       *
+       * Create the pipeline. We first post the first receive, then in the loop we
+       * post the next receive and after that wait for the previous receive to complete
+       * and we disseminating the data to all children.
+       */
+      sendcount[lr] = segcount[lr];
+      base_req      = Request::irecv(tmpbuf[lr], sendcount[lr], datatype, tree->tree_prev, COLL_TAG_BCAST, comm);
+
+      for (segindex = 1; segindex < num_segments[lr]; segindex++) {
+        /* determine how many elements to expect in this round */
+        if (segindex == (num_segments[lr] - 1))
+          sendcount[lr] = counts[lr] - segindex * segcount[lr];
+        /* post new irecv */
+        new_req = Request::irecv(tmpbuf[lr] + realsegsize[lr], sendcount[lr], datatype, tree->tree_prev, COLL_TAG_BCAST,
+                                 comm);
+
+        /* wait for and forward current segment */
+        Request::waitall(1, &base_req, MPI_STATUSES_IGNORE);
+        for (i = 0; i < tree->tree_nextsize; i++) { /* send data to children (segcount[lr]) */
+          Request::send(tmpbuf[lr], segcount[lr], datatype, tree->tree_next[i], COLL_TAG_BCAST, comm);
+        } /* end of for each child */
 
-        for( segindex = 1; segindex < num_segments[lr]; segindex++ ) {
-            /* determine how many elements to expect in this round */
-            if( segindex == (num_segments[lr] - 1))
-                sendcount[lr] = counts[lr] - segindex*segcount[lr];
-            /* post new irecv */
-            new_req = Request::irecv( tmpbuf[lr] + realsegsize[lr], sendcount[lr],
-                                datatype, tree->tree_prev, COLL_TAG_BCAST,
-                                comm);
-
-            /* wait for and forward current segment */
-            Request::waitall( 1, &base_req, MPI_STATUSES_IGNORE );
-            for( i = 0; i < tree->tree_nextsize; i++ ) {  /* send data to children (segcount[lr]) */
-                Request::send( tmpbuf[lr], segcount[lr], datatype,
-                                   tree->tree_next[i], COLL_TAG_BCAST,
-                                   comm);
-            } /* end of for each child */
-
-            /* upate the base request */
-            base_req = new_req;
-            /* go to the next buffer (ie. the one corresponding to the next recv) */
-            tmpbuf[lr] += realsegsize[lr];
+        /* update the base request */
+        base_req = new_req;
+        /* go to the next buffer (ie. the one corresponding to the next recv) */
+        tmpbuf[lr] += realsegsize[lr];
         } /* end of for segindex */
 
         /* wait for the last segment and forward current segment */