walltime.c File Reference

#include <stdlib.h>
#include <mpi.h>
#include <string.h>
#include <stdio.h>
#include "walltime.h"
#include "utils.h"

Include dependency graph for walltime.c:

Go to the source code of this file.

Functions
static void	walltime_clock_insert (const char *name)
static void	walltime_summary_clocks (struct Clock *C, int N, int root, MPI_Comm comm)
static void	walltime_update_parents (void)
static double	seconds (void)
void	walltime_init (struct ClockTable *ct)
void	walltime_summary (int root, MPI_Comm comm)
static int	clockcmp (const void *c1, const void *c2)
int	walltime_clock (const char *name)
char	walltime_get_symbol (const char *name)
double	walltime_get (const char *name, enum clocktype type)
double	walltime_get_time (const char *name)
void	walltime_reset ()
double	walltime_add_internal (const char *name, const double dt)
double	walltime_measure_internal (const char *name)
double	walltime_measure_full (const char *name, const char *file, const int line)
double	walltime_add_full (const char *name, const double dt, const char *file, const int line)
void	walltime_report (FILE *fp, int root, MPI_Comm comm)

Variables
static struct ClockTable *	CT = NULL
static double	WallTimeClock
static double	LastReportTime

Function Documentation

clockcmp()

static int clockcmp ( const void *  c1, const void *  c2  )

static

Definition at line 77 of file walltime.c.

                                                      {
    const struct Clock * p1 = (const struct Clock *) c1;
    const struct Clock * p2 = (const struct Clock *) c2;
    return strcmp(p1->name, p2->name);
}

References Clock::name.

Referenced by walltime_clock(), and walltime_clock_insert().

Here is the caller graph for this function:

seconds()

static double seconds ( void  )

static

Definition at line 216 of file walltime.c.

{
  return MPI_Wtime();
}

Referenced by walltime_init(), walltime_measure_internal(), walltime_reset(), and walltime_summary().

Here is the caller graph for this function:

walltime_add_full()

double walltime_add_full	(	const char *	name,
		const double	dt,
		const char *	file,
		const int	line
	)

Definition at line 203 of file walltime.c.

                                                                                                {
    char fullname[128] = {0};
    const char * basename = file + strlen(file);
    while(basename >= file && *basename != '/') basename --;
    basename ++;
    sprintf(fullname, "%s@%s:%04d", name, basename, line);
    return walltime_add_internal(fullname, dt);
 
}

References name, and walltime_add_internal().

Here is the call graph for this function:

walltime_add_internal()

double walltime_add_internal	(	const char *	name,
		const double	dt
	)

Definition at line 180 of file walltime.c.

                                                                 {
    int id = walltime_clock(name);
    CT->C[id].time += dt;
    return dt;
}

References ClockTable::C, CT, name, Clock::time, and walltime_clock().

Referenced by walltime_add_full().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_clock()

int walltime_clock

(

const char *

name

)

Definition at line 112 of file walltime.c.

                                      {
    struct Clock dummy;
    strncpy(dummy.name, name, sizeof(dummy.name));
    dummy.name[sizeof(dummy.name)-1]='\0';
 
    struct Clock * rt = (struct Clock *) bsearch(&dummy, CT->C, CT->N, sizeof(struct Clock), clockcmp);
    if(rt == NULL) {
        walltime_clock_insert(name);
        rt = (struct Clock *) bsearch(&dummy, CT->C, CT->N, sizeof(struct Clock), clockcmp);
    }
    return rt - CT->C;
};

References ClockTable::C, clockcmp(), CT, ClockTable::N, name, Clock::name, and walltime_clock_insert().

Referenced by walltime_add_internal(), walltime_clock_insert(), walltime_get(), walltime_get_symbol(), walltime_get_time(), and walltime_measure_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_clock_insert()

static void walltime_clock_insert ( const char *  name )

static

Definition at line 83 of file walltime.c.

                                                     {
    if(name[0] != '/') abort();
    if(strlen(name) > 1) {
        char tmp[80] = {0};
        strncpy(tmp, name, 79);
        char * p;
        walltime_clock("/");
        for(p = tmp + 1; *p; p ++) {
            if (*p == '/') {
                *p = 0;
                walltime_clock(tmp);
                *p = '/';
            }
        }
    }
    if(CT->N == CT->Nmax) {
        /* too many counters */
        abort();
    }
    const int nmsz = sizeof(CT->C[CT->N].name);
    strncpy(CT->C[CT->N].name, name, nmsz);
    CT->C[CT->N].name[nmsz-1] = '\0';
    strncpy(CT->AC[CT->N].name, CT->C[CT->N].name, nmsz);
    CT->AC[CT->N].name[nmsz-1] = '\0';
    CT->N ++;
    qsort_openmp(CT->C, CT->N, sizeof(struct Clock), clockcmp);
    qsort_openmp(CT->AC, CT->N, sizeof(struct Clock), clockcmp);
}

