Debian Codegraph @

LspCpp/third_party/rapidjson/test/perftest/rapidjsontest.cpp

raw
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.
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_RAPIDJSON
18
19 #include "rapidjson/rapidjson.h"
20 #include "rapidjson/document.h"
21 #include "rapidjson/prettywriter.h"
22 #include "rapidjson/stringbuffer.h"
23 #include "rapidjson/filereadstream.h"
24 #include "rapidjson/istreamwrapper.h"
25 #include "rapidjson/encodedstream.h"
26 #include "rapidjson/memorystream.h"
27
28 #include <fstream>
29 #include <vector>
30
31 #ifdef RAPIDJSON_SSE2
32 #define SIMD_SUFFIX(name) name##_SSE2
33 #elif defined(RAPIDJSON_SSE42)
34 #define SIMD_SUFFIX(name) name##_SSE42
35 #elif defined(RAPIDJSON_NEON)
36 #define SIMD_SUFFIX(name) name##_NEON
37 #else
38 #define SIMD_SUFFIX(name) name
39 #endif
40
41 using namespace rapidjson;
42
43 class RapidJson : public PerfTest {
44 public:
45 RapidJson() : temp_(), doc_() {}
46
47 virtual void SetUp() {
48 PerfTest::SetUp();
49
50 // temp buffer for insitu parsing.
51 temp_ = (char *)malloc(length_ + 1);
52
53 // Parse as a document
54 EXPECT_FALSE(doc_.Parse(json_).HasParseError());
55
56 for (size_t i = 0; i < 8; i++)
57 EXPECT_FALSE(typesDoc_[i].Parse(types_[i]).HasParseError());
58 }
59
60 virtual void TearDown() {
61 PerfTest::TearDown();
62 free(temp_);
63 }
64
65 private:
66 RapidJson(const RapidJson&);
67 RapidJson& operator=(const RapidJson&);
68
69 protected:
70 char *temp_;
71 Document doc_;
72 Document typesDoc_[8];
73 };
74
75 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseInsitu_DummyHandler)) {
76 for (size_t i = 0; i < kTrialCount; i++) {
77 memcpy(temp_, json_, length_ + 1);
78 InsituStringStream s(temp_);
79 BaseReaderHandler<> h;
80 Reader reader;
81 EXPECT_TRUE(reader.Parse<kParseInsituFlag>(s, h));
82 }
83 }
84
85 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseInsitu_DummyHandler_ValidateEncoding)) {
86 for (size_t i = 0; i < kTrialCount; i++) {
87 memcpy(temp_, json_, length_ + 1);
88 InsituStringStream s(temp_);
89 BaseReaderHandler<> h;
90 Reader reader;
91 EXPECT_TRUE(reader.Parse<kParseInsituFlag | kParseValidateEncodingFlag>(s, h));
92 }
93 }
94
95 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler)) {
96 for (size_t i = 0; i < kTrialCount; i++) {
97 StringStream s(json_);
98 BaseReaderHandler<> h;
99 Reader reader;
100 EXPECT_TRUE(reader.Parse(s, h));
101 }
102 }
103
104 #define TEST_TYPED(index, Name)\
105 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_##Name)) {\
106 for (size_t i = 0; i < kTrialCount * 10; i++) {\
107 StringStream s(types_[index]);\
108 BaseReaderHandler<> h;\
109 Reader reader;\
110 EXPECT_TRUE(reader.Parse(s, h));\
111 }\
112 }\
113 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseInsitu_DummyHandler_##Name)) {\
114 for (size_t i = 0; i < kTrialCount * 10; i++) {\
115 memcpy(temp_, types_[index], typesLength_[index] + 1);\
116 InsituStringStream s(temp_);\
117 BaseReaderHandler<> h;\
118 Reader reader;\
119 EXPECT_TRUE(reader.Parse<kParseInsituFlag>(s, h));\
120 }\
121 }
122
123 TEST_TYPED(0, Booleans)
124 TEST_TYPED(1, Floats)
125 TEST_TYPED(2, Guids)
126 TEST_TYPED(3, Integers)
127 TEST_TYPED(4, Mixed)
128 TEST_TYPED(5, Nulls)
129 TEST_TYPED(6, Paragraphs)
130
131 #undef TEST_TYPED
132
133 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_FullPrecision)) {
134 for (size_t i = 0; i < kTrialCount; i++) {
135 StringStream s(json_);
136 BaseReaderHandler<> h;
137 Reader reader;
138 EXPECT_TRUE(reader.Parse<kParseFullPrecisionFlag>(s, h));
139 }
140 }
141
142 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterative_DummyHandler)) {
143 for (size_t i = 0; i < kTrialCount; i++) {
144 StringStream s(json_);
145 BaseReaderHandler<> h;
146 Reader reader;
147 EXPECT_TRUE(reader.Parse<kParseIterativeFlag>(s, h));
148 }
149 }
150
151 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativeInsitu_DummyHandler)) {
152 for (size_t i = 0; i < kTrialCount; i++) {
153 memcpy(temp_, json_, length_ + 1);
154 InsituStringStream s(temp_);
155 BaseReaderHandler<> h;
156 Reader reader;
157 EXPECT_TRUE(reader.Parse<kParseIterativeFlag|kParseInsituFlag>(s, h));
158 }
159 }
160
161 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativePull_DummyHandler)) {
162 for (size_t i = 0; i < kTrialCount; i++) {
163 StringStream s(json_);
164 BaseReaderHandler<> h;
165 Reader reader;
166 reader.IterativeParseInit();
167 while (!reader.IterativeParseComplete()) {
168 if (!reader.IterativeParseNext<kParseDefaultFlags>(s, h))
169 break;
170 }
171 EXPECT_FALSE(reader.HasParseError());
172 }
173 }
174
175 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativePullInsitu_DummyHandler)) {
176 for (size_t i = 0; i < kTrialCount; i++) {
177 memcpy(temp_, json_, length_ + 1);
178 InsituStringStream s(temp_);
179 BaseReaderHandler<> h;
180 Reader reader;
181 reader.IterativeParseInit();
182 while (!reader.IterativeParseComplete()) {
183 if (!reader.IterativeParseNext<kParseDefaultFlags|kParseInsituFlag>(s, h))
184 break;
185 }
186 EXPECT_FALSE(reader.HasParseError());
187 }
188 }
189
190 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_ValidateEncoding)) {
191 for (size_t i = 0; i < kTrialCount; i++) {
192 StringStream s(json_);
193 BaseReaderHandler<> h;
194 Reader reader;
195 EXPECT_TRUE(reader.Parse<kParseValidateEncodingFlag>(s, h));
196 }
197 }
198
199 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseInsitu_MemoryPoolAllocator)) {
200 for (size_t i = 0; i < kTrialCount; i++) {
201 memcpy(temp_, json_, length_ + 1);
202 Document doc;
203 doc.ParseInsitu(temp_);
204 ASSERT_TRUE(doc.IsObject());
205 }
206 }
207
208 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseIterativeInsitu_MemoryPoolAllocator)) {
209 for (size_t i = 0; i < kTrialCount; i++) {
210 memcpy(temp_, json_, length_ + 1);
211 Document doc;
212 doc.ParseInsitu<kParseIterativeFlag>(temp_);
213 ASSERT_TRUE(doc.IsObject());
214 }
215 }
216
217 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParse_MemoryPoolAllocator)) {
218 for (size_t i = 0; i < kTrialCount; i++) {
219 Document doc;
220 doc.Parse(json_);
221 ASSERT_TRUE(doc.IsObject());
222 }
223 }
224
225 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseLength_MemoryPoolAllocator)) {
226 for (size_t i = 0; i < kTrialCount; i++) {
227 Document doc;
228 doc.Parse(json_, length_);
229 ASSERT_TRUE(doc.IsObject());
230 }
231 }
232
233 #if RAPIDJSON_HAS_STDSTRING
234 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseStdString_MemoryPoolAllocator)) {
235 const std::string s(json_, length_);
236 for (size_t i = 0; i < kTrialCount; i++) {
237 Document doc;
238 doc.Parse(s);
239 ASSERT_TRUE(doc.IsObject());
240 }
241 }
242 #endif
243
244 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseIterative_MemoryPoolAllocator)) {
245 for (size_t i = 0; i < kTrialCount; i++) {
246 Document doc;
247 doc.Parse<kParseIterativeFlag>(json_);
248 ASSERT_TRUE(doc.IsObject());
249 }
250 }
251
252 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParse_CrtAllocator)) {
253 for (size_t i = 0; i < kTrialCount; i++) {
254 memcpy(temp_, json_, length_ + 1);
255 GenericDocument<UTF8<>, CrtAllocator> doc;
256 doc.Parse(temp_);
257 ASSERT_TRUE(doc.IsObject());
258 }
259 }
260
261 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseEncodedInputStream_MemoryStream)) {
262 for (size_t i = 0; i < kTrialCount; i++) {
263 MemoryStream ms(json_, length_);
264 EncodedInputStream<UTF8<>, MemoryStream> is(ms);
265 Document doc;
266 doc.ParseStream<0, UTF8<> >(is);
267 ASSERT_TRUE(doc.IsObject());
268 }
269 }
270
271 TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseAutoUTFInputStream_MemoryStream)) {
272 for (size_t i = 0; i < kTrialCount; i++) {
273 MemoryStream ms(json_, length_);
274 AutoUTFInputStream<unsigned, MemoryStream> is(ms);
275 Document doc;
276 doc.ParseStream<0, AutoUTF<unsigned> >(is);
277 ASSERT_TRUE(doc.IsObject());
278 }
279 }
280
281 template<typename T>
282 size_t Traverse(const T& value) {
283 size_t count = 1;
284 switch(value.GetType()) {
285 case kObjectType:
286 for (typename T::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
287 count++; // name
288 count += Traverse(itr->value);
289 }
290 break;
291
292 case kArrayType:
293 for (typename T::ConstValueIterator itr = value.Begin(); itr != value.End(); ++itr)
294 count += Traverse(*itr);
295 break;
296
297 default:
298 // Do nothing.
299 break;
300 }
301 return count;
302 }
303
304 TEST_F(RapidJson, DocumentTraverse) {
305 for (size_t i = 0; i < kTrialCount; i++) {
306 size_t count = Traverse(doc_);
307 EXPECT_EQ(4339u, count);
308 //if (i == 0)
309 // std::cout << count << std::endl;
310 }
311 }
312
313 #ifdef __GNUC__
314 RAPIDJSON_DIAG_PUSH
315 RAPIDJSON_DIAG_OFF(effc++)
316 #endif
317
318 struct ValueCounter : public BaseReaderHandler<> {
319 ValueCounter() : count_(1) {} // root
320
321 bool EndObject(SizeType memberCount) { count_ += memberCount * 2; return true; }
322 bool EndArray(SizeType elementCount) { count_ += elementCount; return true; }
323
324 SizeType count_;
325 };
326
327 #ifdef __GNUC__
328 RAPIDJSON_DIAG_POP
329 #endif
330
331 TEST_F(RapidJson, DocumentAccept) {
332 for (size_t i = 0; i < kTrialCount; i++) {
333 ValueCounter counter;
334 doc_.Accept(counter);
335 EXPECT_EQ(4339u, counter.count_);
336 }
337 }
338
339 TEST_F(RapidJson, DocumentFind) {
340 typedef Document::ValueType ValueType;
341 typedef ValueType::ConstMemberIterator ConstMemberIterator;
342 const Document &doc = typesDoc_[7]; // alotofkeys.json
343 if (doc.IsObject()) {
344 std::vector<const ValueType*> keys;
345 for (ConstMemberIterator it = doc.MemberBegin(); it != doc.MemberEnd(); ++it) {
346 keys.push_back(&it->name);
347 }
348 for (size_t i = 0; i < kTrialCount; i++) {
349 for (size_t j = 0; j < keys.size(); j++) {
350 EXPECT_TRUE(doc.FindMember(*keys[j]) != doc.MemberEnd());
351 }
352 }
353 }
354 }
355
356 struct NullStream {
357 typedef char Ch;
358
359 NullStream() /*: length_(0)*/ {}
360 void Put(Ch) { /*++length_;*/ }
361 void Flush() {}
362 //size_t length_;
363 };
364
365 TEST_F(RapidJson, Writer_NullStream) {
366 for (size_t i = 0; i < kTrialCount; i++) {
367 NullStream s;
368 Writer<NullStream> writer(s);
369 doc_.Accept(writer);
370 //if (i == 0)
371 // std::cout << s.length_ << std::endl;
372 }
373 }
374
375 TEST_F(RapidJson, SIMD_SUFFIX(Writer_StringBuffer)) {
376 for (size_t i = 0; i < kTrialCount; i++) {
377 StringBuffer s(0, 1024 * 1024);
378 Writer<StringBuffer> writer(s);
379 doc_.Accept(writer);
380 const char* str = s.GetString();
381 (void)str;
382 //if (i == 0)
383 // std::cout << strlen(str) << std::endl;
384 }
385 }
386
387 #define TEST_TYPED(index, Name)\
388 TEST_F(RapidJson, SIMD_SUFFIX(Writer_StringBuffer_##Name)) {\
389 for (size_t i = 0; i < kTrialCount * 10; i++) {\
390 StringBuffer s(0, 1024 * 1024);\
391 Writer<StringBuffer> writer(s);\
392 typesDoc_[index].Accept(writer);\
393 const char* str = s.GetString();\
394 (void)str;\
395 }\
396 }
397
398 TEST_TYPED(0, Booleans)
399 TEST_TYPED(1, Floats)
400 TEST_TYPED(2, Guids)
401 TEST_TYPED(3, Integers)
402 TEST_TYPED(4, Mixed)
403 TEST_TYPED(5, Nulls)
404 TEST_TYPED(6, Paragraphs)
405
406 #undef TEST_TYPED
407
408 TEST_F(RapidJson, SIMD_SUFFIX(PrettyWriter_StringBuffer)) {
409 for (size_t i = 0; i < kTrialCount; i++) {
410 StringBuffer s(0, 2048 * 1024);
411 PrettyWriter<StringBuffer> writer(s);
412 writer.SetIndent(' ', 1);
413 doc_.Accept(writer);
414 const char* str = s.GetString();
415 (void)str;
416 //if (i == 0)
417 // std::cout << strlen(str) << std::endl;
418 }
419 }
420
421 TEST_F(RapidJson, internal_Pow10) {
422 double sum = 0;
423 for (size_t i = 0; i < kTrialCount * kTrialCount; i++)
424 sum += internal::Pow10(int(i & 255));
425 EXPECT_GT(sum, 0.0);
426 }
427
428 TEST_F(RapidJson, SkipWhitespace_Basic) {
429 for (size_t i = 0; i < kTrialCount; i++) {
430 rapidjson::StringStream s(whitespace_);
431 while (s.Peek() == ' ' || s.Peek() == '\n' || s.Peek() == '\r' || s.Peek() == '\t')
432 s.Take();
433 ASSERT_EQ('[', s.Peek());
434 }
435 }
436
437 TEST_F(RapidJson, SIMD_SUFFIX(SkipWhitespace)) {
438 for (size_t i = 0; i < kTrialCount; i++) {
439 rapidjson::StringStream s(whitespace_);
440 rapidjson::SkipWhitespace(s);
441 ASSERT_EQ('[', s.Peek());
442 }
443 }
444
445 TEST_F(RapidJson, SkipWhitespace_strspn) {
446 for (size_t i = 0; i < kTrialCount; i++) {
447 const char* s = whitespace_ + std::strspn(whitespace_, " \t\r\n");
448 ASSERT_EQ('[', *s);
449 }
450 }
451
452 TEST_F(RapidJson, UTF8_Validate) {
453 NullStream os;
454
455 for (size_t i = 0; i < kTrialCount; i++) {
456 StringStream is(json_);
457 bool result = true;
458 while (is.Peek() != '\0')
459 result &= UTF8<>::Validate(is, os);
460 EXPECT_TRUE(result);
461 }
462 }
463
464 TEST_F(RapidJson, FileReadStream) {
465 for (size_t i = 0; i < kTrialCount; i++) {
466 FILE *fp = fopen(filename_, "rb");
467 char buffer[65536];
468 FileReadStream s(fp, buffer, sizeof(buffer));
469 while (s.Take() != '\0')
470 ;
471 fclose(fp);
472 }
473 }
474
475 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_FileReadStream)) {
476 for (size_t i = 0; i < kTrialCount; i++) {
477 FILE *fp = fopen(filename_, "rb");
478 char buffer[65536];
479 FileReadStream s(fp, buffer, sizeof(buffer));
480 BaseReaderHandler<> h;
481 Reader reader;
482 reader.Parse(s, h);
483 fclose(fp);
484 }
485 }
486
487 TEST_F(RapidJson, IStreamWrapper) {
488 for (size_t i = 0; i < kTrialCount; i++) {
489 std::ifstream is(filename_, std::ios::in | std::ios::binary);
490 char buffer[65536];
491 IStreamWrapper isw(is, buffer, sizeof(buffer));
492 while (isw.Take() != '\0')
493 ;
494 is.close();
495 }
496 }
497
498 TEST_F(RapidJson, IStreamWrapper_Unbuffered) {
499 for (size_t i = 0; i < kTrialCount; i++) {
500 std::ifstream is(filename_, std::ios::in | std::ios::binary);
501 IStreamWrapper isw(is);
502 while (isw.Take() != '\0')
503 ;
504 is.close();
505 }
506 }
507
508 TEST_F(RapidJson, IStreamWrapper_Setbuffered) {
509 for (size_t i = 0; i < kTrialCount; i++) {
510 std::ifstream is;
511 char buffer[65536];
512 is.rdbuf()->pubsetbuf(buffer, sizeof(buffer));
513 is.open(filename_, std::ios::in | std::ios::binary);
514 IStreamWrapper isw(is);
515 while (isw.Take() != '\0')
516 ;
517 is.close();
518 }
519 }
520
521 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_IStreamWrapper)) {
522 for (size_t i = 0; i < kTrialCount; i++) {
523 std::ifstream is(filename_, std::ios::in | std::ios::binary);
524 char buffer[65536];
525 IStreamWrapper isw(is, buffer, sizeof(buffer));
526 BaseReaderHandler<> h;
527 Reader reader;
528 reader.Parse(isw, h);
529 is.close();
530 }
531 }
532
533 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_IStreamWrapper_Unbuffered)) {
534 for (size_t i = 0; i < kTrialCount; i++) {
535 std::ifstream is(filename_, std::ios::in | std::ios::binary);
536 IStreamWrapper isw(is);
537 BaseReaderHandler<> h;
538 Reader reader;
539 reader.Parse(isw, h);
540 is.close();
541 }
542 }
543
544 TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_IStreamWrapper_Setbuffered)) {
545 for (size_t i = 0; i < kTrialCount; i++) {
546 std::ifstream is;
547 char buffer[65536];
548 is.rdbuf()->pubsetbuf(buffer, sizeof(buffer));
549 is.open(filename_, std::ios::in | std::ios::binary);
550 IStreamWrapper isw(is);
551 BaseReaderHandler<> h;
552 Reader reader;
553 reader.Parse(isw, h);
554 is.close();
555 }
556 }
557
558 TEST_F(RapidJson, StringBuffer) {
559 StringBuffer sb;
560 for (int i = 0; i < 32 * 1024 * 1024; i++)
561 sb.Put(i & 0x7f);
562 }
563
564 #endif // TEST_RAPIDJSON