← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/tools/ga-5-1/armci/tools/armci_profile.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/tools/armci_profile.c
1
 
#if HAVE_CONFIG_H
2
 
#   include "config.h"
3
 
#endif
4
 
 
5
 
/* $Id: armci_profile.c,v 1.8 2005-11-30 10:20:53 vinod Exp $ */
6
 
 
7
 
/**
8
 
 * Profiler can profile the following ARMCI Calls:
9
 
 *    ARMCI_Get,ARMCI_Put,ARMCI_Acc,ARMCI_NbGet,ARMCI_NbPut,ARMCI_NbAcc,
10
 
 *    ARMCI_GetS,ARMCI_PutS,ARMCI_AccS,ARMCI_NbGetS,ARMCI_NbPutS,ARMCI_NbAccS,
11
 
 *    ARMCI_GetV,ARMCI_PutV,ARMCI_AccV,ARMCI_NbGetV,ARMCI_NbPutV,ARMCI_NbAccV,
12
 
 *    ARMCI_Wait, armci_wait_notify
13
 
 *      (NOTE: As armci_notify is same as ARMCI_Put, it is not profiled.)
14
 
 *   
15
 
 * 
16
 
 * Note #1: Right now, only process 0's profile is printed.
17
 
 * Each and every process saves its profile in the correspoding data struture.
18
 
 * Each process prints its profile to an output file armci_profile.<myrank> 
19
 
 * when armci_profile_terminate() is called (called in ARMCI_Finalize()).
20
 
 *
21
 
 * Note #2: By default profiler prints msg ranges 0 to 21. Example: range 10
22
 
 * corresponds to message ranges from 1024 bytes to 2047 bytes.
23
 
 * Message ranges are in the power of 2. for ex:
24
 
 * ------------------------------------
25
 
 *  MSG_RANGE (r)        BYTES (2^r to 2^(r+1)-1)
26
 
 * ------------------------------------
27
 
 *      0                    0-1 
28
 
 *      1                    2-3
29
 
 *      2                    4-7
30
 
 *     ...                   ...
31
 
 *      10                1024-2047 bytes
32
 
 *     ...                   ...
33
 
 *      20                1MB - (2MB-1)
34
 
 *      21                  >= 2MB
35
 
 * -------------------------------------
36
 
 * To increase the message range, set ARMCI_MAX_MSG_RANGE accordingly.
37
 
 *
38
 
 * Note #3: If Stride information needs to be printed, set ARMCI_PRINT_STRIDE.
39
 
 * Stride information is printed in armci_profile_terminate() for a various 
40
 
 * selective message ranges and event types.Modify it according to your needs.
41
 
 *
42
 
 * Note #4: There is no profiling support for non-blocking operations yet!!
43
 
 */
44
 
#define DEBUG_ 
45
 
#if HAVE_STDIO_H
46
 
#   include <stdio.h>
47
 
#endif
48
 
#if HAVE_STDLIB_H
49
 
#   include <stdlib.h>
50
 
#endif
51
 
#if HAVE_STRING_H
52
 
#   include <string.h>
53
 
#endif
54
 
#if HAVE_MATH_H
55
 
#   include <math.h>
56
 
#endif
57
 
#include "armci.h"
58
 
#include "armcip.h"
59
 
#include "armci_profile.h" 
60
 
 
61
 
#ifndef MPI
62
 
#  include "tcgmsg.h"
63
 
#   define MP_TIMER tcg_time
64
 
#else
65
 
#  include "mpi.h"
66
 
#   define MP_TIMER MPI_Wtime
67
 
#endif
68
 
 
69
 
 
70
 
#define ARMCI_PRINT_STRIDE 1
71
 
#define ARMCI_MAX_MSG_RANGE 22 /* 0 to 21 */
72
 
 
73
 
#if ARMCI_PRINT_STRIDE
74
 
 
75
 
# define STRIDE_COUNT 1000
76
 
# define ARMCI_MAX_DIM 7
77
 
 
78
 
  typedef struct armci_stride {
79
 
    int stride_levels;
80
 
    int proc;
81
 
    int count[ARMCI_MAX_DIM];
82
 
    double time;
83
 
  }armci_stride_t;
84
 
 
85
 
  typedef struct giov {
86
 
    int ptr_array_len;
87
 
    int bytes;
88
 
  }giov_t;
89
 
 
90
 
  typedef struct armci_vector {
91
 
    int vec_len;
92
 
    int proc;
93
 
    giov_t *giov;
94
 
    double time;
95
 
  }armci_vector_t;
96
 
 
97
 
#endif
98
 
 
99
 
#define ARMCI_EVENTS 24
100
 
 
101
 
char *gEventName[ARMCI_EVENTS]={
102
 
  "GET", "PUT", "ACC", 
103
 
  "STRIDED GET", "STRIDED PUT", "STRIDED ACC",
104
 
  "VECTOR GET", "VECTOR PUT", "VECTOR ACC",
105
 
  "NBGET", "NBPUT", "NBACC",
106
 
  "STRIDED NBGET", "STRIDED NBPUT", "STRIDED NBACC",
107
 
  "VECTOR NBGET", "VECTOR NBPUT", "VECTOR NBACC",
108
 
  "BARRIER","ARMCI_WAIT","NOTIFY_WAIT",
109
 
  "FENCE", "ALLFENCE", "RMW"
110
 
};
111
 
 
112
 
