checkpoint

Author: ggouaillardet

ompi/mca/coll/base/coll_base_bcast.c

@@ -35,206 +35,15 @@
 
 int
 ompi_coll_base_bcast_intra_generic( void* buffer,
-                                     int original_count,
-                                     struct ompi_datatype_t* datatype,
-                                     int root,
-                                     struct ompi_communicator_t* comm,
-                                     mca_coll_base_module_t *module,
-                                     uint32_t count_by_segment,
-                                     ompi_coll_tree_t* tree )
+                                    int count,
+                                    struct ompi_datatype_t* datatype,
+                                    int root,
+                                    struct ompi_communicator_t* comm,
+                                    mca_coll_base_module_t *module,
+                                    size_t segment_size,
+                                    ompi_coll_tree_t* tree )
 {
-    int err = 0, line, i, rank, segindex, req_index;
-    int num_segments; /* Number of segments */
-    int sendcount;    /* number of elements sent in this segment */
-    size_t realsegsize, type_size;
-    char *tmpbuf;
-    ptrdiff_t extent, lb;
-    ompi_request_t *recv_reqs[2] = {MPI_REQUEST_NULL, MPI_REQUEST_NULL};
-    ompi_request_t **send_reqs = NULL;
-
-#if OPAL_ENABLE_DEBUG
-    int size;
-    size = ompi_comm_size(comm);
-    assert( size > 1 );
-#endif
-    rank = ompi_comm_rank(comm);
-
-    ompi_datatype_get_extent (datatype, &lb, &extent);
-    ompi_datatype_type_size( datatype, &type_size );
-    num_segments = (original_count + count_by_segment - 1) / count_by_segment;
-    realsegsize = (ptrdiff_t)count_by_segment * extent;
-
-    /* Set the buffer pointers */
-    tmpbuf = (char *) buffer;
-
-    if( tree->tree_nextsize != 0 ) {
-        send_reqs = coll_base_comm_get_reqs(module->base_data, tree->tree_nextsize);
-        if( NULL == send_reqs ) { err = OMPI_ERR_OUT_OF_RESOURCE; line = __LINE__; goto error_hndl; }
-    }
-
-    /* Root code */
-    if( rank == root ) {
-        /*
-           For each segment:
-           - send segment to all children.
-           The last segment may have less elements than other segments.
-        */
-        sendcount = count_by_segment;
-        for( segindex = 0; segindex < num_segments; segindex++ ) {
-            if( segindex == (num_segments - 1) ) {
-                sendcount = original_count - segindex * count_by_segment;
-            }
-            for( i = 0; i < tree->tree_nextsize; i++ ) {
-                err = MCA_PML_CALL(isend(tmpbuf, sendcount, datatype,
-                                         tree->tree_next[i],
-                                         MCA_COLL_BASE_TAG_BCAST,
-                                         MCA_PML_BASE_SEND_STANDARD, comm,
-                                         &send_reqs[i]));
-                if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-            }
-
-            /* complete the sends before starting the next sends */
-            err = ompi_request_wait_all( tree->tree_nextsize, send_reqs,
-                                         MPI_STATUSES_IGNORE );
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-            /* update tmp buffer */
-            tmpbuf += realsegsize;
-
-        }
-    }
-
-    /* Intermediate nodes code */
-    else if( tree->tree_nextsize > 0 ) {
-        /*
-           Create the pipeline.
-           1) Post the first receive
-           2) For segments 1 .. num_segments
-           - post new receive
-           - wait on the previous receive to complete
-           - send this data to children
-           3) Wait on the last segment
-           4) Compute number of elements in last segment.
-           5) Send the last segment to children
-        */
-        req_index = 0;
-        err = MCA_PML_CALL(irecv(tmpbuf, count_by_segment, datatype,
-                                 tree->tree_prev, MCA_COLL_BASE_TAG_BCAST,
-                                 comm, &recv_reqs[req_index]));
-        if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-        for( segindex = 1; segindex < num_segments; segindex++ ) {
-
-            req_index = req_index ^ 0x1;
-
-            /* post new irecv */
-            err = MCA_PML_CALL(irecv( tmpbuf + realsegsize, count_by_segment,
-                                      datatype, tree->tree_prev,
-                                      MCA_COLL_BASE_TAG_BCAST,
-                                      comm, &recv_reqs[req_index]));
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-            /* wait for and forward the previous segment to children */
-            err = ompi_request_wait( &recv_reqs[req_index ^ 0x1],
-                                     MPI_STATUS_IGNORE );
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-            for( i = 0; i < tree->tree_nextsize; i++ ) {
-                err = MCA_PML_CALL(isend(tmpbuf, count_by_segment, datatype,
-                                         tree->tree_next[i],
-                                         MCA_COLL_BASE_TAG_BCAST,
-                                         MCA_PML_BASE_SEND_STANDARD, comm,
-                                         &send_reqs[i]));
-                if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-            }
-
-            /* complete the sends before starting the next iteration */
-            err = ompi_request_wait_all( tree->tree_nextsize, send_reqs,
-                                         MPI_STATUSES_IGNORE );
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-            /* Update the receive buffer */
-            tmpbuf += realsegsize;
-
-        }
-
-        /* Process the last segment */
-        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++ ) {
-            err = MCA_PML_CALL(isend(tmpbuf, sendcount, datatype,
-                                     tree->tree_next[i],
-                                     MCA_COLL_BASE_TAG_BCAST,
-                                     MCA_PML_BASE_SEND_STANDARD, comm,
-                                     &send_reqs[i]));
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-        }
-
-        err = ompi_request_wait_all( tree->tree_nextsize, send_reqs,
-                                     MPI_STATUSES_IGNORE );
-        if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-    }
-
-    /* Leaf nodes */
-    else {
-        /*
-           Receive all segments from parent in a loop:
-           1) post irecv for the first segment
-           2) for segments 1 .. num_segments
-           - post irecv for the next segment
-           - wait on the previous segment to arrive
-           3) wait for the last segment
-        */
-        req_index = 0;
-        err = MCA_PML_CALL(irecv(tmpbuf, count_by_segment, datatype,
-                                 tree->tree_prev, MCA_COLL_BASE_TAG_BCAST,
-                                 comm, &recv_reqs[req_index]));
-        if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-
-        for( segindex = 1; segindex < num_segments; segindex++ ) {
-            req_index = req_index ^ 0x1;
-            tmpbuf += realsegsize;
-            /* post receive for the next segment */
-            err = MCA_PML_CALL(irecv(tmpbuf, count_by_segment, datatype,
-                                     tree->tree_prev, MCA_COLL_BASE_TAG_BCAST,
-                                     comm, &recv_reqs[req_index]));
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-            /* wait on the previous segment */
-            err = ompi_request_wait( &recv_reqs[req_index ^ 0x1],
-                                     MPI_STATUS_IGNORE );
-            if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-        }
-
-        err = ompi_request_wait( &recv_reqs[req_index], MPI_STATUS_IGNORE );
-        if (err != MPI_SUCCESS) { line = __LINE__; goto error_hndl; }
-    }
-
-    return (MPI_SUCCESS);
-
- error_hndl:
-    OPAL_OUTPUT( (ompi_coll_base_framework.framework_output,"%s:%4d\tError occurred %d, rank %2d",
-                  __FILE__, line, err, rank) );
-    (void)line;  // silence compiler warnings
-    ompi_coll_base_free_reqs( recv_reqs, 2);
-    if( NULL != send_reqs ) {
-        ompi_coll_base_free_reqs(send_reqs, tree->tree_nextsize);
-    }
-
-    return err;
-}
-
-int
-ompi_coll_base_bcast_intra_generic2( void* buffer,
-                                     int count,
-                                     struct ompi_datatype_t* datatype,
-                                     int root,
-                                     struct ompi_communicator_t* comm,
-                                     mca_coll_base_module_t *module,
-                                     size_t segment_size,
-                                     ompi_coll_tree_t* tree )
-{
-    int err = 0, line, i = 0, rank, req_index;
+    int err = 0, line, i = 0, rank;
     opal_convertor_t send_convertors[2], recv_convertors[2];
     size_t offset = 0;
     size_t next_offset;
@@ -501,23 +310,15 @@ ompi_coll_base_bcast_intra_bintree ( void* buffer,
                                       mca_coll_base_module_t *module,
                                       uint32_t segsize )
 {
-    int segcount = count;
-    size_t typelng;
     mca_coll_base_comm_t *data = module->base_data;
 
     COLL_BASE_UPDATE_BINTREE( comm, module, root );
 
-    /**
-     * Determine number of elements sent per operation.
-     */
-    ompi_datatype_type_size( datatype, &typelng );
-    COLL_BASE_COMPUTED_SEGCOUNT( segsize, typelng, segcount );
-
-    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_binary rank %d ss %5d typelng %lu segcount %d",
-                 ompi_comm_rank(comm), segsize, (unsigned long)typelng, segcount));
+    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_binary rank %d ss %5d",
+                 ompi_comm_rank(comm), segsize));
 
     return ompi_coll_base_bcast_intra_generic( buffer, count, datatype, root, comm, module,
-                                                segcount, data->cached_bintree );
+                                               segsize, data->cached_bintree );
 }
 
 int
