| //===================================================== |
| // 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 |