1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
//
// Copyright (C) : 2004,2005,2006,2007,2008,2009,2010
// Synchrotron SOLEIL
// L'Orme des Merisiers
// Saint-Aubin - BP 48 - France
//
// This file is part of log4tango.
//
// Log4ango is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Log4tango 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Log4Tango. If not, see <http://www.gnu.org/licenses/>.
#include <cstdlib>
#ifdef WIN32
#include <windows.h>
/* FILETIME of Jan 1 1970 00:00:00. */
static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
/*
* timezone information is stored outside the kernel so tzp isn't used anymore.
*
* Note: this function is not for Win32 high precision timing purpose. See
* elapsed_time().
*/
int gettimeofday(struct timeval *tp, struct timezone *tzp)
{
FILETIME file_time;
SYSTEMTIME system_time;
ULARGE_INTEGER ularge;
GetSystemTime(&system_time);
SystemTimeToFileTime(&system_time, &file_time);
ularge.LowPart = file_time.dwLowDateTime;
ularge.HighPart = file_time.dwHighDateTime;
tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
return 0;
}
#else
#include <sys/time.h> // for struct timeval
#endif
#ifdef __osf__
#include <machine/builtins.h> // for __RPCC()
#elif __linux__ && __i386__
#define rdtscl(low) __asm__ __volatile__("rdtsc" : "=a"(low) : : "edx")
#endif
#include <iostream>
#include "clock.h"
namespace
{
const usec_t UsecPerSec = INT64_CONSTANT(1000000);
}
bool Clock::UsingCPU = std::getenv("CLOCK_USE_CPU") ? true : false;
// -----------------------------------------------------------------------------
usec_t Clock::time(void)
{
if(UsingCPU)
{
static bool warn = true;
if(warn)
{
std::cout << "Using CPU clock." << std::endl;
warn = false;
}
#ifdef __osf__
return (usec_t) __RPCC();
#elif __linux__ && __i386__
{
unsigned long tsc;
rdtscl(tsc);
return (usec_t) tsc;
}
#else
{
std::cerr << "CPU clock not implemented for this architecture" << std::endl;
UsingCPU = false;
return Clock::time();
}
#endif
}
else
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (usec_t) (tv.tv_sec * UsecPerSec + tv.tv_usec);
}
}
// -----------------------------------------------------------------------------
Clock::Clock(void) :
_start(0),
_elapsed(0),
_active(false)
{
start();
}
// -----------------------------------------------------------------------------
Clock::~Clock(void)
{
;
}
// -----------------------------------------------------------------------------
usec_t Clock::elapsed(void) const
{
if(!active())
{
return _elapsed;
}
return time() - _start;
}
// -----------------------------------------------------------------------------
usec_t Clock::start(void)
{
_active = true;
return _start = time();
}
// -----------------------------------------------------------------------------
usec_t Clock::stop(void)
{
_elapsed = elapsed();
_active = false;
return _elapsed;
}
|
