root/natfw-nslp/trunk/include/benchmark.h @ 2252

/*
 * Tools for running benchmarks.
 *
 * $Id$
 * $HeadURL$
 */
#ifndef NATFW__BENCHMARK_H
#define NATFW__BENCHMARK_H

#include <iostream>
#include <string>
#include <ctime>


namespace natfw {

#ifdef BENCHMARK
  #define MP(mp_id)     journal.add(mp_id)
#else
  #define MP(mp_id)
#endif

/**
 * A class for running benchmarks on the NATFW implementation.
 *
 * Only one instance of this class is needed. All threads share a common
 * journal.
 */
class benchmark {
  public:
        /**
         * Each measuring point has an ID on its own.
         *
         * Note: When adding or changing measuring points, please also adjust
         *       the mp_names array in benchmark.cpp.
         */
        enum measuring_point_id_t {
                INVALID_ID              = 0,
                PRE_PROCESSING          = 1,
                POST_PROCESSING         = 2,
                PRE_MAPPING             = 3,
                POST_MAPPING            = 4,
                PRE_PARSER              = 5,
                POST_PARSER             = 6,
                PRE_DISPATCHER          = 7,
                POST_DISPATCHER         = 8,
                PRE_SESSION             = 9,
                POST_SESSION            = 10,
                HIGHEST_VALID_ID        = 10
        };

        benchmark(int journal_size, const std::string &filename="");
        ~benchmark();

        void add(measuring_point_id_t mp_id);

        void write_journal(const std::string &filename);
        void write_journal(std::ostream &out);
        
  private:
        struct measuring_point_t {
                measuring_point_id_t    point;
                pthread_t               thread_id;
                struct timespec         timestamp;
        };

        /*
         * The journal is an array of measuring_point entries. The next entry
         * has to be written to journal[journal_pos].
         */
        int journal_size;
        int journal_pos;
        measuring_point_t *journal;

        pthread_mutex_t mutex;

        std::string filename;
        bool disable_journal;

        static const char *mp_names[HIGHEST_VALID_ID+1];

        static void write_header(std::ostream &out);
};


inline void benchmark::add(measuring_point_id_t mp_id) {
        pthread_mutex_lock(&mutex);

        if ( journal_pos < journal_size ) {
                struct timespec res;
                clock_gettime(CLOCK_REALTIME, &res);

                struct measuring_point_t mp = { mp_id, pthread_self(), res };
                journal[journal_pos++] = mp;
        }
        else if ( disable_journal == false && journal_pos == journal_size ) {
                std::cerr << "*** benchmark journal is full ***" << std::endl;

                if ( filename != "" ) {
                        std::cerr << "writing journal to file "
                                << filename << " ..." << std::endl;
                        write_journal(filename);
                        std::cerr << "done." << std::endl;
                }

                disable_journal = true;
        }

        pthread_mutex_unlock(&mutex);
}


} // namespace natfw


#endif // NATFW__BENCHMARK_H