Consistently use the request array for all modules (single array stored

in the base).
Correctly deal with persistent requests (they must be always freed when
they are stored in the request array associated with the communicator).
Always use MPI_STATUS_IGNORE for single request waiting functions.

ompi/mca/coll/base/base.h

@@ -23,7 +23,7 @@
  * These functions are normally invoked by the back-ends of:
  *
  * - The back-ends of MPI_Init() and MPI_Finalize()
- * - Communuicactor constructors (e.g., MPI_Comm_split()) and
+ * - Communicator constructors (e.g., MPI_Comm_split()) and
  *   destructors (e.g., MPI_Comm_free())
  * - The laminfo command
  */

ompi/mca/coll/base/coll_base_alltoall.c

@@ -650,9 +650,9 @@ int ompi_coll_base_alltoall_intra_basic_linear(const void *sbuf, int scount,
     if( MPI_SUCCESS != err ) {
         OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
                       __FILE__, line, err, rank) );
-        /* Free the reqs */
-        ompi_coll_base_free_reqs(req, nreqs);
     }
+    /* Free the reqs in all cases as they are persistent requests */
+    ompi_coll_base_free_reqs(req, nreqs);
 
     /* All done */
     return err;

ompi/mca/coll/base/coll_base_alltoallv.c

@@ -288,9 +288,8 @@ ompi_coll_base_alltoallv_intra_basic_linear(const void *sbuf, const int *scounts
     err = ompi_request_wait_all(nreqs, data->mcct_reqs,
                                 MPI_STATUSES_IGNORE);
  err_hndl:
-    if( MPI_SUCCESS != err ) {  /* Free the requests. */
+    /* Free the requests in all cases as they are persistent */
-        ompi_coll_base_free_reqs(data->mcct_reqs, nreqs);
+    ompi_coll_base_free_reqs(data->mcct_reqs, nreqs);
-    }
 
     return err;
 }

ompi/mca/coll/base/coll_base_bcast.c