typedef struct armci_profile {
113
 
  int count;          /* number of times called */
114
 
  double time;  /* total execution time for "count" calls */
115
 
#if ARMCI_PRINT_STRIDE
116
 
  armci_stride_t *stride;
117
 
  armci_vector_t *vector;
118
 
#endif
119
 
}armci_profile_t;
120
 
 
121
 
/* profile get/put/acc for various message ranges (i.e ARMCI_MAX_MSG_RANGE) */
122
 
static armci_profile_t ARMCI_PROF[ARMCI_EVENTS][ARMCI_MAX_MSG_RANGE];
123
 
 
124
 
/* Current event */
125
 
struct event_info {
126
 
  int is_set;
127
 
  int event_type;
128
 
  int range;
129
 
  double start_time;
130
 
} gCURRENT_EVNT; 
131
 
 
132
 
static int strided_event(int e) {
133
 
    if (e==ARMCI_PROF_GETS || e==ARMCI_PROF_PUTS || e==ARMCI_PROF_ACCS || 
134
 
        e==ARMCI_PROF_NBGETS || e==ARMCI_PROF_NBPUTS || e==ARMCI_PROF_NBACCS)
135
 
       return 1;
136
 
    return 0;
137
 
}
138
 
 
139
 
void armci_profile_init() {
140
 
    int i,j;
141
 
    if(armci_me==0) {printf("\nProfiling ARMCI - ON\n");fflush(stdout);}
142
 
 
143
 
    gCURRENT_EVNT.is_set = 0;
144
 
 
145
 
    for(i=0; i<ARMCI_EVENTS; i++)
146
 
       for(j=0; j<ARMCI_MAX_MSG_RANGE; j++) {
147
 
          ARMCI_PROF[i][j].count = 0; ARMCI_PROF[i][j].time = 0.0; 
148
 
       }
149
 
 
150
 
#if ARMCI_PRINT_STRIDE
151
 
    for(i=0; i<ARMCI_EVENTS; i++) {
152
 
       if(strided_event(i))
153
 
          for(j=0; j<ARMCI_MAX_MSG_RANGE; j++) {
154
 
             ARMCI_PROF[i][j].stride = (armci_stride_t*)malloc(STRIDE_COUNT*sizeof(armci_stride_t));
155
 
             ARMCI_PROF[i][j].vector = NULL;
156
 
             if( ARMCI_PROF[i][j].stride == NULL)
157
 
                armci_die("armci_profile_init(): malloc failed", armci_me);
158
 
          }
159
 
       if(i==ARMCI_PROF_GETV || i==ARMCI_PROF_PUTV || i==ARMCI_PROF_ACCV ||
160
 
          i==ARMCI_PROF_NBGETV || i==ARMCI_PROF_NBPUTV || i==ARMCI_PROF_NBACCV)
161
 
          for(j=0; j<ARMCI_MAX_MSG_RANGE; j++) {
162
 
             ARMCI_PROF[i][j].vector = (armci_vector_t*)malloc(STRIDE_COUNT*sizeof(armci_vector_t));
163
 
             ARMCI_PROF[i][j].stride = NULL;
164
 
             if( ARMCI_PROF[i][j].vector == NULL)
165
 
                armci_die("armci_profile_init(): malloc failed", armci_me);
166
 
          }
167
 
    }
168
 
#endif
169
 
}
170
 
 
171
 
#define ARMCI_EVENT_CLOSED     0
172
 
#define ARMCI_EVENT_NOTCLOSED -1
173
 
#define ARMCI_EVENT_SET        0
174
 
#define ARMCI_EVENT_NOTSET    -1
175
 
 
176
 
static int armci_profile_set_event(int event_type, int range) {
177
 
#ifdef DEBUG
178
 
    if(SERVER_CONTEXT)
179
 
       printf("\n%d(s):call profile set for %s isset is %d",armci_me,
180
 
                                   gEventName[event_type],gCURRENT_EVNT.is_set);
181
 
    else
182
 
       printf("\n%d:call profile set for %s isset is %d",armci_me,
183
 
                                   gEventName[event_type],gCURRENT_EVNT.is_set);
184
 
    fflush(stdout);
185
 
#endif
186
 
    if(gCURRENT_EVNT.is_set == 0) { /* set an event */
187
 
       gCURRENT_EVNT.is_set     = 1;
188
 
       gCURRENT_EVNT.event_type = event_type;
189
 
       gCURRENT_EVNT.range      = range;
190
 
       gCURRENT_EVNT.start_time = MP_TIMER();
191
 
       return ARMCI_EVENT_SET;
192
 
    }
193
 
    else gCURRENT_EVNT.is_set++; /* event overlap */
194
 
    return ARMCI_EVENT_NOTSET;
195
 
}
196
 
 
197
 
