OOPSE/libmdtools/mdProfile.cpp

#include <sys/time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#ifdef IS_MPI
#include <mpi.h>

#include "mpiSimulation.hpp"
#endif //is_mpi

#include "config.h"
#include "simError.h"
#include "mdProfile.hpp"

namespace mdProfileSpace {

  class ProfileString{
  public:
    char myName[MAX_PROFILE_NAMELENGTH];
  };

  ProfileString theNames[N_PROFILES];
  
  struct timeval startTime[N_PROFILES];
  struct timeval endTime[N_PROFILES];
    
  double accumTime[N_PROFILES];
  
#ifdef IS_MPI
  double globalTime[N_PROFILES];
#endif //is_mpi

  
}

extern "C"{
  
  void F90_FUNC(gettimes, GETTIMES)(double* forceTime, 
                                    double* commTime);
}


using namespace mdProfileSpace;


void initProfile( void ){

  int i;

  for( i=0;i<N_PROFILES;i++ ){
    
    accumTime[i] = 0.0;

#ifdef IS_MPI
    globalTime[i] = 0.0;
#endif //is_mpi
  }

  strncpy( theNames[pro1].myName, "Integrator->integrateStep()", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro2].myName, "Integrator->writes and stats", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro3].myName, "Integrator->preMove", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro4].myName, "Integrator->moveA", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro5].myName, "Integrator->CalcForce", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro6].myName, "Integrator->moveB", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro7].myName, "shortRange force calc", MAX_PROFILE_NAMELENGTH );
  strncpy( theNames[pro8].myName, "fortran force calc", MAX_PROFILE_NAMELENGTH );
}


void startProfile( proNames theProfile ){
  struct timezone tz;

  gettimeofday( &startTime[theProfile], &tz );
}

void endProfile( proNames theProfile ){
  struct timezone tz;
  double startVal, endVal;

  gettimeofday( &endTime[theProfile], &tz );

  startVal = (double)startTime[theProfile].tv_sec 
    + (double)startTime[theProfile].tv_usec / 1000000.0;

  endVal = (double)endTime[theProfile].tv_sec 
    + (double)endTime[theProfile].tv_usec / 1000000.0;
  
  accumTime[theProfile] += endVal - startVal;
}


void writeProfiles( void ){
 
  int i;
  double totalTime;
  double percentTime[N_PROFILES];
  int days, hours, minutes, secs, msecs;
  double donkey;
  
  double forceTime, commTime;
  
#ifdef IS_MPI
  int j;

  MPI_Status istatus;    

  double nodeTime, nodeForceTime, nodeCommTime;
  double nodeAccum[N_PROFILES];
  double nodePercent[N_PROFILES];

  double globalTime, globalForceTime, globalCommTime;
  double globalAccum[N_PROFILES];
  double globalPercent[N_PROFILES];
#endif // is_mpi


#ifndef IS_MPI // single processor version 

  totalTime = 0.0;
  for(i=0;i<N_PROFILES;i++)
    totalTime += accumTime[i];

  for(i=0;i<N_PROFILES;i++)
    percentTime[i] = accumTime[i] / totalTime;

  fprintf(stdout,
          "  Time Spent      Percent Time                        Name\n"
          "--------------  ----------------   -----------------------------------------\n"
          );

  for(i=0;i<N_PROFILES;i++){
    fprintf(stdout,
            " %12G    %14G     %40s\n",
            accumTime[i],
            percentTime[i],
            theNames[i].myName );
  }

  days = (int)floor( totalTime / 86400 );
  donkey = totalTime - 86400 * days;

  hours = (int)floor( donkey / 3600 );
  donkey -= hours * 3600;

  minutes = (int)floor( donkey / 60 );
  donkey -= minutes * 60;

  secs = (int)donkey;
  msecs = (int)( (donkey - secs) * 1000 );

  F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);

  fprintf( stdout,
           "----------------------------------------------------------------------------\n"
           "  Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
           "\n"
           "  From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
           days,
           hours,
           minutes,
           secs,
           msecs,
           totalTime,
           forceTime,
           commTime);

