1 /**
2  * Copyright (C) Mellanox Technologies Ltd. 2001-2016.  ALL RIGHTS RESERVED.
3  * Copyright (C) UT-Battelle, LLC. 2016-2017.  ALL RIGHTS RESERVED.
4  *
5  * See file LICENSE for terms.
6  */
7 
8 #ifndef TEST_UCP_ATOMIC_H_
9 #define TEST_UCP_ATOMIC_H_
10 
11 #include "test_ucp_memheap.h"
12 
13 
14 class test_ucp_atomic : public test_ucp_memheap {
15 public:
16     static std::vector<ucp_test_param> enum_test_params(const ucp_params_t& ctx_params,
17                                                         const std::string& name,
18                                                         const std::string& test_case_name,
19                                                         const std::string& tls);
20 
21     virtual void init();
22 
23     template <typename T>
24     void blocking_add(entity *e,  size_t max_size, void *memheap_addr,
25                       ucp_rkey_h rkey, std::string& expected_data);
26 
27     template<uint32_t> void blocking_add(entity *e,  size_t max_size, void *memheap_addr,
28                                          ucp_rkey_h rkey, std::string& expected_data);
29 
30     void unaligned_blocking_add64(entity *e,  size_t max_size, void *memheap_addr,
31                                   ucp_rkey_h rkey, std::string& expected_data);
32 
33     template <ucp_atomic_post_op_t OP>
34     void unaligned_nb_post(entity *e,  size_t max_size, void *memheap_addr,
35                            ucp_rkey_h rkey, std::string& expected_data);
36 
37     template <typename T>
38     void nb_cswap(entity *e,  size_t max_size, void *memheap_addr,
39                   ucp_rkey_h rkey, std::string& expected_data);
40 
41     template <typename T, typename F>
42     void test(F f, bool malloc_allocate);
43 
44     template <typename T, ucp_atomic_post_op_t OP>
45     void nb_post(entity *e,  size_t max_size, void *memheap_addr,
46                  ucp_rkey_h rkey, std::string& expected_data);
47 
48     template <typename T, ucp_atomic_op_t OP>
49     void nbx_post(entity *e,  size_t max_size, void *memheap_addr,
50                  ucp_rkey_h rkey, std::string& expected_data);
51 
52     template <typename T, ucp_atomic_fetch_op_t FOP>
53     void nb_fetch(entity *e,  size_t max_size, void *memheap_addr,
54                   ucp_rkey_h rkey, std::string& expected_data);
55 
56     template <typename T, ucp_atomic_post_op_t OP>
atomic_op_val(T v1,T v2)57     T atomic_op_val(T v1, T v2)
58     {
59         /* coverity[switch_selector_expr_is_constant] */
60         switch (OP) {
61         case UCP_ATOMIC_POST_OP_ADD:
62             return v1 + v2;
63         case UCP_ATOMIC_POST_OP_AND:
64             return v1 & v2;
65         case UCP_ATOMIC_POST_OP_OR:
66             return v1 | v2;
67         case UCP_ATOMIC_POST_OP_XOR:
68             return v1 ^ v2;
69         default:
70             return 0;
71         }
72     }
73 
74     template <typename T, ucp_atomic_op_t OP>
nbx_atomic_op_val(T v1,T v2)75     T nbx_atomic_op_val(T v1, T v2)
76     {
77         /* coverity[switch_selector_expr_is_constant] */
78         switch (OP) {
79         case UCP_ATOMIC_OP_ADD:
80             return v1 + v2;
81         case UCP_ATOMIC_OP_AND:
82             return v1 & v2;
83         case UCP_ATOMIC_OP_OR:
84             return v1 | v2;
85         case UCP_ATOMIC_OP_XOR:
86             return v1 ^ v2;
87         default:
88             return 0;
89         }
90     }
91 
92     template <typename T, ucp_atomic_fetch_op_t OP>
atomic_fop_val(T v1,T v2)93     T atomic_fop_val(T v1, T v2)
94     {
95         /* coverity[switch_selector_expr_is_constant] */
96         switch (OP) {
97         case UCP_ATOMIC_FETCH_OP_FADD:
98             return v1 + v2;
99         case UCP_ATOMIC_FETCH_OP_FAND:
100             return v1 & v2;
101         case UCP_ATOMIC_FETCH_OP_FOR:
102             return v1 | v2;
103         case UCP_ATOMIC_FETCH_OP_FXOR:
104             return v1 ^ v2;
105         case UCP_ATOMIC_FETCH_OP_SWAP:
106             return v1;
107         default:
108             return 0;
109         }
110     }
111 
112 private:
send_completion(void * request,ucs_status_t status)113     static void send_completion(void *request, ucs_status_t status){}
114     template <typename T>
115     ucs_status_t ucp_atomic_post_nbi(ucp_ep_h ep, ucp_atomic_post_op_t opcode,
116                                  T value, void *remote_addr,
117                                  ucp_rkey_h rkey);
118 
119     template <typename T>
120     ucs_status_t ucp_atomic_post_nbx(ucp_ep_h ep, ucp_atomic_op_t opcode,
121                                      T value, void *remote_addr,
122                                      ucp_rkey_h rkey);
123 
124     template <typename T>
125     ucs_status_ptr_t ucp_atomic_fetch(ucp_ep_h ep, ucp_atomic_fetch_op_t opcode,
126                                       T value, T *result,
127                                       void *remote_addr, ucp_rkey_h rkey);
128 };
129 
130 #endif
131