Utils/src/MeanCounter.cc

// 
#include "LJMet/Utils/interface/MeanCounter.h"

#include <iostream>
#include <math.h>
using std::cout;
using std::endl;
using std::ostream;

//ClassImp(MeanCounter)

MeanCounter::MeanCounter(){
  init();
} 

MeanCounter::MeanCounter( const char *message, unsigned long int theFirst, unsigned long int theDivider ){
  init();
  _message = message;
  if ( _message . length() == 0 ) printCount = false;
  else printCount = true;
  _count = theFirst;
  _firstCount = theFirst;
  _divider = theDivider;
} 

MeanCounter::MeanCounter( unsigned long int theFirst, unsigned long int theDivider ){
  init();
  _count = theFirst;
  _firstCount = theFirst;
  _divider = theDivider;
  printCount = true;
} 

void MeanCounter::setCounter( unsigned long int theCount ){
  _count = theCount;
}

void MeanCounter::setDivider( unsigned int theDivider ){
  _divider = theDivider;
}

void MeanCounter::setPrintCount( bool _printCount ){
  printCount = _printCount;
}

void MeanCounter::setNewLine( bool newLine ){
  _newLine = newLine;
}

void MeanCounter::setMessage( const char *message ){
  _message = message;
}

void MeanCounter::init( void ){
  _count = 0;
  _count_double_type = 0.0;
  _firstCount = 0;
  _divider = 1;
  printCount = false;
  firstCountEntry = true;
  _message = "processing entry #";
  _newLine = true;

  initTime = time( NULL );
  firstTickTime = 1;
  lastTickTime = 1;
  lastPrintTime = 1;

}

void MeanCounter::count( void ){

  _count++;

  double _number;
  double _freq;
  double _limit = 1./(double)_divider;

  _number = (double)_count;
  _freq = (double)_divider;

  if (firstCountEntry){
    //if ( printCount ) cout << "Counter is on:" << endl;
    firstCountEntry = false;
    firstTickTime = time( NULL );
  }

  if ( printCount ){
    if ( fmod( _number, _freq ) < _limit ){
      double averageTimeSinceLastPrint = 0.0;
      double averageTimeSinceFirstTick = 0.0;
      if ( lastPrintTime > 1 )
        {
          averageTimeSinceLastPrint = ( time( NULL ) - lastPrintTime ) / (double)_divider;
        }
      if ( _count > _firstCount )
        {
          averageTimeSinceFirstTick = ( time( NULL ) - firstTickTime ) / (double)( _count - _firstCount );
        }
      if ( !_newLine )
        {
          cout << char(13) << _message . c_str() << _count;
          if ( _count > _firstCount ) cout << ", average time per count, sec: " << averageTimeSinceFirstTick;
          fflush(stdout);
        }
      else
        {
          cout << _message . c_str() << _count;
          if ( _count > _firstCount ) cout << ", average time per count, sec: " << averageTimeSinceFirstTick;
          cout << endl;
        }
      lastPrintTime = time( NULL );
    }
  }
  
  lastTickTime = time( NULL );
}

unsigned long int MeanCounter::getCount( void ){
  return _count;
}

double MeanCounter::getCountDouble( void ){
  return _count_double_type;
}

void MeanCounter::increment( long int _incr ){
  _count += _incr;
}

void MeanCounter::incrementDouble( double _incr ){
  _count_double_type += _incr;
}

MeanCounter::~MeanCounter(){
}

time_t MeanCounter::chime(std::string message){
  time_t result = time(NULL) - lastTickTime;
  if (message.size()>0){
    cout << message << result << endl;
  }
  else{
    cout << "Time passed since the last tick: " << result << endl;
  }
  return result;
}

void MeanCounter::set_times_mark(void){
  static struct tms t_cpu;
  time_mark = times(&t_cpu);
}

clock_t MeanCounter::get_times_diff(void){
  static struct tms t_cpu;
  clock_t result = times(&t_cpu) - time_mark;
  return result;
}


clock_t MeanCounter::get_times(void){
  static struct tms t_cpu;
  clock_t result = times(&t_cpu);
  return result;
}

void MeanCounter::start_clock(){
  st_time = times(&st_cpu);
}

/* This example assumes that the result of each subtraction
   is within the range of values that can be represented in
   an integer type. */