@@ -143,7 +143,7 @@ ompi_coll_base_bcast_intra_generic( void* buffer,
 
             /* wait for and forward the previous segment to children */
             err = ompi_request_wait( &recv_reqs[req_index ^ 0x1],
-                                     MPI_STATUSES_IGNORE );
+                                     MPI_STATUS_IGNORE );
             if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
 
             for( i = 0; i < tree->tree_nextsize; i++ ) {
@@ -175,7 +175,7 @@ ompi_coll_base_bcast_intra_generic( void* buffer,
         }
 
         /* Process the last segment */
-        err = ompi_request_wait( &recv_reqs[req_index], MPI_STATUSES_IGNORE );
+        err = ompi_request_wait( &recv_reqs[req_index], MPI_STATUS_IGNORE );
         if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
         sendcount = original_count - (ptrdiff_t)(num_segments - 1) * count_by_segment;
         for( i = 0; i < tree->tree_nextsize; i++ ) {
@@ -240,8 +240,11 @@ ompi_coll_base_bcast_intra_generic( void* buffer,
  error_hndl:
     OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
                   __FILE__, line, err, rank) );
-    if( (MPI_SUCCESS != err) && (NULL != send_reqs) ) {
+    if( MPI_SUCCESS != err ) {
-        ompi_coll_base_free_reqs( send_reqs, tree->tree_nextsize);
+        ompi_coll_base_free_reqs( recv_reqs, 2);
+        if( NULL != send_reqs ) {
+            ompi_coll_base_free_reqs( send_reqs, tree->tree_nextsize);
+        }
     }
 
     return err;
@@ -378,7 +381,6 @@ ompi_coll_base_bcast_intra_split_bintree ( void* buffer,
     ptrdiff_t type_extent, lb;
     ompi_request_t *base_req, *new_req;
     ompi_coll_tree_t *tree;
-    mca_coll_base_comm_t *data = module->base_data;
 
     size = ompi_comm_size(comm);
     rank = ompi_comm_rank(comm);
@@ -391,7 +393,7 @@ ompi_coll_base_bcast_intra_split_bintree ( void* buffer,
 
     /* setup the binary tree topology. */
     COLL_BASE_UPDATE_BINTREE( comm, module, root );
-    tree = data->cached_bintree;
+    tree = module->base_data->cached_bintree;
 
     err = ompi_datatype_type_size( datatype, &type_size );
 
@@ -501,8 +503,8 @@ ompi_coll_base_bcast_intra_split_bintree ( void* buffer,
                                       comm, &new_req));
             if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
 
-            /* wait for and forward current segment */
+            /* wait for and forward the previous segment */
-            err = ompi_request_wait_all( 1, &base_req, MPI_STATUSES_IGNORE );
+            err = ompi_request_wait( &base_req, MPI_STATUS_IGNORE );
             for( i = 0; i < tree->tree_nextsize; i++ ) {  /* send data to children (segcount[lr]) */
                 err = MCA_PML_CALL(send( tmpbuf[lr], segcount[lr], datatype,
                                          tree->tree_next[i], MCA_COLL_BASE_TAG_BCAST,
@@ -517,7 +519,7 @@ ompi_coll_base_bcast_intra_split_bintree ( void* buffer,
         } /* end of for segindex */
 
         /* wait for the last segment and forward current segment */
-        err = ompi_request_wait_all( 1, &base_req, MPI_STATUSES_IGNORE );
+        err = ompi_request_wait( &base_req, MPI_STATUS_IGNORE );
         for( i = 0; i < tree->tree_nextsize; i++ ) {  /* send data to children */
             err = MCA_PML_CALL(send(tmpbuf[lr], sendcount[lr], datatype,
                                     tree->tree_next[i], MCA_COLL_BASE_TAG_BCAST,
@@ -633,10 +635,8 @@ ompi_coll_base_bcast_intra_basic_linear(void *buff, int count,
                                         mca_coll_base_module_t *module)
 {
     int i, size, rank, err;
-    mca_coll_base_comm_t *data = module->base_data;
     ompi_request_t **preq, **reqs;
 
-
     size = ompi_comm_size(comm);
     rank = ompi_comm_rank(comm);
 
@@ -651,24 +651,20 @@ ompi_coll_base_bcast_intra_basic_linear(void *buff, int count,
     }
 
     /* Root sends data to all others. */
-    preq = reqs = coll_base_comm_get_reqs(data, size-1);
+    preq = reqs = coll_base_comm_get_reqs(module->base_data, size-1);
     for (i = 0; i < size; ++i) {
         if (i == rank) {
             continue;
         }
 
-        err = MCA_PML_CALL(isend_init(buff, count, datatype, i,
+        err = MCA_PML_CALL(isend(buff, count, datatype, i,
-                                      MCA_COLL_BASE_TAG_BCAST,
+                                 MCA_COLL_BASE_TAG_BCAST,
-                                      MCA_PML_BASE_SEND_STANDARD,
+                                 MCA_PML_BASE_SEND_STANDARD,
-                                      comm, preq++));
+                                 comm, preq++));
         if (MPI_SUCCESS != err) { goto err_hndl; }
     }
     --i;
 
-    /* Start your engines.  This will never return an error. */
-
-    MCA_PML_CALL(start(i, reqs));
-
     /* Wait for them all.  If there's an error, note that we don't
      * care what the error was -- just that there *was* an error.  The
      * PML will finish all requests, even if one or more of them fail.

ompi/mca/coll/base/coll_base_frame.c

@@ -68,15 +68,7 @@ OBJ_CLASS_INSTANCE(mca_coll_base_module_t, opal_object_t,
 static void
 coll_base_comm_construct(mca_coll_base_comm_t *data)
 {
-    data->mcct_reqs = NULL;
+    memset ((char *) data + sizeof (data->super), 0, sizeof (*data) - sizeof (data->super));
-    data->mcct_num_reqs = 0;
-    data->cached_ntree = NULL;
-    data->cached_bintree = NULL;
-    data->cached_bmtree = NULL;
-    data->cached_in_order_bmtree = NULL;
-    data->cached_chain = NULL;
-    data->cached_pipeline = NULL;
-    data->cached_in_order_bintree = NULL;
 }
 
 static void

ompi/mca/coll/basic/coll_basic.h

@@ -285,29 +285,12 @@ BEGIN_C_DECLS
 
 struct mca_coll_basic_module_t {
     mca_coll_base_module_t super;
-
-    ompi_request_t **mccb_reqs;
-    int mccb_num_reqs;
 };
 typedef struct mca_coll_basic_module_t mca_coll_basic_module_t;
-OBJ_CLASS_DECLARATION(mca_coll_basic_module_t);
+OMPI_DECLSPEC OBJ_CLASS_DECLARATION(mca_coll_basic_module_t);
 
-/* Utility functions */
+typedef mca_coll_base_comm_t mca_coll_basic_comm_t;
-
+OMPI_DECLSPEC OBJ_CLASS_DECLARATION(mca_coll_basic_comm_t);
-static inline void mca_coll_basic_free_reqs(ompi_request_t ** reqs, int count)
-{
-    int i;
-    for (i = 0; i < count; ++i)
-        if( MPI_REQUEST_NULL != reqs[i] ) {
-            ompi_request_free(&reqs[i]);
-        }
-}
-
-/**
- * Return the array of requests on the data. If the array was not initialized
- * or if it's size was too small, allocate it to fit the requested size.
- */
-ompi_request_t** mca_coll_basic_get_reqs(mca_coll_basic_module_t* data, int nreqs);
 
 END_C_DECLS
 

ompi/mca/coll/basic/coll_basic_allgather.c

@@ -51,7 +51,6 @@ mca_coll_basic_allgather_inter(const void *sbuf, int scount,
     char *tmpbuf = NULL, *ptmp;
     ptrdiff_t rlb, slb, rextent, sextent, incr;
     ompi_request_t *req;
-    mca_coll_basic_module_t *basic_module = (mca_coll_basic_module_t*) module;
     ompi_request_t **reqs = NULL;
 
     rank = ompi_comm_rank(comm);
@@ -80,7 +79,7 @@ mca_coll_basic_allgather_inter(const void *sbuf, int scount,
         if (OMPI_SUCCESS != err) { line = __LINE__; goto exit; }
 
         /* Get a requests arrays of the right size */
-        reqs = mca_coll_basic_get_reqs(basic_module, rsize + 1);
+        reqs = coll_base_comm_get_reqs(module->base_data, rsize + 1);
         if( NULL == reqs ) { line = __LINE__; goto exit; }
 
         /* Do a send-recv between the two root procs. to avoid deadlock */
@@ -156,7 +155,7 @@ mca_coll_basic_allgather_inter(const void *sbuf, int scount,
     if( MPI_SUCCESS != err ) {
         OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
                       __FILE__, line, err, rank) );
-        if( NULL != reqs ) mca_coll_basic_free_reqs(reqs, rsize+1);
+        if( NULL != reqs ) ompi_coll_base_free_reqs(reqs, rsize+1);
     }
     if (NULL != tmpbuf) {
         free(tmpbuf);

ompi/mca/coll/basic/coll_basic_allreduce.c

@@ -85,7 +85,6 @@ mca_coll_basic_allreduce_inter(const void *sbuf, void *rbuf, int count,
     ptrdiff_t true_lb, true_extent;
     char *tmpbuf = NULL, *pml_buffer = NULL;
     ompi_request_t *req[2];
-    mca_coll_basic_module_t *basic_module = (mca_coll_basic_module_t*) module;
     ompi_request_t **reqs = NULL;
 
     rank = ompi_comm_rank(comm);
@@ -114,7 +113,7 @@ mca_coll_basic_allreduce_inter(const void *sbuf, void *rbuf, int count,
         if (NULL == tmpbuf) { err = OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto exit; }
         pml_buffer = tmpbuf - true_lb;
 
-        reqs = mca_coll_basic_get_reqs(basic_module, rsize - 1);
+        reqs = coll_base_comm_get_reqs(module->base_data, rsize - 1);
         if( NULL == reqs ) { err = OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto exit; }
 
         /* Do a send-recv between the two root procs. to avoid deadlock */
@@ -201,7 +200,7 @@ mca_coll_basic_allreduce_inter(const void *sbuf, void *rbuf, int count,
     if( MPI_SUCCESS != err ) {
         OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d", __FILE__,
                      line, err, rank));
-        mca_coll_basic_free_reqs(reqs, rsize - 1);
+        ompi_coll_base_free_reqs(reqs, rsize - 1);
     }
     if (NULL != tmpbuf) {
         free(tmpbuf);

ompi/mca/coll/basic/coll_basic_alltoall.c

@@ -77,7 +77,7 @@ mca_coll_basic_alltoall_inter(const void *sbuf, int scount,
 
     /* Initiate all send/recv to/from others. */
     nreqs = size * 2;
-    req = rreq = mca_coll_basic_get_reqs( (mca_coll_basic_module_t*) module, nreqs);
+    req = rreq = coll_base_comm_get_reqs( module->base_data, nreqs);
     sreq = rreq + size;
 
     prcv = (char *) rbuf;
@@ -88,7 +88,7 @@ mca_coll_basic_alltoall_inter(const void *sbuf, int scount,
         err = MCA_PML_CALL(irecv(prcv + (i * rcvinc), rcount, rdtype, i,
                                  MCA_COLL_BASE_TAG_ALLTOALL, comm, rreq));
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(req, nreqs);
+            ompi_coll_base_free_reqs(req, nreqs);
             return err;
         }
     }
@@ -99,7 +99,7 @@ mca_coll_basic_alltoall_inter(const void *sbuf, int scount,
                                  MCA_COLL_BASE_TAG_ALLTOALL,
                                  MCA_PML_BASE_SEND_STANDARD, comm, sreq));
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(req, nreqs);
+            ompi_coll_base_free_reqs(req, nreqs);
             return err;
         }
     }
@@ -112,7 +112,7 @@ mca_coll_basic_alltoall_inter(const void *sbuf, int scount,
      * the error after we free everything. */
     err = ompi_request_wait_all(nreqs, req, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != err) {
-        mca_coll_basic_free_reqs(req, nreqs);
+        ompi_coll_base_free_reqs(req, nreqs);
     }
 
     /* All done */

ompi/mca/coll/basic/coll_basic_alltoallv.c

@@ -68,7 +68,7 @@ mca_coll_basic_alltoallv_inter(const void *sbuf, const int *scounts, const int *
 
     /* Initiate all send/recv to/from others. */
     nreqs = rsize * 2;
-    preq = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, nreqs);
+    preq = coll_base_comm_get_reqs(module->base_data, nreqs);
 
     /* Post all receives first  */
     /* A simple optimization: do not send and recv msgs of length zero */
@@ -79,7 +79,7 @@ mca_coll_basic_alltoallv_inter(const void *sbuf, const int *scounts, const int *
                                      i, MCA_COLL_BASE_TAG_ALLTOALLV, comm,
                                      &preq[i]));
             if (MPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(preq, i);
+                ompi_coll_base_free_reqs(preq, i);
                 return err;
             }
         }
@@ -94,7 +94,7 @@ mca_coll_basic_alltoallv_inter(const void *sbuf, const int *scounts, const int *
                                      MCA_PML_BASE_SEND_STANDARD, comm,
                                      &preq[rsize + i]));
             if (MPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(preq, rsize + i);
+                ompi_coll_base_free_reqs(preq, rsize + i);
                 return err;
             }
         }
@@ -102,7 +102,7 @@ mca_coll_basic_alltoallv_inter(const void *sbuf, const int *scounts, const int *
 
     err = ompi_request_wait_all(nreqs, preq, MPI_STATUSES_IGNORE);
     if (MPI_SUCCESS != err) {
-        mca_coll_basic_free_reqs(preq, nreqs);
+        ompi_coll_base_free_reqs(preq, nreqs);
     }
 
     /* All done */

ompi/mca/coll/basic/coll_basic_alltoallw.c

@@ -70,7 +70,7 @@ mca_coll_basic_alltoallw_intra_inplace(const void *rbuf, const int *rcounts, con
         return OMPI_ERR_OUT_OF_RESOURCE;
     }
 
-    reqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t*) module, 2);
+    reqs = coll_base_comm_get_reqs( module->base_data, 2);
     /* in-place alltoallw slow algorithm (but works) */
     for (i = 0 ; i < size ; ++i) {
         size_t msg_size_i;
@@ -129,7 +129,7 @@ mca_coll_basic_alltoallw_intra_inplace(const void *rbuf, const int *rcounts, con
     free (tmp_buffer);
     if( MPI_SUCCESS != err ) {  /* Free the requests. */
         if( NULL != reqs ) {
-            mca_coll_basic_free_reqs(reqs, 2);
+            ompi_coll_base_free_reqs(reqs, 2);
         }
     }
 
@@ -192,7 +192,7 @@ mca_coll_basic_alltoallw_intra(const void *sbuf, const int *scounts, const int *
     /* Initiate all send/recv to/from others. */
 
     nreqs = 0;
-    reqs = preq = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, 2 * size);
+    reqs = preq = coll_base_comm_get_reqs(module->base_data, 2 * size);
 
     /* Post all receives first -- a simple optimization */
 
@@ -210,7 +210,7 @@ mca_coll_basic_alltoallw_intra(const void *sbuf, const int *scounts, const int *
                                       preq++));
         ++nreqs;
         if (MPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, nreqs);
+            ompi_coll_base_free_reqs(reqs, nreqs);
             return err;
         }
     }
@@ -232,7 +232,7 @@ mca_coll_basic_alltoallw_intra(const void *sbuf, const int *scounts, const int *
                                       preq++));
         ++nreqs;
         if (MPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, nreqs);
+            ompi_coll_base_free_reqs(reqs, nreqs);
             return err;
         }
     }
@@ -249,12 +249,10 @@ mca_coll_basic_alltoallw_intra(const void *sbuf, const int *scounts, const int *
      * error after we free everything. */
 
     err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE);
-    /* Free the requests. */
+    /* Free the requests in all cases as they are persistent */
-    if( MPI_SUCCESS != err ) {
+    ompi_coll_base_free_reqs(reqs, nreqs);
-        mca_coll_basic_free_reqs(reqs, nreqs);
-    }
-    /* All done */
 
+    /* All done */
     return err;
 }
 
@@ -287,7 +285,7 @@ mca_coll_basic_alltoallw_inter(const void *sbuf, const int *scounts, const int *
 
     /* Initiate all send/recv to/from others. */
     nreqs = 0;
-    reqs = preq = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, 2 * size);
+    reqs = preq = coll_base_comm_get_reqs(module->base_data, 2 * size);
 
     /* Post all receives first -- a simple optimization */
     for (i = 0; i < size; ++i) {
@@ -304,7 +302,7 @@ mca_coll_basic_alltoallw_inter(const void *sbuf, const int *scounts, const int *
                                       comm, preq++));
         ++nreqs;
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, nreqs);
+            ompi_coll_base_free_reqs(reqs, nreqs);
             return err;
         }
     }
