root/natfw-nslp/trunk/src/benchmark_journal.cpp @ 2273

/*
 * The benchmark class.
 *
 * $Id$
 * $HeadURL$
 */
#include <fstream>
#include <cstring>
#include <pthread.h>

#include "benchmark_journal.h"

using namespace natfw;


/**
 * Human readable measuring point names, used in write_header().
 */
const char *
benchmark_journal::mp_names[benchmark_journal::HIGHEST_VALID_ID+1] = {
        "INVALID_ID",
        "PRE_PROCESSING",
        "POST_PROCESSING",
        "PRE_MAPPING",
        "POST_MAPPING",
        "PRE_SERIALIZE",
        "POST_SERIALIZE",
        "PRE_DESERIALIZE",
        "POST_DESERIALIZE",
        "PRE_DISPATCHER",
        "POST_DISPATCHER",
        "PRE_SESSION",
        "POST_SESSION"
};


/**
 * Constructor to create a journal of the given size.
 *
 * The journal is initialized to avoid page faults during usage.
 * If a filename is given (!= the empty string), the journal is written to
 * that file as soon as the journal is full.
 *
 * @param journal_size the size of the in-memory journal
 * @param filename the name of the file to write the journal to
 */
benchmark_journal::benchmark_journal(
                int journal_size, const std::string &filename)
                : journal_size(journal_size), journal_pos(0),
                  filename(filename), disable_journal(false) {

        journal = new measuring_point_t[journal_size];
        memset(journal, 0,
                sizeof(benchmark_journal::measuring_point_t) * journal_size);

        /*
         * Initialize the mutex. We use a recursive mutex to make calling
         * write_journal() from add() easier.
         */
        pthread_mutexattr_t mutex_attr;

        pthread_mutexattr_init(&mutex_attr);
        pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&mutex, &mutex_attr);

        pthread_mutexattr_destroy(&mutex_attr);
}


benchmark_journal::~benchmark_journal() {
        delete journal;
        pthread_mutex_destroy(&mutex);
}


void benchmark_journal::write_journal(const std::string &filename) {
        std::ofstream out(filename.c_str());

        if ( ! out ) {
                std::cerr << "Error opening journal file `" + filename + "'\n";
                return;
        }

        try {
                this->write_journal(out);
        }
        catch ( ... ) {
                std::cerr << "Error writing journal" << std::endl;
        }

        out.close();
}


/**
 * Write the journal to the given stream.
 *
 * Note that the caller is responsible for closing the stream.
 */
void benchmark_journal::write_journal(std::ostream &out) {
        pthread_mutex_lock(&mutex);

        write_header(out);

        for ( int i = 0; i < journal_size
                                && journal[i].point != INVALID_ID; i++ )
                out << (int) journal[i].point << ' '
                        << journal[i].thread_id << ' '
                        << journal[i].timestamp.tv_sec << ' '
                        << journal[i].timestamp.tv_nsec << std::endl;

        pthread_mutex_unlock(&mutex);
}


/**
 * Write a header to the journal documenting the measuring points.
 */
void benchmark_journal::write_header(std::ostream &out) {
        time_t t;

        time(&t);

        out << "# Benchmark Journal, created " << ctime(&t) << std::endl;
        out << "# $Id$" << std::endl;
        out << "# Format: <measuring point ID> <Thread ID>"
                " <seconds> <nano seconds>" << std::endl;
        out << "# Measuring points:" << std::endl;

        for (int i = 0; i <= HIGHEST_VALID_ID; i++)
                out << "# \t" << i << " " << mp_names[i] << std::endl;

        out << "#" << std::endl;
}

// EOF