void MeanCounter::end_clock(char *msg){
  en_time = times(&en_cpu);
  
  fputs(msg,stdout);
  printf("Real Time: %jd, User Time %jd, System Time %jd\n",
         (intmax_t)(en_time - st_time),
         (intmax_t)(en_cpu.tms_utime - st_cpu.tms_utime),
         (intmax_t)(en_cpu.tms_stime - st_cpu.tms_stime));
}
Revision:	1.1
Committed:	Fri Oct 9 19:56:45 2009 UTC (15 years, 6 months ago) by kukartse
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V00-00-02, V00-00-01_BeamSplash09, gak110409, HEAD
Error occurred while calculating annotation data.
Log Message:	* empty log message *
#	Content
1	//
2	#include "LJMet/Utils/interface/MeanCounter.h"
3
4	#include <iostream>
5	#include <math.h>
6	using std::cout;
7	using std::endl;
8	using std::ostream;
9
10	//ClassImp(MeanCounter)
11
12	MeanCounter::MeanCounter(){
13	init();
14	}
15
16	MeanCounter::MeanCounter( const char *message, unsigned long int theFirst, unsigned long int theDivider ){
17	init();
18	_message = message;
19	if ( _message . length() == 0 ) printCount = false;
20	else printCount = true;
21	_count = theFirst;
22	_firstCount = theFirst;
23	_divider = theDivider;
24	}
25
26	MeanCounter::MeanCounter( unsigned long int theFirst, unsigned long int theDivider ){
27	init();
28	_count = theFirst;
29	_firstCount = theFirst;
30	_divider = theDivider;
31	printCount = true;
32	}
33
34	void MeanCounter::setCounter( unsigned long int theCount ){
35	_count = theCount;
36	}
37
38	void MeanCounter::setDivider( unsigned int theDivider ){
39	_divider = theDivider;
40	}
41
42	void MeanCounter::setPrintCount( bool _printCount ){
43	printCount = _printCount;
44	}
45
46	void MeanCounter::setNewLine( bool newLine ){
47	_newLine = newLine;
48	}
49
50	void MeanCounter::setMessage( const char *message ){
51	_message = message;
52	}
53
54	void MeanCounter::init( void ){
55	_count = 0;
56	_count_double_type = 0.0;
57	_firstCount = 0;
58	_divider = 1;
59	printCount = false;
60	firstCountEntry = true;
61	_message = "processing entry #";
62	_newLine = true;
63
64	initTime = time( NULL );
65	firstTickTime = 1;
66	lastTickTime = 1;
67	lastPrintTime = 1;
68
69	}
70
71	void MeanCounter::count( void ){
72
73	_count++;
74
75	double _number;
76	double _freq;
77	double _limit = 1./(double)_divider;
78
79	_number = (double)_count;
80	_freq = (double)_divider;
81
82	if (firstCountEntry){
83	//if ( printCount ) cout << "Counter is on:" << endl;
84	firstCountEntry = false;
85	firstTickTime = time( NULL );
86	}
87
88	if ( printCount ){
89	if ( fmod( _number, _freq ) < _limit ){
90	double averageTimeSinceLastPrint = 0.0;
91	double averageTimeSinceFirstTick = 0.0;
92	if ( lastPrintTime > 1 )
93	{
94	averageTimeSinceLastPrint = ( time( NULL ) - lastPrintTime ) / (double)_divider;
95	}
96	if ( _count > _firstCount )
97	{
98	averageTimeSinceFirstTick = ( time( NULL ) - firstTickTime ) / (double)( _count - _firstCount );
99	}
100	if ( !_newLine )
101	{
102	cout << char(13) << _message . c_str() << _count;
103	if ( _count > _firstCount ) cout << ", average time per count, sec: " << averageTimeSinceFirstTick;
104	fflush(stdout);
105	}
106	else
107	{
108	cout << _message . c_str() << _count;
109	if ( _count > _firstCount ) cout << ", average time per count, sec: " << averageTimeSinceFirstTick;
110	cout << endl;
111	}
112	lastPrintTime = time( NULL );
113	}
114	}
115
116	lastTickTime = time( NULL );
117	}
118
119	unsigned long int MeanCounter::getCount( void ){
120	return _count;
121	}
122
123	double MeanCounter::getCountDouble( void ){
124	return _count_double_type;
125	}
126
127	void MeanCounter::increment( long int _incr ){
128	_count += _incr;
129	}
130
131	void MeanCounter::incrementDouble( double _incr ){
132	_count_double_type += _incr;
133	}
134
135	MeanCounter::~MeanCounter(){
136	}
137
138	time_t MeanCounter::chime(std::string message){
139	time_t result = time(NULL) - lastTickTime;
140	if (message.size()>0){
141	cout << message << result << endl;
142	}
143	else{
144	cout << "Time passed since the last tick: " << result << endl;
145	}
146	return result;
147	}
148
149	void MeanCounter::set_times_mark(void){
150	static struct tms t_cpu;
151	time_mark = times(&t_cpu);
152	}
153
154	clock_t MeanCounter::get_times_diff(void){
155	static struct tms t_cpu;
156	clock_t result = times(&t_cpu) - time_mark;
157	return result;
158	}
159
160
161	clock_t MeanCounter::get_times(void){
162	static struct tms t_cpu;
163	clock_t result = times(&t_cpu);
164	return result;
165	}
166
167	void MeanCounter::start_clock(){
168	st_time = times(&st_cpu);
169	}
170
171	/* This example assumes that the result of each subtraction
172	is within the range of values that can be represented in
173	an integer type. */
174	void MeanCounter::end_clock(char *msg){
175	en_time = times(&en_cpu);
176
177	fputs(msg,stdout);
178	printf("Real Time: %jd, User Time %jd, System Time %jd\n",
179	(intmax_t)(en_time - st_time),
180	(intmax_t)(en_cpu.tms_utime - st_cpu.tms_utime),
181	(intmax_t)(en_cpu.tms_stime - st_cpu.tms_stime));
182	}