- CM blocking send/recv optimizations

This patch tries to do as little as possible in the PML CM blocking
    send/receive routines.  Basically, avoid creating and filling in an
    entire request object.  An OMPI-level request is still needed, but we
    can create that on the stack instead of going to a free list.

Signed-off-by: Andrew Friedley <andrew.friedley@intel.com>
Signed-off-by: Jithin Jose <jithin.jose@intel.com>

ompi/mca/pml/cm/pml_cm_recv.c

@@ -82,6 +82,13 @@ mca_pml_cm_irecv(void *addr,
 }
 
 
+void mca_pml_cm_recv_fast_completion(struct mca_mtl_request_t *mtl_request)
+{
+    // Do nothing!
+    ompi_request_complete(mtl_request->ompi_req, true);
+    return;
+}
+
 int
 mca_pml_cm_recv(void *addr,
                 size_t count,
@@ -92,35 +99,53 @@ mca_pml_cm_recv(void *addr,
                 ompi_status_public_t * status)
 {
     int ret;
-    mca_pml_cm_thin_recv_request_t *recvreq;
-    ompi_proc_t* ompi_proc;
-    
-    MCA_PML_CM_THIN_RECV_REQUEST_ALLOC(recvreq);
-    if( OPAL_UNLIKELY(NULL == recvreq) ) return OMPI_ERR_OUT_OF_RESOURCE;
+    ompi_proc_t *ompi_proc;
+    opal_convertor_t convertor;
+    mca_pml_cm_request_t req;
+    mca_mtl_request_t *req_mtl =
+            alloca(sizeof(mca_mtl_request_t) + ompi_mtl->mtl_request_size);
 
-    MCA_PML_CM_THIN_RECV_REQUEST_INIT(recvreq,
-                                      ompi_proc,
-                                      comm, 
-                                      src,
-                                      datatype,
-                                      addr,
-                                      count);
-    
-    
-    MCA_PML_CM_THIN_RECV_REQUEST_START(recvreq, comm, tag, src, ret);
+    req_mtl->ompi_req = &req.req_ompi;
+    req_mtl->completion_callback = mca_pml_cm_recv_fast_completion;
+
+    req.req_pml_type = MCA_PML_CM_REQUEST_RECV_THIN;
+    req.req_free_called = false;
+    req.req_ompi.req_complete = false;
+    req.req_ompi.req_complete_cb = NULL;
+    req.req_ompi.req_state = OMPI_REQUEST_ACTIVE;
+    req.req_ompi.req_status.MPI_TAG = OMPI_ANY_TAG;
+    req.req_ompi.req_status.MPI_ERROR = OMPI_SUCCESS;
+    req.req_ompi.req_status._cancelled = 0;
+
+    if( MPI_ANY_SOURCE == src ) {
+        ompi_proc = ompi_proc_local_proc;
+    } else {
+        ompi_proc = ompi_comm_peer_lookup( comm, src );
+    }
+
+    opal_convertor_copy_and_prepare_for_recv(
+                                  ompi_proc->super.proc_convertor,
+                                  &(datatype->super),
+                                  count,
+                                  addr,
+                                  0,
+                                  &convertor );
+    ret = OMPI_MTL_CALL(irecv(ompi_mtl,
+                              comm,
+                              src,
+                              tag,
+                              &convertor,
+                              req_mtl));
     if( OPAL_UNLIKELY(OMPI_SUCCESS != ret) ) {
-        /* BWB - XXX - need cleanup of request here */
-        MCA_PML_CM_THIN_RECV_REQUEST_RETURN(recvreq);
         return ret;
     }
 
-    ompi_request_wait_completion(&recvreq->req_base.req_ompi);
+    ompi_request_wait_completion(&req.req_ompi);
 
     if (NULL != status) {  /* return status */
-        *status = recvreq->req_base.req_ompi.req_status;
+        *status = req.req_ompi.req_status;
     }
-    ret = recvreq->req_base.req_ompi.req_status.MPI_ERROR;
-    ompi_request_free( (ompi_request_t**)&recvreq );
+    ret = req.req_ompi.req_status.MPI_ERROR;
 
     return ret;
 }

ompi/mca/pml/cm/pml_cm_send.c

@@ -150,31 +150,20 @@ mca_pml_cm_send(void *buf,
         
         ompi_request_free( (ompi_request_t**)&sendreq );
     } else { 
-        mca_pml_cm_thin_send_request_t *sendreq;
-        ompi_proc_t * ompi_proc;
-        MCA_PML_CM_THIN_SEND_REQUEST_ALLOC(sendreq, comm, dst, ompi_proc);
-        if (OPAL_UNLIKELY(NULL == sendreq)) return OMPI_ERR_OUT_OF_RESOURCE;
-        
-        MCA_PML_CM_THIN_SEND_REQUEST_INIT(sendreq,
-                                          ompi_proc,
-                                          comm,
-                                          tag,
-                                          dst, 
-                                          datatype,
-                                          sendmode,
-                                          buf,
-                                          count);
-        MCA_PML_CM_SEND_REQUEST_START_SETUP((&sendreq->req_send));
-            
+        opal_convertor_t convertor;
+        ompi_proc_t *ompi_proc = ompi_comm_peer_lookup(comm, dst);
+
+        opal_convertor_copy_and_prepare_for_send(
+		ompi_proc->super.proc_convertor,
+                &datatype->super, count, buf, 0,
+                &convertor);
+
         ret = OMPI_MTL_CALL(send(ompi_mtl,                             
                                  comm, 
                                  dst, 
                                  tag,  
-                                 &sendreq->req_send.req_base.req_convertor,
+                                 &convertor,
                                  sendmode));
-        /* Allow a quick path for the request return */
-        sendreq->req_send.req_base.req_free_called = true;
-        MCA_PML_CM_THIN_SEND_REQUEST_PML_COMPLETE(sendreq);
     }
     
     return ret;