static int armci_profile_close_event(int event_type, int range, double *time, 
198
 
                                     char *name) {
199
 
    
200
 
    int curr_event = gCURRENT_EVNT.event_type;
201
 
#ifdef DEBUG
202
 
    if(SERVER_CONTEXT)
203
 
       printf("\n%d(s):call profile close for %s isset is %d",armci_me,
204
 
                                   gEventName[event_type],gCURRENT_EVNT.is_set);
205
 
    else
206
 
       printf("\n%d:call profile close for %s isset is %d",armci_me,
207
 
                                   gEventName[event_type],gCURRENT_EVNT.is_set);
208
 
    fflush(stdout);
209
 
#endif 
210
 
 
211
 
 
212
 
    if(gCURRENT_EVNT.is_set==1) { /* Yep, there is an event set. So close it.*/
213
 
       /*Check if "profile stop" is called for corresponding "profile start"*/
214
 
       if(event_type != curr_event) {
215
 
          printf( 
216
 
                  "%d: %s: ERROR:Profile started for %s, but stopped for %s\n",
217
 
                  armci_me,name,gEventName[curr_event],gEventName[event_type]);
218
 
          fflush(stdout);
219
 
          armci_die("Profile_stop is called a different event", armci_me); 
220
 
       }
221
 
       
222
 
       *time = MP_TIMER() - gCURRENT_EVNT.start_time;
223
 
       ARMCI_PROF[curr_event][range].time += *time;
224
 
       gCURRENT_EVNT.is_set = 0; /* close the event */
225
 
       return ARMCI_EVENT_CLOSED;
226
 
    }
227
 
    else { /* event overlapping */
228
 
       gCURRENT_EVNT.is_set--;
229
 
       if(gCURRENT_EVNT.is_set<=0) {
230
 
          char *msg="Profile_stop is called before profile_start";
231
 
            printf("%d: %s: ERROR: %s. Event Name = %s\n", armci_me, 
232
 
                    name, msg, gEventName[curr_event]);
233
 
            fflush(stdout);
234
 
            armci_die(" profile_stop is called before profile_start", armci_me);
235
 
       }
236
 
    }
237
 
    return ARMCI_EVENT_NOTCLOSED;
238
 
}
239
 
 
240
 
void armci_profile_start_strided(int count[], int stride_levels, int proc, 
241
 
                                 int event_type) {
242
 
    int i, status, bytes=1, range;
243
 
 
244
 
    if(stride_levels >= ARMCI_MAX_DIM) 
245
 
       armci_die("ARMCI_PROFILE: stride_levels >= ARMCI_MAX_DIM. Increase ARMCI_MAX_DIM.", armci_me);
246
 
 
247
 
    /* find the message range */
248
 
    for(i=0; i<= stride_levels; i++)  bytes *= count[i];
249
 
    if(bytes<=0) range=0;
250
 
    else range = (int) (log((double)bytes)/log(2.0));
251
 
    if(range>=ARMCI_MAX_MSG_RANGE-1) range = ARMCI_MAX_MSG_RANGE-1;
252
 
 
253
 
    /* set the curent event for timer */
254
 
    status = armci_profile_set_event(event_type, range);
255
 
    
256
 
    if(status == ARMCI_EVENT_SET) { /* new event set */
257
 
       /* profile update: i.e. update event count */
258
 
       ARMCI_PROF[event_type][range].count++;
259
 
       
260
 
#      if ARMCI_PRINT_STRIDE 
261
 
          if(strided_event(event_type)) {
262
 
             int idx = ARMCI_PROF[event_type][range].count-1;
263
 
             if(idx<STRIDE_COUNT) {
264
 
                ARMCI_PROF[event_type][range].stride[idx].stride_levels = stride_levels;
265
 
                ARMCI_PROF[event_type][range].stride[idx].proc = proc;
266
 
                for(i=0;i<=stride_levels;i++) {
267
 
                   ARMCI_PROF[event_type][range].stride[idx].count[i]=count[i];
268
 
                }
269
 
             }
270
 
          }
271
 
#      endif
272
 
    }
273
 
    else { /* Do nothing. It is just an event overlap */ }
274
 
}
275
 
 
276
 
void armci_profile_stop_strided(int event_type) {
277
 
    double time;
278
 
    int status, range = gCURRENT_EVNT.range;
279
 
 
280
 
    status = armci_profile_close_event(event_type, range, &time,
281
 
                                       "armci_profile_stop_strided");
282
 
    
283
 
#if ARMCI_PRINT_STRIDE
284
 
    if(status == ARMCI_EVENT_CLOSED) {
285
 
       /* record the time of each strided data transfer */
286
 
       if(strided_event(event_type)) {
287
 
          int idx = ARMCI_PROF[event_type][range].count-1;
288
 
          if(idx<STRIDE_COUNT) 
289
 
             ARMCI_PROF[event_type][range].stride[idx].time = time;
290
 
       }
291
 
    }
292
 
#endif
293
 
}
294
 
 
295
 
