blob: 404da5ce8bd8b8626400e7f84c97afabc0b0d9e3 (
plain)
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
150
|
/*
* (C) 2018 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#include <botan/internal/timer.h>
#include <botan/internal/os_utils.h>
#include <algorithm>
#include <sstream>
#include <iomanip>
namespace Botan {
void Timer::start()
{
stop();
m_timer_start = OS::get_system_timestamp_ns();
m_cpu_cycles_start = OS::get_cpu_cycle_counter();
}
void Timer::stop()
{
if(m_timer_start)
{
if(m_cpu_cycles_start != 0)
{
const uint64_t cycles_taken = OS::get_cpu_cycle_counter() - m_cpu_cycles_start;
if(cycles_taken > 0)
{
m_cpu_cycles_used += static_cast<size_t>(cycles_taken * m_clock_cycle_ratio);
}
}
const uint64_t now = OS::get_system_timestamp_ns();
if(now > m_timer_start)
{
const uint64_t dur = now - m_timer_start;
m_time_used += dur;
if(m_event_count == 0)
{
m_min_time = m_max_time = dur;
}
else
{
m_max_time = std::max(m_max_time, dur);
m_min_time = std::min(m_min_time, dur);
}
}
m_timer_start = 0;
++m_event_count;
}
}
bool Timer::operator<(const Timer& other) const
{
if(this->doing() != other.doing())
return (this->doing() < other.doing());
return (this->get_name() < other.get_name());
}
std::string Timer::to_string() const
{
if(m_custom_msg.size() > 0)
{
return m_custom_msg;
}
else if(this->buf_size() == 0)
{
return result_string_ops();
}
else
{
return result_string_bps();
}
}
std::string Timer::result_string_bps() const
{
const size_t MiB = 1024 * 1024;
const double MiB_total = static_cast<double>(events()) / MiB;
const double MiB_per_sec = MiB_total / seconds();
std::ostringstream oss;
oss << get_name();
if(!doing().empty())
{
oss << " " << doing();
}
if(buf_size() > 0)
{
oss << " buffer size " << buf_size() << " bytes:";
}
if(events() == 0)
oss << " " << "N/A";
else
oss << " " << std::fixed << std::setprecision(3) << MiB_per_sec << " MiB/sec";
if(cycles_consumed() != 0)
{
const double cycles_per_byte = static_cast<double>(cycles_consumed()) / events();
oss << " " << std::fixed << std::setprecision(2) << cycles_per_byte << " cycles/byte";
}
oss << " (" << MiB_total << " MiB in " << milliseconds() << " ms)\n";
return oss.str();
}
std::string Timer::result_string_ops() const
{
std::ostringstream oss;
oss << get_name() << " ";
if(events() == 0)
{
oss << "no events\n";
}
else
{
oss << static_cast<uint64_t>(events_per_second())
<< ' ' << doing() << "/sec; "
<< std::setprecision(2) << std::fixed
<< ms_per_event() << " ms/op";
if(cycles_consumed() != 0)
{
const double cycles_per_op = static_cast<double>(cycles_consumed()) / events();
const int precision = (cycles_per_op < 10000) ? 2 : 0;
oss << " " << std::fixed << std::setprecision(precision) << cycles_per_op << " cycles/op";
}
oss << " (" << events() << " " << (events() == 1 ? "op" : "ops")
<< " in " << milliseconds() << " ms)\n";
}
return oss.str();
}
}
|
