← 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-1/armci/testing/perf_nb.c

  • 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-1/armci/testing/perf_nb.c
1
 
#if HAVE_CONFIG_H
2
 
#   include "config.h"
3
 
#endif
4
 
 
5
 
/* $Id: perf_nb.c,v 1.3 2004-03-29 19:14:51 vinod Exp $ */
6
 
#if HAVE_STDIO_H
7
 
#   include <stdio.h>
8
 
#endif
9
 
#if HAVE_STDLIB_H
10
 
#   include <stdlib.h>
11
 
#endif
12
 
#if HAVE_ASSERT_H
13
 
#   include <assert.h>
14
 
#endif
15
 
#if HAVE_MATH_H
16
 
#   include <math.h>
17
 
#endif
18
 
#if HAVE_UNISTD_H
19
 
#   include <unistd.h>
20
 
#elif HAVE_WINDOWS_H
21
 
#   include <windows.h>
22
 
#   define sleep(x) Sleep(1000*(x))
23
 
#endif
24
 
 
25
 
#include "armci.h"
26
 
#include "message.h"
27
 
 
28
 
#define DIM1 5
29
 
#define DIM2 3
30
 
#ifdef __sun
31
 
/* Solaris has shared memory shortages in the default system configuration */
32
 
# define DIM3 6
33
 
# define DIM4 5
34
 
# define DIM5 4
35
 
#elif defined(__alpha__)
36
 
# define DIM3 8
37
 
# define DIM4 5
38
 
# define DIM5 6
39
 
#else
40
 
# define DIM3 8
41
 
# define DIM4 9
42
 
# define DIM5 7
43
 
#endif
44
 
#define DIM6 3
45
 
#define DIM7 2
46
 
 
47
 
 
48
 
#define OFF 1
49
 
#define EDIM1 (DIM1+OFF)
50
 
#define EDIM2 (DIM2+OFF)
51
 
#define EDIM3 (DIM3+OFF)
52
 
#define EDIM4 (DIM4+OFF)
53
 
#define EDIM5 (DIM5+OFF)
54
 
#define EDIM6 (DIM6+OFF)
55
 
#define EDIM7 (DIM7+OFF)
56
 
 
57
 
#define DIMS 4
58
 
#define MAXDIMS 7
59
 
#define MAX_DIM_VAL 50
60
 
#define LOOP 200
61
 
 
62
 
#define BASE 100.
63
 
#define MAXPROC 8
64
 
#define TIMES 100
65
 
 
66
 
#ifdef CRAY
67
 
# define ELEMS 800
68
 
#else
69
 
# define ELEMS 200
70
 
#endif
71
 
 
72
 
#define MAXELEMS      131072 /* 262144 */
73
 
#define MAX_REQUESTS  MAXELEMS
74
 
#define PUT 11
75
 
#define GET 22
76
 
#define ACC 33
77
 
 
78
 
int VERIFY = 1; /* verifies results */
79
 
int DEBUG = 0; /* if debug=1, dump extra messages */
80
 
 
81
 
/***************************** macros ************************/
82
 
#define COPY(src, dst, bytes) memcpy((dst),(src),(bytes))
83
 
#define ARMCI_MAX(a,b) (((a) >= (b)) ? (a) : (b))
84
 
#define ARMCI_MIN(a,b) (((a) <= (b)) ? (a) : (b))
85
 
#define ARMCI_ABS(a) (((a) <0) ? -(a) : (a))
86
 
 
87
 
/***************************** global data *******************/
88
 
int me, nproc;
89
 
void *work[MAXPROC]; /* work array for propagating addresses */
90
 
double *ddst[MAXPROC];
91
 
 
92
 
#ifdef PVM
93
 
void pvm_init(int argc, char *argv[])
94
 