void armci_profile_start_vector(armci_giov_t darr[], int len, int proc, 
296
 
                                int event_type) {
297
 
 
298
 
    int i, bytes=0, range, status;
299
 
 
300
 
    /* find the message range */
301
 
    for(i=0; i<len; i++) bytes += darr[i].bytes;
302
 
    if(bytes<=0) range=0;
303
 
    else range = (int) (log((double)bytes)/log(2.0));
304
 
    if(range>=ARMCI_MAX_MSG_RANGE-1) range = ARMCI_MAX_MSG_RANGE-1;
305
 
       
306
 
    /* set the curent event for timer */
307
 
    status = armci_profile_set_event(event_type, range);
308
 
 
309
 
    if(status == ARMCI_EVENT_SET) { /* new event set */
310
 
       /* profile update: i.e. update event count */
311
 
       ARMCI_PROF[event_type][range].count++;
312
 
       
313
 
#      if ARMCI_PRINT_STRIDE 
314
 
       {
315
 
          int idx = ARMCI_PROF[event_type][range].count-1;
316
 
          if(idx<STRIDE_COUNT) {
317
 
             ARMCI_PROF[event_type][range].vector[idx].vec_len = len;
318
 
             ARMCI_PROF[event_type][range].vector[idx].proc = proc;
319
 
             ARMCI_PROF[event_type][range].vector[idx].giov = 
320
 
               (giov_t*)malloc(len*sizeof(giov_t));
321
 
             for(i=0;i<len;i++) {
322
 
                ARMCI_PROF[event_type][range].vector[idx].giov[i].ptr_array_len = darr[i].ptr_array_len;
323
 
                ARMCI_PROF[event_type][range].vector[idx].giov[i].bytes = 
324
 
                  darr[i].bytes;
325
 
             }
326
 
          }
327
 
       }
328
 
#      endif
329
 
    }
330
 
}
331
 
 
332
 
void armci_profile_stop_vector(int event_type) {
333
 
    double time;
334
 
    int status, range = gCURRENT_EVNT.range;
335
 
    
336
 
    status = armci_profile_close_event(event_type, range, &time, 
337
 
                                       "armci_profile_stop_vector"); 
338
 
 
339
 
#if ARMCI_PRINT_STRIDE
340
 
    if(status == ARMCI_EVENT_CLOSED) {/*record time of each data transfer*/
341
 
       int idx = ARMCI_PROF[event_type][range].count-1;
342
 
       if(idx<STRIDE_COUNT)  
343
 
          ARMCI_PROF[event_type][range].vector[idx].time = time;
344
 
    }
345
 
#endif
346
 
}
347
 
 
348
 
void armci_profile_start(int event_type) {
349
 
    int range, status;
350
 
 
351
 
    /* message range is zero for events registered using this call */
352
 
    range=0;
353
 
    
354
 
    /* set the curent event for timer */
355
 
    status = armci_profile_set_event(event_type, range);
356
 
    if(status == ARMCI_EVENT_SET) { /* new event set */  
357
 
       /* profile update: i.e. update event count */
358
 
       ARMCI_PROF[event_type][range].count++;
359
 
    }
360
 
}
361
 
 
362
 
void armci_profile_stop(int event_type) {
363
 
    double time;
364
 
    int status,range = gCURRENT_EVNT.range;
365
 
    status = armci_profile_close_event(event_type, range, &time, 
366
 
                                       "armci_profile_stop");
367
 
}
368
 
 
369
 
#define ARMCI_HDR0(fp) fprintf(fp, "\n\n************** TOTAL DATA TRANSFERS **************\n\n");
370
 
#define ARMCI_HDR1(fp) fprintf(fp, "\n\n************ CONTIGUOUS DATA TRANSFER ************\n\n");
371
 
#define ARMCI_HDR2(fp) fprintf(fp, "\n\n********** NON-CONTIGUOUS DATA TRANSFER **********\n\n"); 
372
 
#define ARMCI_HDR3(fp) fprintf(fp, "#gets\t #puts\t #accs\t get_time   put_time   acc_time   RANGE(bytes)\n\n");
373
 
#define ARMCI_HDR4(fp) fprintf(fp, "SL#\tndim\t proc\t time      stride_info\n\n");
374
 
#define ARMCI_HDR5(fp) fprintf(fp, "SL#\tnvec\t proc\t time\t    [ #arrays\t bytes\t]\n");
375
 
#define ARMCI_HDR6(fp) fprintf(fp, "\n\n****** NON-BLOCKING CONTIGUOUS DATA TRANSFER *****\n\n");
376
 
#define ARMCI_HDR7(fp) fprintf(fp, "\n\n*** NON-BLOCKING NON-CONTIGUOUS DATA TRANSFER ****\n\n"); 
377
 
#define ARMCI_HDR8(fp) fprintf(fp, "#gets\t #puts\t #accs\t get_time   put_time   acc_time   RANGE(bytes)\n\n");
378
 
#define ARMCI_HDR9(fp) fprintf(fp, "\n\n******************* ARMCI MISC *******************\n\n");
379
 
 
380
 
/* print profile of all get/put/acc calls for every message range */
381
 
