root/oshmem/shmem/c/shmem_swap.c

   1 /*
   2  * Copyright (c) 2013      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 #include "oshmem/include/shmemx.h"
  15 
  16 #include "oshmem/runtime/runtime.h"
  17 
  18 #include "oshmem/mca/atomic/atomic.h"
  19 
  20 /*
  21  * shmem_swap performs an atomic swap operation.
  22  * The atomic swap routines write value to address target on PE pe, and return the previous
  23  * contents of target. The operation must be completed without the possibility of another
  24  * process updating target between the time of the fetch and the update.
  25  */
  26 #define DO_SHMEM_TYPE_ATOMIC_SWAP(ctx, type, target, value, pe, out_value) do { \
  27         int rc = OSHMEM_SUCCESS;                                    \
  28         size_t size = 0;                                            \
  29                                                                     \
  30         RUNTIME_CHECK_INIT();                                       \
  31         RUNTIME_CHECK_PE(pe);                                       \
  32         RUNTIME_CHECK_ADDR(target);                                 \
  33                                                                     \
  34         size = sizeof(out_value);                                   \
  35         rc = MCA_ATOMIC_CALL(swap(                                  \
  36             ctx,                                                    \
  37             (void*)target,                                          \
  38             (void*)&out_value,                                      \
  39             OSHMEM_ATOMIC_PTR_2_INT(&value, sizeof(value)),         \
  40             size,                                                   \
  41             pe));                                                   \
  42         RUNTIME_CHECK_RC(rc);                                       \
  43     } while (0)
  44 
  45 #define SHMEM_CTX_TYPE_ATOMIC_SWAP(type_name, type, prefix)         \
  46     type prefix##_ctx##type_name##_atomic_swap(shmem_ctx_t ctx, type *target, type value, int pe) \
  47     {                                                               \
  48         type out_value;                                             \
  49         DO_SHMEM_TYPE_ATOMIC_SWAP(ctx, type, target, value, pe,     \
  50                                   out_value);                       \
  51         return out_value;                                           \
  52     }
  53 
  54 #define SHMEM_TYPE_ATOMIC_SWAP(type_name, type, prefix)             \
  55     type prefix##type_name##_atomic_swap(type *target, type value, int pe)\
  56     {                                                               \
  57         type out_value;                                             \
  58         DO_SHMEM_TYPE_ATOMIC_SWAP(oshmem_ctx_default, type, target,  \
  59                                   value, pe, out_value);            \
  60         return out_value;                                           \
  61     }
  62 
  63 #if OSHMEM_PROFILING
  64 #include "oshmem/include/pshmem.h"
  65 #pragma weak shmem_ctx_int_atomic_swap = pshmem_ctx_int_atomic_swap
  66 #pragma weak shmem_ctx_long_atomic_swap = pshmem_ctx_long_atomic_swap
  67 #pragma weak shmem_ctx_longlong_atomic_swap = pshmem_ctx_longlong_atomic_swap
  68 #pragma weak shmem_ctx_uint_atomic_swap = pshmem_ctx_uint_atomic_swap
  69 #pragma weak shmem_ctx_ulong_atomic_swap = pshmem_ctx_ulong_atomic_swap
  70 #pragma weak shmem_ctx_ulonglong_atomic_swap = pshmem_ctx_ulonglong_atomic_swap
  71 #pragma weak shmem_ctx_float_atomic_swap = pshmem_ctx_float_atomic_swap
  72 #pragma weak shmem_ctx_double_atomic_swap = pshmem_ctx_double_atomic_swap
  73 
  74 #pragma weak shmem_int_atomic_swap = pshmem_int_atomic_swap
  75 #pragma weak shmem_long_atomic_swap = pshmem_long_atomic_swap
  76 #pragma weak shmem_longlong_atomic_swap = pshmem_longlong_atomic_swap
  77 #pragma weak shmem_uint_atomic_swap = pshmem_uint_atomic_swap
  78 #pragma weak shmem_ulong_atomic_swap = pshmem_ulong_atomic_swap
  79 #pragma weak shmem_ulonglong_atomic_swap = pshmem_ulonglong_atomic_swap
  80 #pragma weak shmem_float_atomic_swap = pshmem_float_atomic_swap
  81 #pragma weak shmem_double_atomic_swap = pshmem_double_atomic_swap
  82 
  83 #pragma weak shmem_int_swap = pshmem_int_swap
  84 #pragma weak shmem_long_swap = pshmem_long_swap
  85 #pragma weak shmem_longlong_swap = pshmem_longlong_swap
  86 #pragma weak shmem_float_swap = pshmem_float_swap
  87 #pragma weak shmem_double_swap = pshmem_double_swap
  88 
  89 #pragma weak shmemx_int32_swap = pshmemx_int32_swap
  90 #pragma weak shmemx_int64_swap = pshmemx_int64_swap
  91 #include "oshmem/shmem/c/profile/defines.h"
  92 #endif
  93 
  94 SHMEM_CTX_TYPE_ATOMIC_SWAP(_int, int, shmem)
  95 SHMEM_CTX_TYPE_ATOMIC_SWAP(_long, long, shmem)
  96 SHMEM_CTX_TYPE_ATOMIC_SWAP(_longlong, long long, shmem)
  97 SHMEM_CTX_TYPE_ATOMIC_SWAP(_uint, unsigned int, shmem)
  98 SHMEM_CTX_TYPE_ATOMIC_SWAP(_ulong, unsigned long, shmem)
  99 SHMEM_CTX_TYPE_ATOMIC_SWAP(_ulonglong, unsigned long long, shmem)
 100 SHMEM_CTX_TYPE_ATOMIC_SWAP(_float, float, shmem)
 101 SHMEM_CTX_TYPE_ATOMIC_SWAP(_double, double, shmem)
 102 SHMEM_TYPE_ATOMIC_SWAP(_int, int, shmem)
 103 SHMEM_TYPE_ATOMIC_SWAP(_long, long, shmem)
 104 SHMEM_TYPE_ATOMIC_SWAP(_longlong, long long, shmem)
 105 SHMEM_TYPE_ATOMIC_SWAP(_uint, unsigned int, shmem)
 106 SHMEM_TYPE_ATOMIC_SWAP(_ulong, unsigned long, shmem)
 107 SHMEM_TYPE_ATOMIC_SWAP(_ulonglong, unsigned long long, shmem)
 108 SHMEM_TYPE_ATOMIC_SWAP(_float, float, shmem)
 109 SHMEM_TYPE_ATOMIC_SWAP(_double, double, shmem)
 110 
 111 /* deprecated APIs */
 112 #define SHMEM_TYPE_SWAP(type_name, type, prefix)                    \
 113     type prefix##type_name##_swap(type *target, type value, int pe) \
 114     {                                                               \
 115         type out_value;                                             \
 116         DO_SHMEM_TYPE_ATOMIC_SWAP(oshmem_ctx_default, type, target,  \
 117                                   value, pe, out_value);            \
 118         return out_value;                                           \
 119     }
 120 SHMEM_TYPE_SWAP(_int, int, shmem)
 121 SHMEM_TYPE_SWAP(_long, long, shmem)
 122 SHMEM_TYPE_SWAP(_longlong, long long, shmem)
 123 SHMEM_TYPE_SWAP(_float, float, shmem)
 124 SHMEM_TYPE_SWAP(_double, double, shmem)
 125 SHMEM_TYPE_SWAP(_int32, int32_t, shmemx)
 126 SHMEM_TYPE_SWAP(_int64, int64_t, shmemx)