~ubuntu-branches/ubuntu/utopic/nwchem/utopic

« back to all changes in this revision

Viewing changes to src/tools/ga-5-1/armci/src/include/armci.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
* 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:
1
 
/* ARMCI header file */
2
 
#ifndef _ARMCI_H
3
 
#define _ARMCI_H   
4
 
 
5
 
/* for size_t */
6
 
#include <stdlib.h>
7
 
 
8
 
#if defined(__cplusplus) || defined(c_plusplus)
9
 
extern "C" {
10
 
#endif
11
 
 
12
 
 
13
 
extern int armci_sameclusnode(int proc);
14
 
 
15
 
typedef struct {
16
 
    void **src_ptr_array;
17
 
    void **dst_ptr_array;
18
 
    int  ptr_array_len;
19
 
    int bytes;
20
 
} armci_giov_t;
21
 
typedef long armci_size_t;
22
 
extern int armci_notify(int proc);
23
 
extern int armci_notify_wait(int proc,int *pval);
24
 
extern int ARMCI_Init(void);    /* initialize ARMCI */
25
 
extern int ARMCI_Init_args(int *argc, char ***argv); /* initialize ARMCI */
26
 
extern int ARMCI_Initialized();
27
 
extern void ARMCI_Barrier(void);    /* ARMCI Barrier*/
28
 
 
29
 
extern int ARMCI_Put(void *src, void* dst, int bytes, int proc);
30
 
extern int ARMCI_Put_flag(void *src, void* dst,int bytes,int *f,int v,int proc);
31
 
 
32
 
/* On path for deprecation */
33
 
#define ARMCI_Put1(_s,_d,_b,_p) memcpy(_d,_s,_b), 0
34
 
 
35
 
extern int ARMCI_PutS(          /* strided put */
36
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
37
 
                int src_stride_arr[], /* array of strides at source */
38
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
39
 
                int dst_stride_arr[], /* array of strides at destination */
40
 
                int count[],          /* number of units at each stride level count[0]=bytes */
41
 
                int stride_levels,    /* number of stride levels */
42
 
                int proc              /* remote process(or) ID */
43
 
                );
44
 
 
45
 
extern int ARMCI_PutS_flag_dir(       /* put with flag that uses direct put */
46
 
                void *src_ptr,        /* pointer to 1st segment at source*/
47
 
                int src_stride_arr[], /* array of strides at source */
48
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
49
 
                int dst_stride_arr[], /* array of strides at destination */
50
 
                int count[],          /* number of segments at each stride 
51
 
                                         levels: count[0]=bytes*/
52
 
                int stride_levels,    /* number of stride levels */
53
 
                int *flag,            /* pointer to remote flag */
54
 
                int val,              /* value to set flag upon completion of
55
 
                                         data transfer */
56
 
                int proc              /* remote process(or) ID */
57
 
                );
58
 
 
59
 
extern int ARMCI_PutS_flag(
60
 
                void *src_ptr,        /* pointer to 1st segment at source*/
61
 
                int src_stride_arr[], /* array of strides at source */
62
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
63
 
                int dst_stride_arr[], /* array of strides at destination */
64
 
                int count[],          /* number of segments at each stride 
65
 
                                         levels: count[0]=bytes*/
66
 
                int stride_levels,    /* number of stride levels */
67
 
                int *flag,            /* pointer to remote flag */
68
 
                int val,              /* value to set flag upon completion of
69
 
                                         data transfer */
70
 
                int proc              /* remote process(or) ID */
71
 
                );
72
 
 
73
 
extern int ARMCI_Acc(int optype, void *scale, void *src, void* dst, int bytes, int proc);
74
 
 
75
 
extern int ARMCI_AccS(                /* strided accumulate */
76
 
                int  optype,          /* operation */
77
 
                void *scale,          /* scale factor x += scale*y */
78
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
79
 
                int src_stride_arr[], /* array of strides at source */
80
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
81
 
                int dst_stride_arr[], /* array of strides at destination */
82
 
                int count[],          /* number of units at each stride level count[0]=bytes */
83
 
                int stride_levels,    /* number of stride levels */
84
 
                int proc              /* remote process(or) ID */
85
 
                );
86
 
 
87
 
 
88
 
extern int ARMCI_Get(void *src, void* dst, int bytes, int proc);
89
 
 
90
 
extern int ARMCI_GetS(          /* strided get */
91
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
92
 
                int src_stride_arr[], /* array of strides at source */
93
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
94
 
                int dst_stride_arr[], /* array of strides at destination */
95
 
                int count[],          /* number of units at each stride level count[0]=bytes */
96
 
                int stride_levels,    /* number of stride levels */
97
 
                int proc              /* remote process(or) ID */
98
 
                );
99
 
 
100
 
extern int ARMCI_GetV( armci_giov_t darr[], /* descriptor array */
101
 
                int len,  /* length of descriptor array */
102
 
                int proc  /* remote process(or) ID */
103
 
              );
104
 
 
105
 
extern int ARMCI_PutV( armci_giov_t darr[], /* descriptor array */
106
 
                int len,  /* length of descriptor array */
107
 
                int proc  /* remote process(or) ID */
108
 
              );
109
 
 
110
 
extern int ARMCI_AccV( int op,       /* operation code */
111
 
                void *scale,         /* scaling factor for accumulate */
112
 
                armci_giov_t darr[], /* descriptor array */
113
 
                int len,             /* length of descriptor array */
114
 
                int proc             /* remote process(or) ID */
115
 
              );
116
 
 
117
 
extern int ARMCI_PutValueInt(int src,     /* value in a register to put     */
118
 
                             void *dst,   /* dest starting addr to put data */
119
 
                             int proc     /* remote process (or) ID         */
120
 
                             );
121
 
 
122
 
extern int ARMCI_PutValueLong(long src,   /* value in a register to put     */
123
 
                              void *dst,  /* dest starting addr to put data */
124
 
                              int proc    /* remote process (or) ID         */
125
 
                              );
126
 
 
127
 
extern int ARMCI_PutValueFloat(float src, /* value in a register to put     */
128
 
                               void *dst, /* dest starting addr to put data */
129
 
                               int proc   /* remote process (or) ID         */
130
 
                               );
131
 
 
132
 
extern int ARMCI_PutValueDouble(double src,/* value in a register to put     */
133
 
                                void *dst, /* dest starting addr to put data */
134
 
                                int proc   /* remote process (or) ID         */
135
 
                                );
136
 
 
137
 
extern int ARMCI_GetValueInt(void *src, int proc);
138
 
extern long ARMCI_GetValueLong(void *src, int proc);
139
 
extern float ARMCI_GetValueFloat(void *src, int proc);     
140
 
extern double ARMCI_GetValueDouble(void *src, int proc);     
141
 
 
142
 
 
143
 
extern int ARMCI_Malloc(void* ptr_arr[], armci_size_t bytes);
144
 
extern int ARMCI_Free(void *ptr);
145
 
extern void* ARMCI_Malloc_local(armci_size_t bytes);
146
 
extern int ARMCI_Free_local(void *ptr);
147
 
extern int ARMCI_Same_node(int proc);
148
 
 
149
 
extern void ARMCI_Finalize();    /* terminate ARMCI */
150
 
extern void ARMCI_Error(char *msg, int code);
151
 
extern void ARMCI_Fence(int proc);
152
 
extern void ARMCI_AllFence(void);
153
 
extern int  ARMCI_Rmw(int op, void *ploc, void *prem, int extra, int proc);
154
 
extern void ARMCI_Cleanup(void);
155
 
extern int ARMCI_Create_mutexes(int num);
156
 
extern int ARMCI_Destroy_mutexes(void);
157
 
extern void ARMCI_Lock(int mutex, int proc);
158
 
extern void ARMCI_Unlock(int mutex, int proc);
159
 
extern void ARMCI_Set_shm_limit(unsigned long shmemlimit);
160
 
extern int ARMCI_Uses_shm();
161
 
extern void ARMCI_Copy(void *src, void *dst, int n);
162
 
 
163
 
#define FAIL  -1
164
 
#define FAIL2 -2
165
 
#define FAIL3 -3
166
 
#define FAIL4 -4
167
 
#define FAIL5 -5
168
 
#define FAIL6 -6
169
 
#define FAIL7 -7
170
 
#define FAIL8 -8
171
 
 
172
 
#define ARMCI_SWAP 10
173
 
#define ARMCI_SWAP_LONG 11
174
 
#define ARMCI_FETCH_AND_ADD 12
175
 
#define ARMCI_FETCH_AND_ADD_LONG 13
176
 
 
177
 
#define ARMCI_ACC_OFF 36
178
 
#define ARMCI_ACC_INT (ARMCI_ACC_OFF + 1)
179
 
#define ARMCI_ACC_DBL (ARMCI_ACC_OFF + 2)
180
 
#define ARMCI_ACC_FLT (ARMCI_ACC_OFF + 3)
181
 
#define ARMCI_ACC_CPL (ARMCI_ACC_OFF + 4)
182
 
#define ARMCI_ACC_DCP (ARMCI_ACC_OFF + 5)
183
 
#define ARMCI_ACC_LNG (ARMCI_ACC_OFF + 6)
184
 
 
185
 
#define ARMCI_MAX_STRIDE_LEVEL 8
186
 
 
187
 
/****************Error/termination macros************************/
188
 
/**Debug assert macro. To be used instead of assert for more user
189
 
 * informative and cleaner death. Also allows individualized
190
 
 * enabling/disabling of assert statements.
191
 
 * @param _enable Ignore this assertion if _enable==0
192
 
 * @param _cond   Condition to be evaluated (assert that it is true)
193
 
 * @param _plist  Information to be printed using printf, should be
194
 
 * within parenthesis (eg., dassert(1,0,("%d:test n=%d\n",me,0));
195
 
 * ). This is fed directly to printf.  
196
 
 */
197
 
int dassertp_fail(const char *cond_string, const char *file, 
198
 
                  const char *func, unsigned int line, int code);
199
 
  void derr_printf(const char *format, ...);
200
 
#undef dassertp
201
 
#define dassertp(_enable,_cond,_plist)  do {              \
202
 
  if((_enable) && !(_cond)) {                             \
203
 
    derr_printf _plist;                                   \
204
 
    dassertp_fail(#_cond,__FILE__,FUNCTION_NAME,__LINE__,1); \
205
 
  }} while(0)
206
 
 
207
 
#undef dassertc
208
 
#define dassertc(_enable,_cond,_plist,_code)  do {              \
209
 
  if((_enable) && !(_cond)) {                             \
210
 
    derr_printf _plist;                                   \
211
 
    dassertp_fail(#_cond,__FILE__,FUNCTION_NAME,__LINE__,_code); \
212
 
  }} while(0)
213
 
 
214
 
#undef dassert
215
 
#define dassert(_enable,_cond) dassertp((_enable),(_cond),(""))
216
 
 
217
 
#undef dassert1
218
 
#define dassert1(_enable,_cond,_ival)                       \
219
 
  dassertp((_enable),(_cond),("%d: error ival=%d\n",        \
220
 
                              armci_msg_me(),(int)(_ival))) 
221
 
 
222
 
#define armci_die(_msg,_code) dassertc(1,0,             \
223
 
("%d:%s: %d\n", armci_msg_me(),(_msg),(_code)),_code)
224
 
 
225
 
