root/oshmem/mca/spml/base/spml_base.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. mca_spml_base_test
  2. mca_spml_base_wait
  3. mca_spml_base_wait_nb
  4. mca_spml_base_oob_get_mkeys
  5. mca_spml_base_rmkey_unpack
  6. mca_spml_base_rmkey_free
  7. mca_spml_base_rmkey_ptr
  8. mca_spml_base_put_nb
  9. mca_spml_base_get_nb
  10. mca_spml_base_memuse_hook
  11. mca_spml_base_put_all_nb
   1 /*
   2  * Copyright (c) 2013      Mellanox Technologies, Inc.
   3  *                         All rights reserved.
   4  * Copyright (c) 2017      ARM, Inc. All rights reserved.
   5  * Copyright (c) 2019      Research Organization for Information Science
   6  *                         and Technology (RIST).  All rights reserved.
   7  * $COPYRIGHT$
   8  *
   9  * Additional copyrights may follow
  10  *
  11  * $HEADER$
  12  */
  13 
  14 #include "oshmem_config.h"
  15 #include "ompi/mca/bml/base/base.h"
  16 #include "opal/datatype/opal_convertor.h"
  17 #include "oshmem/proc/proc.h"
  18 #include "oshmem/mca/spml/base/base.h"
  19 #include "opal/mca/btl/btl.h"
  20 
  21 #define SPML_BASE_DO_CMP(_res, _addr, _op, _val) \
  22     switch((_op)) { \
  23         case SHMEM_CMP_EQ: \
  24             _res = *(_addr) == (_val) ? 1 : 0; \
  25             break; \
  26         case SHMEM_CMP_NE: \
  27             _res = *(_addr) != (_val) ? 1 : 0; \
  28             break; \
  29         case SHMEM_CMP_GT: \
  30             _res =  *(_addr) > (_val) ? 1 : 0; \
  31             break; \
  32         case SHMEM_CMP_LE: \
  33             _res = *(_addr) <= (_val) ? 1 : 0; \
  34             break; \
  35         case SHMEM_CMP_LT: \
  36             _res = *(_addr) < (_val) ?  1 : 0; \
  37             break; \
  38         case SHMEM_CMP_GE: \
  39             _res = *(_addr) >= (_val) ? 1 : 0; \
  40             break; \
  41     }
  42 
  43 #define SPML_BASE_DO_WAIT(_res, _addr, _op, _val)  \
  44     do {                                           \
  45         SPML_BASE_DO_CMP(_res, _addr, _op, _val);  \
  46         if (_res == 0) {                           \
  47             opal_progress();                       \
  48         }                                          \
  49     } while (_res == 0);
  50 
  51 /**
  52  * Check on a variable given in addr to see it is not equal to value.
  53  */
  54 int mca_spml_base_test(void* addr, int cmp, void* value, int datatype, int *out_value)
  55 {
  56     volatile int *int_addr;
  57     volatile long *long_addr;
  58     volatile short *short_addr;
  59     volatile long long *longlong_addr;
  60     volatile int32_t *int32_addr;
  61     volatile int64_t *int64_addr;
  62 
  63     int int_value;
  64     long long_value;
  65     short short_value;
  66     long long longlong_value;
  67     int32_t int32_value;
  68     int64_t int64_value;
  69 
  70     ompi_fortran_integer_t *fint_addr, fint_value;
  71     ompi_fortran_integer4_t *fint4_addr, fint4_value;
  72     ompi_fortran_integer8_t *fint8_addr, fint8_value;
  73 
  74     switch (datatype) {
  75 
  76     /* Int */
  77     case SHMEM_INT:
  78         int_value = *(int*) value;
  79         int_addr = (int*) addr;
  80         SPML_BASE_DO_CMP((*out_value), int_addr, cmp, int_value);
  81         break;
  82 
  83         /* Short */
  84     case SHMEM_SHORT:
  85         short_value = *(short*) value;
  86         short_addr = (short*) addr;
  87         SPML_BASE_DO_CMP((*out_value), short_addr, cmp, short_value);
  88         break;
  89 
  90         /* Long */
  91     case SHMEM_LONG:
  92         long_value = *(long*) value;
  93         long_addr = (long*) addr;
  94         SPML_BASE_DO_CMP((*out_value), long_addr, cmp, long_value);
  95         break;
  96 
  97         /* Long-Long */
  98     case SHMEM_LLONG:
  99         longlong_value = *(long long*) value;
 100         longlong_addr = (long long*) addr;
 101         SPML_BASE_DO_CMP((*out_value), longlong_addr, cmp, longlong_value);
 102         break;
 103 
 104        /* Int32_t */
 105     case SHMEM_INT32_T:
 106         int32_value = *(int32_t*) value;
 107         int32_addr = (int32_t*) addr;
 108         SPML_BASE_DO_CMP((*out_value), int32_addr, cmp, int32_value);
 109         break;
 110 
 111        /* Int64_t */
 112     case SHMEM_INT64_T:
 113         int64_value = *(int64_t*) value;
 114         int64_addr = (int64_t*) addr;
 115         SPML_BASE_DO_CMP((*out_value), int64_addr, cmp, int64_value);
 116         break;
 117 
 118         /*C equivalent of Fortran integer type */
 119     case SHMEM_FINT:
 120         fint_value = *(ompi_fortran_integer_t *) value;
 121         fint_addr = (ompi_fortran_integer_t *) addr;
 122         SPML_BASE_DO_CMP((*out_value), fint_addr, cmp, fint_value);
 123         break;
 124 
 125         /*C equivalent of Fortran int4 type*/
 126     case SHMEM_FINT4:
 127         fint4_value = *(ompi_fortran_integer4_t *) value;
 128         fint4_addr = (ompi_fortran_integer4_t *) addr;
 129         SPML_BASE_DO_CMP((*out_value), fint4_addr, cmp, fint4_value);
 130         break;
 131 
 132         /*C equivalent of Fortran int8 type*/
 133     case SHMEM_FINT8:
 134         fint8_value = *(ompi_fortran_integer8_t *) value;
 135         fint8_addr = (ompi_fortran_integer8_t *) addr;
 136         SPML_BASE_DO_CMP((*out_value), fint8_addr, cmp, fint8_value);
 137         break;
 138     }
 139 
 140     return OSHMEM_SUCCESS;
 141 }
 142 
 143 int mca_spml_base_wait(void* addr, int cmp, void* value, int datatype)
 144 {
 145     volatile int *int_addr;
 146     volatile long *long_addr;
 147     volatile short *short_addr;
 148     volatile long long *longlong_addr;
 149     volatile int32_t *int32_addr;
 150     volatile int64_t *int64_addr;
 151 
 152     int int_value;
 153     long long_value;
 154     short short_value;
 155     long long longlong_value;
 156     int32_t int32_value;
 157     int64_t int64_value;
 158 
 159     ompi_fortran_integer_t *fint_addr, fint_value;
 160     ompi_fortran_integer4_t *fint4_addr, fint4_value;
 161     ompi_fortran_integer8_t *fint8_addr, fint8_value;
 162 
 163     int res = 0;
 164 
 165     switch (datatype) {
 166 
 167     /* Int */
 168     case SHMEM_INT:
 169         int_value = *(int*) value;
 170         int_addr = (int*) addr;
 171         SPML_BASE_DO_WAIT(res, int_addr, cmp, int_value);
 172         break;
 173 
 174         /* Short */
 175     case SHMEM_SHORT:
 176         short_value = *(short*) value;
 177         short_addr = (short*) addr;
 178         SPML_BASE_DO_WAIT(res, short_addr, cmp, short_value);
 179         break;
 180 
 181         /* Long */
 182     case SHMEM_LONG:
 183         long_value = *(long*) value;
 184         long_addr = (long*) addr;
 185         SPML_BASE_DO_WAIT(res, long_addr, cmp, long_value);
 186         break;
 187 
 188         /* Long-Long */
 189     case SHMEM_LLONG:
 190         longlong_value = *(long long*) value;
 191         longlong_addr = (long long*) addr;
 192         SPML_BASE_DO_WAIT(res, longlong_addr, cmp, longlong_value);
 193         break;
 194 
 195        /* Int32_t */
 196     case SHMEM_INT32_T:
 197         int32_value = *(int32_t*) value;
 198         int32_addr = (int32_t*) addr;
 199         SPML_BASE_DO_WAIT(res, int32_addr, cmp, int32_value);
 200         break;
 201 
 202        /* Int64_t */
 203     case SHMEM_INT64_T:
 204         int64_value = *(int64_t*) value;
 205         int64_addr = (int64_t*) addr;
 206         SPML_BASE_DO_WAIT(res, int64_addr, cmp, int64_value);
 207         break;
 208 
 209         /*C equivalent of Fortran integer type */
 210     case SHMEM_FINT:
 211         fint_value = *(ompi_fortran_integer_t *) value;
 212         fint_addr = (ompi_fortran_integer_t *) addr;
 213         SPML_BASE_DO_WAIT(res, fint_addr, cmp, fint_value);
 214         break;
 215 
 216         /*C equivalent of Fortran int4 type*/
 217     case SHMEM_FINT4:
 218         fint4_value = *(ompi_fortran_integer4_t *) value;
 219         fint4_addr = (ompi_fortran_integer4_t *) addr;
 220         SPML_BASE_DO_WAIT(res, fint4_addr, cmp, fint4_value);
 221         break;
 222 
 223         /*C equivalent of Fortran int8 type*/
 224     case SHMEM_FINT8:
 225         fint8_value = *(ompi_fortran_integer8_t *) value;
 226         fint8_addr = (ompi_fortran_integer8_t *) addr;
 227         SPML_BASE_DO_WAIT(res, fint8_addr, cmp, fint8_value);
 228         break;
 229     }
 230 
 231     return OSHMEM_SUCCESS;
 232 }
 233 
 234 
 235 /**
 236  * Waits for completion of a non-blocking put or get issued by the calling PE.
 237  * This function waits for completion of a single non-blocking transfer issued by
 238  * shmem_put_nb() or shmem_get_nb() (or related functions) when called with the
 239  * address of a completion handle.
 240  * Completion of the call to shmem_wait_nb() ensures that a non-blocking transfer has
 241  * completed. The source buffer may then be reused.
 242  */
 243 int mca_spml_base_wait_nb(void* handle)
 244 {
 245     MCA_SPML_CALL(quiet(oshmem_ctx_default));
 246 
 247     return OSHMEM_SUCCESS;
 248 }
 249 
 250 int mca_spml_base_oob_get_mkeys(shmem_ctx_t ctx, int pe, uint32_t segno, sshmem_mkey_t *mkeys)
 251 {
 252     return OSHMEM_ERROR;
 253 }
 254 
 255 void mca_spml_base_rmkey_unpack(shmem_ctx_t ctx, sshmem_mkey_t *mkey, uint32_t segno, int pe, int tr_id)
 256 {
 257 }
 258 
 259 void mca_spml_base_rmkey_free(sshmem_mkey_t *mkey)
 260 {
 261 }
 262 
 263 void *mca_spml_base_rmkey_ptr(const void *dst_addr, sshmem_mkey_t *mkey, int pe)
 264 {
 265     return NULL;
 266 }
 267 
 268 int mca_spml_base_put_nb(void *dst_addr, size_t size,
 269                          void *src_addr, int dst, void **handle)
 270 {
 271     return OSHMEM_ERROR;
 272 }
 273 
 274 int mca_spml_base_get_nb(void *dst_addr, size_t size,
 275                          void *src_addr, int src, void **handle)
 276 {
 277     return OSHMEM_ERROR;
 278 }
 279 
 280 void mca_spml_base_memuse_hook(void *addr, size_t length)
 281 {
 282 }
 283 
 284 int mca_spml_base_put_all_nb(void *target, const void *source,
 285                              size_t size, long *counter)
 286 {
 287     return OSHMEM_ERR_NOT_IMPLEMENTED;
 288 }
/* [<][>][^][v][top][bottom][index][help] */