@@ -325,7 +323,7 @@ mca_coll_basic_alltoallw_inter(const void *sbuf, const int *scounts, const int *
                                       preq++));
         ++nreqs;
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, nreqs);
+            ompi_coll_base_free_reqs(reqs, nreqs);
             return err;
         }
     }
@@ -341,9 +339,8 @@ mca_coll_basic_alltoallw_inter(const void *sbuf, const int *scounts, const int *
      * error after we free everything. */
     err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE);
 
-    if (OMPI_SUCCESS != err) {  /* Free the requests. */
+    /* Free the requests in all cases as they are persistent */
-        mca_coll_basic_free_reqs(reqs, nreqs);
+    ompi_coll_base_free_reqs(reqs, nreqs);
-    }
 
     /* All done */
     return err;

ompi/mca/coll/basic/coll_basic_bcast.c

@@ -81,7 +81,7 @@ mca_coll_basic_bcast_log_intra(void *buff, int count,
 
     /* Send data to the children. */
 
-    reqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, size);
+    reqs = coll_base_comm_get_reqs(module->base_data, size);
 
     err = MPI_SUCCESS;
     preq = reqs;
@@ -92,12 +92,12 @@ mca_coll_basic_bcast_log_intra(void *buff, int count,
             peer = (peer + root) % size;
             ++nreqs;
 
-            err = MCA_PML_CALL(isend_init(buff, count, datatype, peer,
+            err = MCA_PML_CALL(isend(buff, count, datatype, peer,
-                                          MCA_COLL_BASE_TAG_BCAST,
+                                     MCA_COLL_BASE_TAG_BCAST,
-                                          MCA_PML_BASE_SEND_STANDARD,
+                                     MCA_PML_BASE_SEND_STANDARD,
-                                          comm, preq++));
+                                     comm, preq++));
             if (MPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(reqs, nreqs);
+                ompi_coll_base_free_reqs(reqs, nreqs);
                 return err;
             }
         }