{
95
 
  int mytid, mygid, ctid[MAXPROC];
96
 
  int np, i;
97
 
 
98
 
  mytid = pvm_mytid();
99
 
  if ((argc != 2) && (argc != 1)) {
100
 
    goto usage;
101
 
  }
102
 
  if (argc == 1) {
103
 
    np = 1;
104
 
  }
105
 
  if (argc == 2)
106
 
    if ((np = atoi(argv[1])) < 1) {
107
 
      goto usage;
108
 
    }
109
 
  if (np > MAXPROC) {
110
 
    goto usage;
111
 
  }
112
 
 
113
 
  mygid = pvm_joingroup(MPGROUP);
114
 
 
115
 
  if (np > 1)
116
 
    if (mygid == 0) {
117
 
      i = pvm_spawn(argv[0], argv + 1, 0, "", np - 1, ctid);
118
 
    }
119
 
 
120
 
  while (pvm_gsize(MPGROUP) < np) {
121
 
    sleep(1);
122
 
  }
123
 
 
124
 
  /* sync */
125
 
  pvm_barrier(MPGROUP, np);
126
 
 
127
 
  printf("PVM initialization done!\n");
128
 
 
129
 
  return;
130
 
 
131
 
usage:
132
 
  fprintf(stderr, "usage: %s <nproc>\n", argv[0]);
133
 
  pvm_exit();
134
 
  exit(-1);
135
 
}
136
 
#endif
137
 
 
138
 
/*void create_array(void *a[], int elem_size, int ndim, int dims[])*/
139
 
void create_array(double *a[], int ndim, int dims[])
140
 
{
141
 
  int bytes = sizeof(double), i, rc;
142
 
 
143
 
  assert(ndim <= MAXDIMS);
144
 
  for (i = 0; i < ndim; i++) {
145
 
    bytes *= dims[i];
146
 
  }
147
 
 
148
 
  rc = ARMCI_Malloc((void **)a, bytes);
149
 
  assert(rc == 0);
150
 
 
151
 
  assert(a[me]);
152
 
 
153
 
}
154
 
 
155
 
/*void destroy_array(void *ptr[])*/
156
 
void destroy_array(double *ptr[])
157
 
{
158
 
  ARMCI_Barrier();
159
 
 
160
 
  assert(!ARMCI_Free(ptr[me]));
161
 
}
162
 
 
163
 
void verify_results(int op, int *elems)
164
 
{
165
 
  int i, j;
166
 
 
167
 
  switch (op) {
168
 
 
169
 
    case PUT:
170
 
      if (!(me == 0))
171
 
        for (j = 0; j < elems[1]; j++) {
172
 
          if (ARMCI_ABS(ddst[me][j] - j * 1.001) > 0.1) {
173
 
            ARMCI_Error("put failed...Invalid Value Obtained..1", 0);
174
 
          }
175
 
        }
176
 
      ARMCI_Barrier();
177
 
      if (DEBUG) if (me == 0) {
178
 
          printf("  verifying put ..O.K.\n");
179
 
        }
180
 
      break;
181
 
 
182
 
    case GET:
183
 
      if (me == 0) {
184
 
        for (i = 1; i < nproc; i++) {
185
 
          for (j = 0; j < elems[1]; j++) {
186
 
            if (ARMCI_ABS(ddst[me][i*elems[1] + j] - j * 1.001 *(i + 1)) > 0.1) {
187
 
              ARMCI_Error("get failed...Invalid Value Obtained..1", 0);
188
 
            }
189
 
          }
190
 
        }
191
 
      }
192
 
      ARMCI_Barrier();
193
 
      if (DEBUG) if (me == 0) {
194
 
          printf("  verifying get ..O.K.\n\n");
195
 
        }
196
 
      break;
197
 
 
198
 
    case ACC:
199
 
      if (me == 0)
200
 
        for (j = 0; j < elems[1]; j++) {
201
 
          /*printf("ddst[%d][%d] = %lf\n", me, j, ddst[me][j]);
202
 
            fflush(stdout); */
203
 
          if (ARMCI_ABS(ddst[me][j] - (double)nproc) > 0.1) {
204
 
            ARMCI_Error("accumulate failed...Invalid Value Obtained..1", 0);
205
 
          }
206
 
        }
207
 
      ARMCI_Barrier();
208
 
      if (DEBUG)if (me == 0) {
209
 
          printf("  verifying accumulate ..O.K.\n");
210
 
        }
211
 
      break;
212
 
 
213
 
    default:
214
 
      ARMCI_Error("Invalid Operation", 0);
215
 
  }
216
 
  fflush(stdout);
217
 
}
218
 
 
219
 
 
220
 