@@ -536,8 +337,8 @@ ompi_coll_base_bcast_intra_pipeline( void* buffer,
     OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_pipeline rank %d ss %5d",
                  ompi_comm_rank(comm), segsize));
 
-    return ompi_coll_base_bcast_intra_generic2( buffer, count, datatype, root, comm, module,
-                                                segsize, data->cached_pipeline );
+    return ompi_coll_base_bcast_intra_generic( buffer, count, datatype, root, comm, module,
+                                               segsize, data->cached_pipeline );
 }
 
 int
@@ -549,23 +350,15 @@ ompi_coll_base_bcast_intra_chain( void* buffer,
                                    mca_coll_base_module_t *module,
                                    uint32_t segsize, int32_t chains )
 {
-    int segcount = count;
-    size_t typelng;
     mca_coll_base_comm_t *data = module->base_data;
 
     COLL_BASE_UPDATE_CHAIN( comm, module, root, chains );
 
-    /**
-     * Determine number of elements sent per operation.
-     */
-    ompi_datatype_type_size( datatype, &typelng );
-    COLL_BASE_COMPUTED_SEGCOUNT( segsize, typelng, segcount );
-
-    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_chain rank %d fo %d ss %5d typelng %lu segcount %d",
-                 ompi_comm_rank(comm), chains, segsize, (unsigned long)typelng, segcount));
+    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_chain rank %d fo %d ss %5d",
+                 ompi_comm_rank(comm), chains, segsize));
 
     return ompi_coll_base_bcast_intra_generic( buffer, count, datatype, root, comm, module,
-                                                segcount, data->cached_chain );
+                                               segsize, data->cached_chain );
 }
 
 int