@@ -107,10 +107,6 @@ mca_coll_basic_bcast_log_intra(void *buff, int count,
 
     if (nreqs > 0) {
 
-        /* Start your engines.  This will never return an error. */
-
-        MCA_PML_CALL(start(nreqs, reqs));
-
         /* Wait for them all.  If there's an error, note that we don't
          * care what the error was -- just that there *was* an error.
          * The PML will finish all requests, even if one or more of them
@@ -119,11 +115,11 @@ mca_coll_basic_bcast_log_intra(void *buff, int count,
          * error, and return the error after we free everything. */
 
         err = ompi_request_wait_all(nreqs, reqs, MPI_STATUSES_IGNORE);
+        if( MPI_SUCCESS != err ) {
+            ompi_coll_base_free_reqs(reqs, nreqs);
+        }
     }
 
-    if( MPI_SUCCESS != err ) {
-        mca_coll_basic_free_reqs(reqs, nreqs);
-    }
     /* All done */
 
     return err;
@@ -159,7 +155,7 @@ mca_coll_basic_bcast_lin_inter(void *buff, int count,
                                 MCA_COLL_BASE_TAG_BCAST, comm,
                                 MPI_STATUS_IGNORE));
     } else {
-        reqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, rsize);
+        reqs = coll_base_comm_get_reqs(module->base_data, rsize);
         /* root section */
         for (i = 0; i < rsize; i++) {
             err = MCA_PML_CALL(isend(buff, count, datatype, i,
@@ -167,13 +163,13 @@ mca_coll_basic_bcast_lin_inter(void *buff, int count,
                                      MCA_PML_BASE_SEND_STANDARD,
                                      comm, &(reqs[i])));
             if (OMPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(reqs, rsize);
+                ompi_coll_base_free_reqs(reqs, rsize);
                 return err;
             }
         }
         err = ompi_request_wait_all(rsize, reqs, MPI_STATUSES_IGNORE);
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, rsize);
+            ompi_coll_base_free_reqs(reqs, rsize);
         }
     }
 

