opal/mca/btl/ugni/btl_ugni

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mca_btl_ugni_smsg_mbox_construct
mca_btl_ugni_smsg_init
mca_btl_ugni_smsg_process
mca_btl_ugni_handle_remote_smsg_overrun
mca_btl_ugni_progress_remote_smsg
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2011-2017 Los Alamos National Security, LLC. All rights
   4  *                         reserved.
   5  * Copyright (c) 2011      UT-Battelle, LLC. All rights reserved.
   6  * $COPYRIGHT$
   7  *
   8  * Additional copyrights may follow
   9  *
  10  * $HEADER$
  11  */
  12 
  13 #include "btl_ugni_smsg.h"
  14 #include "btl_ugni_rdma.h"
  15 
  16 static void mca_btl_ugni_smsg_mbox_construct (mca_btl_ugni_smsg_mbox_t *mbox) {
  17     struct mca_btl_ugni_reg_t *ugni_reg =
  18         (struct mca_btl_ugni_reg_t *) mbox->super.registration;
  19     mca_rcache_base_registration_t *base_reg =
  20         (mca_rcache_base_registration_t *) ugni_reg;
  21 
  22     /* initialize mailbox attributes */
  23     mbox->attr.smsg_attr.msg_type       = GNI_SMSG_TYPE_MBOX_AUTO_RETRANSMIT;
  24     mbox->attr.smsg_attr.msg_maxsize    = mca_btl_ugni_component.ugni_smsg_limit;
  25     mbox->attr.smsg_attr.mbox_maxcredit = mca_btl_ugni_component.smsg_max_credits;
  26     mbox->attr.smsg_attr.mbox_offset    = (uintptr_t) mbox->super.ptr - (uintptr_t) base_reg->base;
  27     mbox->attr.smsg_attr.msg_buffer     = base_reg->base;
  28     mbox->attr.smsg_attr.buff_size      = mca_btl_ugni_component.smsg_mbox_size;
  29     mbox->attr.smsg_attr.mem_hndl       = ugni_reg->handle.gni_handle;
  30     mbox->attr.proc_name = OPAL_PROC_MY_NAME;
  31     mbox->attr.rmt_irq_mem_hndl = mca_btl_ugni_component.modules[0].devices[0].smsg_irq_mhndl;
  32 }
  33 
  34 OBJ_CLASS_INSTANCE(mca_btl_ugni_smsg_mbox_t, opal_free_list_item_t,
  35                    mca_btl_ugni_smsg_mbox_construct, NULL);
  36 
  37 
  38 int mca_btl_ugni_smsg_init (mca_btl_ugni_module_t *ugni_module)
  39 {
  40     gni_return_t rc;
  41 
  42     for (int i = 0 ; i < mca_btl_ugni_component.virtual_device_count ; ++i) {
  43         rc = GNI_SmsgSetMaxRetrans (ugni_module->devices[i].dev_handle,
  44                                     mca_btl_ugni_component.smsg_max_retries);
  45         if (GNI_RC_SUCCESS != rc) {
  46             BTL_ERROR(("error setting maximum SMSG retries %s",gni_err_str[rc]));
  47             return mca_btl_rc_ugni_to_opal (rc);
  48         }
  49     }
  50 
  51     return OPAL_SUCCESS;
  52 }
  53 
  54 /* progress */
  55 int mca_btl_ugni_smsg_process (mca_btl_base_endpoint_t *ep)
  56 {
  57     mca_btl_ugni_module_t *ugni_module = mca_btl_ugni_ep_btl (ep);
  58     mca_btl_active_message_callback_t *reg;
  59     mca_btl_ugni_base_frag_t frag;
  60     mca_btl_base_segment_t seg;
  61     bool disconnect = false;
  62     int32_t _tmp_value = 0;
  63     uintptr_t data_ptr;
  64     gni_return_t rc;
  65     uint32_t len;
  66     int count = 0;
  67 
  68     if (!opal_atomic_compare_exchange_strong_32 (&ep->smsg_progressing, &_tmp_value, 1)) {
  69         /* already progressing (we can't support reentry here) */
  70         return 0;
  71     }
  72 
  73     /* per uGNI documentation we loop until the mailbox is empty */
  74     do {
  75         uint8_t tag = GNI_SMSG_ANY_TAG;
  76 
  77         rc = mca_btl_ugni_smsg_get_next_wtag (&ep->smsg_ep_handle, &data_ptr, &tag);
  78         if (GNI_RC_SUCCESS != rc) {
  79             if (OPAL_LIKELY(GNI_RC_NOT_DONE == rc)) {
  80                 BTL_VERBOSE(("no smsg message waiting. rc = %s", gni_err_str[rc]));
  81 
  82                 ep->smsg_progressing = 0;
  83                 return count;
  84             }
  85 
  86             BTL_ERROR(("unhandled GNI_SmsgGetNextWTag error"));
  87             return OPAL_ERROR;
  88         }
  89 
  90         assert (0 != data_ptr);
  91 
  92         count++;
  93 
  94         BTL_VERBOSE(("got smsg fragment. tag = %d\n", tag));
  95 
  96         switch (tag) {
  97         case MCA_BTL_UGNI_TAG_SEND:
  98             frag.hdr.send = ((mca_btl_ugni_send_frag_hdr_t *) data_ptr)[0];
  99 
 100             tag = frag.hdr.send.lag >> 24;
 101             len = frag.hdr.send.lag & 0x00ffffff;
 102 
 103             BTL_VERBOSE(("received smsg fragment. hdr = {len = %u, tag = %d}", len, tag));
 104 
 105             reg = mca_btl_base_active_message_trigger + tag;
 106             frag.base.des_segments       = &seg;
 107             frag.base.des_segment_count = 1;
 108 
 109             seg.seg_addr.pval = (void *)((uintptr_t)data_ptr + sizeof (mca_btl_ugni_send_frag_hdr_t));
 110             seg.seg_len       = len;
 111 
 112             assert (NULL != reg->cbfunc);
 113 
 114             reg->cbfunc(&ugni_module->super, tag, &(frag.base), reg->cbdata);
 115 
 116             break;
 117         case MCA_BTL_UGNI_TAG_GET_INIT:
 118             frag.hdr.eager_ex = ((mca_btl_ugni_eager_ex_frag_hdr_t *) data_ptr)[0];
 119 
 120             mca_btl_ugni_start_eager_get (ep, frag.hdr.eager_ex, NULL);
 121             break;
 122         case MCA_BTL_UGNI_TAG_RDMA_COMPLETE:
 123             frag.hdr.rdma = ((mca_btl_ugni_rdma_frag_hdr_t *) data_ptr)[0];
 124 
 125             if (((mca_btl_ugni_base_frag_t *)frag.hdr.rdma.ctx)->flags & MCA_BTL_UGNI_FRAG_SMSG_COMPLETE) {
 126                 mca_btl_ugni_frag_complete (frag.hdr.rdma.ctx, OPAL_SUCCESS);
 127             } else {
 128                 /* let the local smsg completion finish this frag */
 129                 ((mca_btl_ugni_base_frag_t *)frag.hdr.rdma.ctx)->flags &= ~MCA_BTL_UGNI_FRAG_IGNORE;
 130             }
 131             break;
 132         case MCA_BTL_UGNI_TAG_DISCONNECT:
 133             /* remote endpoint has disconnected */
 134             disconnect = true;
 135             break;
 136         default:
 137             BTL_ERROR(("unknown tag %d\n", tag));
 138             break;
 139         }
 140 
 141         rc = mca_btl_ugni_smsg_release (&ep->smsg_ep_handle);
 142         if (OPAL_UNLIKELY(GNI_RC_SUCCESS != rc)) {
 143             BTL_ERROR(("Smsg release failed! rc = %d", rc));
 144             return OPAL_ERROR;
 145         }
 146     } while (!disconnect);
 147 
 148     ep->smsg_progressing = 0;
 149 
 150     /* disconnect if we get here */
 151     opal_mutex_lock (&ep->lock);
 152 
 153     mca_btl_ugni_ep_disconnect (ep, false);
 154 
 155     opal_mutex_unlock (&ep->lock);
 156 
 157     return count;
 158 }
 159 
 160 static inline int
 161 mca_btl_ugni_handle_remote_smsg_overrun (mca_btl_ugni_module_t *btl)
 162 {
 163     size_t endpoint_count;
 164     unsigned int ep_index;
 165     int count, rc;
 166 
 167     BTL_VERBOSE(("btl/ugni_component detected SMSG CQ overrun. "
 168                  "processing message backlog..."));
 169 
 170     /* we don't know which endpoint lost an smsg completion. clear the
 171        smsg remote cq and check all mailboxes */
 172 
 173     /* clear out remote cq */
 174     mca_btl_ugni_cq_clear (btl->devices, btl->smsg_remote_cq);
 175 
 176     endpoint_count = opal_pointer_array_get_size (&btl->endpoints);
 177 
 178     for (ep_index = 0, count = 0 ; ep_index < endpoint_count ; ++ep_index) {
 179         mca_btl_base_endpoint_t *ep;
 180 
 181         ep = (mca_btl_base_endpoint_t *) opal_pointer_array_get_item (&btl->endpoints,
 182                                                                       ep_index);
 183 
 184         if (NULL == ep || MCA_BTL_UGNI_EP_STATE_CONNECTED != ep->state) {
 185             continue;
 186         }
 187 
 188         /* clear out smsg mailbox */
 189         rc = mca_btl_ugni_smsg_process (ep);
 190         if (OPAL_LIKELY(rc >= 0)) {
 191             count += rc;
 192         }
 193     }
 194 
 195     return count;
 196 }
 197 
 198 int mca_btl_ugni_progress_remote_smsg (mca_btl_ugni_module_t *btl)
 199 {
 200     mca_btl_base_endpoint_t *ep;
 201     gni_cq_entry_t event_data;
 202     gni_return_t grc;
 203     uint64_t inst_id;
 204 
 205     grc = mca_btl_ugni_gni_cq_get_event (btl->devices, btl->smsg_remote_cq, &event_data);
 206     if (GNI_RC_NOT_DONE == grc) {
 207         return 0;
 208     }
 209 
 210     if (OPAL_UNLIKELY(GNI_RC_SUCCESS != grc || !GNI_CQ_STATUS_OK(event_data) ||
 211                       GNI_CQ_OVERRUN(event_data))) {
 212         if (GNI_RC_ERROR_RESOURCE == grc ||
 213             (GNI_RC_SUCCESS == grc && GNI_CQ_OVERRUN(event_data))) {
 214             /* recover from smsg cq overrun */
 215             return mca_btl_ugni_handle_remote_smsg_overrun (btl);
 216         }
 217 
 218         BTL_ERROR(("unhandled error in GNI_CqGetEvent"));
 219 
 220         /* unhandled error: crash */
 221         assert (0);
 222         return mca_btl_rc_ugni_to_opal (grc);
 223     }
 224 
 225     BTL_VERBOSE(("REMOTE CQ: Got event 0x%" PRIx64 ". msg id = %" PRIu64
 226                  ". ok = %d, type = %" PRIu64, (uint64_t) event_data,
 227                  GNI_CQ_GET_INST_ID(event_data), GNI_CQ_STATUS_OK(event_data),
 228                  GNI_CQ_GET_TYPE(event_data)));
 229 
 230     inst_id = GNI_CQ_GET_INST_ID(event_data);
 231 
 232     ep = (mca_btl_base_endpoint_t *) opal_pointer_array_get_item (&btl->endpoints, inst_id);
 233 
 234     if (OPAL_UNLIKELY(MCA_BTL_UGNI_EP_STATE_CONNECTED != ep->state)) {
 235         /* due to the nature of datagrams we may get a smsg completion before
 236            we get mailbox info from the peer */
 237         BTL_VERBOSE(("event occurred on an unconnected endpoint! ep state = %d", ep->state));
 238         return 0;
 239     }
 240 
 241     return mca_btl_ugni_smsg_process (ep);
 242 }
 243
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/btl/ugni/btl_ugni_smsg.c

DEFINITIONS