@@ -577,23 +370,15 @@ ompi_coll_base_bcast_intra_binomial( void* buffer,
                                       mca_coll_base_module_t *module,
                                       uint32_t segsize )
 {
-    int segcount = count;
-    size_t typelng;
     mca_coll_base_comm_t *data = module->base_data;
 
     COLL_BASE_UPDATE_BMTREE( comm, module, root );
 
-    /**
-     * Determine number of elements sent per operation.
-     */
-    ompi_datatype_type_size( datatype, &typelng );
-    COLL_BASE_COMPUTED_SEGCOUNT( segsize, typelng, segcount );
-
-    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_binomial rank %d ss %5d typelng %lu segcount %d",
-                 ompi_comm_rank(comm), segsize, (unsigned long)typelng, segcount));
+    OPAL_OUTPUT((ompi_coll_base_framework.framework_output,"coll:base:bcast_intra_binomial rank %d ss %5d",
+                 ompi_comm_rank(comm), segsize));
 
     return ompi_coll_base_bcast_intra_generic( buffer, count, datatype, root, comm, module,
-                                                segcount, data->cached_bmtree );
+                                               segsize, data->cached_bmtree );
 }
 
 int

ompi/mca/coll/base/coll_base_functions.h

@@ -130,8 +130,7 @@ int ompi_coll_base_barrier_intra_tree(BARRIER_ARGS);
 int ompi_coll_base_barrier_intra_basic_linear(BARRIER_ARGS);
 
 /* Bcast */
-int ompi_coll_base_bcast_intra_generic(BCAST_ARGS, uint32_t count_by_segment, ompi_coll_tree_t* tree);
-int ompi_coll_base_bcast_intra_generic2(BCAST_ARGS, size_t segment_size, ompi_coll_tree_t* tree);
+int ompi_coll_base_bcast_intra_generic(BCAST_ARGS, size_t segment_size, ompi_coll_tree_t* tree);
 int ompi_coll_base_bcast_intra_basic_linear(BCAST_ARGS);
 int ompi_coll_base_bcast_intra_chain(BCAST_ARGS, uint32_t segsize, int32_t chains);
 int ompi_coll_base_bcast_intra_pipeline(BCAST_ARGS, uint32_t segsize);