#define armci_die2(_msg,_code1,_code2) dassertc(1,0,    \
226
 
("%d:%s: (%d,%d)\n",armci_me,(_msg),(_code1),(_code2)),_code1)
227
 
 
228
 
/************ locality information **********************************************/
229
 
typedef int armci_domain_t;
230
 
#define ARMCI_DOMAIN_SMP 0        /* SMP node domain for armci_domain_XXX calls */
231
 
extern int armci_domain_nprocs(armci_domain_t domain, int id);
232
 
extern int armci_domain_id(armci_domain_t domain, int glob_proc_id);
233
 
extern int armci_domain_glob_proc_id(armci_domain_t domain, int id, int loc_proc_id);
234
 
extern int armci_domain_my_id(armci_domain_t domain);
235
 
extern int armci_domain_count(armci_domain_t domain);
236
 
extern int armci_domain_same_id(armci_domain_t domain, int proc);
237
 
 
238
 
 
239
 
/* PVM group
240
 
 * On CrayT3E: the default group is the global group which is (char *)NULL
241
 
 *             It is the only working group.
242
 
 * On Workstations: the default group is "mp_working_group". User can set
243
 
 *                  the group name by calling the ARMCI_PVM_init (defined
244
 
 *                  in message.c) and passing the group name to the library.
245
 
 */
