1 #include <benchmark/benchmark.h>
2 #include <iostream>
3 #include "simdjson.h"
4 using namespace simdjson;
5 using namespace benchmark;
6 using namespace std;
7
8 const padded_string EMPTY_ARRAY("[]", 2);
9 const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
10 const char *GSOC_JSON = SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json";
11
12
13
14
fast_minify_twitter(State & state)15 static void fast_minify_twitter(State& state) {
16 dom::parser parser;
17 padded_string docdata;
18 auto error = padded_string::load(TWITTER_JSON).get(docdata);
19 if(error) {
20 cerr << "could not parse twitter.json" << error << endl;
21 return;
22 }
23 std::unique_ptr<char[]> buffer{new char[docdata.size()]};
24
25 size_t bytes = 0;
26 for (simdjson_unused auto _ : state) {
27 size_t new_length{}; // It will receive the minified length.
28 auto error = simdjson::minify(docdata.data(), docdata.size(), buffer.get(), new_length);
29 bytes += docdata.size();
30 benchmark::DoNotOptimize(error);
31 }
32 // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
33 state.counters["Gigabytes"] = benchmark::Counter(
34 double(bytes), benchmark::Counter::kIsRate,
35 benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
36 state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
37 }
__anon8b5c566d0102(const std::vector<double>& v) 38 BENCHMARK(fast_minify_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
39 return *(std::max_element(std::begin(v), std::end(v)));
40 })->DisplayAggregatesOnly(true);
41
42
43
44
fast_minify_gsoc(State & state)45 static void fast_minify_gsoc(State& state) {
46 dom::parser parser;
47 padded_string docdata;
48 auto error = padded_string::load(GSOC_JSON).get(docdata);
49 if(error) {
50 cerr << "could not parse gsoc-2018.json" << error << endl;
51 return;
52 }
53 std::unique_ptr<char[]> buffer{new char[docdata.size()]};
54
55 size_t bytes = 0;
56 for (simdjson_unused auto _ : state) {
57 size_t new_length{}; // It will receive the minified length.
58 auto error = simdjson::minify(docdata.data(), docdata.size(), buffer.get(), new_length);
59 bytes += docdata.size();
60 benchmark::DoNotOptimize(error);
61 }
62 // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
63 state.counters["Gigabytes"] = benchmark::Counter(
64 double(bytes), benchmark::Counter::kIsRate,
65 benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
66 state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
67 }
__anon8b5c566d0202(const std::vector<double>& v) 68 BENCHMARK(fast_minify_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
69 return *(std::max_element(std::begin(v), std::end(v)));
70 })->DisplayAggregatesOnly(true);
71
unicode_validate_twitter(State & state)72 static void unicode_validate_twitter(State& state) {
73 dom::parser parser;
74 padded_string docdata;
75 auto error = padded_string::load(TWITTER_JSON).get(docdata);
76 if(error) {
77 cerr << "could not parse twitter.json" << error << endl;
78 return;
79 }
80 // we do not want mem. alloc. in the loop.
81 error = parser.allocate(docdata.size());
82 if(error) {
83 cout << error << endl;
84 return;
85 }
86 size_t bytes = 0;
87 for (simdjson_unused auto _ : state) {
88 bool is_ok = simdjson::validate_utf8(docdata.data(), docdata.size());
89 bytes += docdata.size();
90 benchmark::DoNotOptimize(is_ok);
91 }
92 // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
93 state.counters["Gigabytes"] = benchmark::Counter(
94 double(bytes), benchmark::Counter::kIsRate,
95 benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
96 state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
97 }
__anon8b5c566d0302(const std::vector<double>& v) 98 BENCHMARK(unicode_validate_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
99 return *(std::max_element(std::begin(v), std::end(v)));
100 })->DisplayAggregatesOnly(true);
101
parse_twitter(State & state)102 static void parse_twitter(State& state) {
103 dom::parser parser;
104 padded_string docdata;
105 auto error = padded_string::load(TWITTER_JSON).get(docdata);
106 if(error) {
107 cerr << "could not parse twitter.json" << error << endl;
108 return;
109 }
110 // we do not want mem. alloc. in the loop.
111 error = parser.allocate(docdata.size());
112 if(error) {
113 cout << error << endl;
114 return;
115 }
116 size_t bytes = 0;
117 for (simdjson_unused auto _ : state) {
118 dom::element doc;
119 bytes += docdata.size();
120 if ((error = parser.parse(docdata).get(doc))) {
121 cerr << "could not parse twitter.json" << error << endl;
122 return;
123 }
124 benchmark::DoNotOptimize(doc);
125 }
126 // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
127 state.counters["Gigabytes"] = benchmark::Counter(
128 double(bytes), benchmark::Counter::kIsRate,
129 benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
130 state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
131 }
__anon8b5c566d0402(const std::vector<double>& v) 132 BENCHMARK(parse_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
133 return *(std::max_element(std::begin(v), std::end(v)));
134 })->DisplayAggregatesOnly(true);
135
136
parse_gsoc(State & state)137 static void parse_gsoc(State& state) {
138 dom::parser parser;
139 padded_string docdata;
140 auto error = padded_string::load(GSOC_JSON).get(docdata);
141 if(error) {
142 cerr << "could not parse gsoc-2018.json" << error << endl;
143 return;
144 }
145 // we do not want mem. alloc. in the loop.
146 error = parser.allocate(docdata.size());
147 if(error) {
148 cout << error << endl;
149 return;
150 }
151 size_t bytes = 0;
152 for (simdjson_unused auto _ : state) {
153 bytes += docdata.size();
154 dom::element doc;
155 if ((error = parser.parse(docdata).get(doc))) {
156 cerr << "could not parse gsoc-2018.json" << error << endl;
157 return;
158 }
159 benchmark::DoNotOptimize(doc);
160 }
161 // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
162 state.counters["Gigabytes"] = benchmark::Counter(
163 double(bytes), benchmark::Counter::kIsRate,
164 benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
165 state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
166 }
__anon8b5c566d0502(const std::vector<double>& v) 167 BENCHMARK(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
168 return *(std::max_element(std::begin(v), std::end(v)));
169 })->DisplayAggregatesOnly(true);
170
171
172
173 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
174 SIMDJSON_PUSH_DISABLE_WARNINGS
175 SIMDJSON_DISABLE_DEPRECATED_WARNING
json_parse(State & state)176 static void json_parse(State& state) {
177 ParsedJson pj;
178 if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
179 for (simdjson_unused auto _ : state) {
180 auto error = json_parse(EMPTY_ARRAY, pj);
181 if (error) { return; }
182 }
183 }
184 SIMDJSON_POP_DISABLE_WARNINGS
185 BENCHMARK(json_parse);
186 #endif // SIMDJSON_DISABLE_DEPRECATED_API
187
parser_parse_error_code(State & state)188 static void parser_parse_error_code(State& state) {
189 dom::parser parser;
190 if (parser.allocate(EMPTY_ARRAY.length())) { return; }
191 for (simdjson_unused auto _ : state) {
192 auto error = parser.parse(EMPTY_ARRAY).error();
193 if (error) { return; }
194 }
195 }
196 BENCHMARK(parser_parse_error_code);
197
198 #if SIMDJSON_EXCEPTIONS
199
parser_parse_exception(State & state)200 static void parser_parse_exception(State& state) {
201 dom::parser parser;
202 if (parser.allocate(EMPTY_ARRAY.length())) { return; }
203 for (simdjson_unused auto _ : state) {
204 try {
205 simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
206 } catch(simdjson_error &j) {
207 cout << j.what() << endl;
208 return;
209 }
210 }
211 }
212 BENCHMARK(parser_parse_exception);
213
214 #endif // SIMDJSON_EXCEPTIONS
215
216 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
217 SIMDJSON_PUSH_DISABLE_WARNINGS
218 SIMDJSON_DISABLE_DEPRECATED_WARNING
build_parsed_json(State & state)219 static void build_parsed_json(State& state) {
220 for (simdjson_unused auto _ : state) {
221 dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
222 if (!parser.valid) { return; }
223 }
224 }
225 SIMDJSON_POP_DISABLE_WARNINGS
226
227 BENCHMARK(build_parsed_json);
228 #endif
229
document_parse_error_code(State & state)230 static void document_parse_error_code(State& state) {
231 for (simdjson_unused auto _ : state) {
232 dom::parser parser;
233 auto error = parser.parse(EMPTY_ARRAY).error();
234 if (error) { return; }
235 }
236 }
237 BENCHMARK(document_parse_error_code);
238
239 #if SIMDJSON_EXCEPTIONS
240
document_parse_exception(State & state)241 static void document_parse_exception(State& state) {
242 for (simdjson_unused auto _ : state) {
243 try {
244 dom::parser parser;
245 simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
246 } catch(simdjson_error &j) {
247 cout << j.what() << endl;
248 return;
249 }
250 }
251 }
252 BENCHMARK(document_parse_exception);
253
254 #endif // SIMDJSON_EXCEPTIONS
255
256 BENCHMARK_MAIN();
257