static void armci_print_all(FILE *fp) {
382
 
    int i, nget, nput, nacc, nrange=ARMCI_MAX_MSG_RANGE;
383
 
    double gtime, ptime, atime;
384
 
 
385
 
    ARMCI_HDR0(fp); ARMCI_HDR3(fp);
386
 
    for(i=0; i< nrange; i++) {
387
 
 
388
 
       nget =(ARMCI_PROF[ARMCI_PROF_GET][i].count + 
389
 
              ARMCI_PROF[ARMCI_PROF_GETS][i].count + 
390
 
              ARMCI_PROF[ARMCI_PROF_GETV][i].count +
391
 
              ARMCI_PROF[ARMCI_PROF_NBGET][i].count + 
392
 
              ARMCI_PROF[ARMCI_PROF_NBGETS][i].count + 
393
 
              ARMCI_PROF[ARMCI_PROF_NBGETV][i].count);
394
 
       nput =(ARMCI_PROF[ARMCI_PROF_PUT][i].count + 
395
 
              ARMCI_PROF[ARMCI_PROF_PUTS][i].count + 
396
 
              ARMCI_PROF[ARMCI_PROF_PUTV][i].count +
397
 
              ARMCI_PROF[ARMCI_PROF_NBPUT][i].count +
398
 
              ARMCI_PROF[ARMCI_PROF_NBPUTS][i].count + 
399
 
              ARMCI_PROF[ARMCI_PROF_NBPUTV][i].count);
400
 
       nacc =(ARMCI_PROF[ARMCI_PROF_ACC][i].count + 
401
 
              ARMCI_PROF[ARMCI_PROF_ACCS][i].count + 
402
 
              ARMCI_PROF[ARMCI_PROF_ACCV][i].count +
403
 
              ARMCI_PROF[ARMCI_PROF_NBACC][i].count +
404
 
              ARMCI_PROF[ARMCI_PROF_NBACCS][i].count + 
405
 
              ARMCI_PROF[ARMCI_PROF_NBACCV][i].count);
406
 
 
407
 
       gtime = (ARMCI_PROF[ARMCI_PROF_GET][i].time + 
408
 
                ARMCI_PROF[ARMCI_PROF_GETS][i].time + 
409
 
                ARMCI_PROF[ARMCI_PROF_GETV][i].time +
410
 
                ARMCI_PROF[ARMCI_PROF_NBGET][i].time +
411
 
                ARMCI_PROF[ARMCI_PROF_NBGETS][i].time + 
412
 
                ARMCI_PROF[ARMCI_PROF_NBGETV][i].time);
413
 
       ptime = (ARMCI_PROF[ARMCI_PROF_PUT][i].time + 
414
 
                ARMCI_PROF[ARMCI_PROF_PUTS][i].time + 
415
 
                ARMCI_PROF[ARMCI_PROF_PUTV][i].time +
416
 
                ARMCI_PROF[ARMCI_PROF_NBPUT][i].time +
417
 
                ARMCI_PROF[ARMCI_PROF_NBPUTS][i].time + 
418
 
                ARMCI_PROF[ARMCI_PROF_NBPUTV][i].time);
419
 
       atime = (ARMCI_PROF[ARMCI_PROF_ACC][i].time + 
420
 
                ARMCI_PROF[ARMCI_PROF_ACCS][i].time + 
421
 
                ARMCI_PROF[ARMCI_PROF_ACCV][i].time +
422
 
                ARMCI_PROF[ARMCI_PROF_NBACC][i].time +
423
 
                ARMCI_PROF[ARMCI_PROF_NBACCS][i].time + 
424
 
                ARMCI_PROF[ARMCI_PROF_NBACCV][i].time);
425
 
       
426
 
       fprintf(fp, "%d\t %d\t %d\t %.2e   %.2e   %.2e  ",
427
 
               nget, nput, nacc,  gtime, ptime, atime);
428
 
       if (i< nrange-1) fprintf(fp, "(%d-%d)\n", 1<<i, (1<<(i+1))-1);
429
 
       else fprintf(fp, "(>=%d)\n", 1<<(ARMCI_MAX_MSG_RANGE-1));
430
 
    }
431
 
}
432
 
 
433
 
/* print profile of contiguous get/put/acc calls for every message range */
434
 
static void armci_print_contig(FILE *fp) {
435
 
    int i, nrange=ARMCI_MAX_MSG_RANGE; 
436
 
    ARMCI_HDR1(fp); ARMCI_HDR3(fp);
437
 
    for(i=0; i< nrange; i++) {
438
 
       fprintf(fp, "%d\t %d\t %d\t %.2e   %.2e   %.2e  ",
439
 
               ARMCI_PROF[ARMCI_PROF_GET][i].count,
440
 
               ARMCI_PROF[ARMCI_PROF_PUT][i].count,
441
 
               ARMCI_PROF[ARMCI_PROF_ACC][i].count, 
442
 
               ARMCI_PROF[ARMCI_PROF_GET][i].time,
443
 
               ARMCI_PROF[ARMCI_PROF_PUT][i].time,
444
 
               ARMCI_PROF[ARMCI_PROF_ACC][i].time);
445
 
       if(i< nrange-1) fprintf(fp, "(%d-%d)\n", 1<<i, (1<<(i+1))-1);
446
 
       else fprintf(fp, "(>=%d)\n", 1<<(ARMCI_MAX_MSG_RANGE-1));
447
 
    }
448
 
}
449
 
 
450
 
