RMUC2026/lib/eigen/bench/btl/generic_bench/timers/x86_timer.hh

//=====================================================
// File   :  x86_timer.hh
// Author :  L. Plagne <laurent.plagne@edf.fr)>
// Copyright (C) EDF R&D,  mar d<>c 3 18:59:35 CET 2002
//=====================================================
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
#ifndef _X86_TIMER_HH
#define _X86_TIMER_HH

#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <sys/times.h>
// #include "system_time.h"
#define u32 unsigned int
#include <asm/msr.h>
#include "utilities.h"
#include <map>
#include <fstream>
#include <string>
#include <iostream>

// frequence de la becanne en Hz
// #define FREQUENCY 648000000
// #define FREQUENCY 1400000000
#define FREQUENCY 1695000000

using namespace std;

class X86_Timer {
 public:
  X86_Timer(void) : _frequency(FREQUENCY), _nb_sample(0) { MESSAGE("X86_Timer Default Ctor"); }

  inline void start(void) { rdtsc(_click_start.n32[0], _click_start.n32[1]); }

  inline void stop(void) { rdtsc(_click_stop.n32[0], _click_stop.n32[1]); }

  inline double frequency(void) { return _frequency; }

  double get_elapsed_time_in_second(void) { return (_click_stop.n64 - _click_start.n64) / double(FREQUENCY); }

  unsigned long long get_click(void) { return (_click_stop.n64 - _click_start.n64); }

  inline void find_frequency(void) {
    time_t initial, final;
    int dummy = 2;

    initial = time(0);
    start();
    do {
      dummy += 2;
    } while (time(0) == initial);
    // On est au debut d'un cycle d'une seconde !!!
    initial = time(0);
    start();
    do {
      dummy += 2;
    } while (time(0) == initial);
    final = time(0);
    stop();
    //    INFOS("fine grained time : "<<  get_elapsed_time_in_second());
    //  INFOS("coarse grained time : "<<  final-initial);
    _frequency = _frequency * get_elapsed_time_in_second() / double(final - initial);
    ///  INFOS("CPU frequency : "<<  _frequency);
  }

  void add_get_click(void) {
    _nb_sample++;
    _counted_clicks[get_click()]++;
    fill_history_clicks();
  }

  void dump_statistics(string filemane) {
    ofstream outfile(filemane.c_str(), ios::out);

    std::map<unsigned long long, unsigned long long>::iterator itr;
    for (itr = _counted_clicks.begin(); itr != _counted_clicks.end(); itr++) {
      outfile << (*itr).first << "  " << (*itr).second << endl;
    }

    outfile.close();
  }

  void dump_history(string filemane) {
    ofstream outfile(filemane.c_str(), ios::out);

    for (int i = 0; i < _history_mean_clicks.size(); i++) {
      outfile << i << " " << _history_mean_clicks[i] << " " << _history_shortest_clicks[i] << " "
              << _history_most_occured_clicks[i] << endl;
    }

    outfile.close();
  }

  double get_mean_clicks(void) {
    std::map<unsigned long long, unsigned long long>::iterator itr;

    unsigned long long mean_clicks = 0;

    for (itr = _counted_clicks.begin(); itr != _counted_clicks.end(); itr++) {
      mean_clicks += (*itr).second * (*itr).first;
    }

    return mean_clicks / double(_nb_sample);
  }

  double get_shortest_clicks(void) { return double((*_counted_clicks.begin()).first); }

  void fill_history_clicks(void) {
    _history_mean_clicks.push_back(get_mean_clicks());
    _history_shortest_clicks.push_back(get_shortest_clicks());
    _history_most_occured_clicks.push_back(get_most_occured_clicks());
  }

  double get_most_occured_clicks(void) {
    unsigned long long moc = 0;
    unsigned long long max_occurence = 0;

    std::map<unsigned long long, unsigned long long>::iterator itr;

    for (itr = _counted_clicks.begin(); itr != _counted_clicks.end(); itr++) {
      if (max_occurence <= (*itr).second) {
        max_occurence = (*itr).second;
        moc = (*itr).first;
      }
    }

    return double(moc);
  }

  void clear(void) {
    _counted_clicks.clear();

    _history_mean_clicks.clear();
    _history_shortest_clicks.clear();
    _history_most_occured_clicks.clear();

    _nb_sample = 0;
  }

 private:
  union {
    unsigned long int n32[2];
    unsigned long long n64;
  } _click_start;

  union {
    unsigned long int n32[2];
    unsigned long long n64;
  } _click_stop;

  double _frequency;

  map<unsigned long long, unsigned long long> _counted_clicks;

  vector<double> _history_mean_clicks;
  vector<double> _history_shortest_clicks;
  vector<double> _history_most_occured_clicks;

  unsigned long long _nb_sample;
};

#endif