References ClockTable::AC, ClockTable::C, clockcmp(), CT, ClockTable::N, name, Clock::name, ClockTable::Nmax, qsort_openmp, and walltime_clock().

Referenced by walltime_clock(), and walltime_init().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_get()

double walltime_get	(	const char *	name,
		enum clocktype	type
	)

Definition at line 130 of file walltime.c.

                                                            {
    int id = walltime_clock(name);
    /* only make sense on root */
    switch(type) {
        case CLOCK_STEP_MEAN:
            return CT->C[id].mean;
        case CLOCK_STEP_MIN:
            return CT->C[id].min;
        case CLOCK_STEP_MAX:
            return CT->C[id].max;
        case CLOCK_ACCU_MEAN:
            return CT->AC[id].mean;
        case CLOCK_ACCU_MIN:
            return CT->AC[id].min;
        case CLOCK_ACCU_MAX:
            return CT->AC[id].max;
    }
    return 0;
}

References ClockTable::AC, ClockTable::C, CLOCK_ACCU_MAX, CLOCK_ACCU_MEAN, CLOCK_ACCU_MIN, CLOCK_STEP_MAX, CLOCK_STEP_MEAN, CLOCK_STEP_MIN, CT, Clock::max, Clock::mean, Clock::min, name, and walltime_clock().

Here is the call graph for this function:

walltime_get_symbol()

char walltime_get_symbol

(

const char *

name

)

Definition at line 125 of file walltime.c.

                                            {
    int id = walltime_clock(name);
    return CT->C[id].symbol;
}

References ClockTable::C, CT, name, Clock::symbol, and walltime_clock().

Here is the call graph for this function:

walltime_get_time()

double walltime_get_time

(

const char *

name

)

Definition at line 149 of file walltime.c.

                                            {
    int id = walltime_clock(name);
    return CT->C[id].time;
}

References ClockTable::C, CT, name, Clock::time, and walltime_clock().

Here is the call graph for this function:

walltime_init()

void walltime_init

(

struct ClockTable *

ct

)

Definition at line 19 of file walltime.c.

                                           {
    CT = ct;
    CT->Nmax = 512;
    CT->N = 0;
    CT->ElapsedTime = 0;
    walltime_reset();
    walltime_clock_insert("/");
    LastReportTime = seconds();
}

References CT, ClockTable::ElapsedTime, LastReportTime, ClockTable::N, ClockTable::Nmax, seconds(), walltime_clock_insert(), and walltime_reset().

Referenced by begrun(), main(), setup_density(), setup_particles(), setup_tree(), and test_fof().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_measure_full()

double walltime_measure_full	(	const char *	name,
		const char *	file,
		const int	line
	)

Definition at line 195 of file walltime.c.

                                                                                   {
    char fullname[128] = {0};
    const char * basename = file + strlen(file);
    while(basename >= file && *basename != '/') basename --;
    basename ++;
    sprintf(fullname, "%s@%s:%04d", name, basename, line);
    return walltime_measure_internal(fullname);
}

References name, and walltime_measure_internal().

Here is the call graph for this function:

walltime_measure_internal()

double walltime_measure_internal

(

const char *

name

)

Definition at line 185 of file walltime.c.

                                                    {
    double t = seconds();
    double dt = t - WallTimeClock;
    WallTimeClock = seconds();
    if(name[0] != '.') {
        int id = walltime_clock(name);
        CT->C[id].time += dt;
    }
    return dt;
}

References ClockTable::C, CT, name, seconds(), Clock::time, walltime_clock(), and WallTimeClock.

Referenced by walltime_measure_full().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_report()

void walltime_report	(	FILE *	fp,
		int	root,
		MPI_Comm	comm
	)

Definition at line 220 of file walltime.c.

                                                         {
    int rank;
    MPI_Comm_rank(comm, &rank);
    if(rank != root) return;
    int i;
    for(i = 0; i < CT->N; i ++) {
        char * name = CT->C[i].name;
        int level = 0;
        char * p = name;
        while(*p) {
            if(*p == '/') {
                level ++;
                name = p + 1;
            }
            p++;
        }
        /* if there is just one child, don't print it*/
        if(CT->Nchildren[i] == 1) continue;
        fprintf(fp, "%*s%-26s  %10.2f %4.1f%%  %10.2f %4.1f%%  %10.2f %10.2f\n",
                level, "",  /* indents */
                name,   /* just the last seg of name*/
                CT->AC[i].mean,
                CT->AC[i].mean / CT->ElapsedTime * 100.,
                CT->C[i].mean,
                CT->C[i].mean / CT->StepTime * 100.,
                CT->C[i].min,
                CT->C[i].max
                );
    }
}

