← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nwchem/saucy

« back to all changes in this revision

Viewing changes to src/tools/ga-4-3/armci/src/capi.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Michael Banck, Daniel Leidert
  • Date: 2012-02-09 20:02:41 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120209200241-jgk03qfsphal4ug2
Tags: 6.1-1
http://bugs.debian.org/632611
https://launchpad.net/bugs/791308
* New upstream release.

[ Michael Banck ]
* debian/patches/02_makefile_flags.patch: Updated.
* debian/patches/02_makefile_flags.patch: Use internal blas and lapack code.
* debian/patches/02_makefile_flags.patch: Define GCC4 for LINUX and LINUX64
  (Closes: #632611 and LP: #791308).
* debian/control (Build-Depends): Added openssh-client.
* debian/rules (USE_SCALAPACK, SCALAPACK): Removed variables (Closes:
  #654658).
* debian/rules (LIBDIR, USE_MPIF4, ARMCI_NETWORK): New variables.
* debian/TODO: New file.
* debian/control (Build-Depends): Removed libblas-dev, liblapack-dev and
  libscalapack-mpi-dev.
* debian/patches/04_show_testsuite_diff_output.patch: New patch, shows the
  diff output for failed tests.
* debian/patches/series: Adjusted.
* debian/testsuite: Optionally run all tests if "all" is passed as option.
* debian/rules: Run debian/testsuite with "all" if DEB_BUILD_OPTIONS
  contains "checkall".

[ Daniel Leidert ]
* debian/control: Used wrap-and-sort. Added Vcs-Svn and Vcs-Browser fields.
  (Priority): Moved to extra according to policy section 2.5.
  (Standards-Version): Bumped to 3.9.2.
  (Description): Fixed a typo.
* debian/watch: Added.
* debian/patches/03_hurd-i386_define_path_max.patch: Added.
  - Define MAX_PATH if not defines to fix FTBFS on hurd.
* debian/patches/series: Adjusted.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-4-3/armci/src/capi.c
 
1
 
 
2
#include <stdio.h>
 
3
#include "armci.h"
 
4
#include "parmci.h"
 
5
 
 
6
int
 
7
ARMCI_AccV (int op, void *scale, armci_giov_t * darr, int len, int proc)
 
8
{
 
9
  int rval;
 
10
  rval = PARMCI_AccV (op, scale, darr, len, proc);
 
11
  return rval;
 
12
}
 
13
 
 
14
void
 
15
ARMCI_Barrier ()
 
16
{
 
17
  PARMCI_Barrier ();
 
18
}
 
19
 
 
20
int
 
21
ARMCI_AccS (int optype, void *scale, void *src_ptr, int *src_stride_arr,
 
22
            void *dst_ptr, int *dst_stride_arr, int *count, int stride_levels,
 
23
            int proc)
 
24
{
 
25
  int rval;
 
26
  rval =
 
27
    PARMCI_AccS (optype, scale, src_ptr, src_stride_arr, dst_ptr,
 
28
                 dst_stride_arr, count, stride_levels, proc);
 
29
  return rval;
 
30
}
 
31
 
 
32
void
 
33
ARMCI_Finalize ()
 
34
{
 
35
  PARMCI_Finalize ();
 
36
}
 
37
 
 
38
int
 
39
ARMCI_NbPut (void *src, void *dst, int bytes, int proc,
 
40
             armci_hdl_t * nb_handle)
 
41
{
 
42
  int rval;
 
43
  rval = PARMCI_NbPut (src, dst, bytes, proc, nb_handle);
 
44
  return rval;
 
45
}
 
46
 
 
47
int
 
48
ARMCI_GetValueInt (void *src, int proc)
 
49
{
 
50
  int rval;
 
51
  rval = PARMCI_GetValueInt (src, proc);
 
52
  return rval;
 
53
}
 
54
 
 
55
int
 
56
ARMCI_Put_flag (void *src, void *dst, int bytes, int *f, int v, int proc)
 
57
{
 
58
  int rval;
 
59
  rval = PARMCI_Put_flag (src, dst, bytes, f, v, proc);
 
60
  return rval;
 
61
}
 
62
 
 
63
int
 
64
ARMCI_NbGetS (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
65
              int *dst_stride_arr, int *count, int stride_levels, int proc,
 
66
              armci_hdl_t * nb_handle)
 
67
{
 
68
  int rval;
 
69
  rval =
 
70
    PARMCI_NbGetS (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr, count,
 
71
                   stride_levels, proc, nb_handle);
 
72
  return rval;
 
73
}
 
74
 
 
75
void *
 
76
ARMCI_Malloc_local (armci_size_t bytes)
 
77
{
 
78
  void *rval;
 
79
  rval = PARMCI_Malloc_local (bytes);
 
80
  return rval;
 
81
}
 
82
 
 
83
int
 
84
ARMCI_Free_local (void *ptr)
 
85
{
 
86
  int rval;
 
87
  rval = PARMCI_Free_local (ptr);
 
88
  return rval;
 
89
}
 
90
 
 
91
int
 
92
ARMCI_Get (void *src, void *dst, int bytes, int proc)
 
93
{
 
94
  int rval;
 
95
  rval = PARMCI_Get (src, dst, bytes, proc);
 
96
  return rval;
 
97
}
 
98
 
 
99
int
 
100
ARMCI_Put (void *src, void *dst, int bytes, int proc)
 
101
{
 
102
  int rval;
 
103
  rval = PARMCI_Put (src, dst, bytes, proc);
 
104
  return rval;
 
105
}
 
106
 
 
107
int
 
108
ARMCI_Destroy_mutexes ()
 
109
{
 
110
  int rval;
 
111
  rval = PARMCI_Destroy_mutexes ();
 
112
  return rval;
 
113
}
 
114
 
 
115
int
 
116
ARMCI_GetS (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
117
            int *dst_stride_arr, int *count, int stride_levels, int proc)
 
118
{
 
119
  int rval;
 
120
  rval =
 
121
    PARMCI_GetS (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr, count,
 
122
                 stride_levels, proc);
 
123
  return rval;
 
124
}
 
125
 
 
126
int
 
127
ARMCI_NbAccV (int op, void *scale, armci_giov_t * darr, int len, int proc,
 
128
              armci_hdl_t * nb_handle)
 
129
{
 
130
  int rval;
 
131
  rval = PARMCI_NbAccV (op, scale, darr, len, proc, nb_handle);
 
132
  return rval;
 
133
}
 
134
 
 
135
float
 
136
ARMCI_GetValueFloat (void *src, int proc)
 
137
{
 
138
  float rval;
 
139
  rval = PARMCI_GetValueFloat (src, proc);
 
140
  return rval;
 
141
}
 
142
 
 
143
int
 
144
ARMCI_Malloc (void **ptr_arr, armci_size_t bytes)
 
145
{
 
146
  int rval;
 
147
  rval = PARMCI_Malloc (ptr_arr, bytes);
 
148
  return rval;
 
149
}
 
150
 
 
151
int
 
152
ARMCI_NbAccS (int optype, void *scale, void *src_ptr, int *src_stride_arr,
 
153
              void *dst_ptr, int *dst_stride_arr, int *count,
 
154
              int stride_levels, int proc, armci_hdl_t * nb_handle)
 
155
{
 
156
  int rval;
 
157
  rval =
 
158
    PARMCI_NbAccS (optype, scale, src_ptr, src_stride_arr, dst_ptr,
 
159
                   dst_stride_arr, count, stride_levels, proc, nb_handle);
 
160
  return rval;
 
161
}
 
162
 
 
163
int
 
164
ARMCI_PutS (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
165
            int *dst_stride_arr, int *count, int stride_levels, int proc)
 
166
{
 
167
  int rval;
 
168
  rval =
 
169
    PARMCI_PutS (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr, count,
 
170
                 stride_levels, proc);
 
171
  return rval;
 
172
}
 
173
 
 
174
void *
 
175
ARMCI_Memat (armci_meminfo_t * meminfo, int memflg)
 
176
{
 
177
  void *rval;
 
178
  rval = PARMCI_Memat (meminfo, memflg);
 
179
  return rval;
 
180
}
 
181
 
 
182
int
 
183
ARMCI_PutV (armci_giov_t * darr, int len, int proc)
 
184
{
 
185
  int rval;
 
186
  rval = PARMCI_PutV (darr, len, proc);
 
187
  return rval;
 
188
}
 
189
 
 
190
int
 
191
ARMCI_Free (void *ptr)
 
192
{
 
193
  int rval;
 
194
  rval = PARMCI_Free (ptr);
 
195
  return rval;
 
196
}
 
197
 
 
198
int
 
199
ARMCI_Init_args (int *argc, char ***argv)
 
200
{
 
201
  int rval;
 
202
  rval = PARMCI_Init_args (argc, argv);
 
203
  return rval;
 
204
}
 
205
 
 
206
int
 
207
ARMCI_PutValueInt (int src, void *dst, int proc)
 
208
{
 
209
  int rval;
 
210
  rval = PARMCI_PutValueInt (src, dst, proc);
 
211
  return rval;
 
212
}
 
213
 
 
214
void
 
215
ARMCI_Memget (size_t bytes, armci_meminfo_t * meminfo, int memflg)
 
216
{
 
217
  PARMCI_Memget (bytes, meminfo, memflg);
 
218
}
 
219
 
 
220
void
 
221
ARMCI_AllFence ()
 
222
{
 
223
  PARMCI_AllFence ();
 
224
}
 
225
 
 
226
int
 
227
ARMCI_NbPutV (armci_giov_t * darr, int len, int proc, armci_hdl_t * nb_handle)
 
228
{
 
229
  int rval;
 
230
  rval = PARMCI_NbPutV (darr, len, proc, nb_handle);
 
231
  return rval;
 
232
}
 
233
 
 
234
int
 
235
ARMCI_PutValueDouble (double src, void *dst, int proc)
 
236
{
 
237
  int rval;
 
238
  rval = PARMCI_PutValueDouble (src, dst, proc);
 
239
  return rval;
 
240
}
 
241
 
 
242
int
 
243
ARMCI_GetV (armci_giov_t * darr, int len, int proc)
 
244
{
 
245
  int rval;
 
246
  rval = PARMCI_GetV (darr, len, proc);
 
247
  return rval;
 
248
}
 
249
 
 
250
int
 
251
ARMCI_Test (armci_hdl_t * nb_handle)
 
252
{
 
253
  int rval;
 
254
  rval = PARMCI_Test (nb_handle);
 
255
  return rval;
 
256
}
 
257
 
 
258
void
 
259
ARMCI_Unlock (int mutex, int proc)
 
260
{
 
261
  PARMCI_Unlock (mutex, proc);
 
262
}
 
263
 
 
264
void
 
265
ARMCI_Fence (int proc)
 
266
{
 
267
  PARMCI_Fence (proc);
 
268
}
 
269
 
 
270
int
 
271
ARMCI_Create_mutexes (int num)
 
272
{
 
273
  int rval;
 
274
  rval = PARMCI_Create_mutexes (num);
 
275
  return rval;
 
276
}
 
277
 
 
278
int
 
279
ARMCI_PutS_flag (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
280
                 int *dst_stride_arr, int *count, int stride_levels,
 
281
                 int *flag, int val, int proc)
 
282
{
 
283
  int rval;
 
284
  rval =
 
285
    PARMCI_PutS_flag (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr, count,
 
286
                      stride_levels, flag, val, proc);
 
287
  return rval;
 
288
}
 
289
 
 
290
int
 
291
ARMCI_WaitProc (int proc)
 
292
{
 
293
  int rval;
 
294
  rval = PARMCI_WaitProc (proc);
 
295
  return rval;
 
296
}
 
297
 
 
298
void
 
299
ARMCI_Lock (int mutex, int proc)
 
300
{
 
301
  PARMCI_Lock (mutex, proc);
 
302
}
 
303
 
 
304
double
 
305
ARMCI_GetValueDouble (void *src, int proc)
 
306
{
 
307
  double rval;
 
308
  rval = PARMCI_GetValueDouble (src, proc);
 
309
  return rval;
 
310
}
 
311
 
 
312
int
 
313
ARMCI_NbGetV (armci_giov_t * darr, int len, int proc, armci_hdl_t * nb_handle)
 
314
{
 
315
  int rval;
 
316
  rval = PARMCI_NbGetV (darr, len, proc, nb_handle);
 
317
  return rval;
 
318
}
 
319
 
 
320
int
 
321
ARMCI_Rmw (int op, int *ploc, int *prem, int extra, int proc)
 
322
{
 
323
  int rval;
 
324
  rval = PARMCI_Rmw (op, ploc, prem, extra, proc);
 
325
  return rval;
 
326
}
 
327
 
 
328
int
 
329
ARMCI_Init ()
 
330
{
 
331
  int rval;
 
332
  rval = PARMCI_Init ();
 
333
  return rval;
 
334
}
 
335
 
 
336
int
 
337
ARMCI_WaitAll ()
 
338
{
 
339
  int rval;
 
340
  rval = PARMCI_WaitAll ();
 
341
  return rval;
 
342
}
 
343
 
 
344
int
 
345
ARMCI_NbGet (void *src, void *dst, int bytes, int proc,
 
346
             armci_hdl_t * nb_handle)
 
347
{
 
348
  int rval;
 
349
  rval = PARMCI_NbGet (src, dst, bytes, proc, nb_handle);
 
350
  return rval;
 
351
}
 
352
 
 
353
int
 
354
ARMCI_PutValueFloat (float src, void *dst, int proc)
 
355
{
 
356
  int rval;
 
357
  rval = PARMCI_PutValueFloat (src, dst, proc);
 
358
  return rval;
 
359
}
 
360
 
 
361
int
 
362
ARMCI_NbPutS (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
363
              int *dst_stride_arr, int *count, int stride_levels, int proc,
 
364
              armci_hdl_t * nb_handle)
 
365
{
 
366
  int rval;
 
367
  rval =
 
368
    PARMCI_NbPutS (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr, count,
 
369
                   stride_levels, proc, nb_handle);
 
370
  return rval;
 
371
}
 
372
 
 
373
int
 
374
ARMCI_PutS_flag_dir (void *src_ptr, int *src_stride_arr, void *dst_ptr,
 
375
                     int *dst_stride_arr, int *count, int stride_levels,
 
376
                     int *flag, int val, int proc)
 
377
{
 
378
  int rval;
 
379
  rval =
 
380
    PARMCI_PutS_flag_dir (src_ptr, src_stride_arr, dst_ptr, dst_stride_arr,
 
381
                          count, stride_levels, flag, val, proc);
 
382
  return rval;
 
383
}
 
384
 
 
385
int
 
386
ARMCI_PutValueLong (long src, void *dst, int proc)
 
387
{
 
388
  int rval;
 
389
  rval = PARMCI_PutValueLong (src, dst, proc);
 
390
  return rval;
 
391
}
 
392
 
 
393
int
 
394
ARMCI_Wait (armci_hdl_t * nb_handle)
 
395
{
 
396
  int rval;
 
397
  rval = PARMCI_Wait (nb_handle);
 
398
  return rval;
 
399
}
 
400
 
 
401
long
 
402
ARMCI_GetValueLong (void *src, int proc)
 
403
{
 
404
  long rval;
 
405
  rval = PARMCI_GetValueLong (src, proc);
 
406
  return rval;
 
407
}