1 | #include "string_util.h" |
2 | |
3 | #include <array> |
4 | #ifdef BENCHMARK_STL_ANDROID_GNUSTL |
5 | #include <cerrno> |
6 | #endif |
7 | #include <cmath> |
8 | #include <cstdarg> |
9 | #include <cstdio> |
10 | #include <memory> |
11 | #include <sstream> |
12 | |
13 | #include "arraysize.h" |
14 | |
15 | namespace benchmark { |
16 | namespace { |
17 | |
18 | // kilo, Mega, Giga, Tera, Peta, Exa, Zetta, Yotta. |
19 | const char kBigSIUnits[] = "kMGTPEZY" ; |
20 | // Kibi, Mebi, Gibi, Tebi, Pebi, Exbi, Zebi, Yobi. |
21 | const char kBigIECUnits[] = "KMGTPEZY" ; |
22 | // milli, micro, nano, pico, femto, atto, zepto, yocto. |
23 | const char kSmallSIUnits[] = "munpfazy" ; |
24 | |
25 | // We require that all three arrays have the same size. |
26 | static_assert(arraysize(kBigSIUnits) == arraysize(kBigIECUnits), |
27 | "SI and IEC unit arrays must be the same size" ); |
28 | static_assert(arraysize(kSmallSIUnits) == arraysize(kBigSIUnits), |
29 | "Small SI and Big SI unit arrays must be the same size" ); |
30 | |
31 | static const int64_t kUnitsSize = arraysize(kBigSIUnits); |
32 | |
33 | void ToExponentAndMantissa(double val, double thresh, int precision, |
34 | double one_k, std::string* mantissa, |
35 | int64_t* exponent) { |
36 | std::stringstream mantissa_stream; |
37 | |
38 | if (val < 0) { |
39 | mantissa_stream << "-" ; |
40 | val = -val; |
41 | } |
42 | |
43 | // Adjust threshold so that it never excludes things which can't be rendered |
44 | // in 'precision' digits. |
45 | const double adjusted_threshold = |
46 | std::max(thresh, 1.0 / std::pow(10.0, precision)); |
47 | const double big_threshold = adjusted_threshold * one_k; |
48 | const double small_threshold = adjusted_threshold; |
49 | // Values in ]simple_threshold,small_threshold[ will be printed as-is |
50 | const double simple_threshold = 0.01; |
51 | |
52 | if (val > big_threshold) { |
53 | // Positive powers |
54 | double scaled = val; |
55 | for (size_t i = 0; i < arraysize(kBigSIUnits); ++i) { |
56 | scaled /= one_k; |
57 | if (scaled <= big_threshold) { |
58 | mantissa_stream << scaled; |
59 | *exponent = i + 1; |
60 | *mantissa = mantissa_stream.str(); |
61 | return; |
62 | } |
63 | } |
64 | mantissa_stream << val; |
65 | *exponent = 0; |
66 | } else if (val < small_threshold) { |
67 | // Negative powers |
68 | if (val < simple_threshold) { |
69 | double scaled = val; |
70 | for (size_t i = 0; i < arraysize(kSmallSIUnits); ++i) { |
71 | scaled *= one_k; |
72 | if (scaled >= small_threshold) { |
73 | mantissa_stream << scaled; |
74 | *exponent = -static_cast<int64_t>(i + 1); |
75 | *mantissa = mantissa_stream.str(); |
76 | return; |
77 | } |
78 | } |
79 | } |
80 | mantissa_stream << val; |
81 | *exponent = 0; |
82 | } else { |
83 | mantissa_stream << val; |
84 | *exponent = 0; |
85 | } |
86 | *mantissa = mantissa_stream.str(); |
87 | } |
88 | |
89 | std::string ExponentToPrefix(int64_t exponent, bool iec) { |
90 | if (exponent == 0) return "" ; |
91 | |
92 | const int64_t index = (exponent > 0 ? exponent - 1 : -exponent - 1); |
93 | if (index >= kUnitsSize) return "" ; |
94 | |
95 | const char* array = |
96 | (exponent > 0 ? (iec ? kBigIECUnits : kBigSIUnits) : kSmallSIUnits); |
97 | if (iec) |
98 | return array[index] + std::string("i" ); |
99 | else |
100 | return std::string(1, array[index]); |
101 | } |
102 | |
103 | std::string ToBinaryStringFullySpecified(double value, double threshold, |
104 | int precision, double one_k = 1024.0) { |
105 | std::string mantissa; |
106 | int64_t exponent; |
107 | ToExponentAndMantissa(value, threshold, precision, one_k, &mantissa, |
108 | &exponent); |
109 | return mantissa + ExponentToPrefix(exponent, false); |
110 | } |
111 | |
112 | } // end namespace |
113 | |
114 | void AppendHumanReadable(int n, std::string* str) { |
115 | std::stringstream ss; |
116 | // Round down to the nearest SI prefix. |
117 | ss << ToBinaryStringFullySpecified(n, 1.0, 0); |
118 | *str += ss.str(); |
119 | } |
120 | |
121 | std::string HumanReadableNumber(double n, double one_k) { |
122 | // 1.1 means that figures up to 1.1k should be shown with the next unit down; |
123 | // this softens edge effects. |
124 | // 1 means that we should show one decimal place of precision. |
125 | return ToBinaryStringFullySpecified(n, 1.1, 1, one_k); |
126 | } |
127 | |
128 | std::string StrFormatImp(const char* msg, va_list args) { |
129 | // we might need a second shot at this, so pre-emptivly make a copy |
130 | va_list args_cp; |
131 | va_copy(args_cp, args); |
132 | |
133 | // TODO(ericwf): use std::array for first attempt to avoid one memory |
134 | // allocation guess what the size might be |
135 | std::array<char, 256> local_buff; |
136 | std::size_t size = local_buff.size(); |
137 | // 2015-10-08: vsnprintf is used instead of snd::vsnprintf due to a limitation |
138 | // in the android-ndk |
139 | auto ret = vsnprintf(local_buff.data(), size, msg, args_cp); |
140 | |
141 | va_end(args_cp); |
142 | |
143 | // handle empty expansion |
144 | if (ret == 0) return std::string{}; |
145 | if (static_cast<std::size_t>(ret) < size) |
146 | return std::string(local_buff.data()); |
147 | |
148 | // we did not provide a long enough buffer on our first attempt. |
149 | // add 1 to size to account for null-byte in size cast to prevent overflow |
150 | size = static_cast<std::size_t>(ret) + 1; |
151 | auto buff_ptr = std::unique_ptr<char[]>(new char[size]); |
152 | // 2015-10-08: vsnprintf is used instead of snd::vsnprintf due to a limitation |
153 | // in the android-ndk |
154 | vsnprintf(buff_ptr.get(), size, msg, args); |
155 | return std::string(buff_ptr.get()); |
156 | } |
157 | |
158 | std::string StrFormat(const char* format, ...) { |
159 | va_list args; |
160 | va_start(args, format); |
161 | std::string tmp = StrFormatImp(format, args); |
162 | va_end(args); |
163 | return tmp; |
164 | } |
165 | |
166 | std::vector<std::string> StrSplit(const std::string& str, char delim) { |
167 | if (str.empty()) return {}; |
168 | std::vector<std::string> ret; |
169 | size_t first = 0; |
170 | size_t next = str.find(delim); |
171 | for (; next != std::string::npos; |
172 | first = next + 1, next = str.find(delim, first)) { |
173 | ret.push_back(str.substr(first, next - first)); |
174 | } |
175 | ret.push_back(str.substr(first)); |
176 | return ret; |
177 | } |
178 | |
179 | #ifdef BENCHMARK_STL_ANDROID_GNUSTL |
180 | /* |
181 | * GNU STL in Android NDK lacks support for some C++11 functions, including |
182 | * stoul, stoi, stod. We reimplement them here using C functions strtoul, |
183 | * strtol, strtod. Note that reimplemented functions are in benchmark:: |
184 | * namespace, not std:: namespace. |
185 | */ |
186 | unsigned long stoul(const std::string& str, size_t* pos, int base) { |
187 | /* Record previous errno */ |
188 | const int oldErrno = errno; |
189 | errno = 0; |
190 | |
191 | const char* strStart = str.c_str(); |
192 | char* strEnd = const_cast<char*>(strStart); |
193 | const unsigned long result = strtoul(strStart, &strEnd, base); |
194 | |
195 | const int strtoulErrno = errno; |
196 | /* Restore previous errno */ |
197 | errno = oldErrno; |
198 | |
199 | /* Check for errors and return */ |
200 | if (strtoulErrno == ERANGE) { |
201 | throw std::out_of_range("stoul failed: " + str + |
202 | " is outside of range of unsigned long" ); |
203 | } else if (strEnd == strStart || strtoulErrno != 0) { |
204 | throw std::invalid_argument("stoul failed: " + str + " is not an integer" ); |
205 | } |
206 | if (pos != nullptr) { |
207 | *pos = static_cast<size_t>(strEnd - strStart); |
208 | } |
209 | return result; |
210 | } |
211 | |
212 | int stoi(const std::string& str, size_t* pos, int base) { |
213 | /* Record previous errno */ |
214 | const int oldErrno = errno; |
215 | errno = 0; |
216 | |
217 | const char* strStart = str.c_str(); |
218 | char* strEnd = const_cast<char*>(strStart); |
219 | const long result = strtol(strStart, &strEnd, base); |
220 | |
221 | const int strtolErrno = errno; |
222 | /* Restore previous errno */ |
223 | errno = oldErrno; |
224 | |
225 | /* Check for errors and return */ |
226 | if (strtolErrno == ERANGE || long(int(result)) != result) { |
227 | throw std::out_of_range("stoul failed: " + str + |
228 | " is outside of range of int" ); |
229 | } else if (strEnd == strStart || strtolErrno != 0) { |
230 | throw std::invalid_argument("stoul failed: " + str + " is not an integer" ); |
231 | } |
232 | if (pos != nullptr) { |
233 | *pos = static_cast<size_t>(strEnd - strStart); |
234 | } |
235 | return int(result); |
236 | } |
237 | |
238 | double stod(const std::string& str, size_t* pos) { |
239 | /* Record previous errno */ |
240 | const int oldErrno = errno; |
241 | errno = 0; |
242 | |
243 | const char* strStart = str.c_str(); |
244 | char* strEnd = const_cast<char*>(strStart); |
245 | const double result = strtod(strStart, &strEnd); |
246 | |
247 | /* Restore previous errno */ |
248 | const int strtodErrno = errno; |
249 | errno = oldErrno; |
250 | |
251 | /* Check for errors and return */ |
252 | if (strtodErrno == ERANGE) { |
253 | throw std::out_of_range("stoul failed: " + str + |
254 | " is outside of range of int" ); |
255 | } else if (strEnd == strStart || strtodErrno != 0) { |
256 | throw std::invalid_argument("stoul failed: " + str + " is not an integer" ); |
257 | } |
258 | if (pos != nullptr) { |
259 | *pos = static_cast<size_t>(strEnd - strStart); |
260 | } |
261 | return result; |
262 | } |
263 | #endif |
264 | |
265 | } // end namespace benchmark |
266 | |