References ClockTable::AC, ClockTable::C, CT, ClockTable::ElapsedTime, Clock::max, Clock::mean, Clock::min, ClockTable::N, name, Clock::name, ClockTable::Nchildren, and ClockTable::StepTime.

Referenced by compute_global_quantities_of_system(), and main().

Here is the caller graph for this function:

walltime_reset()

void walltime_reset

(

void

)

Definition at line 176 of file walltime.c.

                      {
    WallTimeClock = seconds();
}

References seconds(), and WallTimeClock.

Referenced by walltime_init().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_summary()

void walltime_summary	(	int	root,
		MPI_Comm	comm
	)

Definition at line 55 of file walltime.c.

                                               {
    walltime_update_parents();
    int i;
    /* add to the cumulative time */
    for(i = 0; i < CT->N; i ++) {
        CT->AC[i].time += CT->C[i].time;
    }
    walltime_summary_clocks(CT->C, CT->N, root, comm);
    walltime_summary_clocks(CT->AC, CT->N, root, comm);
 
    /* clear .time for next step */
    for(i = 0; i < CT->N; i ++) {
        CT->C[i].time = 0;
    }
    MPI_Barrier(comm);
    /* wo do this here because all processes are sync after summary_clocks*/
    double step_all = seconds() - LastReportTime;
    LastReportTime = seconds();
    CT->ElapsedTime += step_all;
    CT->StepTime = step_all;
}

References ClockTable::AC, ClockTable::C, CT, ClockTable::ElapsedTime, LastReportTime, ClockTable::N, seconds(), ClockTable::StepTime, Clock::time, walltime_summary_clocks(), and walltime_update_parents().

Referenced by compute_global_quantities_of_system(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

walltime_summary_clocks()

static void walltime_summary_clocks ( struct Clock *  C, int  N, int  root, MPI_Comm  comm  )

static

Definition at line 29 of file walltime.c.

                                                                                      {
    double * t = ta_malloc("clocks", double, 4 * N);
    double * min = t + N;
    double * max = t + 2 * N;
    double * sum = t + 3 * N;
    int i;
    for(i = 0; i < CT->N; i ++) {
        t[i] = C[i].time;
    }
    MPI_Reduce(t, min, N, MPI_DOUBLE, MPI_MIN, root, comm);
    MPI_Reduce(t, max, N, MPI_DOUBLE, MPI_MAX, root, comm);
    MPI_Reduce(t, sum, N, MPI_DOUBLE, MPI_SUM, root, comm);
 
    int NTask;
    MPI_Comm_size(comm, &NTask);
    /* min, max and mean are good only on process 0 */
    for(i = 0; i < CT->N; i ++) {
        C[i].min = min[i];
        C[i].max = max[i];
        C[i].mean = sum[i] / NTask;
    }
    ta_free(t);
}

References ClockTable::C, CT, Clock::max, Clock::mean, Clock::min, ClockTable::N, NTask, ta_free, ta_malloc, and Clock::time.

Referenced by walltime_summary().

Here is the caller graph for this function:

walltime_update_parents()

static void walltime_update_parents ( void  )

static

Definition at line 154 of file walltime.c.

                                      {
    /* returns the sum of every clock with the same prefix */
    int i = 0;
    for(i = 0; i < CT->N; i ++) {
        CT->Nchildren[i] = 0;
        int j;
        char * prefix = CT->C[i].name;
        int l = strlen(prefix);
        double t = 0;
        for(j = i + 1; j < CT->N; j++) {
            if(0 == strncmp(prefix, CT->C[j].name, l)) {
                t += CT->C[j].time;
                CT->Nchildren[i] ++;
            } else {
                break;
            }
        }
        /* update only if there are children */
        if (t > 0) CT->C[i].time = t;
    }
}

References ClockTable::C, CT, ClockTable::N, Clock::name, ClockTable::Nchildren, prefix, and Clock::time.

Referenced by walltime_summary().

Here is the caller graph for this function:

Variable Documentation

CT

struct ClockTable* CT = NULL

static

Definition at line 9 of file walltime.c.

Referenced by walltime_add_internal(), walltime_clock(), walltime_clock_insert(), walltime_get(), walltime_get_symbol(), walltime_get_time(), walltime_init(), walltime_measure_internal(), walltime_report(), walltime_summary(), walltime_summary_clocks(), and walltime_update_parents().

LastReportTime

double LastReportTime

static

Definition at line 12 of file walltime.c.

Referenced by walltime_init(), and walltime_summary().

WallTimeClock

double WallTimeClock

static

Definition at line 11 of file walltime.c.

Referenced by walltime_measure_internal(), and walltime_reset().