246
 
 
247
 
extern char *mp_group_name;
248
 
 
249
 
/*********************stuff for non-blocking API******************************/
250
 
/*\ the request structure for non-blocking api. 
251
 
  \*/
252
 
/*max of sizes for all platforms. Increase if any platform needs more*/
253
 
typedef struct{
254
 
    int data[4]; /* tag, bufid, agg_flag, op, proc */
255
 
    double dummy[72]; 
256
 
} armci_hdl_t;
257
 
 
258
 
#define armci_req_t armci_hdl_t
259
 
 
260
 
typedef int ARMCI_Group;
261
 
 
262
 
extern void ARMCI_Group_create(int n, int *pid_list, ARMCI_Group *group_out);
263
 
extern void ARMCI_Group_create_child(int n, int *pid_list,
264
 
        ARMCI_Group *group_out, ARMCI_Group *group_parent);
265
 
extern void ARMCI_Group_free(ARMCI_Group *group);
266
 
extern int  ARMCI_Group_rank(ARMCI_Group *group, int *rank);
267
 
extern void ARMCI_Group_size(ARMCI_Group *group, int *size);
268
 
extern void ARMCI_Group_set_default(ARMCI_Group *group);
269
 
extern void ARMCI_Group_get_default(ARMCI_Group *group_out);
270
 
