void finalize_logging() {
#ifdef MPE_LOG
char filename[256];
sprintf( filename, "%s/mpe_log.dat", logfile_directory );
MPE_Finish_log(filename);
#endif
#ifdef LOG_STAR_CREATION
log_star_creation(-1,-1.0,FILE_CLOSE);
#endif
if ( local_proc_id == MASTER_NODE ) {
/* close log files */
fclose(steptimes);
fclose(runtimes);
fclose(energy);
}
#ifdef PAPI_PROFILING
fclose(papi_profile);
#endif
fclose(timing);
fclose(workload);
}
adlb_code
ADLB_Finalize()
{
MPE_LOG(xlb_mpe_all_finalize_start);
adlb_code rc = ADLBP_Finalize();
MPE_LOG(xlb_mpe_all_finalize_end);
// Safely write log before exiting
MPE(MPE_Finish_log("adlb"));
return rc;
}
void shutdown_mpi(void)
{
MPI_Barrier(MPI_COMM_WORLD); /* Wait for all processes to arrive */
#ifdef MPELOG
MPE_Log_sync_clocks();
#ifdef NO_LLMPE
MPE_Finish_log( progname );
#endif
#endif
MPI_Finalize(); /* Shutdown */
}
static int PyMPELog_Finish(void)
{
int ierr = 0;
#if HAVE_MPE
const char *filename = logFileName;
if (!filename[0]) filename = "Unknown";
if (MPE_Initialized_logging() == 1)
ierr = MPE_Finish_log((char *)filename);
#endif
return ierr;
}
/*@C
PetscLogMPEDump - Dumps the MPE logging info to file for later use with Upshot.
Collective over PETSC_COMM_WORLD
Level: advanced
.seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogMPEBegin()
@*/
PetscErrorCode PetscLogMPEDump(const char sname[])
{
char name[PETSC_MAX_PATH_LEN];
PetscErrorCode ierr;
PetscFunctionBegin;
if (PetscBeganMPE) {
ierr = PetscInfo(0,"Finalizing MPE.\n");CHKERRQ(ierr);
if (sname) { ierr = PetscStrcpy(name,sname);CHKERRQ(ierr);}
else { ierr = PetscGetProgramName(name,PETSC_MAX_PATH_LEN);CHKERRQ(ierr);}
ierr = MPE_Finish_log(name);CHKERRQ(ierr);
} else {
ierr = PetscInfo(0,"Not finalizing MPE (not started by PETSc).\n");CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static Int /* mpe_close(+FileName) */
p_close()
{
Term t_str = Deref(ARG1);
char *str;
/* The arg must be bound to an atom. */
if (IsVarTerm(t_str)) {
Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_close");
return (FALSE);
} else if( !IsAtomTerm(t_str) ) {
Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_close");
return (FALSE);
} else {
str = RepAtom(AtomOfTerm(t_str))->StrOfAE;
}
return (MPE_Finish_log(str) == 0);
}
int main(int argc, char** argv)
{
int my_rank; /* My process rank */
int p; /* The number of processes */
float a = 0.0; /* Left endpoint */
float b = 30.0; /* Right endpoint */
long int n = 10000000; /* Number of trapezoids */
double h; /* Trapezoid base length */
float local_a; /* Left endpoint my process */
float local_b; /* Right endpoint my process */
long int local_n; /* Number of trapezoids for */
/* my calculation */
long double integral; /* Integral over my interval */
long double total_integral; /* Total integral */
int source; /* Process sending integral */
int dest = 0; /* All messages go to 0 */
int tag = 0;
MPI_Status status;
double startTime, endTime, timeDifference;
/* Let the system do what it needs to start up MPI */
MPI_Init(&argc, &argv);
/* Get my process rank */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Find out how many processes are being used */
MPI_Comm_size(MPI_COMM_WORLD, &p);
// Initializing the log, after communication
MPE_Init_log();
int event1a = MPE_Log_get_event_number();
int event1b = MPE_Log_get_event_number();
int event2a = MPE_Log_get_event_number();
int event2b = MPE_Log_get_event_number();
int event3a = MPE_Log_get_event_number();
int event3b = MPE_Log_get_event_number();
MPE_Describe_state(event1a, event1b, "Receive", "blue");
MPE_Describe_state(event2a, event2b, "Send", "yellow");
MPE_Describe_state(event3a, event3b, "Compute", "red");
// Starting to log
MPE_Start_log();
if (my_rank==0)
startTime=MPI_Wtime();
local_n = n / p; /* So is the number of trapezoids */
/* Length of each process' interval of integration = local_n * h.
* So my interval starts at: */
MPE_Log_event(event3a, 0, "start compute");
integral = throwNeedles(local_n);
MPE_Log_event(event3b, 0, "end compute");
/* Add up the integrals calculated by each process */
if (my_rank == 0)
{
total_integral = integral;
for (source=1; source<p; source++)
{
MPE_Log_event(event1a, 0, "Start to receive");
MPI_Recv(&integral, 1, MPI_DOUBLE, source, tag, MPI_COMM_WORLD, &status);
MPE_Log_event(event1b, 0, "Recieved");
total_integral = total_integral + integral;
}
}
else {
MPE_Log_event(event2a, 0, "Start to Send");
MPI_Send(&integral, 1, MPI_DOUBLE, dest, tag, MPI_COMM_WORLD);
MPE_Log_event(event2b, 0, "Sent");
}
if (my_rank==0)
{
endTime = MPI_Wtime();
timeDifference = endTime - startTime;
}
/* Print the result */
if(my_rank == 0)
{
printf("The real value of PI is 3.141592653589793238462643\n");
printf("our estimate of the value of PI is %.25Lf\n", total_integral/p);
printf("Time taken for whole computation = %f seconds\n", timeDifference);
}
// Before finalize
MPE_Finish_log(argv[1]);
/* Shut down MPI */
MPI_Finalize();
return 0;
} /* main */
int main( int argc, char *argv[] )
{
int n, myid, numprocs, ii, jj;
double PI25DT = 3.141592653589793238462643;
double mypi, pi, h, sum, x;
double startwtime = 0.0, endwtime;
int namelen;
int event1a, event1b, event2a, event2b,
event3a, event3b, event4a, event4b;
char processor_name[ MPI_MAX_PROCESSOR_NAME ];
MPE_LOG_BYTES bytebuf;
int bytebuf_pos;
MPI_Init( &argc, &argv );
MPI_Pcontrol( 0 );
MPI_Comm_size( MPI_COMM_WORLD, &numprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &myid );
MPI_Get_processor_name( processor_name, &namelen );
fprintf( stderr, "Process %d running on %s\n", myid, processor_name );
/*
MPE_Init_log() & MPE_Finish_log() are NOT needed when
liblmpe.a is linked with this program. In that case,
MPI_Init() would have called MPE_Init_log() already.
*/
#if defined( NO_MPI_LOGGING )
MPE_Init_log();
#endif
/* Get event ID from MPE, user should NOT assign event ID directly */
event1a = MPE_Log_get_event_number();
event1b = MPE_Log_get_event_number();
event2a = MPE_Log_get_event_number();
event2b = MPE_Log_get_event_number();
event3a = MPE_Log_get_event_number();
event3b = MPE_Log_get_event_number();
event4a = MPE_Log_get_event_number();
event4b = MPE_Log_get_event_number();
if ( myid == 0 ) {
MPE_Describe_state( event1a, event1b, "Broadcast", "red" );
MPE_Describe_info_state( event2a, event2b, "Sync", "orange",
"source = %s()'s line %d." );
MPE_Describe_info_state( event3a, event3b, "Compute", "blue",
"mypi = %E computed at iteration %d." );
MPE_Describe_info_state( event4a, event4b, "Reduce", "green",
"final pi = %E at iteration %d." );
}
if ( myid == 0 ) {
n = 1000000;
startwtime = MPI_Wtime();
}
MPI_Barrier( MPI_COMM_WORLD );
MPI_Pcontrol( 1 );
/*
MPE_Start_log();
*/
for ( jj = 0; jj < ITER_COUNT; jj++ ) {
MPE_Log_event( event1a, 0, NULL );
MPI_Bcast( &n, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPE_Log_event( event1b, 0, NULL );
MPE_Log_event( event2a, 0, NULL );
MPI_Barrier( MPI_COMM_WORLD );
int line_num;
bytebuf_pos = 0;
MPE_Log_pack( bytebuf, &bytebuf_pos, 's',
sizeof(__func__)-1, __func__ );
line_num = __LINE__;
MPE_Log_pack( bytebuf, &bytebuf_pos, 'd', 1, &line_num );
MPE_Log_event( event2b, 0, bytebuf );
MPE_Log_event( event3a, 0, NULL );
h = 1.0 / (double) n;
sum = 0.0;
for ( ii = myid + 1; ii <= n; ii += numprocs ) {
x = h * ((double)ii - 0.5);
sum += f(x);
}
mypi = h * sum;
bytebuf_pos = 0;
MPE_Log_pack( bytebuf, &bytebuf_pos, 'E', 1, &mypi );
MPE_Log_pack( bytebuf, &bytebuf_pos, 'd', 1, &jj );
MPE_Log_event( event3b, 0, bytebuf );
pi = 0.0;
MPE_Log_event( event4a, 0, NULL );
MPI_Reduce( &mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD );
bytebuf_pos = 0;
MPE_Log_pack( bytebuf, &bytebuf_pos, 'E', 1, &pi );
MPE_Log_pack( bytebuf, &bytebuf_pos, 'd', 1, &jj );
MPE_Log_event( event4b, 0, bytebuf );
}
#if defined( NO_MPI_LOGGING )
if ( argv != NULL )
MPE_Finish_log( argv[0] );
else
MPE_Finish_log( "cpilog" );
#endif
if ( myid == 0 ) {
endwtime = MPI_Wtime();
printf( "pi is approximately %.16f, Error is %.16f\n",
pi, fabs(pi - PI25DT) );
printf( "wall clock time = %f\n", endwtime-startwtime );
}
MPI_Finalize();
return( 0 );
}
int MPI_Finalize(void)
{
MPE_Finish_log("log.dat");
return PMPI_Finalize();
};
int main( int argc, char *argv[] )
{
int n, myid, numprocs, ii, jj;
double PI25DT = 3.141592653589793238462643;
double mypi, pi, h, sum, x;
double startwtime = 0.0, endwtime;
int namelen;
int event1a, event1b, event2a, event2b,
event3a, event3b, event4a, event4b;
int event1, event2, event3;
char processor_name[ MPI_MAX_PROCESSOR_NAME ];
MPI_Init( &argc, &argv );
MPI_Pcontrol( 0 );
MPI_Comm_size( MPI_COMM_WORLD, &numprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &myid );
MPI_Get_processor_name( processor_name, &namelen );
fprintf( stderr, "Process %d running on %s\n", myid, processor_name );
/*
MPE_Init_log() & MPE_Finish_log() are NOT needed when
liblmpe.a is linked with this program. In that case,
MPI_Init() would have called MPE_Init_log() already.
*/
#if defined( NO_MPI_LOGGING )
MPE_Init_log();
#endif
/*
user should NOT assign eventIDs directly in MPE_Describe_state()
Get the eventIDs for user-defined STATES(rectangles) from
MPE_Log_get_state_eventIDs() instead of the deprecated function
MPE_Log_get_event_number().
*/
MPE_Log_get_state_eventIDs( &event1a, &event1b );
MPE_Log_get_state_eventIDs( &event2a, &event2b );
MPE_Log_get_state_eventIDs( &event3a, &event3b );
MPE_Log_get_state_eventIDs( &event4a, &event4b );
if ( myid == 0 ) {
MPE_Describe_state( event1a, event1b, "Broadcast", "red" );
MPE_Describe_state( event2a, event2b, "Sync", "orange" );
MPE_Describe_state( event3a, event3b, "Compute", "blue" );
MPE_Describe_state( event4a, event4b, "Reduce", "green" );
}
/* Get event ID for Solo-Event(single timestamp object) from MPE */
MPE_Log_get_solo_eventID( &event1 );
MPE_Log_get_solo_eventID( &event2 );
MPE_Log_get_solo_eventID( &event3 );
if ( myid == 0 ) {
MPE_Describe_event( event1, "Broadcast Post", "white" );
MPE_Describe_event( event2, "Compute Start", "purple" );
MPE_Describe_event( event3, "Compute End", "navy" );
}
if ( myid == 0 ) {
n = 1000000;
startwtime = MPI_Wtime();
}
MPI_Barrier( MPI_COMM_WORLD );
MPI_Pcontrol( 1 );
/*
MPE_Start_log();
*/
for ( jj = 0; jj < 5; jj++ ) {
MPE_Log_event( event1a, 0, NULL );
MPI_Bcast( &n, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPE_Log_event( event1b, 0, NULL );
MPE_Log_event( event1, 0, NULL );
MPE_Log_event( event2a, 0, NULL );
MPI_Barrier( MPI_COMM_WORLD );
MPE_Log_event( event2b, 0, NULL );
MPE_Log_event( event2, 0, NULL );
MPE_Log_event( event3a, 0, NULL );
h = 1.0 / (double) n;
sum = 0.0;
for ( ii = myid + 1; ii <= n; ii += numprocs ) {
x = h * ((double)ii - 0.5);
sum += f(x);
}
mypi = h * sum;
MPE_Log_event( event3b, 0, NULL );
MPE_Log_event( event3, 0, NULL );
pi = 0.0;
MPE_Log_event( event4a, 0, NULL );
MPI_Reduce( &mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD );
MPE_Log_event( event4b, 0, NULL );
MPE_Log_sync_clocks();
}
#if defined( NO_MPI_LOGGING )
if ( argv != NULL )
MPE_Finish_log( argv[0] );
else
MPE_Finish_log( "cpilog" );
#endif
if ( myid == 0 ) {
endwtime = MPI_Wtime();
printf( "pi is approximately %.16f, Error is %.16f\n",
pi, fabs(pi - PI25DT) );
printf( "wall clock time = %f\n", endwtime-startwtime );
}
MPI_Finalize();
return( 0 );
}