/* This prints the number of non-contiguous get/put/acc/ calls for every 
451
 
   message range */
452
 
static void armci_print_noncontig(FILE *fp) {
453
 
    int i, nget, nput, nacc, nrange=ARMCI_MAX_MSG_RANGE;
454
 
    double gtime, ptime, atime;
455
 
 
456
 
    ARMCI_HDR2(fp); ARMCI_HDR3(fp);
457
 
    for(i=0; i< nrange; i++) {
458
 
       nget = (ARMCI_PROF[ARMCI_PROF_GETS][i].count + 
459
 
               ARMCI_PROF[ARMCI_PROF_GETV][i].count);
460
 
       nput = (ARMCI_PROF[ARMCI_PROF_PUTS][i].count + 
461
 
               ARMCI_PROF[ARMCI_PROF_PUTV][i].count);
462
 
       nacc = (ARMCI_PROF[ARMCI_PROF_ACCS][i].count + 
463
 
               ARMCI_PROF[ARMCI_PROF_ACCV][i].count);
464
 
       gtime = (ARMCI_PROF[ARMCI_PROF_GETS][i].time + 
465
 
                ARMCI_PROF[ARMCI_PROF_GETV][i].time);
466
 
       ptime = (ARMCI_PROF[ARMCI_PROF_PUTS][i].time + 
467
 
                ARMCI_PROF[ARMCI_PROF_PUTV][i].time);
468
 
       atime = (ARMCI_PROF[ARMCI_PROF_ACCS][i].time + 
469
 
                ARMCI_PROF[ARMCI_PROF_ACCV][i].time);
470
 
       
471
 
       fprintf(fp, "%d\t %d\t %d\t %.2e   %.2e   %.2e  ",
472
 
               nget, nput, nacc,  gtime, ptime, atime);
473
 
       if (i< nrange-1) fprintf(fp, "(%d-%d)\n", 1<<i, (1<<(i+1))-1);
474
 
       else fprintf(fp, "(>=%d)\n", 1<<(ARMCI_MAX_MSG_RANGE-1));
475
 
    }
476
 
}
477
 
 
478
 
/* print profile of non-blocking contiguous get/put/acc calls for every 
479
 
   message range */
480
 
static void armci_print_nbcontig(FILE *fp) {
481
 
    int i, nrange=ARMCI_MAX_MSG_RANGE; 
482
 
    ARMCI_HDR6(fp); ARMCI_HDR8(fp);
483
 
    for(i=0; i< nrange; i++) {
484
 
       fprintf(fp, "%d\t %d\t %d\t %.2e   %.2e   %.2e  ",
485
 
               ARMCI_PROF[ARMCI_PROF_NBGET][i].count,
486
 
               ARMCI_PROF[ARMCI_PROF_NBPUT][i].count,
487
 
               ARMCI_PROF[ARMCI_PROF_NBACC][i].count, 
488
 
               ARMCI_PROF[ARMCI_PROF_NBGET][i].time,
489
 
               ARMCI_PROF[ARMCI_PROF_NBPUT][i].time,
490
 
               ARMCI_PROF[ARMCI_PROF_NBACC][i].time);
491
 
       if(i< nrange-1) fprintf(fp, "(%d-%d)\n", 1<<i, (1<<(i+1))-1);
492
 
       else fprintf(fp, "(>=%d)\n", 1<<(ARMCI_MAX_MSG_RANGE-1));
493
 
    }
494
 
}
495
 
 
496
 
/* This prints the number of non-blocking non-contiguous get/put/acc/ calls 
497
 
   for every message range */
498
 
static void armci_print_nbnoncontig(FILE *fp) {
499
 
    int i, nget, nput, nacc, nrange=ARMCI_MAX_MSG_RANGE;
500
 
    double gtime, ptime, atime;
501
 
 
502
 
    ARMCI_HDR7(fp); ARMCI_HDR8(fp);
503
 
    for(i=0; i< nrange; i++) {
504
 
       nget = (ARMCI_PROF[ARMCI_PROF_NBGETS][i].count + 
505
 
               ARMCI_PROF[ARMCI_PROF_NBGETV][i].count);
506
 
       nput = (ARMCI_PROF[ARMCI_PROF_NBPUTS][i].count + 
507
 
               ARMCI_PROF[ARMCI_PROF_NBPUTV][i].count);
508
 
       nacc = (ARMCI_PROF[ARMCI_PROF_NBACCS][i].count + 
509
 
               ARMCI_PROF[ARMCI_PROF_NBACCV][i].count);
510
 
       gtime = (ARMCI_PROF[ARMCI_PROF_NBGETS][i].time + 
511
 
                ARMCI_PROF[ARMCI_PROF_NBGETV][i].time);
512
 
       ptime = (ARMCI_PROF[ARMCI_PROF_NBPUTS][i].time + 
513
 
                ARMCI_PROF[ARMCI_PROF_NBPUTV][i].time);
514
 
       atime = (ARMCI_PROF[ARMCI_PROF_NBACCS][i].time + 
515
 
                ARMCI_PROF[ARMCI_PROF_NBACCV][i].time);
516
 
 
517
 
       fprintf(fp, "%d\t %d\t %d\t %.2e   %.2e   %.2e  ",
518
 
               nget, nput, nacc,  gtime, ptime, atime);
519
 
       if (i< nrange-1) fprintf(fp, "(%d-%d)\n", 1<<i, (1<<(i+1))-1);
520
 
       else fprintf(fp, "(>=%d)\n", 1<<(ARMCI_MAX_MSG_RANGE-1));
521
 
    }
522
 
}
523
 
 
524
 
