1 // Copyright (c) 2023 Huawei Device Co., Ltd.
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 //     http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 
14 //! Benchmarks for the json serialization
15 
16 #![feature(test)]
17 
18 mod task_helpers;
19 
20 #[cfg(test)]
21 mod deserialize_cmp {
22     extern crate test;
23     use crate::task_helpers::*;
24     use test::Bencher;
25 
26     use serde_json::Value;
27     use std::str::FromStr;
28     use ylong_json::JsonValue;
29 
30     #[bench]
null_serialize_perf_ylong_json(b: &mut Bencher)31     fn null_serialize_perf_ylong_json(b: &mut Bencher) {
32         let value = JsonValue::from_str(NULL_EXAMPLE).unwrap();
33         b.iter(|| {
34             for _ in 0..LOOPS_NUM {
35                 let _ = value.to_compact_string();
36             }
37         });
38     }
39 
40     #[bench]
boolean_serialize_perf_ylong_json(b: &mut Bencher)41     fn boolean_serialize_perf_ylong_json(b: &mut Bencher) {
42         let value = JsonValue::from_str(BOOLEAN_EXAMPLE).unwrap();
43         b.iter(|| {
44             for _ in 0..LOOPS_NUM {
45                 let _ = value.to_compact_string();
46             }
47         });
48     }
49 
50     #[bench]
number_serialize_perf_ylong_json(b: &mut Bencher)51     fn number_serialize_perf_ylong_json(b: &mut Bencher) {
52         let value = JsonValue::from_str(NUMBER_EXAMPLE).unwrap();
53         b.iter(|| {
54             for _ in 0..LOOPS_NUM {
55                 let _ = value.to_compact_string();
56             }
57         });
58     }
59 
60     #[bench]
string_serialize_perf_ylong_json(b: &mut Bencher)61     fn string_serialize_perf_ylong_json(b: &mut Bencher) {
62         let value = JsonValue::from_str(STRING_EXAMPLE).unwrap();
63         b.iter(|| {
64             for _ in 0..LOOPS_NUM {
65                 let _ = value.to_compact_string();
66             }
67         });
68     }
69 
70     #[bench]
array_serialize_perf_ylong_json(b: &mut Bencher)71     fn array_serialize_perf_ylong_json(b: &mut Bencher) {
72         let value = JsonValue::from_str(ARRAY_EXAMPLE).unwrap();
73         b.iter(|| {
74             for _ in 0..LOOPS_NUM {
75                 let _ = value.to_compact_string();
76             }
77         });
78     }
79 
80     #[bench]
object_serialize_perf_ylong_json(b: &mut Bencher)81     fn object_serialize_perf_ylong_json(b: &mut Bencher) {
82         let value = JsonValue::from_str(OBJECT_EXAMPLE).unwrap();
83         b.iter(|| {
84             for _ in 0..LOOPS_NUM {
85                 let _ = value.to_compact_string();
86             }
87         });
88     }
89 
90     #[bench]
exp1_serialize_perf_ylong_json(b: &mut Bencher)91     fn exp1_serialize_perf_ylong_json(b: &mut Bencher) {
92         let value = JsonValue::from_str(RFC7159_EXAMPLE1).unwrap();
93         b.iter(|| {
94             for _ in 0..LOOPS_NUM {
95                 let _ = value.to_compact_string();
96             }
97         });
98     }
99 
100     #[bench]
exp2_serialize_perf_ylong_json(b: &mut Bencher)101     fn exp2_serialize_perf_ylong_json(b: &mut Bencher) {
102         let value = JsonValue::from_str(RFC7159_EXAMPLE2).unwrap();
103         b.iter(|| {
104             for _ in 0..LOOPS_NUM {
105                 let _ = value.to_compact_string();
106             }
107         });
108     }
109 
110     #[bench]
exp3_serialize_perf_ylong_json(b: &mut Bencher)111     fn exp3_serialize_perf_ylong_json(b: &mut Bencher) {
112         let value = JsonValue::from_str(JSON_PARSE_TEST).unwrap();
113         b.iter(|| {
114             for _ in 0..LOOPS_NUM {
115                 let _ = value.to_compact_string();
116             }
117         });
118     }
119 
120     #[bench]
exp4_serialize_perf_ylong_json(b: &mut Bencher)121     fn exp4_serialize_perf_ylong_json(b: &mut Bencher) {
122         let value = JsonValue::from_str(LONG_KEY_VALUE).unwrap();
123         b.iter(|| {
124             for _ in 0..LOOPS_NUM {
125                 let _ = value.to_compact_string();
126             }
127         });
128     }
129 
130     #[bench]
null_serialize_perf_serde_json(b: &mut Bencher)131     fn null_serialize_perf_serde_json(b: &mut Bencher) {
132         let value: Value = serde_json::from_str(NULL_EXAMPLE).unwrap();
133         b.iter(|| {
134             for _ in 0..LOOPS_NUM {
135                 format!("{value}");
136             }
137         });
138     }
139 
140     #[bench]
boolean_serialize_perf_serde_json(b: &mut Bencher)141     fn boolean_serialize_perf_serde_json(b: &mut Bencher) {
142         let value: Value = serde_json::from_str(BOOLEAN_EXAMPLE).unwrap();
143         b.iter(|| {
144             for _ in 0..LOOPS_NUM {
145                 format!("{value}");
146             }
147         });
148     }
149 
150     #[bench]
number_serialize_perf_serde_json(b: &mut Bencher)151     fn number_serialize_perf_serde_json(b: &mut Bencher) {
152         let value: Value = serde_json::from_str(NUMBER_EXAMPLE).unwrap();
153         b.iter(|| {
154             for _ in 0..LOOPS_NUM {
155                 format!("{value}");
156             }
157         });
158     }
159 
160     #[bench]
string_serialize_perf_serde_json(b: &mut Bencher)161     fn string_serialize_perf_serde_json(b: &mut Bencher) {
162         let value: Value = serde_json::from_str(STRING_EXAMPLE).unwrap();
163         b.iter(|| {
164             for _ in 0..LOOPS_NUM {
165                 format!("{value}");
166             }
167         });
168     }
169 
170     #[bench]
array_serialize_perf_serde_json(b: &mut Bencher)171     fn array_serialize_perf_serde_json(b: &mut Bencher) {
172         let value: Value = serde_json::from_str(ARRAY_EXAMPLE).unwrap();
173         b.iter(|| {
174             for _ in 0..LOOPS_NUM {
175                 format!("{value}");
176             }
177         });
178     }
179 
180     #[bench]
object_serialize_perf_serde_json(b: &mut Bencher)181     fn object_serialize_perf_serde_json(b: &mut Bencher) {
182         let value: Value = serde_json::from_str(OBJECT_EXAMPLE).unwrap();
183         b.iter(|| {
184             for _ in 0..LOOPS_NUM {
185                 format!("{value}");
186             }
187         });
188     }
189 
190     #[bench]
exp1_serialize_perf_serde_json(b: &mut Bencher)191     fn exp1_serialize_perf_serde_json(b: &mut Bencher) {
192         let value: Value = serde_json::from_str(RFC7159_EXAMPLE1).unwrap();
193         b.iter(|| {
194             for _ in 0..LOOPS_NUM {
195                 format!("{value}");
196             }
197         });
198     }
199 
200     #[bench]
exp2_serialize_perf_serde_json(b: &mut Bencher)201     fn exp2_serialize_perf_serde_json(b: &mut Bencher) {
202         let value: Value = serde_json::from_str(RFC7159_EXAMPLE2).unwrap();
203         b.iter(|| {
204             for _ in 0..LOOPS_NUM {
205                 format!("{value}");
206             }
207         });
208     }
209 
210     #[bench]
exp3_serialize_perf_serde_json(b: &mut Bencher)211     fn exp3_serialize_perf_serde_json(b: &mut Bencher) {
212         let value: Value = serde_json::from_str(JSON_PARSE_TEST).unwrap();
213         b.iter(|| {
214             for _ in 0..LOOPS_NUM {
215                 format!("{value}");
216             }
217         });
218     }
219 
220     #[bench]
exp4_serialize_perf_serde_json(b: &mut Bencher)221     fn exp4_serialize_perf_serde_json(b: &mut Bencher) {
222         let value: Value = serde_json::from_str(LONG_KEY_VALUE).unwrap();
223         b.iter(|| {
224             for _ in 0..LOOPS_NUM {
225                 format!("{value}");
226             }
227         });
228     }
229 }
230