void test_perf_nb(int dry_run)
221
 
{
222
 
 
223
 
  int i, j, loop, rc, bytes, elems[2] = {MAXPROC, MAXELEMS};
224
 
  int stride, k = 0, ntimes;
225
 
  double stime, t1, t2, t3, t4, t5, t6, t7, t8, t9;
226
 
  double *dsrc[MAXPROC], scale = 1.0;
227
 
  armci_hdl_t hdl_get, hdl_put, hdl_acc;
228
 
 
229
 
  create_array(ddst, 2, elems);
230
 
  create_array(dsrc, 1, &elems[1]);
231
 
 
232
 
  if (!dry_run)if (me == 0) {
233
 
      printf("\n\t\t\tRemote 1-D Array Section\n");
234
 
      printf("section    get      nbget    wait     put     nbput  ");
235
 
      printf("   wait     acc     nbacc     wait\n");
236
 
      printf("-------  -------- -------- -------- -------- --------");
237
 
      printf(" -------- -------- -------- --------\n");
238
 
      fflush(stdout);
239
 
    }
240
 
 
241
 
  for (loop = 1; loop <= MAXELEMS; loop *= 2, k++) {
242
 
 
243
 
    elems[1] = loop;
244
 
    ntimes = (int)sqrt((double)(MAXELEMS / elems[1]));
245
 
    if (ntimes < 1) {
246
 
      ntimes = 1;
247
 
    }
248
 
 
249
 
    /* -------------------------- SETUP --------------------------- */
250
 
    /*initializing non-blocking handles,time,src & dst buffers*/
251
 
    ARMCI_INIT_HANDLE(&hdl_put);
252
 
    ARMCI_INIT_HANDLE(&hdl_get);
253
 
    ARMCI_INIT_HANDLE(&hdl_acc);
254
 
    t1 = t2 = t3 = t4 = t5 = t6 = t7 = t8 = t9 = 0.0;
255
 
    for (i = 0; i < elems[1]; i++) {
256
 
      dsrc[me][i] = i * 1.001 * (me + 1);
257
 
    }
258
 
    for (i = 0; i < elems[0]*elems[1]; i++) {
259
 
      ddst[me][i] = 0.0;
260
 
    }
261
 
    ARMCI_Barrier();
262
 
 
263
 
    /* bytes transfered */
264
 
    bytes = sizeof(double) * elems[1];
265
 
    ARMCI_Barrier();
266
 
 
267
 
    /* -------------------------- PUT/GET -------------------------- */
268
 
    if (me == 0) {
269
 
      for (i = 1; i < nproc; i++) {
270
 
        stime = armci_timer();
271
 
        for (j = 0; j < ntimes; j++)
272
 
          if ((rc = ARMCI_Put(&dsrc[me][0], &ddst[i][me*elems[1]], bytes, i))) {
273
 
            ARMCI_Error("armci_nbput failed\n", rc);
274
 
          }
275
 
        t1 += armci_timer() - stime;
276
 
      }
277
 
    }
278
 
    ARMCI_Barrier();
279
 
    ARMCI_AllFence();
280
 
    ARMCI_Barrier();
281
 
    if (VERIFY) {
282
 
      verify_results(PUT, elems);
283
 
    }
284
 
    for (i = 0; i < elems[0]*elems[1]; i++) {
285
 
      ddst[me][i] = 0.0;
286
 
    }
287
 
    ARMCI_Barrier();
288
 
 
289
 
    if (me == 0) {
290
 
      for (i = 1; i < nproc; i++) {
291
 
        stime = armci_timer();
292
 
        for (j = 0; j < ntimes; j++)
293
 
          if ((rc = ARMCI_Get(&dsrc[i][0], &ddst[me][i*elems[1]], bytes, i))) {
294
 
            printf("%d: armci_get. rc=%d\n", me, rc);
295
 
            fflush(stdout);
296
 
            ARMCI_Error("armci_nbget failed\n", rc);
297
 
          }
298
 
        t4 += armci_timer() - stime;
299
 
      }
300
 
    }
301
 
    ARMCI_Barrier();
302
 
    ARMCI_AllFence();
303
 
    ARMCI_Barrier();
304
 
    if (VERIFY) {
305
 
      verify_results(GET, elems);
306
 
    }
307
 
    for (i = 0; i < elems[0]*elems[1]; i++) {
308
 
      ddst[me][i] = 0.0;
309
 
    }
310
 
    ARMCI_Barrier();
311
 
 
312
 
    /* ------------------------ nb PUT/GET ------------------------- */
313
 
    if (me == 0) {
314
 
      for (i = 1; i < nproc; i++) {
315
 
        for (j = 0; j < ntimes; j++) {
316
 
          stime = armci_timer();
317
 
          if ((rc = ARMCI_NbPut(&dsrc[me][0], &ddst[i][me*elems[1]], bytes,
318
 
                                i, &hdl_put))) {
319
 
            ARMCI_Error("armci_nbput failed\n", rc);
320
 
          }
321
 
          t2 += armci_timer() - stime;
322
 
          stime = armci_timer();
323
 
          ARMCI_Wait(&hdl_put);
324
 
          t3 += armci_timer() - stime;
325
 
        }
326
 
      }
327
 
    }
328
 
    ARMCI_Barrier();
329
 
    ARMCI_AllFence();
330
 
    ARMCI_Barrier();
331
 
    if (VERIFY) {
332
 
      verify_results(PUT, elems);
333
 
    }
334
 
    for (i = 0; i < elems[0]*elems[1]; i++) {
335
 
      ddst[me][i] = 0.0;
336
 
    }
337
 
    ARMCI_Barrier();
338
 
 
339
 
    if (me == 0) {
340
 
      for (i = 1; i < nproc; i++) {
341
 
        for (j = 0; j < ntimes; j++) {
342
 
          stime = armci_timer();
343
 
          if ((rc = ARMCI_NbGet(&dsrc[i][0], &ddst[me][i*elems[1]], bytes,
344
 
                                i, &hdl_get))) {
345
 
            ARMCI_Error("armci_nbget failed\n", rc);
346
 
          }
347
 
          t5 += armci_timer() - stime;
348
 
          stime = armci_timer();
349
 
          ARMCI_Wait(&hdl_get);
350
 
          t6 += armci_timer() - stime;
351
 
        }
352
 
      }
353
 
    }
354
 
    ARMCI_Barrier();
355
 
    ARMCI_AllFence();
356
 
    ARMCI_Barrier();
357
 
    if (VERIFY) {
358
 
      verify_results(GET, elems);
359
 
    }
360
 
    for (i = 0; i < elems[0]*elems[1]; i++) {
361
 
      ddst[me][i] = 0.0;
362
 
    }
363
 
    ARMCI_Barrier();
364
 
 
365
 
 
366
 
    /* ------------------------ Accumulate ------------------------- */
367
 
    for (i = 0; i < elems[1]; i++) {
368
 
      dsrc[me][i] = 1.0;
369
 
    }
370
 
    ARMCI_Barrier();
371
 
    stride = elems[1] * sizeof(double);
372
 
    scale  = 1.0;
373
 
    for (j = 0; j < ntimes; j++) {
374
 
      stime = armci_timer();
375
 
      if ((rc = ARMCI_AccS(ARMCI_ACC_DBL, &scale, &dsrc[me][0], &stride,
376
 
                           &ddst[0][0], &stride, &bytes, 0, 0))) {
377
 
        ARMCI_Error("armci_acc failed\n", rc);
378
 
      }
379
 
      t7 += armci_timer() - stime;
380
 
 
381
 
      ARMCI_Barrier();
382
 
      ARMCI_AllFence();
383
 
      ARMCI_Barrier();
384
 
      if (VERIFY) {
385
 
        verify_results(ACC, elems);
386
 
      }
387
 
      for (i = 0; i < elems[0]*elems[1]; i++) {
388
 
        ddst[me][i] = 0.0;
389
 
      }
390
 
      ARMCI_Barrier();
391
 
    }
392
 
 
393
 
#if PORTALS
394
 
    /* See the note below why this part is disabled */
395
 
    /* ---------------------- nb-Accumulate ------------------------ */
396
 
    for (i = 0; i < elems[1]; i++) {
397
 
      dsrc[me][i] = 1.0;
398
 
    }
399
 
    ARMCI_Barrier();
400
 
    stride = elems[1] * sizeof(double);
401
 
    scale  = 1.0;
402
 
    for (j = 0; j < ntimes; j++) {
403
 
      stime = armci_timer();
404
 
      if ((rc = ARMCI_NbAccS(ARMCI_ACC_DBL, &scale, &dsrc[me][0], &stride,
405
 
                             &ddst[0][0], &stride, &bytes, 0, 0, &hdl_acc))) {
406
 
        ARMCI_Error("armci_nbacc failed\n", rc);
407
 
      }
408
 
      t8 += armci_timer() - stime;
409
 
      stime = armci_timer();
410
 
      ARMCI_Wait(&hdl_acc);
411
 
      t9 += armci_timer() - stime;
412
 
 
413
 
      ARMCI_Barrier();
414
 
      ARMCI_AllFence();
415
 
      ARMCI_Barrier();
416
 
      if (VERIFY) {
417
 
        verify_results(ACC, elems);
418
 
      }
419
 
      for (i = 0; i < elems[0]*elems[1]; i++) {
420
 
        ddst[me][i] = 0.0;
421
 
      }
422
 
      ARMCI_Barrier();
423
 
    }
424
 
#endif
425
 
 
426
 
    /* print timings */
427
 
    if (!dry_run) if (me == 0) printf("%d\t %.2e %.2e %.2e %.2e %.2e %.2e %.2e %.2e %.2e\n",
428
 
                                          bytes, t4 / ntimes, t5 / ntimes, t6 / ntimes, t1 / ntimes,
429
 
                                          t2 / ntimes, t3 / ntimes, t7 / ntimes, t8 / ntimes, t9 / ntimes);
430
 
  }
431
 
 
432
 
  ARMCI_AllFence();
433
 
  ARMCI_Barrier();
434
 
 
435
 
  if (!dry_run)if (me == 0) {
436
 
      printf("O.K.\n");
437
 
      fflush(stdout);
438
 
    }
439
 
  destroy_array(ddst);
440
 
  destroy_array(dsrc);
441
 
}
442
 
 
443
 
 
444
 