/* Profile of armci_notify_wait(), ARMCI_Wait() and ARMCI_Barrier() */
525
 
static void armci_print_misc(FILE *fp) {
526
 
    ARMCI_HDR9(fp);
527
 
    fprintf(fp, "#calls\t time\t   EVENT\n\n");
528
 
    fprintf(fp, "%d\t %.2e  ARMCI_Wait()\n", 
529
 
            ARMCI_PROF[ARMCI_PROF_WAIT][0].count, 
530
 
            ARMCI_PROF[ARMCI_PROF_WAIT][0].time);
531
 
    fprintf(fp, "%d\t %.2e  armci_notify_wait()\n", 
532
 
            ARMCI_PROF[ARMCI_PROF_NOTIFY][0].count, 
533
 
            ARMCI_PROF[ARMCI_PROF_NOTIFY][0].time);
534
 
    fprintf(fp, "%d\t %.2e  ARMCI_Barrier()\n", 
535
 
            ARMCI_PROF[ARMCI_PROF_BARRIER][0].count, 
536
 
            ARMCI_PROF[ARMCI_PROF_BARRIER][0].time);
537
 
    fprintf(fp, "%d\t %.2e  ARMCI_Fence()\n", 
538
 
            ARMCI_PROF[ARMCI_PROF_FENCE][0].count, 
539
 
            ARMCI_PROF[ARMCI_PROF_FENCE][0].time);
540
 
    fprintf(fp, "%d\t %.2e  ARMCI_Allfence()\n", 
541
 
            ARMCI_PROF[ARMCI_PROF_ALLFENCE][0].count, 
542
 
            ARMCI_PROF[ARMCI_PROF_ALLFENCE][0].time);
543
 
    fprintf(fp, "%d\t %.2e  ARMCI_Rmw()\n", 
544
 
            ARMCI_PROF[ARMCI_PROF_RMW][0].count, 
545
 
            ARMCI_PROF[ARMCI_PROF_RMW][0].time);
546
 
}
547
 
 
548
 
#if ARMCI_PRINT_STRIDE 
549
 
static void armci_print_warning_msg(FILE *fp, int range, int str_count) {
550
 
    fprintf(fp, "WARNING: In your program, total number of data transfers\n");
551
 
    fprintf(fp, "for message range[%d - %d] is %d. This exceeds\n", 
552
 
            1<<range, 1<<(range+1), str_count);
553
 
    fprintf(fp,"the maximum # of data transfers [%d] that can be profiled.\n",
554
 
            STRIDE_COUNT); 
555
 
    fprintf(fp, "Therefore profile of only first %d data \n", STRIDE_COUNT);
556
 
    fprintf(fp, "transfers are shown below. To increase the count, set\n");
557
 
    fprintf(fp, "STRIDE_COUNT > %d (in armci_profile.c)\n", str_count);
558
 
}
559
 
 
560
 
static void armci_print_stridedinfo(FILE *fp, int event, int range) {
561
 
    int i, j, stride_levels, str_count;
562
 
    double time=0.0;
563
 
    
564
 
    str_count = ARMCI_PROF[event][range].count;
565
 
    if(str_count <=0) return;    
566
 
    if(str_count > STRIDE_COUNT) { 
567
 
       armci_print_warning_msg(fp, range, str_count);
568
 
       str_count = STRIDE_COUNT;
569
 
    }
570
 
 
571
 
    fprintf(fp, "\n\nSTRIDE INFORMATION FOR MSG_RANGE %d-%d for EVENT: %s\n", 
572
 
            1<<range, (1<<(range+1))-1, gEventName[event]);
573
 
    ARMCI_HDR4(fp);
574
 
 
575
 
    for(i=0; i< str_count; i++) {
576
 
       time += ARMCI_PROF[event][range].stride[i].time;
577
 
       stride_levels  = ARMCI_PROF[event][range].stride[i].stride_levels;
578
 
       fprintf(fp, "%d\t%d\t %d\t %.2e  (",i, stride_levels,
579
 
               ARMCI_PROF[event][range].stride[i].proc,
580
 
               ARMCI_PROF[event][range].stride[i].time);
581
 
       for(j=0;j<=stride_levels;j++) {
582
 
          fprintf(fp, "%d", ARMCI_PROF[event][range].stride[i].count[j]);
583
 
          if(j!=stride_levels) fprintf(fp, "x");
584
 
       }
585
 
       fprintf(fp, ")\n");
586
 
    }
587
 
    /*This o/p is just for verification*/
588
 
    fprintf(fp, "**** STRIDE_COUNT = %d ; TOTAL TIME = %.2e\n",
589
 
            str_count, time);
590
 
}
591
 
 
592
 