extern void ARMCI_Group_get_world(ARMCI_Group *group_out);
271
 
   
272
 
extern int ARMCI_Absolute_id(ARMCI_Group *group, int group_rank);
273
 
extern int ARMCI_Uses_shm_grp(ARMCI_Group *group);
274
 
 
275
 
extern int ARMCI_Malloc_group(void *ptr_arr[], armci_size_t bytes,ARMCI_Group *group);
276
 
extern int ARMCI_Free_group(void *ptr, ARMCI_Group *group);
277
 
 
278
 
extern int ARMCI_NbPut(void *src, void* dst, int bytes, int proc,armci_hdl_t* nb_handle);
279
 
 
280
 
extern int ARMCI_NbPutS(          /* strided put */
281
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
282
 
                int src_stride_arr[], /* array of strides at source */
283
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
284
 
                int dst_stride_arr[], /* array of strides at destination */
285
 
                int count[],          /* number of units at each stride level count[0]=bytes */
286
 
                int stride_levels,    /* number of stride levels */
287
 
                int proc,             /* remote process(or) ID */
288
 
                armci_hdl_t* nb_handle /*armci_non-blocking request handle*/
289
 
                );
290
 
 
291
 
extern int ARMCI_NbAccS(                /* strided accumulate */
292
 
                int  optype,          /* operation */
293
 
                void *scale,          /* scale factor x += scale*y */
294
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
295
 
                int src_stride_arr[], /* array of strides at source */
296
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
297
 
                int dst_stride_arr[], /* array of strides at destination */
298
 
                int count[],          /* number of units at each stride level count[0]=bytes */
299
 
                int stride_levels,    /* number of stride levels */
300
 
                int proc,             /* remote process(or) ID */
301
 
                armci_hdl_t* nb_handle /*armci_non-blocking request handle*/
302
 
                );
303
 
 
304
 
extern int ARMCI_NbGet(void *src, void* dst, int bytes, int proc,armci_hdl_t* nb_handle);
305
 
 
306
 
extern int ARMCI_NbGetS(          /* strided get */
307
 
                void *src_ptr,        /* pointer to 1st segment at source*/ 
308
 
                int src_stride_arr[], /* array of strides at source */
309
 
                void* dst_ptr,        /* pointer to 1st segment at destination*/
310
 
                int dst_stride_arr[], /* array of strides at destination */
311
 
                int count[],          /* number of units at each stride level count[0]=bytes */
312
 
                int stride_levels,    /* number of stride levels */
313
 
                int proc,             /* remote process(or) ID */
314
 
                armci_hdl_t* nb_handler/*armci_non-blocking request handle*/
315
 
                );
316
 
 
317
 
extern int ARMCI_NbGetV( armci_giov_t darr[], /* descriptor array */
318
 
                int len,  /* length of descriptor array */
319
 
                int proc,  /* remote process(or) ID */
320
 
                armci_hdl_t* nb_handle /*armci_non-blocking request handle*/
321
 
              );
322
 
 
323
 