int main(int argc, char *argv[])
445
 
{
446
 
  ARMCI_Init_args(&argc, &argv);
447
 
  nproc = armci_msg_nproc();
448
 
  me = armci_msg_me();
449
 
 
450
 
  if (nproc < 2 || nproc > MAXPROC) {
451
 
    if (me == 0)
452
 
      fprintf(stderr,
453
 
              "USAGE: 2 <= processes < %d - got %d\n", MAXPROC, nproc);
454
 
    ARMCI_Barrier();
455
 
    armci_msg_finalize();
456
 
    exit(0);
457
 
  }
458
 
 
459
 
  if (me == 0) {
460
 
    printf("ARMCI test program (%d processes)\n", nproc);
461
 
    fflush(stdout);
462
 
    sleep(1);
463
 
  }
464
 
 
465
 
  if (me == 0) {
466
 
    printf("\n put/get/acc requests (Time in secs)\n\n");
467
 
    fflush(stdout);
468
 
  }
469
 
 
470
 
  test_perf_nb(1);
471
 
  test_perf_nb(0);
472
 
 
473
 
  ARMCI_AllFence();
474
 
  ARMCI_Barrier();
475
 
  if (me == 0) {
476
 
    printf("\nSuccess!!\n");
477
 
    fflush(stdout);
478
 
  }
479
 
  sleep(2);
480
 
 
481
 
  ARMCI_Barrier();
482
 
  ARMCI_Finalize();
483
 
  armci_msg_finalize();
484
 
  return(0);
485
 
}
486
 
 
487
 
/*
488
 
   NOTE: ARMCI_NbAcc fails in opus for buffer sizes greater than 400Kb
489
 
*/