ompi/mca/coll/basic/coll_basic_component.c

@@ -106,22 +106,10 @@ basic_register(void)
     return OMPI_SUCCESS;
 }
 
-
-static void
-mca_coll_basic_module_construct(mca_coll_basic_module_t *module)
-{
-    module->mccb_reqs = NULL;
-    module->mccb_num_reqs = 0;
-}
-
-static void
-mca_coll_basic_module_destruct(mca_coll_basic_module_t *module)
-{
-    if (NULL != module->mccb_reqs) free(module->mccb_reqs);
-}
-
-
 OBJ_CLASS_INSTANCE(mca_coll_basic_module_t,
                    mca_coll_base_module_t,
-                   mca_coll_basic_module_construct,
+                   NULL,
-                   mca_coll_basic_module_destruct);
+                   NULL);
+
+OBJ_CLASS_INSTANCE(mca_coll_basic_comm_t, mca_coll_base_comm_t,
+                   NULL, NULL);

ompi/mca/coll/basic/coll_basic_gatherv.c

@@ -142,21 +142,21 @@ mca_coll_basic_gatherv_inter(const void *sbuf, int scount,
             return OMPI_ERROR;
         }
 
-        reqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, size);
+        reqs = coll_base_comm_get_reqs(module->base_data, size);
         for (i = 0; i < size; ++i) {
             ptmp = ((char *) rbuf) + (extent * disps[i]);
             err = MCA_PML_CALL(irecv(ptmp, rcounts[i], rdtype, i,
                                      MCA_COLL_BASE_TAG_GATHERV,
                                      comm, &reqs[i]));
             if (OMPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(reqs, size);
+                ompi_coll_base_free_reqs(reqs, size);
                 return err;
             }
         }
 
         err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE);
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, size);
+            ompi_coll_base_free_reqs(reqs, size);
         }
     }
 

ompi/mca/coll/basic/coll_basic_module.c

@@ -181,11 +181,16 @@ int
 mca_coll_basic_module_enable(mca_coll_base_module_t *module,
                              struct ompi_communicator_t *comm)
 {
+    /* prepare the placeholder for the array of request* */
+    module->base_data = OBJ_NEW(mca_coll_basic_comm_t);
+    if (NULL == module->base_data) {
+        return OMPI_ERROR;
+    }
+
     /* All done */
     return OMPI_SUCCESS;
 }
 
-
 int
 mca_coll_basic_ft_event(int state) {
     if(OPAL_CRS_CHECKPOINT == state) {

ompi/mca/coll/basic/coll_basic_neighbor_allgather.c

@@ -50,7 +50,7 @@ mca_coll_basic_neighbor_allgather_cart(const void *sbuf, int scount,
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
 
-    reqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 4 * cart->ndims );
+    reqs = coll_base_comm_get_reqs( module->base_data, 4 * cart->ndims );
     /* The ordering is defined as -1 then +1 in each dimension in
      * order of dimension. */
     for (dim = 0, nreqs = 0 ; dim < cart->ndims ; ++dim) {
@@ -99,13 +99,13 @@ mca_coll_basic_neighbor_allgather_cart(const void *sbuf, int scount,
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, nreqs);
+        ompi_coll_base_free_reqs(reqs, nreqs);
         return rc;
     }
 
     rc = ompi_request_wait_all (nreqs, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, nreqs);
+        ompi_coll_base_free_reqs(reqs, nreqs);
     }
     return rc;
 }
@@ -133,7 +133,7 @@ mca_coll_basic_neighbor_allgather_graph(const void *sbuf, int scount,
     }
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
-    reqs = preqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t *) module, 2 * degree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 2 * degree);
 
     for (neighbor = 0; neighbor < degree ; ++neighbor) {
         rc = MCA_PML_CALL(irecv(rbuf, rcount, rdtype, edges[neighbor], MCA_COLL_BASE_TAG_ALLGATHER,
@@ -150,13 +150,13 @@ mca_coll_basic_neighbor_allgather_graph(const void *sbuf, int scount,
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, (2 * neighbor + 1));
+        ompi_coll_base_free_reqs( reqs, (2 * neighbor + 1));
         return rc;
     }
 
     rc = ompi_request_wait_all (degree * 2, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, degree * 2);
+        ompi_coll_base_free_reqs( reqs, degree * 2);
     }
     return rc;
 }
