Debian Codegraph @

modules/libfabric/prov/gni/include/rdma/fi_direct_atomic.h

raw
1 /*
2 * Copyright (c) 2015-2017 Los Alamos National Security, LLC. All
3 * rights reserved.
4 * Copyright (c) 2015-2016 Cray Inc. All rights reserved.
5 *
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * BSD license below:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
33 */
34
35 #ifndef _FI_DIRECT_ATOMIC_H_
36 #define _FI_DIRECT_ATOMIC_H_
37
38 #define FABRIC_DIRECT_ATOMIC 1
39
40 /*******************************************************************************
41 * GNI API Functions
42 ******************************************************************************/
43 extern ssize_t gnix_ep_atomic_write(struct fid_ep *ep, const void *buf,
44 size_t count, void *desc,
45 fi_addr_t dest_addr, uint64_t addr,
46 uint64_t key, enum fi_datatype datatype,
47 enum fi_op op, void *context);
48
49 extern ssize_t gnix_ep_atomic_writev(struct fid_ep *ep,
50 const struct fi_ioc *iov, void **desc,
51 size_t count, fi_addr_t dest_addr,
52 uint64_t addr, uint64_t key,
53 enum fi_datatype datatype, enum fi_op op,
54 void *context);
55
56 extern ssize_t gnix_ep_atomic_writemsg(struct fid_ep *ep,
57 const struct fi_msg_atomic *msg,
58 uint64_t flags);
59
60 extern ssize_t gnix_ep_atomic_inject(struct fid_ep *ep, const void *buf,
61 size_t count, fi_addr_t dest_addr,
62 uint64_t addr, uint64_t key,
63 enum fi_datatype datatype, enum fi_op op);
64
65 extern ssize_t gnix_ep_atomic_readwrite(struct fid_ep *ep, const void *buf,
66 size_t count, void *desc, void *result,
67 void *result_desc, fi_addr_t dest_addr,
68 uint64_t addr, uint64_t key,
69 enum fi_datatype datatype,
70 enum fi_op op, void *context);
71
72 extern ssize_t gnix_ep_atomic_readwritev(struct fid_ep *ep,
73 const struct fi_ioc *iov,
74 void **desc, size_t count,
75 struct fi_ioc *resultv,
76 void **result_desc,
77 size_t result_count,
78 fi_addr_t dest_addr, uint64_t addr,
79 uint64_t key,
80 enum fi_datatype datatype,
81 enum fi_op op, void *context);
82
83 extern ssize_t gnix_ep_atomic_readwritemsg(struct fid_ep *ep,
84 const struct fi_msg_atomic *msg,
85 struct fi_ioc *resultv,
86 void **result_desc,
87 size_t result_count, uint64_t flags);
88
89 extern ssize_t gnix_ep_atomic_compwrite(struct fid_ep *ep, const void *buf,
90 size_t count, void *desc,
91 const void *compare, void *compare_desc,
92 void *result, void *result_desc,
93 fi_addr_t dest_addr, uint64_t addr,
94 uint64_t key, enum fi_datatype datatype,
95 enum fi_op op, void *context);
96
97 extern ssize_t gnix_ep_atomic_compwritev(struct fid_ep *ep,
98 const struct fi_ioc *iov, void **desc,
99 size_t count,
100 const struct fi_ioc *comparev,
101 void **compare_desc,
102 size_t compare_count,
103 struct fi_ioc *resultv,
104 void **result_desc,
105 size_t result_count,
106 fi_addr_t dest_addr, uint64_t addr,
107 uint64_t key,
108 enum fi_datatype datatype,
109 enum fi_op op, void *context);
110
111 extern ssize_t
112 gnix_ep_atomic_compwritemsg(struct fid_ep *ep, const struct fi_msg_atomic *msg,
113 const struct fi_ioc *comparev, void **compare_desc,
114 size_t compare_count, struct fi_ioc *resultv,
115 void **result_desc, size_t result_count,
116 uint64_t flags);
117
118 extern int gnix_ep_atomic_valid(struct fid_ep *ep,
119 enum fi_datatype datatype, enum fi_op op,
120 size_t *count);
121
122 extern int gnix_ep_fetch_atomic_valid(struct fid_ep *ep,
123 enum fi_datatype datatype, enum fi_op op,
124 size_t *count);
125
126 extern int gnix_ep_cmp_atomic_valid(struct fid_ep *ep,
127 enum fi_datatype datatype,
128 enum fi_op op, size_t *count);
129
130 /*******************************************************************************
131 * Libfabric API Functions
132 ******************************************************************************/
133 static inline ssize_t fi_atomic(struct fid_ep *ep, const void *buf,
134 size_t count, void *desc, fi_addr_t dest_addr,
135 uint64_t addr, uint64_t key,
136 enum fi_datatype datatype, enum fi_op op,
137 void *context)
138 {
139 return gnix_ep_atomic_write(ep, buf, count, desc, dest_addr, addr, key,
140 datatype, op, context);
141 }
142
143 static inline ssize_t fi_atomicv(struct fid_ep *ep, const struct fi_ioc *iov,
144 void **desc, size_t count, fi_addr_t dest_addr,
145 uint64_t addr, uint64_t key,
146 enum fi_datatype datatype, enum fi_op op,
147 void *context)
148 {
149 return gnix_ep_atomic_writev(ep, iov, desc, count, dest_addr, addr, key,
150 datatype, op, context);
151 }
152
153 static inline ssize_t
154 fi_atomicmsg(struct fid_ep *ep, const struct fi_msg_atomic *msg, uint64_t flags)
155 {
156 return gnix_ep_atomic_writemsg(ep, msg, flags);
157 }
158
159 static inline ssize_t fi_inject_atomic(struct fid_ep *ep, const void *buf,
160 size_t count, fi_addr_t dest_addr,
161 uint64_t addr, uint64_t key,
162 enum fi_datatype datatype, enum fi_op op)
163 {
164 return gnix_ep_atomic_inject(ep, buf, count, dest_addr, addr, key,
165 datatype, op);
166 }
167
168 static inline ssize_t fi_fetch_atomic(struct fid_ep *ep, const void *buf,
169 size_t count, void *desc, void *result,
170 void *result_desc, fi_addr_t dest_addr,
171 uint64_t addr, uint64_t key,
172 enum fi_datatype datatype, enum fi_op op,
173 void *context)
174 {
175 return gnix_ep_atomic_readwrite(ep, buf, count, desc, result,
176 result_desc, dest_addr, addr, key,
177 datatype, op, context);
178 }
179
180 static inline ssize_t fi_fetch_atomicv(struct fid_ep *ep,
181 const struct fi_ioc *iov, void **desc,
182 size_t count, struct fi_ioc *resultv,
183 void **result_desc, size_t result_count,
184 fi_addr_t dest_addr, uint64_t addr,
185 uint64_t key, enum fi_datatype datatype,
186 enum fi_op op, void *context)
187 {
188 return gnix_ep_atomic_readwritev(ep, iov, desc, count, resultv,
189 result_desc, result_count, dest_addr,
190 addr, key, datatype, op, context);
191 }
192
193 static inline ssize_t fi_fetch_atomicmsg(struct fid_ep *ep,
194 const struct fi_msg_atomic *msg,
195 struct fi_ioc *resultv,
196 void **result_desc,
197 size_t result_count, uint64_t flags)
198 {
199 return gnix_ep_atomic_readwritemsg(ep, msg, resultv, result_desc,
200 result_count, flags);
201 }
202
203 static inline ssize_t fi_compare_atomic(struct fid_ep *ep, const void *buf,
204 size_t count, void *desc,
205 const void *compare, void *compare_desc,
206 void *result, void *result_desc,
207 fi_addr_t dest_addr, uint64_t addr,
208 uint64_t key, enum fi_datatype datatype,
209 enum fi_op op, void *context)
210 {
211 return gnix_ep_atomic_compwrite(
212 ep, buf, count, desc, compare, compare_desc, result, result_desc,
213 dest_addr, addr, key, datatype, op, context);
214 }
215
216 static inline ssize_t fi_compare_atomicv(struct fid_ep *ep,
217 const struct fi_ioc *iov,
218 void **desc, size_t count,
219 const struct fi_ioc *comparev,
220 void **compare_desc,
221 size_t compare_count,
222 struct fi_ioc *resultv,
223 void **result_desc,
224 size_t result_count,
225 fi_addr_t dest_addr, uint64_t addr,
226 uint64_t key,
227 enum fi_datatype datatype,
228 enum fi_op op, void *context)
229 {
230 return gnix_ep_atomic_compwritev(ep, iov, desc, count, comparev,
231 compare_desc, compare_count, resultv,
232 result_desc, result_count, dest_addr,
233 addr, key, datatype, op, context);
234 }
235
236 static inline ssize_t
237 fi_compare_atomicmsg(struct fid_ep *ep, const struct fi_msg_atomic *msg,
238 const struct fi_ioc *comparev, void **compare_desc,
239 size_t compare_count, struct fi_ioc *resultv,
240 void **result_desc, size_t result_count, uint64_t flags)
241 {
242 return gnix_ep_atomic_compwritemsg(ep, msg, comparev, compare_desc,
243 compare_count, resultv, result_desc,
244 result_count, flags);
245 }
246
247 static inline int fi_atomicvalid(struct fid_ep *ep, enum fi_datatype datatype,
248 enum fi_op op, size_t *count)
249 {
250 return gnix_ep_atomic_valid(ep, datatype, op, count);
251 }
252
253 static inline int fi_fetch_atomicvalid(struct fid_ep *ep,
254 enum fi_datatype datatype, enum fi_op op,
255 size_t *count)
256 {
257 return gnix_ep_fetch_atomic_valid(ep, datatype, op, count);
258 }
259
260 static inline int fi_compare_atomicvalid(struct fid_ep *ep,
261 enum fi_datatype datatype,
262 enum fi_op op, size_t *count)
263 {
264 return gnix_ep_cmp_atomic_valid(ep, datatype, op, count);
265 }
266
267 #endif /* _FI_DIRECT_ATOMIC_H_ */