← Back to branch summary

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

« back to all changes in this revision

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