]> git.proxmox.com Git - ceph.git/blob - ceph/src/rapidjson/test/perftest/misctest.cpp
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
buildsys: change download over to reef release
[ceph.git] / ceph / src / rapidjson / test / perftest / misctest.cpp
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14
15 #include "perftest.h"
16
17 #if TEST_MISC
18
19 #define __STDC_FORMAT_MACROS
20 #include "rapidjson/stringbuffer.h"
21
22 #define protected public
23 #include "rapidjson/writer.h"
24 #undef private
25
26 class Misc : public PerfTest {
27 };
28
29 // Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
30 // See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
31
32 #define UTF8_ACCEPT 0
33 #define UTF8_REJECT 12
34
35 static const unsigned char utf8d[] = {
36 // The first part of the table maps bytes to character classes that
37 // to reduce the size of the transition table and create bitmasks.
38 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
39 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
40 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
41 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
42 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
43 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
44 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
45 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
46
47 // The second part is a transition table that maps a combination
48 // of a state of the automaton and a character class to a state.
49 0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
50 12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
51 12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
52 12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
53 12,36,12,12,12,12,12,12,12,12,12,12,
54 };
55
56 static unsigned inline decode(unsigned* state, unsigned* codep, unsigned byte) {
57 unsigned type = utf8d[byte];
58
59 *codep = (*state != UTF8_ACCEPT) ?
60 (byte & 0x3fu) | (*codep << 6) :
61 (0xff >> type) & (byte);
62
63 *state = utf8d[256 + *state + type];
64 return *state;
65 }
66
67 static bool IsUTF8(unsigned char* s) {
68 unsigned codepoint, state = 0;
69
70 while (*s)
71 decode(&state, &codepoint, *s++);
72
73 return state == UTF8_ACCEPT;
74 }
75
76 TEST_F(Misc, Hoehrmann_IsUTF8) {
77 for (size_t i = 0; i < kTrialCount; i++) {
78 EXPECT_TRUE(IsUTF8((unsigned char*)json_));
79 }
80 }
81
82 ////////////////////////////////////////////////////////////////////////////////
83 // CountDecimalDigit: Count number of decimal places
84
85 inline unsigned CountDecimalDigit_naive(unsigned n) {
86 unsigned count = 1;
87 while (n >= 10) {
88 n /= 10;
89 count++;
90 }
91 return count;
92 }
93
94 inline unsigned CountDecimalDigit_enroll4(unsigned n) {
95 unsigned count = 1;
96 while (n >= 10000) {
97 n /= 10000u;
98 count += 4;
99 }
100 if (n < 10) return count;
101 if (n < 100) return count + 1;
102 if (n < 1000) return count + 2;
103 return count + 3;
104 }
105
106 inline unsigned CountDecimalDigit64_enroll4(uint64_t n) {
107 unsigned count = 1;
108 while (n >= 10000) {
109 n /= 10000u;
110 count += 4;
111 }
112 if (n < 10) return count;
113 if (n < 100) return count + 1;
114 if (n < 1000) return count + 2;
115 return count + 3;
116 }
117
118 inline unsigned CountDecimalDigit_fast(unsigned n) {
119 static const uint32_t powers_of_10[] = {
120 0,
121 10,
122 100,
123 1000,
124 10000,
125 100000,
126 1000000,
127 10000000,
128 100000000,
129 1000000000
130 };
131
132 #if defined(_M_IX86) || defined(_M_X64)
133 unsigned long i = 0;
134 _BitScanReverse(&i, n | 1);
135 uint32_t t = (i + 1) * 1233 >> 12;
136 #elif defined(__GNUC__)
137 uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
138 #else
139 #error
140 #endif
141 return t - (n < powers_of_10[t]) + 1;
142 }
143
144 inline unsigned CountDecimalDigit64_fast(uint64_t n) {
145 static const uint64_t powers_of_10[] = {
146 0,
147 10,
148 100,
149 1000,
150 10000,
151 100000,
152 1000000,
153 10000000,
154 100000000,
155 1000000000,
156 10000000000,
157 100000000000,
158 1000000000000,
159 10000000000000,
160 100000000000000,
161 1000000000000000,
162 10000000000000000,
163 100000000000000000,
164 1000000000000000000,
165 10000000000000000000U
166 };
167
168 #if defined(_M_IX86)
169 uint64_t m = n | 1;
170 unsigned long i = 0;
171 if (_BitScanReverse(&i, m >> 32))
172 i += 32;
173 else
174 _BitScanReverse(&i, m & 0xFFFFFFFF);
175 uint32_t t = (i + 1) * 1233 >> 12;
176 #elif defined(_M_X64)
177 unsigned long i = 0;
178 _BitScanReverse64(&i, n | 1);
179 uint32_t t = (i + 1) * 1233 >> 12;
180 #elif defined(__GNUC__)
181 uint32_t t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12;
182 #else
183 #error
184 #endif
185
186 return t - (n < powers_of_10[t]) + 1;
187 }
188
189 #if 0
190 // Exhaustive, very slow
191 TEST_F(Misc, CountDecimalDigit_Verify) {
192 unsigned i = 0;
193 do {
194 if (i % (65536 * 256) == 0)
195 printf("%u\n", i);
196 ASSERT_EQ(CountDecimalDigit_enroll4(i), CountDecimalDigit_fast(i));
197 i++;
198 } while (i != 0);
199 }
200
201 static const unsigned kDigits10Trial = 1000000000u;
202 TEST_F(Misc, CountDecimalDigit_naive) {
203 unsigned sum = 0;
204 for (unsigned i = 0; i < kDigits10Trial; i++)
205 sum += CountDecimalDigit_naive(i);
206 printf("%u\n", sum);
207 }
208
209 TEST_F(Misc, CountDecimalDigit_enroll4) {
210 unsigned sum = 0;
211 for (unsigned i = 0; i < kDigits10Trial; i++)
212 sum += CountDecimalDigit_enroll4(i);
213 printf("%u\n", sum);
214 }
215
216 TEST_F(Misc, CountDecimalDigit_fast) {
217 unsigned sum = 0;
218 for (unsigned i = 0; i < kDigits10Trial; i++)
219 sum += CountDecimalDigit_fast(i);
220 printf("%u\n", sum);
221 }
222 #endif
223
224 TEST_F(Misc, CountDecimalDigit64_VerifyFast) {
225 uint64_t i = 1, j;
226 do {
227 //printf("%" PRIu64 "\n", i);
228 ASSERT_EQ(CountDecimalDigit64_enroll4(i), CountDecimalDigit64_fast(i));
229 j = i;
230 i *= 3;
231 } while (j < i);
232 }
233
234 ////////////////////////////////////////////////////////////////////////////////
235 // integer-to-string conversion
236
237 // https://gist.github.com/anonymous/7179097
238 static const int randval[] ={
239 936116, 369532, 453755, -72860, 209713, 268347, 435278, -360266, -416287, -182064,
240 -644712, 944969, 640463, -366588, 471577, -69401, -744294, -505829, 923883, 831785,
241 -601136, -636767, -437054, 591718, 100758, 231907, -719038, 973540, -605220, 506659,
242 -871653, 462533, 764843, -919138, 404305, -630931, -288711, -751454, -173726, -718208,
243 432689, -281157, 360737, 659827, 19174, -376450, 769984, -858198, 439127, 734703,
244 -683426, 7, 386135, 186997, -643900, -744422, -604708, -629545, 42313, -933592,
245 -635566, 182308, 439024, -367219, -73924, -516649, 421935, -470515, 413507, -78952,
246 -427917, -561158, 737176, 94538, 572322, 405217, 709266, -357278, -908099, -425447,
247 601119, 750712, -862285, -177869, 900102, 384877, 157859, -641680, 503738, -702558,
248 278225, 463290, 268378, -212840, 580090, 347346, -473985, -950968, -114547, -839893,
249 -738032, -789424, 409540, 493495, 432099, 119755, 905004, -174834, 338266, 234298,
250 74641, -965136, -754593, 685273, 466924, 920560, 385062, 796402, -67229, 994864,
251 376974, 299869, -647540, -128724, 469890, -163167, -547803, -743363, 486463, -621028,
252 612288, 27459, -514224, 126342, -66612, 803409, -777155, -336453, -284002, 472451,
253 342390, -163630, 908356, -456147, -825607, 268092, -974715, 287227, 227890, -524101,
254 616370, -782456, 922098, -624001, -813690, 171605, -192962, 796151, 707183, -95696,
255 -23163, -721260, 508892, 430715, 791331, 482048, -996102, 863274, 275406, -8279,
256 -556239, -902076, 268647, -818565, 260069, -798232, -172924, -566311, -806503, -885992,
257 813969, -78468, 956632, 304288, 494867, -508784, 381751, 151264, 762953, 76352,
258 594902, 375424, 271700, -743062, 390176, 924237, 772574, 676610, 435752, -153847,
259 3959, -971937, -294181, -538049, -344620, -170136, 19120, -703157, 868152, -657961,
260 -818631, 219015, -872729, -940001, -956570, 880727, -345910, 942913, -942271, -788115,
261 225294, 701108, -517736, -416071, 281940, 488730, 942698, 711494, 838382, -892302,
262 -533028, 103052, 528823, 901515, 949577, 159364, 718227, -241814, -733661, -462928,
263 -495829, 165170, 513580, -629188, -509571, -459083, 198437, 77198, -644612, 811276,
264 -422298, -860842, -52584, 920369, 686424, -530667, -243476, 49763, 345866, -411960,
265 -114863, 470810, -302860, 683007, -509080, 2, -174981, -772163, -48697, 447770,
266 -268246, 213268, 269215, 78810, -236340, -639140, -864323, 505113, -986569, -325215,
267 541859, 163070, -819998, -645161, -583336, 573414, 696417, -132375, 3, -294501,
268 320435, 682591, 840008, 351740, 426951, 609354, 898154, -943254, 227321, -859793,
269 -727993, 44137, -497965, -782239, 14955, -746080, -243366, 9837, -233083, 606507,
270 -995864, -615287, -994307, 602715, 770771, -315040, 610860, 446102, -307120, 710728,
271 -590392, -230474, -762625, -637525, 134963, -202700, -766902, -985541, 218163, 682009,
272 926051, 525156, -61195, 403211, -810098, 245539, -431733, 179998, -806533, 745943,
273 447597, 131973, -187130, 826019, 286107, -937230, -577419, 20254, 681802, -340500,
274 323080, 266283, -667617, 309656, 416386, 611863, 759991, -534257, 523112, -634892,
275 -169913, -204905, -909867, -882185, -944908, 741811, -717675, 967007, -317396, 407230,
276 -412805, 792905, 994873, 744793, -456797, 713493, 355232, 116900, -945199, 880539,
277 342505, -580824, -262273, 982968, -349497, -735488, 311767, -455191, 570918, 389734,
278 -958386, 10262, -99267, 155481, 304210, 204724, 704367, -144893, -233664, -671441,
279 896849, 408613, 762236, 322697, 981321, 688476, 13663, -970704, -379507, 896412,
280 977084, 348869, 875948, 341348, 318710, 512081, 6163, 669044, 833295, 811883,
281 708756, -802534, -536057, 608413, -389625, -694603, 541106, -110037, 720322, -540581,
282 645420, 32980, 62442, 510157, -981870, -87093, -325960, -500494, -718291, -67889,
283 991501, 374804, 769026, -978869, 294747, 714623, 413327, -199164, 671368, 804789,
284 -362507, 798196, -170790, -568895, -869379, 62020, -316693, -837793, 644994, -39341,
285 -417504, -243068, -957756, 99072, 622234, -739992, 225668, 8863, -505910, 82483,
286 -559244, 241572, 1315, -36175, -54990, 376813, -11, 162647, -688204, -486163,
287 -54934, -197470, 744223, -762707, 732540, 996618, 351561, -445933, -898491, 486531,
288 456151, 15276, 290186, -817110, -52995, 313046, -452533, -96267, 94470, -500176,
289 -818026, -398071, -810548, -143325, -819741, 1338, -897676, -101577, -855445, 37309,
290 285742, 953804, -777927, -926962, -811217, -936744, -952245, -802300, -490188, -964953,
291 -552279, 329142, -570048, -505756, 682898, -381089, -14352, 175138, 152390, -582268,
292 -485137, 717035, 805329, 239572, -730409, 209643, -184403, -385864, 675086, 819648,
293 629058, -527109, -488666, -171981, 532788, 552441, 174666, 984921, 766514, 758787,
294 716309, 338801, -978004, -412163, 876079, -734212, 789557, -160491, -522719, 56644,
295 -991, -286038, -53983, 663740, 809812, 919889, -717502, -137704, 220511, 184396,
296 -825740, -588447, 430870, 124309, 135956, 558662, -307087, -788055, -451328, 812260,
297 931601, 324347, -482989, -117858, -278861, 189068, -172774, 929057, 293787, 198161,
298 -342386, -47173, 906555, -759955, -12779, 777604, -97869, 899320, 927486, -25284,
299 -848550, 259450, -485856, -17820, 88, 171400, 235492, -326783, -340793, 886886,
300 112428, -246280, 5979, 648444, -114982, 991013, -56489, -9497, 419706, 632820,
301 -341664, 393926, -848977, -22538, 257307, 773731, -905319, 491153, 734883, -868212,
302 -951053, 644458, -580758, 764735, 584316, 297077, 28852, -397710, -953669, 201772,
303 879050, -198237, -588468, 448102, -116837, 770007, -231812, 642906, -582166, -885828,
304 9, 305082, -996577, 303559, 75008, -772956, -447960, 599825, -295552, 870739,
305 -386278, -950300, 485359, -457081, 629461, -850276, 550496, -451755, -620841, -11766,
306 -950137, 832337, 28711, -273398, -507197, 91921, -271360, -705991, -753220, -388968,
307 967945, 340434, -320883, -662793, -554617, -574568, 477946, -6148, -129519, 689217,
308 920020, -656315, -974523, -212525, 80921, -612532, 645096, 545655, 655713, -591631,
309 -307385, -816688, -618823, -113713, 526430, 673063, 735916, -809095, -850417, 639004,
310 432281, -388185, 270708, 860146, -39902, -786157, -258180, -246169, -966720, -264957,
311 548072, -306010, -57367, -635665, 933824, 70553, -989936, -488741, 72411, -452509,
312 529831, 956277, 449019, -577850, -360986, -803418, 48833, 296073, 203430, 609591,
313 715483, 470964, 658106, -718254, -96424, 790163, 334739, 181070, -373578, 5,
314 -435088, 329841, 330939, -256602, 394355, 912412, 231910, 927278, -661933, 788539,
315 -769664, -893274, -96856, 298205, 901043, -608122, -527430, 183618, -553963, -35246,
316 -393924, 948832, -483198, 594501, 35460, -407007, 93494, -336881, -634072, 984205,
317 -812161, 944664, -31062, 753872, 823933, -69566, 50445, 290147, 85134, 34706,
318 551902, 405202, -991246, -84642, 154341, 316432, -695101, -651588, -5030, 137564,
319 -294665, 332541, 528307, -90572, -344923, 523766, -758498, -968047, 339028, 494578,
320 593129, -725773, 31834, -718406, -208638, 159665, -2043, 673344, -442767, 75816,
321 755442, 769257, -158730, -410272, 691688, 589550, -878398, -184121, 460679, 346312,
322 294163, -544602, 653308, 254167, -276979, 52073, -892684, 887653, -41222, 983065,
323 -68258, -408799, -99069, -674069, -863635, -32890, 622757, -743862, 40872, -4837,
324 -967228, 522370, -903951, -818669, 524459, 514702, 925801, 20007, -299229, 579348,
325 626021, 430089, 348139, -562692, -607728, -130606, -928451, -424793, -458647, -448892,
326 -312230, 143337, 109746, 880042, -339658, -785614, 938995, 540916, 118429, 661351,
327 -402967, 404729, -40918, -976535, 743230, 713110, 440182, -381314, -499252, 74613,
328 193652, 912717, 491323, 583633, 324691, 459397, 281253, 195540, -2764, -888651,
329 892449, 132663, -478373, -430002, -314551, 527826, 247165, 557966, 554778, 481531,
330 -946634, 431685, -769059, -348371, 174046, 184597, -354867, 584422, 227390, -850397,
331 -542924, -849093, -737769, 325359, 736314, 269101, 767940, 674809, 81413, -447458,
332 445076, 189072, 906218, 502688, -718476, -863827, -731381, 100660, 623249, 710008,
333 572060, 922203, 685740, 55096, 263394, -243695, -353910, -516788, 388471, 455165,
334 844103, -643772, 363976, 268875, -899450, 104470, 104029, -238874, -274659, 732969,
335 -676443, 953291, -916289, -861849, -242344, 958083, -479593, -970395, 799831, 277841,
336 -243236, -283462, -201510, 166263, -259105, -575706, 878926, 891064, 895297, 655262,
337 -34807, -809833, -89281, 342585, 554920, 1, 902141, -333425, 139703, 852318,
338 -618438, 329498, -932596, -692836, -513372, 733656, -523411, 85779, 500478, -682697,
339 -502836, 138776, 156341, -420037, -557964, -556378, 710993, -50383, -877159, 916334,
340 132996, 583516, -603392, -111615, -12288, -780214, 476780, 123327, 137607, 519956,
341 745837, 17358, -158581, -53490
342 };
343 static const size_t randvalCount = sizeof(randval) / sizeof(randval[0]);
344 static const size_t kItoaTrialCount = 10000;
345
346 static const char digits[201] =
347 "0001020304050607080910111213141516171819"
348 "2021222324252627282930313233343536373839"
349 "4041424344454647484950515253545556575859"
350 "6061626364656667686970717273747576777879"
351 "8081828384858687888990919293949596979899";
352
353 // Prevent code being optimized out
354 //#define OUTPUT_LENGTH(length) printf("", length)
355 #define OUTPUT_LENGTH(length) printf("%u\n", (unsigned)length)
356
357 template<typename OutputStream>
358 class Writer1 {
359 public:
360 Writer1() : os_() {}
361 Writer1(OutputStream& os) : os_(&os) {}
362
363 void Reset(OutputStream& os) {
364 os_ = &os;
365 }
366
367 bool WriteInt(int i) {
368 if (i < 0) {
369 os_->Put('-');
370 i = -i;
371 }
372 return WriteUint((unsigned)i);
373 }
374
375 bool WriteUint(unsigned u) {
376 char buffer[10];
377 char *p = buffer;
378 do {
379 *p++ = char(u % 10) + '0';
380 u /= 10;
381 } while (u > 0);
382
383 do {
384 --p;
385 os_->Put(*p);
386 } while (p != buffer);
387 return true;
388 }
389
390 bool WriteInt64(int64_t i64) {
391 if (i64 < 0) {
392 os_->Put('-');
393 i64 = -i64;
394 }
395 WriteUint64((uint64_t)i64);
396 return true;
397 }
398
399 bool WriteUint64(uint64_t u64) {
400 char buffer[20];
401 char *p = buffer;
402 do {
403 *p++ = char(u64 % 10) + '0';
404 u64 /= 10;
405 } while (u64 > 0);
406
407 do {
408 --p;
409 os_->Put(*p);
410 } while (p != buffer);
411 return true;
412 }
413
414 private:
415 OutputStream* os_;
416 };
417
418 template<>
419 bool Writer1<rapidjson::StringBuffer>::WriteUint(unsigned u) {
420 char buffer[10];
421 char* p = buffer;
422 do {
423 *p++ = char(u % 10) + '0';
424 u /= 10;
425 } while (u > 0);
426
427 char* d = os_->Push(p - buffer);
428 do {
429 --p;
430 *d++ = *p;
431 } while (p != buffer);
432 return true;
433 }
434
435 // Using digits LUT to reduce divsion/modulo
436 template<typename OutputStream>
437 class Writer2 {
438 public:
439 Writer2() : os_() {}
440 Writer2(OutputStream& os) : os_(&os) {}
441
442 void Reset(OutputStream& os) {
443 os_ = &os;
444 }
445
446 bool WriteInt(int i) {
447 if (i < 0) {
448 os_->Put('-');
449 i = -i;
450 }
451 return WriteUint((unsigned)i);
452 }
453
454 bool WriteUint(unsigned u) {
455 char buffer[10];
456 char* p = buffer;
457 while (u >= 100) {
458 const unsigned i = (u % 100) << 1;
459 u /= 100;
460 *p++ = digits[i + 1];
461 *p++ = digits[i];
462 }
463 if (u < 10)
464 *p++ = char(u) + '0';
465 else {
466 const unsigned i = u << 1;
467 *p++ = digits[i + 1];
468 *p++ = digits[i];
469 }
470
471 do {
472 --p;
473 os_->Put(*p);
474 } while (p != buffer);
475 return true;
476 }
477
478 bool WriteInt64(int64_t i64) {
479 if (i64 < 0) {
480 os_->Put('-');
481 i64 = -i64;
482 }
483 WriteUint64((uint64_t)i64);
484 return true;
485 }
486
487 bool WriteUint64(uint64_t u64) {
488 char buffer[20];
489 char* p = buffer;
490 while (u64 >= 100) {
491 const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
492 u64 /= 100;
493 *p++ = digits[i + 1];
494 *p++ = digits[i];
495 }
496 if (u64 < 10)
497 *p++ = char(u64) + '0';
498 else {
499 const unsigned i = static_cast<unsigned>(u64) << 1;
500 *p++ = digits[i + 1];
501 *p++ = digits[i];
502 }
503
504 do {
505 --p;
506 os_->Put(*p);
507 } while (p != buffer);
508 return true;
509 }
510
511 private:
512 OutputStream* os_;
513 };
514
515 // First pass to count digits
516 template<typename OutputStream>
517 class Writer3 {
518 public:
519 Writer3() : os_() {}
520 Writer3(OutputStream& os) : os_(&os) {}
521
522 void Reset(OutputStream& os) {
523 os_ = &os;
524 }
525
526 bool WriteInt(int i) {
527 if (i < 0) {
528 os_->Put('-');
529 i = -i;
530 }
531 return WriteUint((unsigned)i);
532 }
533
534 bool WriteUint(unsigned u) {
535 char buffer[10];
536 char *p = buffer;
537 do {
538 *p++ = char(u % 10) + '0';
539 u /= 10;
540 } while (u > 0);
541
542 do {
543 --p;
544 os_->Put(*p);
545 } while (p != buffer);
546 return true;
547 }
548
549 bool WriteInt64(int64_t i64) {
550 if (i64 < 0) {
551 os_->Put('-');
552 i64 = -i64;
553 }
554 WriteUint64((uint64_t)i64);
555 return true;
556 }
557
558 bool WriteUint64(uint64_t u64) {
559 char buffer[20];
560 char *p = buffer;
561 do {
562 *p++ = char(u64 % 10) + '0';
563 u64 /= 10;
564 } while (u64 > 0);
565
566 do {
567 --p;
568 os_->Put(*p);
569 } while (p != buffer);
570 return true;
571 }
572
573 private:
574 void WriteUintReverse(char* d, unsigned u) {
575 do {
576 *--d = char(u % 10) + '0';
577 u /= 10;
578 } while (u > 0);
579 }
580
581 void WriteUint64Reverse(char* d, uint64_t u) {
582 do {
583 *--d = char(u % 10) + '0';
584 u /= 10;
585 } while (u > 0);
586 }
587
588 OutputStream* os_;
589 };
590
591 template<>
592 inline bool Writer3<rapidjson::StringBuffer>::WriteUint(unsigned u) {
593 unsigned digit = CountDecimalDigit_fast(u);
594 WriteUintReverse(os_->Push(digit) + digit, u);
595 return true;
596 }
597
598 template<>
599 inline bool Writer3<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
600 unsigned digit = CountDecimalDigit_fast(u);
601 WriteUintReverse(os_->Push(digit) + digit, u);
602 return true;
603 }
604
605 template<>
606 inline bool Writer3<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
607 unsigned digit = CountDecimalDigit64_fast(u);
608 WriteUint64Reverse(os_->Push(digit) + digit, u);
609 return true;
610 }
611
612 template<>
613 inline bool Writer3<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
614 unsigned digit = CountDecimalDigit64_fast(u);
615 WriteUint64Reverse(os_->Push(digit) + digit, u);
616 return true;
617 }
618
619 // Using digits LUT to reduce divsion/modulo, two passes
620 template<typename OutputStream>
621 class Writer4 {
622 public:
623 Writer4() : os_() {}
624 Writer4(OutputStream& os) : os_(&os) {}
625
626 void Reset(OutputStream& os) {
627 os_ = &os;
628 }
629
630 bool WriteInt(int i) {
631 if (i < 0) {
632 os_->Put('-');
633 i = -i;
634 }
635 return WriteUint((unsigned)i);
636 }
637
638 bool WriteUint(unsigned u) {
639 char buffer[10];
640 char* p = buffer;
641 while (u >= 100) {
642 const unsigned i = (u % 100) << 1;
643 u /= 100;
644 *p++ = digits[i + 1];
645 *p++ = digits[i];
646 }
647 if (u < 10)
648 *p++ = char(u) + '0';
649 else {
650 const unsigned i = u << 1;
651 *p++ = digits[i + 1];
652 *p++ = digits[i];
653 }
654
655 do {
656 --p;
657 os_->Put(*p);
658 } while (p != buffer);
659 return true;
660 }
661
662 bool WriteInt64(int64_t i64) {
663 if (i64 < 0) {
664 os_->Put('-');
665 i64 = -i64;
666 }
667 WriteUint64((uint64_t)i64);
668 return true;
669 }
670
671 bool WriteUint64(uint64_t u64) {
672 char buffer[20];
673 char* p = buffer;
674 while (u64 >= 100) {
675 const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
676 u64 /= 100;
677 *p++ = digits[i + 1];
678 *p++ = digits[i];
679 }
680 if (u64 < 10)
681 *p++ = char(u64) + '0';
682 else {
683 const unsigned i = static_cast<unsigned>(u64) << 1;
684 *p++ = digits[i + 1];
685 *p++ = digits[i];
686 }
687
688 do {
689 --p;
690 os_->Put(*p);
691 } while (p != buffer);
692 return true;
693 }
694
695 private:
696 void WriteUintReverse(char* d, unsigned u) {
697 while (u >= 100) {
698 const unsigned i = (u % 100) << 1;
699 u /= 100;
700 *--d = digits[i + 1];
701 *--d = digits[i];
702 }
703 if (u < 10) {
704 *--d = char(u) + '0';
705 }
706 else {
707 const unsigned i = u << 1;
708 *--d = digits[i + 1];
709 *--d = digits[i];
710 }
711 }
712
713 void WriteUint64Reverse(char* d, uint64_t u) {
714 while (u >= 100) {
715 const unsigned i = (u % 100) << 1;
716 u /= 100;
717 *--d = digits[i + 1];
718 *--d = digits[i];
719 }
720 if (u < 10) {
721 *--d = char(u) + '0';
722 }
723 else {
724 const unsigned i = u << 1;
725 *--d = digits[i + 1];
726 *--d = digits[i];
727 }
728 }
729
730 OutputStream* os_;
731 };
732
733 template<>
734 inline bool Writer4<rapidjson::StringBuffer>::WriteUint(unsigned u) {
735 unsigned digit = CountDecimalDigit_fast(u);
736 WriteUintReverse(os_->Push(digit) + digit, u);
737 return true;
738 }
739
740 template<>
741 inline bool Writer4<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
742 unsigned digit = CountDecimalDigit_fast(u);
743 WriteUintReverse(os_->Push(digit) + digit, u);
744 return true;
745 }
746
747 template<>
748 inline bool Writer4<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
749 unsigned digit = CountDecimalDigit64_fast(u);
750 WriteUint64Reverse(os_->Push(digit) + digit, u);
751 return true;
752 }
753
754 template<>
755 inline bool Writer4<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
756 unsigned digit = CountDecimalDigit64_fast(u);
757 WriteUint64Reverse(os_->Push(digit) + digit, u);
758 return true;
759 }
760
761 template <typename Writer>
762 void itoa_Writer_StringBufferVerify() {
763 rapidjson::StringBuffer sb;
764 Writer writer(sb);
765 for (size_t j = 0; j < randvalCount; j++) {
766 char buffer[32];
767 sprintf(buffer, "%d", randval[j]);
768 writer.WriteInt(randval[j]);
769 ASSERT_STREQ(buffer, sb.GetString());
770 sb.Clear();
771 }
772 }
773
774 template <typename Writer>
775 void itoa_Writer_InsituStringStreamVerify() {
776 Writer writer;
777 for (size_t j = 0; j < randvalCount; j++) {
778 char buffer[32];
779 sprintf(buffer, "%d", randval[j]);
780 char buffer2[32];
781 rapidjson::InsituStringStream ss(buffer2);
782 writer.Reset(ss);
783 char* begin = ss.PutBegin();
784 writer.WriteInt(randval[j]);
785 ss.Put('\0');
786 ss.PutEnd(begin);
787 ASSERT_STREQ(buffer, buffer2);
788 }
789 }
790
791 template <typename Writer>
792 void itoa_Writer_StringBuffer() {
793 size_t length = 0;
794
795 rapidjson::StringBuffer sb;
796 Writer writer(sb);
797
798 for (size_t i = 0; i < kItoaTrialCount; i++) {
799 for (size_t j = 0; j < randvalCount; j++) {
800 writer.WriteInt(randval[j]);
801 length += sb.GetSize();
802 sb.Clear();
803 }
804 }
805 OUTPUT_LENGTH(length);
806 }
807
808 template <typename Writer>
809 void itoa_Writer_InsituStringStream() {
810 size_t length = 0;
811
812 char buffer[32];
813 Writer writer;
814 for (size_t i = 0; i < kItoaTrialCount; i++) {
815 for (size_t j = 0; j < randvalCount; j++) {
816 rapidjson::InsituStringStream ss(buffer);
817 writer.Reset(ss);
818 char* begin = ss.PutBegin();
819 writer.WriteInt(randval[j]);
820 length += ss.PutEnd(begin);
821 }
822 }
823 OUTPUT_LENGTH(length);
824 };
825
826 template <typename Writer>
827 void itoa64_Writer_StringBufferVerify() {
828 rapidjson::StringBuffer sb;
829 Writer writer(sb);
830 for (size_t j = 0; j < randvalCount; j++) {
831 char buffer[32];
832 int64_t x = randval[j] * randval[j];
833 sprintf(buffer, "%" PRIi64, x);
834 writer.WriteInt64(x);
835 ASSERT_STREQ(buffer, sb.GetString());
836 sb.Clear();
837 }
838 }
839
840 template <typename Writer>
841 void itoa64_Writer_InsituStringStreamVerify() {
842 Writer writer;
843 for (size_t j = 0; j < randvalCount; j++) {
844 char buffer[32];
845 int64_t x = randval[j] * randval[j];
846 sprintf(buffer, "%" PRIi64, x);
847 char buffer2[32];
848 rapidjson::InsituStringStream ss(buffer2);
849 writer.Reset(ss);
850 char* begin = ss.PutBegin();
851 writer.WriteInt64(x);
852 ss.Put('\0');
853 ss.PutEnd(begin);
854 ASSERT_STREQ(buffer, buffer2);
855 }
856 }
857
858 template <typename Writer>
859 void itoa64_Writer_StringBuffer() {
860 size_t length = 0;
861
862 rapidjson::StringBuffer sb;
863 Writer writer(sb);
864
865 for (size_t i = 0; i < kItoaTrialCount; i++) {
866 for (size_t j = 0; j < randvalCount; j++) {
867 writer.WriteInt64(randval[j] * randval[j]);
868 length += sb.GetSize();
869 sb.Clear();
870 }
871 }
872 OUTPUT_LENGTH(length);
873 }
874
875 template <typename Writer>
876 void itoa64_Writer_InsituStringStream() {
877 size_t length = 0;
878
879 char buffer[32];
880 Writer writer;
881 for (size_t i = 0; i < kItoaTrialCount; i++) {
882 for (size_t j = 0; j < randvalCount; j++) {
883 rapidjson::InsituStringStream ss(buffer);
884 writer.Reset(ss);
885 char* begin = ss.PutBegin();
886 writer.WriteInt64(randval[j] * randval[j]);
887 length += ss.PutEnd(begin);
888 }
889 }
890 OUTPUT_LENGTH(length);
891 };
892
893 // Full specialization for InsituStringStream to prevent memory copying
894 // (normally we will not use InsituStringStream for writing, just for testing)
895
896 namespace rapidjson {
897
898 template<>
899 bool rapidjson::Writer<InsituStringStream>::WriteInt(int i) {
900 char *buffer = os_->Push(11);
901 const char* end = internal::i32toa(i, buffer);
902 os_->Pop(11 - (end - buffer));
903 return true;
904 }
905
906 template<>
907 bool Writer<InsituStringStream>::WriteUint(unsigned u) {
908 char *buffer = os_->Push(10);
909 const char* end = internal::u32toa(u, buffer);
910 os_->Pop(10 - (end - buffer));
911 return true;
912 }
913
914 template<>
915 bool Writer<InsituStringStream>::WriteInt64(int64_t i64) {
916 char *buffer = os_->Push(21);
917 const char* end = internal::i64toa(i64, buffer);
918 os_->Pop(21 - (end - buffer));
919 return true;
920 }
921
922 template<>
923 bool Writer<InsituStringStream>::WriteUint64(uint64_t u) {
924 char *buffer = os_->Push(20);
925 const char* end = internal::u64toa(u, buffer);
926 os_->Pop(20 - (end - buffer));
927 return true;
928 }
929
930 } // namespace rapidjson
931
932 TEST_F(Misc, itoa_Writer_StringBufferVerify) { itoa_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
933 TEST_F(Misc, itoa_Writer1_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
934 TEST_F(Misc, itoa_Writer2_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
935 TEST_F(Misc, itoa_Writer3_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
936 TEST_F(Misc, itoa_Writer4_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
937 TEST_F(Misc, itoa_Writer_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
938 TEST_F(Misc, itoa_Writer1_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
939 TEST_F(Misc, itoa_Writer2_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
940 TEST_F(Misc, itoa_Writer3_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
941 TEST_F(Misc, itoa_Writer4_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
942 TEST_F(Misc, itoa_Writer_StringBuffer) { itoa_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
943 TEST_F(Misc, itoa_Writer1_StringBuffer) { itoa_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
944 TEST_F(Misc, itoa_Writer2_StringBuffer) { itoa_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
945 TEST_F(Misc, itoa_Writer3_StringBuffer) { itoa_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
946 TEST_F(Misc, itoa_Writer4_StringBuffer) { itoa_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
947 TEST_F(Misc, itoa_Writer_InsituStringStream) { itoa_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
948 TEST_F(Misc, itoa_Writer1_InsituStringStream) { itoa_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
949 TEST_F(Misc, itoa_Writer2_InsituStringStream) { itoa_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
950 TEST_F(Misc, itoa_Writer3_InsituStringStream) { itoa_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
951 TEST_F(Misc, itoa_Writer4_InsituStringStream) { itoa_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
952
953 TEST_F(Misc, itoa64_Writer_StringBufferVerify) { itoa64_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
954 TEST_F(Misc, itoa64_Writer1_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
955 TEST_F(Misc, itoa64_Writer2_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
956 TEST_F(Misc, itoa64_Writer3_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
957 TEST_F(Misc, itoa64_Writer4_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
958 TEST_F(Misc, itoa64_Writer_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
959 TEST_F(Misc, itoa64_Writer1_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
960 TEST_F(Misc, itoa64_Writer2_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
961 TEST_F(Misc, itoa64_Writer3_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
962 TEST_F(Misc, itoa64_Writer4_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
963 TEST_F(Misc, itoa64_Writer_StringBuffer) { itoa64_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
964 TEST_F(Misc, itoa64_Writer1_StringBuffer) { itoa64_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
965 TEST_F(Misc, itoa64_Writer2_StringBuffer) { itoa64_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
966 TEST_F(Misc, itoa64_Writer3_StringBuffer) { itoa64_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
967 TEST_F(Misc, itoa64_Writer4_StringBuffer) { itoa64_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
968 TEST_F(Misc, itoa64_Writer_InsituStringStream) { itoa64_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
969 TEST_F(Misc, itoa64_Writer1_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
970 TEST_F(Misc, itoa64_Writer2_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
971 TEST_F(Misc, itoa64_Writer3_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
972 TEST_F(Misc, itoa64_Writer4_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
973
974 #endif // TEST_MISC
Ceph