← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nwchem/trusty-proposed

« back to all changes in this revision

Viewing changes to src/tools/ga-5-2/armci/src/devices/dcmf/armcix.h

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Daniel Leidert, Andreas Tille, Michael Banck
  • Date: 2013-07-04 12:14:55 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130704121455-5tvsx2qabor3nrui
Tags: 6.3-1
http://bugs.debian.org/696361
* New upstream release.
* Fixes anisotropic properties (Closes: #696361).
* New features include:
  + Multi-reference coupled cluster (MRCC) approaches
  + Hybrid DFT calculations with short-range HF 
  + New density-functionals including Minnesota (M08, M11) and HSE hybrid
    functionals
  + X-ray absorption spectroscopy (XAS) with TDDFT
  + Analytical gradients for the COSMO solvation model
  + Transition densities from TDDFT 
  + DFT+U and Electron-Transfer (ET) methods for plane wave calculations
  + Exploitation of space group symmetry in plane wave geometry optimizations
  + Local density of states (LDOS) collective variable added to Metadynamics
  + Various new XC functionals added for plane wave calculations, including
    hybrid and range-corrected ones
  + Electric field gradients with relativistic corrections 
  + Nudged Elastic Band optimization method
  + Updated basis sets and ECPs 

[ Daniel Leidert ]
* debian/watch: Fixed.

[ Andreas Tille ]
* debian/upstream: References

[ Michael Banck ]
* debian/upstream (Name): New field.
* debian/patches/02_makefile_flags.patch: Refreshed.
* debian/patches/06_statfs_kfreebsd.patch: Likewise.
* debian/patches/07_ga_target_force_linux.patch: Likewise.
* debian/patches/05_avoid_inline_assembler.patch: Removed, no longer needed.
* debian/patches/09_backported_6.1.1_fixes.patch: Likewise.
* debian/control (Build-Depends): Added gfortran-4.7 and gcc-4.7.
* debian/patches/10_force_gcc-4.7.patch: New patch, explicitly sets
  gfortran-4.7 and gcc-4.7, fixes test suite hang with gcc-4.8 (Closes:
  #701328, #713262).
* debian/testsuite: Added tests for COSMO analytical gradients and MRCC.
* debian/rules (MRCC_METHODS): New variable, required to enable MRCC methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-5-2/armci/src/devices/dcmf/armcix.h
 
1
/* begin_generated_IBM_copyright_prolog                             */
 
2
/*                                                                  */
 
3
/* ---------------------------------------------------------------- */
 
4
/* (C)Copyright IBM Corp.  2007, 2008                               */
 
5
/* IBM BSD License                                                  */
 
6
/* ---------------------------------------------------------------- */
 
7
/*                                                                  */
 
8
/* end_generated_IBM_copyright_prolog                               */
 
9
/**
 
10
 * \file armci/src/x/armcix.h
 
11
 * \brief ARMCI Extension interface.
 
12
 */
 
13
#ifndef __armci_src_x_armcix_h
 
14
#define __armci_src_x_armcix_h
 
15
 
 
16
#include "armci.h"
 
17
#include "armcip.h"
 
18
#include "request.h"
 
19
#include "memlock.h"
 
20
 
 
21
 
 
22
/**
 
23
 * \brief Creates a compile error if the condition is false.
 
24
 *
 
25
 * This macro must be used within a function for the compiler to process it.
 
26
 * It is suggested that C++ classes and C files create an inline function
 
27
 * similar to the following example. The inline function is never used at
 
28
 * runtime and should be optimized out by the compiler. It exists for the sole
 
29
 * purpose of moving runtime \c assert calls to compile-time errors.
 
30
 *
 
31
 * \code
 
32
 * static inline void compile_time_assert ()
 
33
 * {
 
34
 *   // This compile time assert will succeed.
 
35
 *   COMPILE_TIME_ASSERT(sizeof(char) <= sizeof(double));
 
36
 *
 
37
 *   // This compile time assert will fail.
 
38
 *   COMPILE_TIME_ASSERT(sizeof(double) <= sizeof(char));
 
39
 * }
 
40
 * \endcode
 
41
 *
 
42
 * Compile time assert errors will look similar to the following:
 
43
 *
 
44
 * \code
 
45
 * foo.h: In function compile_time_assert:
 
46
 * foo.h:43: error: duplicate case value
 
47
 * foo.h:43: error: previously used here
 
48
 * \endcode
 
49
 */
 
50
#define COMPILE_TIME_ASSERT(expr) switch(0){case 0:case expr:;}
 
51
 
 
52
/**
 
53
 * \brief Assert during compile if certain conditions are not met.
 
54
 */
 
55
static inline void armcix_compile_time_assert ()
 
56
{
 
57
  /*
 
58
   * Assert that the size of the internal armci handle data structure is less
 
59
   * than or equal to the size of the public armci handle data structure.
 
60
   */
 
61
  COMPILE_TIME_ASSERT(sizeof(armci_ireq_t)<=sizeof(armci_hdl_t));
 
62
}
 
63
 
 
64
/**
 
65
 * \brief Initialize the ARMCI Extension.
 
66
 *
 
67
 * \todo Define return values.
 
68
 * \return ?
 
69
 */
 
70
int ARMCIX_Init ();
 
71
 
 
72
/**
 
73
 * \brief Initialize the ARMCI Extention lock resources.
 
74
 *
 
75
 * \param[in]  local_memlock_table memlock table
 
76
 */
 
77
void ARMCIX_init_memlock (memlock_t * local_memlock_table);
 
78
 
 
79
/**
 
80
 * \brief ARMCI Extension blocking memory lock operation.
 
81
 *
 
82
 * Send a lock request to the remote node and block until the lock has been
 
83
 * acquired on the remote node.
 
84
 *
 
85
 * \param[in] pstart The start virtual address of the range of memory to lock.
 
86
 * \param[in] pend   The end virtual address of the range of memory to lock.
 
87
 * \param[in] proc   Remote process(or) ID
 
88
 */
 
89
void ARMCIX_Lockmem (void * pstart, void * pend, int proc);
 
90
 
 
91
/**
 
92
 * \brief ARMCI Extension release memory lock operation.
 
93
 *
 
94
 * Send a lock release message to the remote node. This is a \e fire-and-forget
 
95
 * operation because the node does not block for an acknowledgement that the
 
96
 * lock release was successful.
 
97
 *
 
98
 * \param[in] proc   Remote process rank
 
99
 */
 
100
void ARMCIX_Unlockmem (int proc);
 
101
 
 
102
/**
 
103
 * \brief ARMCI Extension blocking wait operation for a specifc request
 
104
 *
 
105
 * The armcix_opaque_t structure is a field in the armci_ireq_t structure
 
106
 * and is used to maintain ARMCIX state information for an operation in
 
107
 * progress.
 
108
 *
 
109
 * \param[in] cmpl_info Pointer to the ARMCIX opaque object
 
110
 *
 
111
 * \todo define return values
 
112
 * \return ???
 
113
 *
 
114
 * \see armci_ireq_t
 
115
 */
 
116
int ARMCIX_Wait (armcix_opaque_t * cmpl_info);
 
117
 
 
118
/**
 
119
 * \brief ARMCI Extension blocking wait operation for all requests to a specific process
 
120
 *
 
121
 * All existing requests to the remote process are compelte after this function returns.
 
122
 *
 
123
 * \param[in] proc Remote process rank
 
124
 *
 
125
 * \todo define return values
 
126
 * \return ???
 
127
 */
 
128
int ARMCIX_WaitProc (int proc);
 
129
 
 
130
/**
 
131
 * \brief ARMCI Extension blocking wait operation for all requests to all processes
 
132
 *
 
133
 * All existing requests to all processes are completed after this function returns.
 
134
 *
 
135
 * \todo define return values
 
136
 * \return ???
 
137
 */
 
138
int ARMCIX_WaitAll ();
 
139
 
 
140
 
 
141
/**
 
142
 * \brief Point-to-point fence operation.
 
143
 *
 
144
 * Blocks until all active messages between the local node and the remote
 
145
 * node have completed and acknowledged by the remote node.
 
146
 *
 
147
 * \param[in] proc       Rank of the remote node to fence
 
148
 *
 
149
 * \see ARMCIX_AllFence
 
150
 */
 
151
void ARMCIX_Fence (int proc);
 
152
 
 
153
/**
 
154
 * \brief Global fence operation.
 
155
 *
 
156
 * Blocks until all active messages between the local node and all remote
 
157
 * nodes have completed and acknowledged by the remote node.
 
158
 *
 
159
 * \see ARMCIX_Fence
 
160
 */
 
161
void ARMCIX_AllFence ();
 
162
 
 
163
/**
 
164
 * \brief ARMCI Extension blocking read-modify-write operation.
 
165
 *
 
166
 * \param[in] op
 
167
 * \param[in] ploc
 
168
 * \param[in] prem
 
169
 * \param[in] extra
 
170
 * \param[in] proc
 
171
 *
 
172
 * \todo define return code and input parameters; add detailed doxygen description
 
173
 * \retval ???
 
174
 */
 
175
int ARMCIX_Rmw (int op, int * ploc, int * prem, int extra, int proc);
 
176
 
 
177
/**
 
178
 * \brief ARMCI Extension blocking get operation.
 
179
 *
 
180
 * \param[in] src       Source buffer on the remote node
 
181
 * \param[in] dst       Destination buffer on the local node
 
182
 * \param[in] bytes     Number of bytes to transfer
 
183
 * \param[in] proc      Remote node rank
 
184
 *
 
185
 * \todo define return code; add detailed doxygen description
 
186
 * \return ???
 
187
 */
 
188
int ARMCIX_Get (void * src, void * dst, int bytes, int proc);
 
189
 
 
190
/**
 
191
 * \brief ARMCI Extension blocking vector get operation.
 
192
 *
 
193
 * \param[in] darr      Descriptor array
 
194
 * \param[in] len       Length of descriptor array
 
195
 * \param[in] proc      Remote process(or) ID
 
196
 *
 
197
 * \todo define return code; add detailed doxygen description
 
198
 * \return ???
 
199
 */
 
200
int ARMCIX_GetV (armci_giov_t * darr, int len, int proc);
 
201
 
 
202
/**
 
203
 * \brief ARMCI Extension blocking strided get operation.
 
204
 *
 
205
 * \param[in] src_ptr        pointer to 1st segment at source
 
206
 * \param[in] src_stride_arr array of strides at source
 
207
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
208
 * \param[in] dst_stride_arr array of strides at destination
 
209
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
210
 * \param[in] stride_levels  number of stride levels
 
211
 * \param[in] proc           remote process(or) ID
 
212
 *
 
213
 * \todo define return code; add detailed doxygen description
 
214
 * \return ???
 
215
 */
 
216
int ARMCIX_GetS (void * src_ptr, int * src_stride_arr, 
 
217
                 void * dst_ptr, int * dst_stride_arr, 
 
218
                 int * seg_count, int stride_levels, int proc);
 
219
 
 
220
/**
 
221
 * \brief ARMCI Extension non-blocking get operation.
 
222
 *
 
223
 * \param[in] src       Source buffer on the remote node
 
224
 * \param[in] dst       Destination buffer on the local node
 
225
 * \param[in] bytes     Number of bytes to transfer
 
226
 * \param[in] proc      Remote node rank
 
227
 * \param[in] nb_handle ARMCI non-blocking handle
 
228
 *
 
229
 * \todo define return code; add detailed doxygen description
 
230
 * \return ???
 
231
 */
 
232
int ARMCIX_NbGet (void * src, void * dst, int bytes, int proc, armci_ihdl_t nb_handle);
 
233
 
 
234
/**
 
235
 * \brief ARMCI Extension non-blocking vector get operation.
 
236
 *
 
237
 * \param[in] darr      Descriptor array
 
238
 * \param[in] len       Length of descriptor array
 
239
 * \param[in] proc      Remote process(or) ID
 
240
 * \param[in] nb_handle ARMCI non-blocking handle
 
241
 *
 
242
 * \todo define return code; add detailed doxygen description
 
243
 * \return ???
 
244
 */
 
245
int ARMCIX_NbGetV (armci_giov_t * darr, int len, int proc, armci_ihdl_t nb_handle);
 
246
 
 
247
/**
 
248
 * \brief ARMCI Extension non-blocking strided get operation.
 
249
 *
 
250
 * \param[in] src_ptr        pointer to 1st segment at source
 
251
 * \param[in] src_stride_arr array of strides at source
 
252
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
253
 * \param[in] dst_stride_arr array of strides at destination
 
254
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
255
 * \param[in] stride_levels  number of stride levels
 
256
 * \param[in] proc           remote process(or) ID
 
257
 * \param[in] nb_handle      ARMCI non-blocking handle
 
258
 *
 
259
 * \todo define return code; add detailed doxygen description
 
260
 * \return ???
 
261
 */
 
262
int ARMCIX_NbGetS (void * src_ptr, int * src_stride_arr, 
 
263
                   void * dst_ptr, int * dst_stride_arr, 
 
264
                   int * seg_count, int stride_levels, int proc,
 
265
                   armci_ihdl_t nb_handle);
 
266
 
 
267
/**
 
268
 * \brief ARMCI Extension blocking put operation.
 
269
 *
 
270
 * \param[in] src       Source buffer on the local node
 
271
 * \param[in] dst       Destination buffer on the remote node
 
272
 * \param[in] bytes     Number of bytes to transfer
 
273
 * \param[in] proc      Remote node rank
 
274
 *
 
275
 * \todo define return code; add detailed doxygen description
 
276
 * \return ???
 
277
 */
 
278
int ARMCIX_Put (void * src, void * dst, int bytes, int proc);
 
279
 
 
280
/**
 
281
 * \brief ARMCI Extension blocking vector put operation.
 
282
 *
 
283
 * \param[in] darr      Descriptor array
 
284
 * \param[in] len       Length of descriptor array
 
285
 * \param[in] proc      Remote process(or) ID
 
286
 *
 
287
 * \todo define return code; add detailed doxygen description
 
288
 * \return ???
 
289
 */
 
290
int ARMCIX_PutV (armci_giov_t * darr, int len, int proc);
 
291
 
 
292
/**
 
293
 * \brief ARMCI Extension blocking strided put operation.
 
294
 *
 
295
 * \param[in] src_ptr        pointer to 1st segment at source
 
296
 * \param[in] src_stride_arr array of strides at source
 
297
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
298
 * \param[in] dst_stride_arr array of strides at destination
 
299
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
300
 * \param[in] stride_levels  number of stride levels
 
301
 * \param[in] proc           remote process(or) ID
 
302
 *
 
303
 * \todo define return code; add detailed doxygen description
 
304
 * \return ???
 
305
 */
 
306
int ARMCIX_PutS (void * src_ptr, int * src_stride_arr, 
 
307
                 void * dst_ptr, int * dst_stride_arr, 
 
308
                 int * seg_count, int stride_levels, int proc);
 
309
 
 
310
/**
 
311
 * \brief ARMCI Extension non-blocking put operation.
 
312
 *
 
313
 * \param[in] src       Source buffer on the local node
 
314
 * \param[in] dst       Destination buffer on the remote node
 
315
 * \param[in] bytes     Number of bytes to transfer
 
316
 * \param[in] proc      Remote node rank
 
317
 * \param[in] nb_handle ARMCI non-blocking handle
 
318
 *
 
319
 * \todo define return code; add detailed doxygen description
 
320
 * \return ???
 
321
 */
 
322
int ARMCIX_NbPut (void * src, void * dst, int bytes, int proc, armci_ihdl_t nb_handle);
 
323
 
 
324
/**
 
325
 * \brief ARMCI Extension non-blocking vector put operation.
 
326
 *
 
327
 * \param[in] darr      Descriptor array
 
328
 * \param[in] len       Length of descriptor array
 
329
 * \param[in] proc      Remote process(or) ID
 
330
 * \param[in] nb_handle ARMCI non-blocking handle
 
331
 *
 
332
 * \todo define return code; add detailed doxygen description
 
333
 * \return ???
 
334
 */
 
335
int ARMCIX_NbPutV (armci_giov_t * darr, int len, int proc, armci_ihdl_t nb_handle);
 
336
 
 
337
/**
 
338
 * \brief ARMCI Extension non-blocking strided put operation.
 
339
 *
 
340
 * \param[in] src_ptr        pointer to 1st segment at source
 
341
 * \param[in] src_stride_arr array of strides at source
 
342
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
343
 * \param[in] dst_stride_arr array of strides at destination
 
344
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
345
 * \param[in] stride_levels  number of stride levels
 
346
 * \param[in] proc           remote process(or) ID
 
347
 * \param[in] nb_handle      ARMCI non-blocking handle
 
348
 *
 
349
 * \todo define return code; add detailed doxygen description
 
350
 * \return ???
 
351
 */
 
352
int ARMCIX_NbPutS (void * src_ptr, int * src_stride_arr, 
 
353
                   void * dst_ptr, int * dst_stride_arr, 
 
354
                   int * seg_count, int stride_levels, int proc,
 
355
                   armci_ihdl_t nb_handle);
 
356
 
 
357
/**
 
358
 * \brief ARMCI Extension blocking accumulate operation.
 
359
 *
 
360
 * \param[in] datatype  accumulate datatype (operation code)
 
361
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
362
 * \param[in] src       Source buffer on the local node
 
363
 * \param[in] dst       Destination buffer on the remote node
 
364
 * \param[in] bytes     Number of bytes to transfer
 
365
 * \param[in] proc      Remote node rank
 
366
 *
 
367
 * \todo define return code; add detailed doxygen description
 
368
 * \return ???
 
369
 */
 
370
int ARMCIX_Acc (int datatype, void * scale, void * src, void * dst, int bytes, int proc);
 
371
 
 
372
/**
 
373
 * \brief ARMCI Extension blocking vector accumulate operation.
 
374
 *
 
375
 * \param[in] datatype accumulate datatype (operation code)
 
376
 * \param[in] scale    opaque pointer to the scaling factor for accumulate
 
377
 * \param[in] darr     descriptor array
 
378
 * \param[in] len      length of the descriptor array
 
379
 * \param[in] proc     process(or) ID
 
380
 *
 
381
 * \todo define return code; add detailed doxygen description
 
382
 * \return ???
 
383
 */
 
384
int ARMCIX_AccV (int datatype, void * scale, armci_giov_t * darr, int len, int proc);
 
385
 
 
386
/**
 
387
 * \brief ARMCI Extension blocking strided accumulate operation.
 
388
 *
 
389
 * \param[in] datatype       accumulate datatype (operation code)
 
390
 * \param[in] scale          opaque pointer to the scaling factor for accumulate
 
391
 * \param[in] src_ptr        pointer to 1st segment at source
 
392
 * \param[in] src_stride_arr array of strides at source
 
393
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
394
 * \param[in] dst_stride_arr array of strides at destination
 
395
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
396
 * \param[in] stride_levels  number of stride levels
 
397
 * \param[in] proc           remote process(or) ID
 
398
 *
 
399
 * \todo define return code; add detailed doxygen description
 
400
 * \return ???
 
401
 */
 
402
int ARMCIX_AccS (int datatype, void * scale,
 
403
                 void * src_ptr, int * src_stride_arr, 
 
404
                 void * dst_ptr, int * dst_stride_arr, 
 
405
                 int * seg_count, int stride_levels, int proc);
 
406
 
 
407
/**
 
408
 * \brief ARMCI Extension non-blocking accumulate operation.
 
409
 *
 
410
 * \param[in] datatype  accumulate datatype (operation code)
 
411
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
412
 * \param[in] src       Source buffer on the local node
 
413
 * \param[in] dst       Destination buffer on the remote node
 
414
 * \param[in] bytes     Number of bytes to transfer
 
415
 * \param[in] proc      Remote node rank
 
416
 * \param[in] nb_handle ARMCI non-blocking handle
 
417
 *
 
418
 * \todo define return code; add detailed doxygen description
 
419
 * \return ???
 
420
 */
 
421
int ARMCIX_NbAcc (int datatype, void * scale, void * src, void * dst, int bytes, int proc, armci_ihdl_t nb_handle);
 
422
 
 
423
/**
 
424
 * \brief ARMCI Extension non-blocking vector accumulate operation.
 
425
 *
 
426
 * \param[in] datatype  accumulate datatype (operation code)
 
427
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
428
 * \param[in] darr      Descriptor array
 
429
 * \param[in] len       Length of descriptor array
 
430
 * \param[in] proc      Remote process(or) ID
 
431
 * \param[in] nb_handle ARMCI non-blocking handle
 
432
 *
 
433
 * \todo define return code; add detailed doxygen description
 
434
 * \return ???
 
435
 */
 
436
int ARMCIX_NbAccV (int datatype, void * scale, armci_giov_t * darr, int len, int proc, armci_ihdl_t nb_handle);
 
437
 
 
438
/**
 
439
 * \brief ARMCI Extension non-blocking strided accumulate operation.
 
440
 *
 
441
 * \param[in] datatype       accumulate datatype (operation code)
 
442
 * \param[in] scale          opaque pointer to the scaling factor for accumulate
 
443
 * \param[in] src_ptr        pointer to 1st segment at source
 
444
 * \param[in] src_stride_arr array of strides at source
 
445
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
446
 * \param[in] dst_stride_arr array of strides at destination
 
447
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
448
 * \param[in] stride_levels  number of stride levels
 
449
 * \param[in] proc           remote process(or) ID
 
450
 * \param[in] nb_handle      ARMCI non-blocking handle
 
451
 *
 
452
 * \todo define return code; add detailed doxygen description
 
453
 * \return ???
 
454
 */
 
455
int ARMCIX_NbAccS (int datatype, void * scale,
 
456
                   void * src_ptr, int * src_stride_arr, 
 
457
                   void * dst_ptr, int * dst_stride_arr, 
 
458
                   int * seg_count, int stride_levels, int proc,
 
459
                   armci_ihdl_t nb_handle);
 
460
 
 
461
 
 
462
/**
 
463
 * \page get_page Get APIs
 
464
 *
 
465
 * This is a description of the ARMCI Extension Get APIs
 
466
 *
 
467
 * \section get_blocking Blocking APIs
 
468
 * - ARMCIX_Get()
 
469
 * - ARMCIX_GetV()
 
470
 * - ARMCIX_GetS()
 
471
 * \section get_nonblocking Non-blocking APIs
 
472
 * - ARMCIX_NbGet()
 
473
 * - ARMCIX_NbGetV()
 
474
 * - ARMCIX_NbGetS()
 
475
 */
 
476
 
 
477
/**
 
478
 * \page put_page Put APIs
 
479
 *
 
480
 * This is a description of the ARMCI Extension Put APIs
 
481
 *
 
482
 * \section put_blocking Blocking APIs
 
483
 * - ARMCIX_Put()
 
484
 * - ARMCIX_PutV()
 
485
 * - ARMCIX_PutS()
 
486
 * \section put_nonblocking Non-blocking APIs
 
487
 * - ARMCIX_NbPut()
 
488
 * - ARMCIX_NbPutV()
 
489
 * - ARMCIX_NbPutS()
 
490
 */
 
491
 
 
492
/**
 
493
 * \page acc_page Accumulate APIs
 
494
 *
 
495
 * This is a description of the ARMCI Extension Accumulate APIs
 
496
 *
 
497
 * \section acc_blocking Blocking APIs
 
498
 * - ARMCIX_Acc()
 
499
 * - ARMCIX_AccV()
 
500
 * - ARMCIX_AccS()
 
501
 * \section acc_nonblocking Non-blocking APIs
 
502
 * - ARMCIX_NbAcc()
 
503
 * - ARMCIX_NbAccV()
 
504
 * - ARMCIX_NbAccS()
 
505
 */
 
506
 
 
507
/**
 
508
 * \page blocking_page Blocking APIs
 
509
 *
 
510
 * This is a description of the \b blocking ARMCI Extension APIs
 
511
 *
 
512
 * \section transfer Data transfer APIs
 
513
 * - ARMCIX_Get()
 
514
 * - ARMCIX_GetV()
 
515
 * - ARMCIX_GetS()
 
516
 * - ARMCIX_Put()
 
517
 * - ARMCIX_PutV()
 
518
 * - ARMCIX_PutS()
 
519
 * - ARMCIX_Acc()
 
520
 * - ARMCIX_AccV()
 
521
 * - ARMCIX_AccS()
 
522
 * - ARMCIX_Rmw()
 
523
 * \section sync Syncronization APIs
 
524
 * - ARMCIX_Fence()
 
525
 * - ARMCIX_AllFence()
 
526
 * - ARMCIX_Wait()
 
527
 * - ARMCIX_WaitProc()
 
528
 * - ARMCIX_WaitAll()
 
529
 * - ARMCIX_Lockmem()
 
530
 */
 
531
 
 
532
/**
 
533
 * \page nonblocking_page Non-blocking APIs
 
534
 *
 
535
 * This is a description of the \b non-blocking ARMCI Extension APIs
 
536
 *
 
537
 * \section transfer Data transfer APIs
 
538
 * - ARMCIX_NbGet()
 
539
 * - ARMCIX_NbGetV()
 
540
 * - ARMCIX_NbGetS()
 
541
 * - ARMCIX_NbPut()
 
542
 * - ARMCIX_NbPutV()
 
543
 * - ARMCIX_NbPutS()
 
544
 * - ARMCIX_NbAcc()
 
545
 * - ARMCIX_NbAccV()
 
546
 * - ARMCIX_NbAccS()
 
547
 */
 
548
 
 
549
/**
 
550
 * \page vector_page Vector APIs
 
551
 *
 
552
 * This is a description of the ARMCI Extension vector APIs
 
553
 *
 
554
 * \section vector_blocking Blocking APIs
 
555
 * - ARMCIX_GetV()
 
556
 * - ARMCIX_PutV()
 
557
 * - ARMCIX_AccV()
 
558
 * \section vector_nonblocking Non-blocking APIs
 
559
 * - ARMCIX_NbGetV()
 
560
 * - ARMCIX_NbPutV()
 
561
 * - ARMCIX_NbAccV()
 
562
 */
 
563
 
 
564
/**
 
565
 * \page strided_page Strided APIs
 
566
 *
 
567
 * This is a description of the ARMCI Extension strided APIs
 
568
 *
 
569
 * \section strided_blocking Blocking APIs
 
570
 * - ARMCIX_GetS()
 
571
 * - ARMCIX_PutS()
 
572
 * - ARMCIX_AccS()
 
573
 * \section strided_nonblocking Non-blocking APIs
 
574
 * - ARMCIX_NbGetS()
 
575
 * - ARMCIX_NbPutS()
 
576
 * - ARMCIX_NbAccS()
 
577
 */
 
578
 
 
579
 
 
580
 
 
581
#endif