svg_trace.c

Go to the documentation of this file.

#include "svg_trace.h"

static int    eventNumCore  [SVG_TRACE_MAX_CORES];
static double eventStartCore[SVG_TRACE_MAX_CORES][SVG_TRACE_MAX_EVENTS];
static double eventStopCore [SVG_TRACE_MAX_CORES][SVG_TRACE_MAX_EVENTS];
static int    eventColorCore[SVG_TRACE_MAX_CORES][SVG_TRACE_MAX_EVENTS];


static double get_time_of_day()
{
    struct timeval  time_val;
    struct timezone time_zone;
    gettimeofday(&time_val, &time_zone);
    return (double)(time_val.tv_sec) + (double)(time_val.tv_usec) / 1000000.0;
}


void svg_trace_init(int num_cores)
{
    assert(num_cores <= SVG_TRACE_MAX_CORES);
    assert(__builtin_popcount(SVG_TRACE_MAX_EVENTS) == 0x01);
}


void svg_trace_start(int thread_rank)
{
    assert(thread_rank < SVG_TRACE_MAX_CORES);
    eventStartCore[thread_rank][eventNumCore[thread_rank]] = get_time_of_day();
}


void svg_trace_stop(int thread_rank, int color)
{
    assert(thread_rank < SVG_TRACE_MAX_CORES);
    eventStopCore [thread_rank][eventNumCore[thread_rank]] = get_time_of_day();
    eventColorCore[thread_rank][eventNumCore[thread_rank]] = color;
    eventNumCore[thread_rank]++;
    eventNumCore[thread_rank] &= (SVG_TRACE_MAX_EVENTS-1);
}


void svg_trace_finish()
{
    int mpi_rank;
    int mpi_size;
    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);

    int proc;
    int core;
    int event;
    double max_time = 0.0;
    for (core = 0; core < SVG_TRACE_MAX_CORES; core++) {
        double time =
            eventStopCore [core][eventNumCore[core]-1] -
            eventStopCore[0][0];
        if (time > max_time)
            max_time = time;
    }
    double max_time_out;
    MPI_Reduce(
        &max_time, &max_time_out, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
    double hscale = 2000.0 / max_time_out;

    int max_core_in = 0;
    for (core = 0; core < SVG_TRACE_MAX_CORES; core++)
        if (eventNumCore[core] > 1)
            max_core_in = core;
    int max_core;
    MPI_Reduce(
        &max_core_in, &max_core, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
    double vscale = 1000.0 / ((max_core+1)*mpi_size);

    if (mpi_rank == 0) {
        char trace_file_name[SVG_TRACE_FILE_NAME_SIZE];
        sprintf(trace_file_name, "trace_%d.svg", (int)(time(NULL)));
        FILE *trace_file = fopen(trace_file_name, "w");
        assert(trace_file != NULL);
        fprintf(trace_file,
            "<svg width=\"200mm\" height=\"100mm\" viewBox=\"0 0 2000 1000\">\n"
            "  <g>\n");

        for (proc = 0; proc < mpi_size; proc++) {
            if (proc > 0) {
                MPI_Recv(
                    &eventNumCore[0],
                    SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS, MPI_INT,
                    proc, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                MPI_Recv(
                    &eventStartCore[0][0],
                    SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS, MPI_DOUBLE,
                    proc, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                MPI_Recv(
                    &eventStopCore[0][0],
                    SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS, MPI_DOUBLE,
                    proc, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                MPI_Recv(
                    &eventColorCore[0][0],
                    SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS, MPI_INT,
                    proc, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            }
            for (core = 0; core < SVG_TRACE_MAX_CORES; core++) {
                for (event = 0; event < eventNumCore[core]; event++) {
                    double start = eventStartCore[core][event] - eventStopCore[0][0];
                    double stop =  eventStopCore [core][event] - eventStopCore[0][0];
                    double width = (stop-start) * hscale;
                    int color = eventColorCore[core][event];
                    int thread = proc*(max_core+1)+core;
                    fprintf(trace_file,
                        "    "
                        "<rect x=\"%.2lf\" y=\"%.0lf\" width=\"%.2lf\" height=\"%.0lf\" "
                        "fill=\"#%06x\" stroke=\"#%06x\" stroke-width=\"1\"/>\n",
                        start * hscale,
                        thread * vscale,
                        width < 2.0 ? 2.0 : width,
                        vscale * 0.9,
                        abs(color),
                        color < 0 ? color : 0);
                }
            }
        }
        fprintf(trace_file,
            "  </g>\n"
            "</svg>\n");
        fclose(trace_file);
    }
    else {
        MPI_Send(
            &eventNumCore[0],
            SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS,
            MPI_INT, 0, 0, MPI_COMM_WORLD);
        MPI_Send(
            &eventStartCore[0][0],
            SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS,
            MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
        MPI_Send(
            &eventStopCore[0][0],
            SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS,
            MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
        MPI_Send(
            &eventColorCore[0][0],
            SVG_TRACE_MAX_CORES*SVG_TRACE_MAX_EVENTS,
            MPI_INT, 0, 0, MPI_COMM_WORLD);
    }
}