static void armci_print_vectorinfo(FILE *fp, int event, int range) {
593
 
    int i, j, vec_len, str_count;
594
 
    double time=0.0;
595
 
    
596
 
    str_count = ARMCI_PROF[event][range].count;
597
 
    if(str_count <=0) return; 
598
 
    if(str_count > STRIDE_COUNT) { 
599
 
       armci_print_warning_msg(fp, range, str_count);
600
 
       str_count = STRIDE_COUNT;
601
 
    }
602
 
    
603
 
    fprintf(fp, "\n\nVECTOR INFORMATION FOR MSG_RANGE %d-%d for EVENT: %s\n", 
604
 
            1<<range, (1<<(range+1))-1, gEventName[event]);
605
 
    ARMCI_HDR5(fp);
606
 
 
607
 
    for(i=0; i< str_count; i++) {
608
 
       time += ARMCI_PROF[event][range].vector[i].time;
609
 
       vec_len  = ARMCI_PROF[event][range].vector[i].vec_len;
610
 
       fprintf(fp, "%d\t%d\t %d\t %.2e   [  ",i, vec_len,
611
 
               ARMCI_PROF[event][range].vector[i].proc,
612
 
               ARMCI_PROF[event][range].vector[i].time);
613
 
       for(j=0;j<vec_len;j++) {
614
 
          fprintf(fp, "%-9d %d\t]\n", 
615
 
                  ARMCI_PROF[event][range].vector[i].giov[j].ptr_array_len,
616
 
                  ARMCI_PROF[event][range].vector[i].giov[j].bytes);
617
 
          if(j!=vec_len-1) fprintf(fp, "\t\t\t\t    [  ");
618
 
       }
619
 
    }
620
 
    /*This o/p is just for verification*/
621
 
    fprintf(fp, "**** STRIDE_COUNT = %d ; TOTAL TIME = %.2e\n",
622
 
            str_count, time);
623
 
}
624
 
#endif /* end of ARMCI_PRINT_STRIDE */
625
 
 
626
 
void armci_profile_terminate() {
627
 
    FILE *fp = stdout;
628
 
    char file_name[50];
629
 
    sprintf(file_name, "armci_profile.%d", armci_me);
630
 
    fp = fopen(file_name, "w");
631
 
 
632
 
    armci_print_all(fp);         /* total get/put/acc calls */
633
 
    armci_print_contig(fp);      /* contiguous calls */
634
 
    armci_print_noncontig(fp);   /* non-contiguous calls */
635
 
    armci_print_nbcontig(fp);    /* non-blocking contiguous calls */
636
 
    armci_print_nbnoncontig(fp); /* non-blocking non-contiguous calls */
637
 
    
638
 
    /* miscellaneous (barrier, armci_wait, notify_wait) */
639
 
    armci_print_misc(fp);
640
 
 
641
 
#if ARMCI_PRINT_STRIDE
642
 
    {
643
 
       /**
644
 
        * printing stride info for non-contiguous get (ARMCI_PROF_GETS) for message
645
 
        * range #6. 2^6 - 2^(6+1) bytes (i.e. 64-128 bytes)
646
 
        *    Ex: armci_print_stridedinfo(ARMCI_PROF_GETS,6);
647
 
        */
648
 
#define ARMCI_PRINT_EVENTS 6
649
 
       int i,j;
650
 
       int str_event[ARMCI_PRINT_EVENTS]={ARMCI_PROF_GETS, ARMCI_PROF_PUTS,
651
 
                                          ARMCI_PROF_ACCS, ARMCI_PROF_NBGETS,
652
 
                                          ARMCI_PROF_NBPUTS,ARMCI_PROF_NBACCS};
653
 
       int vec_event[ARMCI_PRINT_EVENTS]={ARMCI_PROF_GETV, ARMCI_PROF_PUTV,
654
 
                                          ARMCI_PROF_ACCV, ARMCI_PROF_NBGETV,
655
 
                                          ARMCI_PROF_NBPUTV,ARMCI_PROF_NBACCV};
656
 
       
657
 
       fprintf(fp,"\n\n***************************************************\n");
658
 
       fprintf(fp,    " STRIDE INFORMATION for all strided data transfers\n");
659
 
       fprintf(fp,    "***************************************************\n");
660
 
       for(i=0; i<ARMCI_MAX_MSG_RANGE; i++)
661
 
          for(j=0; j<ARMCI_PRINT_EVENTS; j++)
662
 
             armci_print_stridedinfo(fp,str_event[j], i);
663
 
       
664
 
       fprintf(fp,"\n\n**************************************************\n");
665
 
       fprintf(fp,    " VECTOR INFORMATION for all vector data transfers\n");
666
 
       fprintf(fp,    "**************************************************\n");
667
 
       for(i=0; i<ARMCI_MAX_MSG_RANGE; i++)
668
 
          for(j=0; j<ARMCI_PRINT_EVENTS; j++)
669
 
             armci_print_vectorinfo(fp,vec_event[j], i);
670
 
    }
671
 
#endif
672
 
    fclose(fp);
673
 
}