oshmem/shmem/c/shmem_put

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
SHMEM_CTX_TYPE_PUTMEM_NB
   1 /*
   2  * Copyright (c) 2016      Mellanox Technologies, Inc.
   3  *                         All rights reserved.
   4  * $COPYRIGHT$
   5  *
   6  * Additional copyrights may follow
   7  *
   8  * $HEADER$
   9  */
  10 #include "oshmem_config.h"
  11 
  12 #include "oshmem/constants.h"
  13 #include "oshmem/include/shmem.h"
  14 
  15 #include "oshmem/runtime/runtime.h"
  16 
  17 #include "oshmem/mca/spml/spml.h"
  18 
  19 /*
  20  * The nonblocking put routines provide a method for copying data from a contiguous local data
  21  * object to a data object on a specified PE.
  22  * These routines transfer nelems elements of the data object at address source on the calling
  23  * PE, to the data object at address target on the remote PE pe. These routines start the
  24  * remote transfer and may return before the data is delivered to the remote PE. The delivery
  25  * of data into the data object on the destination PE from different put calls may occur in any
  26  * order. Because of this, two successive put operations may deliver data out of order unless a
  27  * call to shmem_fence() is introduced between the two calls.
  28  * The routines return after posting the operation. The operation is considered complete after a
  29  * subsequent call to shmem_quiet. At the completion of shmem_quiet, the data has been copied
  30  * into the dest array on the destination PE.
  31  */
  32 #define DO_SHMEM_TYPE_PUT_NB(ctx, type, target, source, len, pe) do { \
  33         int rc = OSHMEM_SUCCESS;                                    \
  34         size_t size = 0;                                            \
  35                                                                     \
  36         RUNTIME_CHECK_INIT();                                       \
  37         RUNTIME_CHECK_PE(pe);                                       \
  38         RUNTIME_CHECK_ADDR(target);                                 \
  39                                                                     \
  40         size = len * sizeof(type);                                  \
  41         rc = MCA_SPML_CALL(put_nb(                                  \
  42             ctx,                                                    \
  43             (void *)target,                                         \
  44             size,                                                   \
  45             (void *)source,                                         \
  46             pe, NULL));                                             \
  47         RUNTIME_CHECK_RC(rc);                                       \
  48     } while (0)
  49 
  50 #define SHMEM_CTX_TYPE_PUT_NB(type_name, type)                      \
  51     void shmem_ctx##type_name##_put_nbi(shmem_ctx_t ctx, type *target, const type *source, size_t len, int pe) \
  52     {                                                               \
  53         DO_SHMEM_TYPE_PUT_NB(ctx, type, target, source, len, pe);   \
  54         return ;                                                    \
  55     }
  56 
  57 #define SHMEM_TYPE_PUT_NB(type_name, type)                          \
  58     void shmem##type_name##_put_nbi(type *target, const type *source, size_t len, int pe) \
  59     {                                                               \
  60         DO_SHMEM_TYPE_PUT_NB(oshmem_ctx_default, type, target,       \
  61                              source, len, pe);                      \
  62         return ;                                                    \
  63     }
  64 
  65 #if OSHMEM_PROFILING
  66 #include "oshmem/include/pshmem.h"
  67 #pragma weak shmem_ctx_char_put_nbi       = pshmem_ctx_char_put_nbi
  68 #pragma weak shmem_ctx_short_put_nbi      = pshmem_ctx_short_put_nbi
  69 #pragma weak shmem_ctx_int_put_nbi        = pshmem_ctx_int_put_nbi
  70 #pragma weak shmem_ctx_long_put_nbi       = pshmem_ctx_long_put_nbi
  71 #pragma weak shmem_ctx_float_put_nbi      = pshmem_ctx_float_put_nbi
  72 #pragma weak shmem_ctx_double_put_nbi     = pshmem_ctx_double_put_nbi
  73 #pragma weak shmem_ctx_longlong_put_nbi   = pshmem_ctx_longlong_put_nbi
  74 #pragma weak shmem_ctx_schar_put_nbi      = pshmem_ctx_schar_put_nbi
  75 #pragma weak shmem_ctx_uchar_put_nbi      = pshmem_ctx_uchar_put_nbi
  76 #pragma weak shmem_ctx_ushort_put_nbi     = pshmem_ctx_ushort_put_nbi
  77 #pragma weak shmem_ctx_uint_put_nbi       = pshmem_ctx_uint_put_nbi
  78 #pragma weak shmem_ctx_ulong_put_nbi      = pshmem_ctx_ulong_put_nbi
  79 #pragma weak shmem_ctx_ulonglong_put_nbi  = pshmem_ctx_ulonglong_put_nbi
  80 #pragma weak shmem_ctx_longdouble_put_nbi = pshmem_ctx_longdouble_put_nbi
  81 #pragma weak shmem_ctx_int8_put_nbi       = pshmem_ctx_int8_put_nbi
  82 #pragma weak shmem_ctx_int16_put_nbi      = pshmem_ctx_int16_put_nbi
  83 #pragma weak shmem_ctx_int32_put_nbi      = pshmem_ctx_int32_put_nbi
  84 #pragma weak shmem_ctx_int64_put_nbi      = pshmem_ctx_int64_put_nbi
  85 #pragma weak shmem_ctx_uint8_put_nbi      = pshmem_ctx_uint8_put_nbi
  86 #pragma weak shmem_ctx_uint16_put_nbi     = pshmem_ctx_uint16_put_nbi
  87 #pragma weak shmem_ctx_uint32_put_nbi     = pshmem_ctx_uint32_put_nbi
  88 #pragma weak shmem_ctx_uint64_put_nbi     = pshmem_ctx_uint64_put_nbi
  89 #pragma weak shmem_ctx_size_put_nbi       = pshmem_ctx_size_put_nbi
  90 #pragma weak shmem_ctx_ptrdiff_put_nbi    = pshmem_ctx_ptrdiff_put_nbi
  91 
  92 #pragma weak shmem_char_put_nbi           = pshmem_char_put_nbi
  93 #pragma weak shmem_short_put_nbi          = pshmem_short_put_nbi
  94 #pragma weak shmem_int_put_nbi            = pshmem_int_put_nbi
  95 #pragma weak shmem_long_put_nbi           = pshmem_long_put_nbi
  96 #pragma weak shmem_float_put_nbi          = pshmem_float_put_nbi
  97 #pragma weak shmem_double_put_nbi         = pshmem_double_put_nbi
  98 #pragma weak shmem_longlong_put_nbi       = pshmem_longlong_put_nbi
  99 #pragma weak shmem_schar_put_nbi          = pshmem_schar_put_nbi
 100 #pragma weak shmem_uchar_put_nbi          = pshmem_uchar_put_nbi
 101 #pragma weak shmem_ushort_put_nbi         = pshmem_ushort_put_nbi
 102 #pragma weak shmem_uint_put_nbi           = pshmem_uint_put_nbi
 103 #pragma weak shmem_ulong_put_nbi          = pshmem_ulong_put_nbi
 104 #pragma weak shmem_ulonglong_put_nbi      = pshmem_ulonglong_put_nbi
 105 #pragma weak shmem_longdouble_put_nbi     = pshmem_longdouble_put_nbi
 106 #pragma weak shmem_int8_put_nbi           = pshmem_int8_put_nbi
 107 #pragma weak shmem_int16_put_nbi          = pshmem_int16_put_nbi
 108 #pragma weak shmem_int32_put_nbi          = pshmem_int32_put_nbi
 109 #pragma weak shmem_int64_put_nbi          = pshmem_int64_put_nbi
 110 #pragma weak shmem_uint8_put_nbi          = pshmem_uint8_put_nbi
 111 #pragma weak shmem_uint16_put_nbi         = pshmem_uint16_put_nbi
 112 #pragma weak shmem_uint32_put_nbi         = pshmem_uint32_put_nbi
 113 #pragma weak shmem_uint64_put_nbi         = pshmem_uint64_put_nbi
 114 #pragma weak shmem_size_put_nbi           = pshmem_size_put_nbi
 115 #pragma weak shmem_ptrdiff_put_nbi        = pshmem_ptrdiff_put_nbi
 116 
 117 #pragma weak shmem_put8_nbi = pshmem_put8_nbi
 118 #pragma weak shmem_put16_nbi = pshmem_put16_nbi
 119 #pragma weak shmem_put32_nbi = pshmem_put32_nbi
 120 #pragma weak shmem_put64_nbi = pshmem_put64_nbi
 121 #pragma weak shmem_put128_nbi = pshmem_put128_nbi
 122 #pragma weak shmem_putmem_nbi = pshmem_putmem_nbi
 123 
 124 #pragma weak shmem_ctx_put8_nbi = pshmem_ctx_put8_nbi
 125 #pragma weak shmem_ctx_put16_nbi = pshmem_ctx_put16_nbi
 126 #pragma weak shmem_ctx_put32_nbi = pshmem_ctx_put32_nbi
 127 #pragma weak shmem_ctx_put64_nbi = pshmem_ctx_put64_nbi
 128 #pragma weak shmem_ctx_put128_nbi = pshmem_ctx_put128_nbi
 129 #pragma weak shmem_ctx_putmem_nbi = pshmem_ctx_putmem_nbi
 130 #include "oshmem/shmem/c/profile/defines.h"
 131 #endif
 132 
 133 SHMEM_CTX_TYPE_PUT_NB(_char, char)
 134 SHMEM_CTX_TYPE_PUT_NB(_short, short)
 135 SHMEM_CTX_TYPE_PUT_NB(_int, int)
 136 SHMEM_CTX_TYPE_PUT_NB(_long, long)
 137 SHMEM_CTX_TYPE_PUT_NB(_longlong, long long)
 138 SHMEM_CTX_TYPE_PUT_NB(_schar, signed char)
 139 SHMEM_CTX_TYPE_PUT_NB(_uchar, unsigned char)
 140 SHMEM_CTX_TYPE_PUT_NB(_ushort, unsigned short)
 141 SHMEM_CTX_TYPE_PUT_NB(_uint, unsigned int)
 142 SHMEM_CTX_TYPE_PUT_NB(_ulong, unsigned long)
 143 SHMEM_CTX_TYPE_PUT_NB(_ulonglong, unsigned long long)
 144 SHMEM_CTX_TYPE_PUT_NB(_float, float)
 145 SHMEM_CTX_TYPE_PUT_NB(_double, double)
 146 SHMEM_CTX_TYPE_PUT_NB(_longdouble, long double)
 147 SHMEM_CTX_TYPE_PUT_NB(_int8, int8_t)
 148 SHMEM_CTX_TYPE_PUT_NB(_int16, int16_t)
 149 SHMEM_CTX_TYPE_PUT_NB(_int32, int32_t)
 150 SHMEM_CTX_TYPE_PUT_NB(_int64, int64_t)
 151 SHMEM_CTX_TYPE_PUT_NB(_uint8, uint8_t)
 152 SHMEM_CTX_TYPE_PUT_NB(_uint16, uint16_t)
 153 SHMEM_CTX_TYPE_PUT_NB(_uint32, uint32_t)
 154 SHMEM_CTX_TYPE_PUT_NB(_uint64, uint64_t)
 155 SHMEM_CTX_TYPE_PUT_NB(_size, size_t)
 156 SHMEM_CTX_TYPE_PUT_NB(_ptrdiff, ptrdiff_t)
 157 
 158 SHMEM_TYPE_PUT_NB(_char, char)
 159 SHMEM_TYPE_PUT_NB(_short, short)
 160 SHMEM_TYPE_PUT_NB(_int, int)
 161 SHMEM_TYPE_PUT_NB(_long, long)
 162 SHMEM_TYPE_PUT_NB(_longlong, long long)
 163 SHMEM_TYPE_PUT_NB(_schar, signed char)
 164 SHMEM_TYPE_PUT_NB(_uchar, unsigned char)
 165 SHMEM_TYPE_PUT_NB(_ushort, unsigned short)
 166 SHMEM_TYPE_PUT_NB(_uint, unsigned int)
 167 SHMEM_TYPE_PUT_NB(_ulong, unsigned long)
 168 SHMEM_TYPE_PUT_NB(_ulonglong, unsigned long long)
 169 SHMEM_TYPE_PUT_NB(_float, float)
 170 SHMEM_TYPE_PUT_NB(_double, double)
 171 SHMEM_TYPE_PUT_NB(_longdouble, long double)
 172 SHMEM_TYPE_PUT_NB(_int8, int8_t)
 173 SHMEM_TYPE_PUT_NB(_int16, int16_t)
 174 SHMEM_TYPE_PUT_NB(_int32, int32_t)
 175 SHMEM_TYPE_PUT_NB(_int64, int64_t)
 176 SHMEM_TYPE_PUT_NB(_uint8, uint8_t)
 177 SHMEM_TYPE_PUT_NB(_uint16, uint16_t)
 178 SHMEM_TYPE_PUT_NB(_uint32, uint32_t)
 179 SHMEM_TYPE_PUT_NB(_uint64, uint64_t)
 180 SHMEM_TYPE_PUT_NB(_size, size_t)
 181 SHMEM_TYPE_PUT_NB(_ptrdiff, ptrdiff_t)
 182 
 183 #define DO_SHMEM_PUTMEM_NB(ctx, target, source, element_size, nelems, pe) do { \
 184         int rc = OSHMEM_SUCCESS;                                    \
 185         size_t size = 0;                                            \
 186                                                                     \
 187         RUNTIME_CHECK_INIT();                                       \
 188         RUNTIME_CHECK_PE(pe);                                       \
 189         RUNTIME_CHECK_ADDR(target);                                 \
 190                                                                     \
 191         size = nelems * element_size;                               \
 192         rc = MCA_SPML_CALL(put_nb(                                  \
 193             ctx,                                                    \
 194             (void *)target,                                         \
 195             size,                                                   \
 196             (void *)source,                                         \
 197             pe, NULL));                                             \
 198         RUNTIME_CHECK_RC(rc);                                       \
 199     } while (0)
 200 
 201 #define SHMEM_CTX_TYPE_PUTMEM_NB(name, element_size, prefix)        \
 202     void prefix##_ctx##name##_nbi(shmem_ctx_t ctx, void *target, const void *source, size_t nelems, int pe) \
 203     {                                                               \
 204         DO_SHMEM_PUTMEM_NB(ctx, target, source, element_size,       \
 205                            nelems, pe);                             \
 206         return ;                                                    \
 207     }
 208 
 209 #define SHMEM_TYPE_PUTMEM_NB(name, element_size, prefix)            \
 210     void prefix##name##_nbi(void *target, const void *source, size_t nelems, int pe) \
 211     {                                                               \
 212         DO_SHMEM_PUTMEM_NB(oshmem_ctx_default, target, source,       \
 213                            element_size, nelems, pe);               \
 214         return ;                                                    \
 215     }
 216 
 217 SHMEM_CTX_TYPE_PUTMEM_NB(_put8, 1, shmem)
 218 SHMEM_CTX_TYPE_PUTMEM_NB(_put16, 2, shmem)
 219 SHMEM_CTX_TYPE_PUTMEM_NB(_put32, 4, shmem)
 220 SHMEM_CTX_TYPE_PUTMEM_NB(_put64, 8, shmem)
 221 SHMEM_CTX_TYPE_PUTMEM_NB(_put128, 16, shmem)
 222 SHMEM_CTX_TYPE_PUTMEM_NB(_putmem, 1, shmem)
 223 SHMEM_TYPE_PUTMEM_NB(_put8, 1, shmem)
 224 SHMEM_TYPE_PUTMEM_NB(_put16, 2, shmem)
 225 SHMEM_TYPE_PUTMEM_NB(_put32, 4, shmem)
 226 SHMEM_TYPE_PUTMEM_NB(_put64, 8, shmem)
 227 SHMEM_TYPE_PUTMEM_NB(_put128, 16, shmem)
 228 SHMEM_TYPE_PUTMEM_NB(_putmem, 1, shmem)
 229 
 230 void shmemx_alltoall_global_nb(void *dest,
 231                                const void *source,
 232                                size_t size,
 233                                long *counter)
 234 {
 235     int rc = MCA_SPML_CALL(put_all_nb(dest, source, size, counter));
 236     RUNTIME_CHECK_RC(rc);
 237 }
/* [<][>][^][v][top][bottom][index][help] */
root/oshmem/shmem/c/shmem_put_nb.c

DEFINITIONS