@@ -182,7 +182,7 @@ mca_coll_basic_neighbor_allgather_dist_graph(const void *sbuf, int scount,
     outedges = dist_graph->out;
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
-    reqs = preqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t *) module, indegree + outdegree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, indegree + outdegree);
 
     for (neighbor = 0; neighbor < indegree ; ++neighbor) {
         rc = MCA_PML_CALL(irecv(rbuf, rcount, rdtype, inedges[neighbor],
@@ -193,7 +193,7 @@ mca_coll_basic_neighbor_allgather_dist_graph(const void *sbuf, int scount,
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, neighbor);
+        ompi_coll_base_free_reqs(reqs, neighbor);
         return rc;
     }
 
@@ -208,13 +208,13 @@ mca_coll_basic_neighbor_allgather_dist_graph(const void *sbuf, int scount,
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + neighbor);
+        ompi_coll_base_free_reqs(reqs, indegree + neighbor);
         return rc;
     }
 
     rc = ompi_request_wait_all (indegree + outdegree, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + outdegree);
+        ompi_coll_base_free_reqs(reqs, indegree + outdegree);
     }
     return rc;
 }

ompi/mca/coll/basic/coll_basic_neighbor_allgatherv.c

@@ -49,7 +49,7 @@ mca_coll_basic_neighbor_allgatherv_cart(const void *sbuf, int scount, struct omp
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
 
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 4 * cart->ndims);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 4 * cart->ndims);
 
     /* The ordering is defined as -1 then +1 in each dimension in
      * order of dimension. */
@@ -88,13 +88,13 @@ mca_coll_basic_neighbor_allgatherv_cart(const void *sbuf, int scount, struct omp
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
         return rc;
     }
 
     rc = ompi_request_wait_all (nreqs, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
     }
     return rc;
 }
@@ -120,7 +120,7 @@ mca_coll_basic_neighbor_allgatherv_graph(const void *sbuf, int scount, struct om
     }
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 2 * degree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 2 * degree);
 
     for (neighbor = 0; neighbor < degree ; ++neighbor) {
         rc = MCA_PML_CALL(irecv((char *) rbuf + disps[neighbor] * extent, rcounts[neighbor],
@@ -136,13 +136,13 @@ mca_coll_basic_neighbor_allgatherv_graph(const void *sbuf, int scount, struct om
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, 2 * (neighbor + 1) );
+        ompi_coll_base_free_reqs( reqs, 2 * (neighbor + 1) );
         return rc;
     }
 
     rc = ompi_request_wait_all (degree * 2, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, 2 * degree );
+        ompi_coll_base_free_reqs( reqs, 2 * degree );
     }
     return rc;
 }
@@ -167,7 +167,7 @@ mca_coll_basic_neighbor_allgatherv_dist_graph(const void *sbuf, int scount, stru
     outedges = dist_graph->out;
 
     ompi_datatype_get_extent(rdtype, &lb, &extent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, indegree + outdegree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, indegree + outdegree);
 
     for (neighbor = 0; neighbor < indegree ; ++neighbor) {
         rc = MCA_PML_CALL(irecv((char *) rbuf + disps[neighbor] * extent, rcounts[neighbor], rdtype,
@@ -176,7 +176,7 @@ mca_coll_basic_neighbor_allgatherv_dist_graph(const void *sbuf, int scount, stru
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, neighbor);
+        ompi_coll_base_free_reqs(reqs, neighbor);
         return rc;
     }
 
@@ -190,13 +190,13 @@ mca_coll_basic_neighbor_allgatherv_dist_graph(const void *sbuf, int scount, stru
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + neighbor);
+        ompi_coll_base_free_reqs(reqs, indegree + neighbor);
         return rc;
     }
 
     rc = ompi_request_wait_all (indegree + outdegree, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + outdegree);
+        ompi_coll_base_free_reqs(reqs, indegree + outdegree);
     }
     return rc;
 }

ompi/mca/coll/basic/coll_basic_neighbor_alltoall.c

@@ -48,7 +48,7 @@ mca_coll_basic_neighbor_alltoall_cart(const void *sbuf, int scount, struct ompi_
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 4 * cart->ndims);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 4 * cart->ndims);
 
     /* post receives first */
     for (dim = 0, nreqs = 0; dim < cart->ndims ; ++dim) {
@@ -82,7 +82,7 @@ mca_coll_basic_neighbor_alltoall_cart(const void *sbuf, int scount, struct ompi_
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs);
+        ompi_coll_base_free_reqs( reqs, nreqs);
         return rc;
     }
 
@@ -121,13 +121,13 @@ mca_coll_basic_neighbor_alltoall_cart(const void *sbuf, int scount, struct ompi_
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs);
+        ompi_coll_base_free_reqs( reqs, nreqs);
         return rc;
     }
 
     rc = ompi_request_wait_all (nreqs, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs);
+        ompi_coll_base_free_reqs( reqs, nreqs);
     }
     return rc;
 }
@@ -153,7 +153,7 @@ mca_coll_basic_neighbor_alltoall_graph(const void *sbuf, int scount, struct ompi
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 2 * degree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 2 * degree);
 
     /* post receives first */
     for (neighbor = 0; neighbor < degree ; ++neighbor) {
@@ -163,7 +163,7 @@ mca_coll_basic_neighbor_alltoall_graph(const void *sbuf, int scount, struct ompi
         rbuf = (char *) rbuf + rdextent * rcount;
     }
     if( MPI_SUCCESS != rc ) {
-        mca_coll_basic_free_reqs( reqs, neighbor );
+        ompi_coll_base_free_reqs( reqs, neighbor );
         return rc;
     }
 
@@ -178,13 +178,13 @@ mca_coll_basic_neighbor_alltoall_graph(const void *sbuf, int scount, struct ompi
     }
 
     if( MPI_SUCCESS != rc ) {
-        mca_coll_basic_free_reqs( reqs, degree + neighbor );
+        ompi_coll_base_free_reqs( reqs, degree + neighbor );
         return rc;
     }
 
     rc = ompi_request_wait_all (degree * 2, reqs, MPI_STATUSES_IGNORE);
     if( MPI_SUCCESS != rc ) {
-        mca_coll_basic_free_reqs( reqs, 2 * degree );
+        ompi_coll_base_free_reqs( reqs, 2 * degree );
     }
     return rc;
 }