#else // the parrallel version

  if( worldRank == 0 ){
    
    double *nodeTots = new double[mpiSim->getNprocessors()];
    double *nodePercentTots = new double[mpiSim->getNprocessors()];
    
    totalTime = 0.0;
    for(i=0;i<N_PROFILES;i++)
      totalTime += accumTime[i];
    
    for(i=0;i<N_PROFILES;i++)
      percentTime[i] = accumTime[i] / totalTime;
    
    fprintf(stdout,
            "\n"
            "----------------------------------------------------------------------------\n"
            "  Output from Node %d:   \n"
            "\n"
            "  Time Spent      Percent Time                        Name\n"
            "--------------  ----------------   -----------------------------------------\n",
            worldRank);
    
    for(i=0;i<N_PROFILES;i++){
      fprintf(stdout,
              " %12G    %14G     %40s\n",
              accumTime[i],
              percentTime[i],
              theNames[i].myName );
    }
    
    days = (int)floor( totalTime / 86400 );
    donkey = totalTime - 86400 * days;
    
    hours = (int)floor( donkey / 3600 );
    donkey -= hours * 3600;
    
    minutes = (int)floor( donkey / 60 );
    donkey -= minutes * 60;
    
    secs = (int)donkey;
    msecs = (int)( (donkey - secs) * 1000 );
    
    F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);

    fprintf( stdout,
             "----------------------------------------------------------------------------\n"
             "  Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
             "\n"
             "  From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
             days,
             hours,
             minutes,
             secs,
             msecs,
             totalTime,
             forceTime,
             commTime);
    
    // now the rest of the nodes
    
    nodeTots[0] = totalTime;
    
    globalTime = totalTime;
    globalForceTime = forceTime;
    globalCommTime = commTime;
    for(i=0;i<N_PROFILES;i++)
      globalAccum[i] = accumTime[i];
    
    
    for(j=1;j<mpiSim->getNprocessors();j++){
      
      nodeTime = 0.0;
     
      MPI_Recv(nodeAccum, N_PROFILES, MPI_DOUBLE, j,
               1, MPI_COMM_WORLD, &istatus );

      MPI_Recv(&nodeForceTime, 1, MPI_DOUBLE, j,
               1, MPI_COMM_WORLD, &istatus );
      MPI_Recv(&nodeCommTime, 1, MPI_DOUBLE, j,
               1, MPI_COMM_WORLD, &istatus );

      for(i=0;i<N_PROFILES;i++){
        nodeTime += nodeAccum[i];
      }
      
      for(i=0;i<N_PROFILES;i++)
        nodePercent[i] = nodeAccum[i] / nodeTime;
      
      fprintf(stdout,
              "\n"
              "----------------------------------------------------------------------------\n"
              "  Output from Node %d:   \n"
              "\n"
              "  Time Spent      Percent Time                        Name\n"
              "--------------  ----------------   -----------------------------------------\n",
              j);
      
      for(i=0;i<N_PROFILES;i++){
        fprintf(stdout,
                " %12G    %14G     %40s\n",
                nodeAccum[i],
                nodePercent[i],
                theNames[i].myName );
      }
      
      days = (int)floor( nodeTime / 86400 );
      donkey = nodeTime - 86400 * days;
      
      hours = (int)floor( donkey / 3600 );
      donkey -= hours * 3600;
      
      minutes = (int)floor( donkey / 60 );
      donkey -= minutes * 60;
      
      secs = (int)donkey;
      msecs = (int)( (donkey - secs) * 1000 );
      
      fprintf( stdout,
               "----------------------------------------------------------------------------\n"
               "  Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
               "\n"
               "  From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
               days,
               hours,
               minutes,
               secs,
               msecs,
               nodeTime,
               nodeForceTime,
               nodeCommTime);
      
      for(i=0;i<N_PROFILES;i++)
        globalAccum[i] += nodeAccum[i];
      
      globalTime += nodeTime;
      globalForceTime += nodeForceTime;
      globalCommTime += nodeCommTime;
      nodeTots[j] = nodeTime;
    }

    // print out the totals
    
    for(j=0;j<mpiSim->getNprocessors();j++)
      nodePercentTots[j] = nodeTots[j] / globalTime;
    
    for(i=0;i<N_PROFILES;i++)
      globalPercent[i] = globalAccum[i] / globalTime;

    fprintf(stdout,
            "\n"
            "----------------------------------------------------------------------------\n"
            "  Total Across Nodes\n"
            "\n"
            "  Time Spent      Percent Time                        Name\n"
            "--------------  ----------------   -----------------------------------------\n",
            j);
    
    for(i=0;i<N_PROFILES;i++){
      fprintf(stdout,
              " %12G    %14G     %40s\n",
              globalAccum[i],
              globalPercent[i],
              theNames[i].myName );
    }
    fprintf(stdout,
            "\n"
            "\n" );
    
    for(j=0;j<mpiSim->getNprocessors();j++){
      
      fprintf(stdout,
              " %12G    %14G     node %d\n",
              nodeTots[j],
              nodePercentTots[j],
              j );
    }
    
    days = (int)floor( globalTime / 86400 );
    donkey = nodeTime - 86400 * days;
    

    hours = (int)floor( donkey / 3600 );
    donkey -= hours * 3600;
    
    minutes = (int)floor( donkey / 60 );
    donkey -= minutes * 60;
    
    secs = (int)donkey;
    msecs = (int)( (donkey - secs) * 1000 );
    
    fprintf( stdout,
             "----------------------------------------------------------------------------\n"
             "  Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
             "\n"
             "  From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
             days,
             hours,
             minutes,
             secs,
             msecs,
             globalTime,
             globalForceTime,
             globalCommTime);
  }

  else{

    for(j=1;j<mpiSim->getNprocessors();j++){
      
      if( worldRank == j ){
        
        F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);

        MPI_Send( accumTime, N_PROFILES, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
        MPI_Send( &forceTime, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
        MPI_Send( &commTime, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
      }
    }
  }
    
#endif // is_mpi
  

}
Revision:	1198
Committed:	Thu May 27 00:48:12 2004 UTC (20 years, 11 months ago) by tim
File size:	9650 byte(s)
Log Message:	in the progress of fixing MPI version of cutoff group
#	Content
1	#include <sys/time.h>
2	#include <string.h>
3	#include <stdio.h>
4	#include <stdlib.h>
5	#include <math.h>
6
7	#ifdef IS_MPI
8	#include <mpi.h>
9
10	#include "mpiSimulation.hpp"
11	#endif //is_mpi
12
13	#include "config.h"
14	#include "simError.h"
15	#include "mdProfile.hpp"
16
17	namespace mdProfileSpace {
18
19	class ProfileString{
20	public:
21	char myName[MAX_PROFILE_NAMELENGTH];
22	};
23
24	ProfileString theNames[N_PROFILES];
25
26	struct timeval startTime[N_PROFILES];
27	struct timeval endTime[N_PROFILES];
28
29	double accumTime[N_PROFILES];
30
31	#ifdef IS_MPI
32	double globalTime[N_PROFILES];
33	#endif //is_mpi
34
35
36	}
37
38	extern "C"{
39
40	void F90_FUNC(gettimes, GETTIMES)(double* forceTime,
41	double* commTime);
42	}
43
44
45	using namespace mdProfileSpace;
46
47
48	void initProfile( void ){
49
50	int i;
51
52	for( i=0;i<N_PROFILES;i++ ){
53
54	accumTime[i] = 0.0;
55
56	#ifdef IS_MPI
57	globalTime[i] = 0.0;
58	#endif //is_mpi
59	}
60
61	strncpy( theNames[pro1].myName, "Integrator->integrateStep()", MAX_PROFILE_NAMELENGTH );
62	strncpy( theNames[pro2].myName, "Integrator->writes and stats", MAX_PROFILE_NAMELENGTH );
63	strncpy( theNames[pro3].myName, "Integrator->preMove", MAX_PROFILE_NAMELENGTH );
64	strncpy( theNames[pro4].myName, "Integrator->moveA", MAX_PROFILE_NAMELENGTH );
65	strncpy( theNames[pro5].myName, "Integrator->CalcForce", MAX_PROFILE_NAMELENGTH );
66	strncpy( theNames[pro6].myName, "Integrator->moveB", MAX_PROFILE_NAMELENGTH );
67	strncpy( theNames[pro7].myName, "shortRange force calc", MAX_PROFILE_NAMELENGTH );
68	strncpy( theNames[pro8].myName, "fortran force calc", MAX_PROFILE_NAMELENGTH );
69	}
70
71
72	void startProfile( proNames theProfile ){
73	struct timezone tz;
74
75	gettimeofday( &startTime[theProfile], &tz );
76	}
77
78	void endProfile( proNames theProfile ){
79	struct timezone tz;
80	double startVal, endVal;
81
82	gettimeofday( &endTime[theProfile], &tz );
83
84	startVal = (double)startTime[theProfile].tv_sec
85	+ (double)startTime[theProfile].tv_usec / 1000000.0;
86
87	endVal = (double)endTime[theProfile].tv_sec
88	+ (double)endTime[theProfile].tv_usec / 1000000.0;
89
90	accumTime[theProfile] += endVal - startVal;
91	}
92
93
94	void writeProfiles( void ){
95
96	int i;
97	double totalTime;
98	double percentTime[N_PROFILES];
99	int days, hours, minutes, secs, msecs;
100	double donkey;
101
102	double forceTime, commTime;
103
104	#ifdef IS_MPI
105	int j;
106
107	MPI_Status istatus;
108
109	double nodeTime, nodeForceTime, nodeCommTime;
110	double nodeAccum[N_PROFILES];
111	double nodePercent[N_PROFILES];
112
113	double globalTime, globalForceTime, globalCommTime;
114	double globalAccum[N_PROFILES];
115	double globalPercent[N_PROFILES];
116	#endif // is_mpi
117
118
119	#ifndef IS_MPI // single processor version
120
121	totalTime = 0.0;
122	for(i=0;i<N_PROFILES;i++)
123	totalTime += accumTime[i];
124
125	for(i=0;i<N_PROFILES;i++)
126	percentTime[i] = accumTime[i] / totalTime;
127
128	fprintf(stdout,
129	" Time Spent Percent Time Name\n"
130	"-------------- ---------------- -----------------------------------------\n"
131	);
132
133	for(i=0;i<N_PROFILES;i++){
134	fprintf(stdout,
135	" %12G %14G %40s\n",
136	accumTime[i],
137	percentTime[i],
138	theNames[i].myName );
139	}
140
141	days = (int)floor( totalTime / 86400 );
142	donkey = totalTime - 86400 * days;
143
144	hours = (int)floor( donkey / 3600 );
145	donkey -= hours * 3600;
146
147	minutes = (int)floor( donkey / 60 );
148	donkey -= minutes * 60;
149
150	secs = (int)donkey;
151	msecs = (int)( (donkey - secs) * 1000 );
152
153	F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);
154
155	fprintf( stdout,
156	"----------------------------------------------------------------------------\n"
157	" Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
158	"\n"
159	" From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
160	days,
161	hours,
162	minutes,
163	secs,
164	msecs,
165	totalTime,
166	forceTime,
167	commTime);
168
169	#else // the parrallel version
170
171	if( worldRank == 0 ){
172
173	double *nodeTots = new double[mpiSim->getNprocessors()];
174	double *nodePercentTots = new double[mpiSim->getNprocessors()];
175
176	totalTime = 0.0;
177	for(i=0;i<N_PROFILES;i++)
178	totalTime += accumTime[i];
179
180	for(i=0;i<N_PROFILES;i++)
181	percentTime[i] = accumTime[i] / totalTime;
182
183	fprintf(stdout,
184	"\n"
185	"----------------------------------------------------------------------------\n"
186	" Output from Node %d: \n"
187	"\n"
188	" Time Spent Percent Time Name\n"
189	"-------------- ---------------- -----------------------------------------\n",
190	worldRank);
191
192	for(i=0;i<N_PROFILES;i++){
193	fprintf(stdout,
194	" %12G %14G %40s\n",
195	accumTime[i],
196	percentTime[i],
197	theNames[i].myName );
198	}
199
200	days = (int)floor( totalTime / 86400 );
201	donkey = totalTime - 86400 * days;
202
203	hours = (int)floor( donkey / 3600 );
204	donkey -= hours * 3600;
205
206	minutes = (int)floor( donkey / 60 );
207	donkey -= minutes * 60;
208
209	secs = (int)donkey;
210	msecs = (int)( (donkey - secs) * 1000 );
211
212	F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);
213
214	fprintf( stdout,
215	"----------------------------------------------------------------------------\n"
216	" Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
217	"\n"
218	" From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
219	days,
220	hours,
221	minutes,
222	secs,
223	msecs,
224	totalTime,
225	forceTime,
226	commTime);
227
228	// now the rest of the nodes
229
230	nodeTots[0] = totalTime;
231
232	globalTime = totalTime;
233	globalForceTime = forceTime;
234	globalCommTime = commTime;
235	for(i=0;i<N_PROFILES;i++)
236	globalAccum[i] = accumTime[i];
237
238
239	for(j=1;j<mpiSim->getNprocessors();j++){
240
241	nodeTime = 0.0;
242
243	MPI_Recv(nodeAccum, N_PROFILES, MPI_DOUBLE, j,
244	1, MPI_COMM_WORLD, &istatus );
245
246	MPI_Recv(&nodeForceTime, 1, MPI_DOUBLE, j,
247	1, MPI_COMM_WORLD, &istatus );
248	MPI_Recv(&nodeCommTime, 1, MPI_DOUBLE, j,
249	1, MPI_COMM_WORLD, &istatus );
250
251	for(i=0;i<N_PROFILES;i++){
252	nodeTime += nodeAccum[i];
253	}
254
255	for(i=0;i<N_PROFILES;i++)
256	nodePercent[i] = nodeAccum[i] / nodeTime;
257
258	fprintf(stdout,
259	"\n"
260	"----------------------------------------------------------------------------\n"
261	" Output from Node %d: \n"
262	"\n"
263	" Time Spent Percent Time Name\n"
264	"-------------- ---------------- -----------------------------------------\n",
265	j);
266
267	for(i=0;i<N_PROFILES;i++){
268	fprintf(stdout,
269	" %12G %14G %40s\n",
270	nodeAccum[i],
271	nodePercent[i],
272	theNames[i].myName );
273	}
274
275	days = (int)floor( nodeTime / 86400 );
276	donkey = nodeTime - 86400 * days;
277
278	hours = (int)floor( donkey / 3600 );
279	donkey -= hours * 3600;
280
281	minutes = (int)floor( donkey / 60 );
282	donkey -= minutes * 60;
283
284	secs = (int)donkey;
285	msecs = (int)( (donkey - secs) * 1000 );
286
287	fprintf( stdout,
288	"----------------------------------------------------------------------------\n"
289	" Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
290	"\n"
291	" From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
292	days,
293	hours,
294	minutes,
295	secs,
296	msecs,
297	nodeTime,
298	nodeForceTime,
299	nodeCommTime);
300
301	for(i=0;i<N_PROFILES;i++)
302	globalAccum[i] += nodeAccum[i];
303
304	globalTime += nodeTime;
305	globalForceTime += nodeForceTime;
306	globalCommTime += nodeCommTime;
307	nodeTots[j] = nodeTime;
308	}
309
310	// print out the totals
311
312	for(j=0;j<mpiSim->getNprocessors();j++)
313	nodePercentTots[j] = nodeTots[j] / globalTime;
314
315	for(i=0;i<N_PROFILES;i++)
316	globalPercent[i] = globalAccum[i] / globalTime;
317
318	fprintf(stdout,
319	"\n"
320	"----------------------------------------------------------------------------\n"
321	" Total Across Nodes\n"
322	"\n"
323	" Time Spent Percent Time Name\n"
324	"-------------- ---------------- -----------------------------------------\n",
325	j);
326
327	for(i=0;i<N_PROFILES;i++){
328	fprintf(stdout,
329	" %12G %14G %40s\n",
330	globalAccum[i],
331	globalPercent[i],
332	theNames[i].myName );
333	}
334	fprintf(stdout,
335	"\n"
336	"\n" );
337
338	for(j=0;j<mpiSim->getNprocessors();j++){
339
340	fprintf(stdout,
341	" %12G %14G node %d\n",
342	nodeTots[j],
343	nodePercentTots[j],
344	j );
345	}
346
347	days = (int)floor( globalTime / 86400 );
348	donkey = nodeTime - 86400 * days;
349
350
351	hours = (int)floor( donkey / 3600 );
352	donkey -= hours * 3600;
353
354	minutes = (int)floor( donkey / 60 );
355	donkey -= minutes * 60;
356
357	secs = (int)donkey;
358	msecs = (int)( (donkey - secs) * 1000 );
359
360	fprintf( stdout,
361	"----------------------------------------------------------------------------\n"
362	" Total Time = %03d:%02d:%02d:%02d.%03d ( %G sec )\n"
363	"\n"
364	" From Fortran: forceTime = %G secs; communicationTime = %G secs.\n",
365	days,
366	hours,
367	minutes,
368	secs,
369	msecs,
370	globalTime,
371	globalForceTime,
372	globalCommTime);
373	}
374
375	else{
376
377	for(j=1;j<mpiSim->getNprocessors();j++){
378
379	if( worldRank == j ){
380
381	F90_FUNC(gettimes, GETTIMES)(&forceTime, &commTime);
382
383	MPI_Send( accumTime, N_PROFILES, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
384	MPI_Send( &forceTime, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
385	MPI_Send( &commTime, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD );
386	}
387	}
388	}
389
390	#endif // is_mpi
391
392
393	}