osc/pt2pt: do not use frag send to send lock request

This commit cleans up some code in the passive target path. The code
used the buffered frag control send path but it is more appropriate to
use the unbuffered one. This avoids checking structures that are
should not be in use in this path.

Signed-off-by: Nathan Hjelm <hjelmn@lanl.gov>

ompi/mca/osc/pt2pt/osc_pt2pt_data_move.c

@@ -1546,12 +1546,6 @@ static inline int process_frag (ompi_osc_pt2pt_module_t *module,
                 ret = process_acc_long (module, frag->source, &header->acc);
                 break;
 
-            case OMPI_OSC_PT2PT_HDR_TYPE_LOCK_REQ:
-                ret = ompi_osc_pt2pt_process_lock(module, frag->source, &header->lock);
-                if (OPAL_LIKELY(OMPI_SUCCESS == ret)) {
-                    ret = sizeof (header->lock);
-                }
-                break;
             case OMPI_OSC_PT2PT_HDR_TYPE_UNLOCK_REQ:
                 ret = process_unlock(module, frag->source, &header->unlock);
                 break;
@@ -1656,6 +1650,9 @@ int ompi_osc_pt2pt_process_receive (ompi_osc_pt2pt_receive_t *recv)
     case OMPI_OSC_PT2PT_HDR_TYPE_POST:
         osc_pt2pt_incoming_post (module, source);
         break;
+    case OMPI_OSC_PT2PT_HDR_TYPE_LOCK_REQ:
+        ompi_osc_pt2pt_process_lock(module, source, (ompi_osc_pt2pt_header_lock_t *) base_header);
+        break;
     case OMPI_OSC_PT2PT_HDR_TYPE_LOCK_ACK:
         ompi_osc_pt2pt_process_lock_ack(module, (ompi_osc_pt2pt_header_lock_ack_t *) base_header);
         break;

ompi/mca/osc/pt2pt/osc_pt2pt_frag.c

@@ -151,38 +151,6 @@ int ompi_osc_pt2pt_frag_flush_target (ompi_osc_pt2pt_module_t *module, int targe
     return ret;
 }
 
-int ompi_osc_pt2pt_frag_flush_target_locked (ompi_osc_pt2pt_module_t *module, int target)
-{
-    ompi_osc_pt2pt_peer_t *peer = ompi_osc_pt2pt_peer_lookup (module, target);
-    ompi_osc_pt2pt_frag_t *frag;
-    int ret = OMPI_SUCCESS;
-
-    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
-                         "osc pt2pt: frag flush to target target %d. queue fragments: %lu",
-                         target, (unsigned long) opal_list_get_size (&peer->queued_frags)));
-
-    /* walk through the pending list and send */
-    while (NULL != (frag = ((ompi_osc_pt2pt_frag_t *) opal_list_remove_first (&peer->queued_frags)))) {
-        ret = frag_send(module, frag);
-        if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
-            break;
-        }
-    }
-
-    /* XXX -- TODO -- better error handling */
-    if (OMPI_SUCCESS != ret) {
-        return ret;
-    }
-
-    /* flush the active frag */
-    ret = ompi_osc_pt2pt_flush_active_frag (module, peer);
-
-    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
-                         "osc pt2pt: frag flush target %d finished", target));
-
-    return ret;
-}
-
 int ompi_osc_pt2pt_frag_flush_all (ompi_osc_pt2pt_module_t *module)
 {
     int ret = OMPI_SUCCESS;

ompi/mca/osc/pt2pt/osc_pt2pt_frag.h

@@ -43,7 +43,6 @@ OBJ_CLASS_DECLARATION(ompi_osc_pt2pt_frag_t);
 
 int ompi_osc_pt2pt_frag_start(ompi_osc_pt2pt_module_t *module, ompi_osc_pt2pt_frag_t *buffer);
 int ompi_osc_pt2pt_frag_flush_target(ompi_osc_pt2pt_module_t *module, int target);
-int ompi_osc_pt2pt_frag_flush_target_locked(ompi_osc_pt2pt_module_t *module, int target);
 int ompi_osc_pt2pt_frag_flush_all(ompi_osc_pt2pt_module_t *module);
 
 static inline int ompi_osc_pt2pt_frag_finish (ompi_osc_pt2pt_module_t *module,

ompi/mca/osc/pt2pt/osc_pt2pt_passive_target.c

@@ -143,22 +143,13 @@ int ompi_osc_pt2pt_lock_remote (ompi_osc_pt2pt_module_t *module, int target, omp
     lock_req.lock_ptr = (uint64_t) (uintptr_t) lock;
     OSC_PT2PT_HTON(&lock_req, module, target);
 
-    do {
-        ret = ompi_osc_pt2pt_control_send (module, target, &lock_req, sizeof (lock_req));
-        if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
-            break;
-        }
-
-        /* make sure the request gets sent, so we can start eager sending... */
-        ret = ompi_osc_pt2pt_frag_flush_target_locked (module, target);
-    } while (0);
-
+    ret = ompi_osc_pt2pt_control_send_unbuffered (module, target, &lock_req, sizeof (lock_req));
     if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
         OPAL_THREAD_ADD32(&lock->sync_expected, -1);
+    } else {
+        ompi_osc_pt2pt_peer_set_locked (peer, true);
     }
 
-    ompi_osc_pt2pt_peer_set_locked (peer, true);
-
     OPAL_THREAD_UNLOCK(&peer->lock);
 
     return ret;