ompi/mca/pml/ob1/pml_ob1_recvreq.c

@@ -694,7 +694,7 @@ void mca_pml_ob1_recv_request_progress_rget( mca_pml_ob1_recv_request_t* recvreq
 #endif /* OPAL_CUDA_GDR_SUPPORT */
 
 
-        offset = 0;
+        offset = recvreq->req_recv.req_base.req_offset;
 
         OPAL_THREAD_LOCK(&recvreq->lock);
         opal_convertor_set_position( &recvreq->req_recv.req_base.req_convertor, &offset);
@@ -731,14 +731,12 @@ void mca_pml_ob1_recv_request_progress_rget( mca_pml_ob1_recv_request_t* recvreq
         memcpy (frag->remote_handle, hdr + 1, btl->btl_registration_handle_size);
 
         /* update the read location */
-        frag->remote_address = hdr->hdr_src_ptr + offset;
+        frag->remote_address = hdr->hdr_src_ptr + offset - recvreq->req_recv.req_base.req_offset;
 
         /* updating the write location */
         OPAL_THREAD_LOCK(&recvreq->lock);
-        offset += recvreq->req_recv.req_base.req_offset;
         opal_convertor_set_position( &recvreq->req_recv.req_base.req_convertor, &offset);
         opal_convertor_get_current_pointer (&recvreq->req_recv.req_base.req_convertor, &frag->local_address);
-        offset -= recvreq->req_recv.req_base.req_offset;
         OPAL_THREAD_UNLOCK(&recvreq->lock);
 
         frag->rdma_bml = rdma_bml;
@@ -846,7 +844,8 @@ void mca_pml_ob1_recv_request_progress_match( mca_pml_ob1_recv_request_t* recvre
                                               mca_btl_base_segment_t* segments,
                                               size_t num_segments )
 {
-    size_t bytes_received, data_offset = 0;
+    // size_t bytes_received, data_offset = 0;
+    size_t bytes_received, data_offset = recvreq->req_recv.req_base.req_offset;
     size_t bytes_delivered __opal_attribute_unused__; /* is being set to zero in MCA_PML_OB1_RECV_REQUEST_UNPACK */
     mca_pml_ob1_hdr_t* hdr = (mca_pml_ob1_hdr_t*)segments->seg_addr.pval;
 

ompi/mca/pml/ob1/pml_ob1_sendreq.h

@@ -159,10 +159,10 @@ get_request_from_send_pending(mca_pml_ob1_send_pending_t *type)
 
 #define MCA_PML_OB1_SEND_REQUEST_RESET(sendreq)                         \
     if ((sendreq)->req_send.req_bytes_packed > 0) {                     \
-        size_t _position = 0;                                           \
+        size_t _position = sendreq->req_send.req_base.req_offset;       \
         opal_convertor_set_position(&(sendreq)->req_send.req_base.req_convertor, \
                                     &_position);                        \
-        assert( 0 == _position );                                       \
+        assert( sendreq->req_send.req_base.req_offset == _position );   \
     }
 
 static inline void mca_pml_ob1_free_rdma_resources (mca_pml_ob1_send_request_t* sendreq)

ompi/mpiext/split/c/Makefile.am

@@ -48,6 +48,7 @@ libmpiext_split_c_la_SOURCES += \
         $(ompi_HEADERS) \
         mpiext_isplit_recv.c \
         mpiext_isplit_send.c \
+        mpiext_split_recv.c \
         mpiext_split_send.c
 endif
 

ompi/mpiext/split/c/mpiext_isplit_recv.c

@@ -88,12 +88,14 @@ int OMPI_Isplit_recv(void *buf, int count, MPI_Datatype type, int source,
     }
     size = size / 2;
     offset = 0;
+#if 0
     opal_convertor_set_position(&convertor, &offset);
     OPAL_CR_ENTER_LIBRARY();
     rc = MCA_PML_CALL(icrecv(&convertor, &size, source, tag, comm, request));
     if (OMPI_SUCCESS != rc) {
         OMPI_ERRHANDLER_RETURN(rc, comm, rc, FUNC_NAME);
     }
+#endif
     offset += size;
     opal_convertor_set_position(&convertor, &offset);
     rc = MCA_PML_CALL(icrecv(&convertor, &size, source, tag, comm, request+1));