extern int ARMCI_NbPutV( armci_giov_t darr[], /* descriptor array */
324
 
                int len,  /* length of descriptor array */
325
 
                int proc,  /* remote process(or) ID */
326
 
                armci_hdl_t* nb_handle /*armci_non-blocking request handle*/
327
 
              );
328
 
 
329
 
extern int ARMCI_NbAccV( int op,       /* operation code */
330
 
                void *scale,         /* scaling factor for accumulate */
331
 
                armci_giov_t darr[], /* descriptor array */
332
 
                int len,             /* length of descriptor array */
333
 
                int proc,             /* remote process(or) ID */
334
 
                armci_hdl_t* nb_handle /*armci_non-blocking request handle*/
335
 
              );
336
 
 
337
 
extern int ARMCI_NbPutValueInt(int src,   /* value in a register to put     */
338
 
                               void *dst, /* dest starting addr to put data */
339
 
                               int proc,  /* remote process (or) ID         */
340
 
                               armci_hdl_t* nb_handle /*armci_non-blocking 
341
 
                                                       request handle       */
342
 
                               );
343
 
 
344
 
extern int ARMCI_NbPutValueLong(long src,  /* value in a register to put     */
345
 
                                void *dst, /* dest starting addr to put data */
346
 
                                int proc,  /* remote process (or) ID         */
347
 
                                armci_hdl_t* nb_handle /*armci_non-blocking 
348
 
                                                        request handle       */
349
 
                                );
350
 
 
351
 
extern int ARMCI_NbPutValueFloat(float src,/* value in a register to put     */
352
 
                                 void *dst,/* dest starting addr to put data */
353
 
                                 int proc, /* remote process (or) ID         */
354
 
                                 armci_hdl_t* nb_handle /*armci_non-blocking 
355
 
                                                         request handle      */
356
 
                                 );
357
 
 
358
 
extern int ARMCI_NbPutValueDouble(double src,/* value in a register to put   */
359
 
                                  void *dst,/* dest starting addr to put data*/
360
 
                                  int proc,   /* remote process (or) ID      */
361
 
                                  armci_hdl_t* nb_handle /*armci_non-blocking 
362
 
                                                          request handle     */
363
 
                                  );
364
 
 
365
 
extern int ARMCI_Wait(armci_hdl_t* nb_handle); /*non-blocking request handle*/
366
 
 
367
 
extern int ARMCI_Test(armci_hdl_t* nb_handle); /*non-blocking request handle*/
368
 
 
369
 
extern int ARMCI_WaitAll (void);
370
 
 
371
 
extern int ARMCI_WaitProc (int proc);
372
 
 
373
 
extern void ARMCI_SET_AGGREGATE_HANDLE(armci_hdl_t* nb_handle);
374
 
 
375
 
extern void ARMCI_UNSET_AGGREGATE_HANDLE(armci_hdl_t* nb_handle);
376
 
 
377
 
#define ARMCI_INIT_HANDLE(hdl) do {((double *)((hdl)->data))[0]=0; \
378
 
  ((double *)((hdl)->data))[1]=0; }while(0)
379
 
 
380
 
/* -------------- ARMCI Non-collective memory allocator ------------- */
381
 
typedef struct armci_meminfo_ds {
382
 
  char    * armci_addr;   /* remote address of the creator which can be
383
 
                               used in ARMCI communication */
384
 
  char     *addr;         /* local address of creator which can be used in
385
 
                               to set SMP memoffset, armci_set_mem_offset() */
386
 
  size_t    size;         /* size of remote pid's segment (bytes) */
387
 
  int       cpid;         /* armci pid of creator  */
388
 
  long      idlist[64];
389
 
} armci_meminfo_t;
390
 
 
391
 
extern void ARMCI_Memget(size_t bytes, armci_meminfo_t *meminfo, int memflg);
392
 
  
393
 
extern void* ARMCI_Memat(armci_meminfo_t *meminfo, long offset);
394
 
  
395
 
extern void ARMCI_Memdt(armci_meminfo_t *meminfo, long offset);
396
 
  
397
 
extern void ARMCI_Memctl(armci_meminfo_t *meminfo);
398
 
  
399
 
/* ------------------------------------------------------------------ */
400
 
 
401
 
#if defined(__cplusplus) || defined(c_plusplus)
402
 
}
403
 
#endif
404
 
 
405
 
#endif /* _ARMCI_H */