@@ -209,7 +209,7 @@ mca_coll_basic_neighbor_alltoall_dist_graph(const void *sbuf, int scount,struct
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, indegree + outdegree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, indegree + outdegree);
 
     /* post receives first */
     for (neighbor = 0; neighbor < indegree ; ++neighbor) {
@@ -221,7 +221,7 @@ mca_coll_basic_neighbor_alltoall_dist_graph(const void *sbuf, int scount,struct
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, neighbor);
+        ompi_coll_base_free_reqs(reqs, neighbor);
         return rc;
     }
 
@@ -235,13 +235,13 @@ mca_coll_basic_neighbor_alltoall_dist_graph(const void *sbuf, int scount,struct
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + neighbor);
+        ompi_coll_base_free_reqs(reqs, indegree + neighbor);
         return rc;
     }
 
     rc = ompi_request_wait_all (indegree + outdegree, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs(reqs, indegree + outdegree);
+        ompi_coll_base_free_reqs(reqs, indegree + outdegree);
     }
     return rc;
 }

ompi/mca/coll/basic/coll_basic_neighbor_alltoallv.c

@@ -49,7 +49,7 @@ mca_coll_basic_neighbor_alltoallv_cart(const void *sbuf, const int scounts[], co
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 4 * cart->ndims );
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 4 * cart->ndims );
 
     /* post receives first */
     for (dim = 0, nreqs = 0, i = 0; dim < cart->ndims ; ++dim, i += 2) {
@@ -77,7 +77,7 @@ mca_coll_basic_neighbor_alltoallv_cart(const void *sbuf, const int scounts[], co
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
         return rc;
     }
 
@@ -107,13 +107,13 @@ mca_coll_basic_neighbor_alltoallv_cart(const void *sbuf, const int scounts[], co
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
         return rc;
     }
 
     rc = ompi_request_wait_all (nreqs, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
     }
     return rc;
 }
@@ -140,7 +140,7 @@ mca_coll_basic_neighbor_alltoallv_graph(const void *sbuf, const int scounts[], c
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 2 * degree );
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 2 * degree );
 
     /* post all receives first */
     for (neighbor = 0; neighbor < degree ; ++neighbor) {
@@ -150,7 +150,7 @@ mca_coll_basic_neighbor_alltoallv_graph(const void *sbuf, const int scounts[], c
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, neighbor );
+        ompi_coll_base_free_reqs( reqs, neighbor );
         return rc;
     }
 
@@ -163,13 +163,13 @@ mca_coll_basic_neighbor_alltoallv_graph(const void *sbuf, const int scounts[], c
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, degree + neighbor );
+        ompi_coll_base_free_reqs( reqs, degree + neighbor );
         return rc;
     }
 
     rc = ompi_request_wait_all (degree * 2, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, degree * 2);
+        ompi_coll_base_free_reqs( reqs, degree * 2);
     }
     return rc;
 }
@@ -195,7 +195,7 @@ mca_coll_basic_neighbor_alltoallv_dist_graph(const void *sbuf, const int scounts
 
     ompi_datatype_get_extent(rdtype, &lb, &rdextent);
     ompi_datatype_get_extent(sdtype, &lb, &sdextent);
-    reqs = preqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t *) module, indegree + outdegree);
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, indegree + outdegree);
 
     /* post all receives first */
     for (neighbor = 0; neighbor < indegree ; ++neighbor) {
@@ -205,7 +205,7 @@ mca_coll_basic_neighbor_alltoallv_dist_graph(const void *sbuf, const int scounts
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, neighbor );
+        ompi_coll_base_free_reqs( reqs, neighbor );
         return rc;
     }
 
@@ -218,13 +218,13 @@ mca_coll_basic_neighbor_alltoallv_dist_graph(const void *sbuf, const int scounts
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, indegree + neighbor );
+        ompi_coll_base_free_reqs( reqs, indegree + neighbor );
         return rc;
     }
 
     rc = ompi_request_wait_all (indegree + outdegree, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, indegree + outdegree );
+        ompi_coll_base_free_reqs( reqs, indegree + outdegree );
     }
     return rc;
 }

ompi/mca/coll/basic/coll_basic_neighbor_alltoallw.c

@@ -46,7 +46,7 @@ mca_coll_basic_neighbor_alltoallw_cart(const void *sbuf, const int scounts[], co
     int rc = MPI_SUCCESS, dim, i, nreqs;
     ompi_request_t **reqs, **preqs;
 
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 4 * cart->ndims );
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 4 * cart->ndims );
 
     /* post receives first */
     for (dim = 0, i = 0, nreqs = 0; dim < cart->ndims ; ++dim, i += 2) {
@@ -74,7 +74,7 @@ mca_coll_basic_neighbor_alltoallw_cart(const void *sbuf, const int scounts[], co
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
         return rc;
     }
 
@@ -104,13 +104,13 @@ mca_coll_basic_neighbor_alltoallw_cart(const void *sbuf, const int scounts[], co
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
         return rc;
     }
 
     rc = ompi_request_wait_all (nreqs, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, nreqs );
+        ompi_coll_base_free_reqs( reqs, nreqs );
     }
     return rc;
 }
