root/opal/mca/btl/self/btl_self.c

DEFINITIONS

1. mca_btl_self_add_procs
2. mca_btl_self_del_procs
3. mca_btl_self_finalize
4. mca_btl_self_alloc
5. mca_btl_self_free
6. mca_btl_self_prepare_src
7. mca_btl_self_send
8. mca_btl_self_sendi
9. mca_btl_self_put
10. mca_btl_self_get
11. mca_btl_self_ft_event

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2013 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2012-2013 Inria.  All rights reserved.
  14  * Copyright (c) 2014-2016 Los Alamos National Security, LLC. All rights
  15  *                         reserved.
  16  * Copyright (c) 2016      Research Organization for Information Science
  17  *                         and Technology (RIST). All rights reserved.
  18  * $COPYRIGHT$
  19  *
  20  * Additional copyrights may follow
  21  *
  22  * $HEADER$
  23  */
  24 
  25 #include "opal_config.h"
  26 
  27 #include <string.h>
  28 #include <stdlib.h>
  29 
  30 #include "opal/class/opal_bitmap.h"
  31 #include "opal/datatype/opal_convertor.h"
  32 #include "btl_self.h"
  33 #include "btl_self_frag.h"
  34 #include "opal/util/proc.h"
  35 
  36 /**
  37  * PML->BTL notification of change in the process list.
  38  * PML->BTL Notification that a receive fragment has been matched.
  39  * Called for message that is send from process with the virtual
  40  * address of the shared memory segment being different than that of
  41  * the receiver.
  42  *
  43  * @param btl (IN)
  44  * @param proc (IN)
  45  * @param peer (OUT)
  46  * @return     OPAL_SUCCESS or error status on failure.
  47  *
  48  */
  49 static int mca_btl_self_add_procs (struct mca_btl_base_module_t *btl, size_t nprocs,
  50                                    struct opal_proc_t **procs,
  51                                    struct mca_btl_base_endpoint_t **peers,
  52                                    opal_bitmap_t* reachability)
  53 {
  54     for (int i = 0; i < (int)nprocs; i++ ) {
  55         if( 0 == opal_compare_proc(procs[i]->proc_name, OPAL_PROC_MY_NAME) ) {
  56             opal_bitmap_set_bit( reachability, i );
  57             /* need to return something to keep the bml from ignoring us */
  58             peers[i] = (struct mca_btl_base_endpoint_t *) 1;
  59             break;  /* there will always be only one ... */
  60         }
  61     }
  62 
  63     return OPAL_SUCCESS;
  64 }
  65 
  66 /**
  67  * PML->BTL notification of change in the process list.
  68  *
  69  * @param btl (IN)     BTL instance
  70  * @param proc (IN)    Peer process
  71  * @param peer (IN)    Peer addressing information.
  72  * @return             Status indicating if cleanup was successful
  73  *
  74  */
  75 static int mca_btl_self_del_procs (struct mca_btl_base_module_t *btl, size_t nprocs,
  76                                    struct opal_proc_t **procs,
  77                                    struct mca_btl_base_endpoint_t **peers)
  78 {
  79     return OPAL_SUCCESS;
  80 }
  81 
  82 
  83 /**
  84  * MCA->BTL Clean up any resources held by BTL module
  85  * before the module is unloaded.
  86  *
  87  * @param btl (IN)   BTL module.
  88  *
  89  * Prior to unloading a BTL module, the MCA framework will call
  90  * the BTL finalize method of the module. Any resources held by
  91  * the BTL should be released and if required the memory corresponding
  92  * to the BTL module freed.
  93  *
  94  */
  95 
  96 static int mca_btl_self_finalize(struct mca_btl_base_module_t* btl)
  97 {
  98     return OPAL_SUCCESS;
  99 }
 100 
 101 
 102 /**
 103  * Allocate a segment.
 104  *
 105  * @param btl (IN)      BTL module
 106  * @param size (IN)     Request segment size.
 107  */
 108 static mca_btl_base_descriptor_t *mca_btl_self_alloc (struct mca_btl_base_module_t *btl,
 109                                                       struct mca_btl_base_endpoint_t *endpoint,
 110                                                       uint8_t order, size_t size, uint32_t flags)
 111 {
 112     mca_btl_self_frag_t *frag = NULL;
 113 
 114     if (size <= MCA_BTL_SELF_MAX_INLINE_SIZE) {
 115         MCA_BTL_SELF_FRAG_ALLOC_RDMA(frag);
 116     } else if (size <= mca_btl_self.btl_eager_limit) {
 117         MCA_BTL_SELF_FRAG_ALLOC_EAGER(frag);
 118     } else if (size <= btl->btl_max_send_size) {
 119         MCA_BTL_SELF_FRAG_ALLOC_SEND(frag);
 120     }
 121 
 122     if( OPAL_UNLIKELY(NULL == frag) ) {
 123         return NULL;
 124     }
 125 
 126     frag->segments[0].seg_len = size;
 127     frag->base.des_segment_count = 1;
 128     frag->base.des_flags       = flags;
 129 
 130     return &frag->base;
 131 }
 132 
 133 /**
 134  * Return a segment allocated by this BTL.
 135  *
 136  * @param btl (IN)      BTL module
 137  * @param segment (IN)  Allocated segment.
 138  */
 139 static int mca_btl_self_free (struct mca_btl_base_module_t *btl, mca_btl_base_descriptor_t *des)
 140 {
 141     MCA_BTL_SELF_FRAG_RETURN((mca_btl_self_frag_t *) des);
 142 
 143     return OPAL_SUCCESS;
 144 }
 145 
 146 
 147 /**
 148  * Prepare data for send
 149  *
 150  * @param btl (IN)      BTL module
 151  */
 152 static struct mca_btl_base_descriptor_t *mca_btl_self_prepare_src (struct mca_btl_base_module_t* btl,
 153                                                                    struct mca_btl_base_endpoint_t *endpoint,
 154                                                                    struct opal_convertor_t *convertor,
 155                                                                    uint8_t order, size_t reserve,
 156                                                                    size_t *size, uint32_t flags)
 157 {
 158     bool inline_send = !opal_convertor_need_buffers(convertor);
 159     size_t buffer_len = reserve + (inline_send ? 0 : *size);
 160     mca_btl_self_frag_t *frag;
 161 
 162     frag = (mca_btl_self_frag_t *) mca_btl_self_alloc (btl, endpoint, order, buffer_len, flags);
 163     if (OPAL_UNLIKELY(NULL == frag)) {
 164         return NULL;
 165     }
 166 
 167     /* non-contigous data */
 168     if (OPAL_UNLIKELY(!inline_send)) {
 169         struct iovec iov = {.iov_len = *size, .iov_base = (IOVBASE_TYPE *) ((uintptr_t) frag->data + reserve)};
 170         size_t max_data = *size;
 171         uint32_t iov_count = 1;
 172         int rc;
 173 
 174         rc = opal_convertor_pack (convertor, &iov, &iov_count, &max_data);
 175         if(rc < 0) {
 176             mca_btl_self_free (btl, &frag->base);
 177             return NULL;
 178         }
 179 
 180         *size = max_data;
 181         frag->segments[0].seg_len = reserve + max_data;
 182     } else {
 183         void *data_ptr;
 184 
 185         opal_convertor_get_current_pointer (convertor, &data_ptr);
 186 
 187         frag->segments[1].seg_addr.pval = data_ptr;
 188         frag->segments[1].seg_len = *size;
 189         frag->base.des_segment_count = 2;
 190     }
 191 
 192     return &frag->base;
 193 }
 194 
 195 /**
 196  * Initiate a send to the peer.
 197  *
 198  * @param btl (IN)      BTL module
 199  * @param peer (IN)     BTL peer addressing
 200  */
 201 
 202 static int mca_btl_self_send (struct mca_btl_base_module_t *btl,
 203                               struct mca_btl_base_endpoint_t *endpoint,
 204                               struct mca_btl_base_descriptor_t *des,
 205                               mca_btl_base_tag_t tag)
 206 {
 207     mca_btl_active_message_callback_t* reg;
 208     int btl_ownership = (des->des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP);
 209 
 210     /* upcall */
 211     reg = mca_btl_base_active_message_trigger + tag;
 212     reg->cbfunc( btl, tag, des, reg->cbdata );
 213 
 214     /* send completion */
 215     if( des->des_flags & MCA_BTL_DES_SEND_ALWAYS_CALLBACK ) {
 216         des->des_cbfunc( btl, endpoint, des, OPAL_SUCCESS );
 217     }
 218     if( btl_ownership ) {
 219         mca_btl_self_free( btl, des );
 220     }
 221     return 1;
 222 }
 223 
 224 static int mca_btl_self_sendi (struct mca_btl_base_module_t *btl, struct mca_btl_base_endpoint_t *endpoint,
 225                                struct opal_convertor_t *convertor, void *header, size_t header_size,
 226                                size_t payload_size, uint8_t order, uint32_t flags, mca_btl_base_tag_t tag,
 227                                mca_btl_base_descriptor_t **descriptor)
 228 {
 229     mca_btl_base_descriptor_t *frag;
 230 
 231     if (!payload_size || !opal_convertor_need_buffers(convertor)) {
 232         void *data_ptr = NULL;
 233         if (payload_size) {
 234             opal_convertor_get_current_pointer (convertor, &data_ptr);
 235         }
 236 
 237         mca_btl_base_segment_t segments[2] = {{.seg_addr.pval = header, .seg_len = header_size},
 238                                               {.seg_addr.pval = data_ptr, .seg_len = payload_size}};
 239         mca_btl_base_descriptor_t des = {.des_segments = segments, .des_segment_count = payload_size ? 2 : 1,
 240                                          .des_flags = 0};
 241 
 242         (void) mca_btl_self_send (btl, endpoint, &des, tag);
 243         return OPAL_SUCCESS;
 244     }
 245 
 246     frag = mca_btl_self_prepare_src (btl, endpoint, convertor, order, header_size, &payload_size,
 247                                      flags | MCA_BTL_DES_FLAGS_BTL_OWNERSHIP);
 248     if (NULL == frag) {
 249         *descriptor = NULL;
 250         return OPAL_ERR_OUT_OF_RESOURCE;
 251     }
 252 
 253     memcpy (frag->des_segments[0].seg_addr.pval, header, header_size);
 254     (void) mca_btl_self_send (btl, endpoint, frag, tag);
 255     return OPAL_SUCCESS;
 256 }
 257 
 258 static int mca_btl_self_put (mca_btl_base_module_t *btl, struct mca_btl_base_endpoint_t *endpoint, void *local_address,
 259                              uint64_t remote_address, mca_btl_base_registration_handle_t *local_handle,
 260                              mca_btl_base_registration_handle_t *remote_handle, size_t size, int flags,
 261                              int order, mca_btl_base_rdma_completion_fn_t cbfunc, void *cbcontext, void *cbdata)
 262 {
 263     memcpy ((void *)(intptr_t) remote_address, local_address, size);
 264 
 265     cbfunc (btl, endpoint, local_address, NULL, cbcontext, cbdata, OPAL_SUCCESS);
 266 
 267     return OPAL_SUCCESS;
 268 }
 269 
 270 static int mca_btl_self_get (mca_btl_base_module_t *btl, struct mca_btl_base_endpoint_t *endpoint, void *local_address,
 271                              uint64_t remote_address, mca_btl_base_registration_handle_t *local_handle,
 272                              mca_btl_base_registration_handle_t *remote_handle, size_t size, int flags,
 273                              int order, mca_btl_base_rdma_completion_fn_t cbfunc, void *cbcontext, void *cbdata)
 274 {
 275     memcpy (local_address, (void *)(intptr_t) remote_address, size);
 276 
 277     cbfunc (btl, endpoint, local_address, NULL, cbcontext, cbdata, OPAL_SUCCESS);
 278 
 279     return OPAL_SUCCESS;
 280 }
 281 
 282 static int mca_btl_self_ft_event(int state) {
 283     return OPAL_SUCCESS;
 284 }
 285 
 286 /* btl self module */
 287 mca_btl_base_module_t mca_btl_self = {
 288     .btl_component = &mca_btl_self_component.super,
 289     .btl_add_procs = mca_btl_self_add_procs,
 290     .btl_del_procs = mca_btl_self_del_procs,
 291     .btl_finalize = mca_btl_self_finalize,
 292     .btl_alloc = mca_btl_self_alloc,
 293     .btl_free = mca_btl_self_free,
 294     .btl_prepare_src = mca_btl_self_prepare_src,
 295     .btl_send = mca_btl_self_send,
 296     .btl_sendi = mca_btl_self_sendi,
 297     .btl_put = mca_btl_self_put,
 298     .btl_get = mca_btl_self_get,
 299     .btl_dump = mca_btl_base_dump,
 300     .btl_ft_event = mca_btl_self_ft_event,
 301 };