@@ -128,7 +128,7 @@ mca_coll_basic_neighbor_alltoallw_graph(const void *sbuf, const int scounts[], c
     const int *edges;
 
     mca_topo_base_graph_neighbors_count (comm, rank, &degree);
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, 2 * degree );
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, 2 * degree );
 
     edges = graph->edges;
     if (rank > 0) {
@@ -143,7 +143,7 @@ mca_coll_basic_neighbor_alltoallw_graph(const void *sbuf, const int scounts[], c
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, neighbor );
+        ompi_coll_base_free_reqs( reqs, neighbor );
         return rc;
     }
 
@@ -156,13 +156,13 @@ mca_coll_basic_neighbor_alltoallw_graph(const void *sbuf, const int scounts[], c
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, neighbor + degree );
+        ompi_coll_base_free_reqs( reqs, neighbor + degree );
         return rc;
     }
 
     rc = ompi_request_wait_all (degree * 2, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, degree * 2 );
+        ompi_coll_base_free_reqs( reqs, degree * 2 );
     }
     return rc;
 }
@@ -185,7 +185,7 @@ mca_coll_basic_neighbor_alltoallw_dist_graph(const void *sbuf, const int scounts
     inedges = dist_graph->in;
     outedges = dist_graph->out;
 
-    reqs = preqs = mca_coll_basic_get_reqs( (mca_coll_basic_module_t *) module, indegree + outdegree );
+    reqs = preqs = coll_base_comm_get_reqs( module->base_data, indegree + outdegree );
     /* post all receives first */
     for (neighbor = 0; neighbor < indegree ; ++neighbor) {
         rc = MCA_PML_CALL(irecv((char *) rbuf + rdisps[neighbor], rcounts[neighbor], rdtypes[neighbor],
@@ -194,7 +194,7 @@ mca_coll_basic_neighbor_alltoallw_dist_graph(const void *sbuf, const int scounts
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, neighbor );
+        ompi_coll_base_free_reqs( reqs, neighbor );
         return rc;
     }
 
@@ -207,13 +207,13 @@ mca_coll_basic_neighbor_alltoallw_dist_graph(const void *sbuf, const int scounts
     }
 
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, indegree + neighbor );
+        ompi_coll_base_free_reqs( reqs, indegree + neighbor );
         return rc;
     }
 
     rc = ompi_request_wait_all (indegree + outdegree, reqs, MPI_STATUSES_IGNORE);
     if (OMPI_SUCCESS != rc) {
-        mca_coll_basic_free_reqs( reqs, indegree + outdegree );
+        ompi_coll_base_free_reqs( reqs, indegree + outdegree );
     }
     return rc;
 }

ompi/mca/coll/basic/coll_basic_scatter.c

@@ -68,7 +68,7 @@ mca_coll_basic_scatter_inter(const void *sbuf, int scount,
             return OMPI_ERROR;
         }
 
-        reqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, size);
+        reqs = coll_base_comm_get_reqs(module->base_data, size);
 
         incr *= scount;
         for (i = 0, ptmp = (char *) sbuf; i < size; ++i, ptmp += incr) {
@@ -77,14 +77,14 @@ mca_coll_basic_scatter_inter(const void *sbuf, int scount,
                                      MCA_PML_BASE_SEND_STANDARD, comm,
                                      reqs++));
             if (OMPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(reqs, i);
+                ompi_coll_base_free_reqs(reqs, i);
                 return err;
             }
         }
 
         err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE);
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, size);
+            ompi_coll_base_free_reqs(reqs, size);
         }
     }
 

ompi/mca/coll/basic/coll_basic_scatterv.c

@@ -144,7 +144,7 @@ mca_coll_basic_scatterv_inter(const void *sbuf, const int *scounts,
             return OMPI_ERROR;
         }
 
-        reqs = mca_coll_basic_get_reqs((mca_coll_basic_module_t*) module, size);
+        reqs = coll_base_comm_get_reqs(module->base_data, size);
         for (i = 0; i < size; ++i) {
             ptmp = ((char *) sbuf) + (extent * disps[i]);
             err = MCA_PML_CALL(isend(ptmp, scounts[i], sdtype, i,
@@ -152,14 +152,14 @@ mca_coll_basic_scatterv_inter(const void *sbuf, const int *scounts,
                                      MCA_PML_BASE_SEND_STANDARD, comm,
                                      &(reqs[i])));
             if (OMPI_SUCCESS != err) {
-                mca_coll_basic_free_reqs(reqs, i);
+                ompi_coll_base_free_reqs(reqs, i);
                 return err;
             }
         }
 
         err = ompi_request_wait_all(size, reqs, MPI_STATUSES_IGNORE);
         if (OMPI_SUCCESS != err) {
-            mca_coll_basic_free_reqs(reqs, size);
+            ompi_coll_base_free_reqs(reqs, size);
         }
     }
 

ompi/mca/coll/tuned/coll_tuned_module.c

@@ -200,7 +200,7 @@ tuned_module_enable( mca_coll_base_module_t *module,
      * The default is set very high
      */
 
-    /* if we within the memory/size limit, allow preallocated data */
+    /* prepare the placeholder for the array of request* */
     data = OBJ_NEW(mca_coll_base_comm_t);
     if (NULL == data) {
         return OMPI_ERROR;