]>
Commit | Line | Data |
---|---|---|
9f95a23c TL |
1 | /* |
2 | * This file is open source software, licensed to you under the terms | |
3 | * of the Apache License, Version 2.0 (the "License"). See the NOTICE file | |
4 | * distributed with this work for additional information regarding copyright | |
5 | * ownership. You may not use this file except in compliance with the License. | |
6 | * | |
7 | * You may obtain a copy of the License at | |
8 | * | |
9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
10 | * | |
11 | * Unless required by applicable law or agreed to in writing, | |
12 | * software distributed under the License is distributed on an | |
13 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
14 | * KIND, either express or implied. See the License for the | |
15 | * specific language governing permissions and limitations | |
16 | * under the License. | |
17 | */ | |
18 | /* | |
19 | * Copyright (C) 2019 Scylladb, Ltd. | |
20 | */ | |
21 | ||
22 | #include <random> | |
23 | ||
24 | #include <seastar/rpc/lz4_compressor.hh> | |
25 | #include <seastar/rpc/lz4_fragmented_compressor.hh> | |
26 | ||
27 | #include <seastar/testing/perf_tests.hh> | |
20effc67 | 28 | #include <seastar/testing/random.hh> |
9f95a23c TL |
29 | |
30 | template<typename Compressor> | |
31 | struct compression { | |
32 | static constexpr size_t small_buffer_size = 128; | |
33 | static constexpr size_t large_buffer_size = 16 * 1024 * 1024; | |
34 | ||
35 | private: | |
36 | Compressor _compressor; | |
37 | ||
38 | seastar::temporary_buffer<char> _small_buffer_random; | |
39 | seastar::temporary_buffer<char> _small_buffer_zeroes; | |
40 | ||
41 | std::vector<seastar::temporary_buffer<char>> _large_buffer_random; | |
42 | std::vector<seastar::temporary_buffer<char>> _large_buffer_zeroes; | |
43 | ||
44 | std::vector<seastar::temporary_buffer<char>> _small_compressed_buffer_random; | |
45 | std::vector<seastar::temporary_buffer<char>> _small_compressed_buffer_zeroes; | |
46 | ||
47 | std::vector<seastar::temporary_buffer<char>> _large_compressed_buffer_random; | |
48 | std::vector<seastar::temporary_buffer<char>> _large_compressed_buffer_zeroes; | |
49 | ||
50 | private: | |
51 | static seastar::rpc::rcv_buf get_rcv_buf(std::vector<temporary_buffer<char>>& input) { | |
52 | if (input.size() == 1) { | |
53 | return seastar::rpc::rcv_buf(input.front().share()); | |
54 | } | |
55 | auto bufs = std::vector<temporary_buffer<char>>{}; | |
56 | auto total_size = std::accumulate(input.begin(), input.end(), size_t(0), | |
57 | [&] (size_t n, temporary_buffer<char>& buf) { | |
58 | bufs.emplace_back(buf.share()); | |
59 | return n + buf.size(); | |
60 | }); | |
61 | return seastar::rpc::rcv_buf(std::move(bufs), total_size); | |
62 | } | |
63 | ||
64 | static seastar::rpc::snd_buf get_snd_buf(std::vector<temporary_buffer<char>>& input) { | |
65 | auto bufs = std::vector<temporary_buffer<char>>{}; | |
66 | auto total_size = std::accumulate(input.begin(), input.end(), size_t(0), | |
67 | [&] (size_t n, temporary_buffer<char>& buf) { | |
68 | bufs.emplace_back(buf.share()); | |
69 | return n + buf.size(); | |
70 | }); | |
71 | return seastar::rpc::snd_buf(std::move(bufs), total_size); | |
72 | } | |
73 | static seastar::rpc::snd_buf get_snd_buf(temporary_buffer<char>& input) { | |
74 | return seastar::rpc::snd_buf(input.share()); | |
75 | } | |
76 | ||
77 | public: | |
78 | compression() | |
79 | : _small_buffer_random(seastar::temporary_buffer<char>(small_buffer_size)) | |
80 | , _small_buffer_zeroes(seastar::temporary_buffer<char>(small_buffer_size)) | |
81 | { | |
20effc67 | 82 | auto& eng = testing::local_random_engine; |
1e59de90 | 83 | auto dist = std::uniform_int_distribution<int>(0, std::numeric_limits<char>::max()); |
9f95a23c TL |
84 | |
85 | std::generate_n(_small_buffer_random.get_write(), small_buffer_size, [&] { return dist(eng); }); | |
86 | for (auto i = 0u; i < large_buffer_size / seastar::rpc::snd_buf::chunk_size; i++) { | |
87 | _large_buffer_random.emplace_back(seastar::rpc::snd_buf::chunk_size); | |
88 | std::generate_n(_large_buffer_random.back().get_write(), seastar::rpc::snd_buf::chunk_size, [&] { return dist(eng); }); | |
89 | _large_buffer_zeroes.emplace_back(seastar::rpc::snd_buf::chunk_size); | |
90 | std::fill_n(_large_buffer_zeroes.back().get_write(), seastar::rpc::snd_buf::chunk_size, 0); | |
91 | } | |
92 | ||
93 | auto rcv = _compressor.compress(0, seastar::rpc::snd_buf(_small_buffer_random.share())); | |
f67539c2 | 94 | if (auto buffer = std::get_if<seastar::temporary_buffer<char>>(&rcv.bufs)) { |
9f95a23c TL |
95 | _small_compressed_buffer_random.emplace_back(std::move(*buffer)); |
96 | } else { | |
97 | _small_compressed_buffer_random | |
f67539c2 | 98 | = std::move(std::get<std::vector<seastar::temporary_buffer<char>>>(rcv.bufs)); |
9f95a23c TL |
99 | } |
100 | ||
101 | rcv = _compressor.compress(0, seastar::rpc::snd_buf(_small_buffer_zeroes.share())); | |
f67539c2 | 102 | if (auto buffer = std::get_if<seastar::temporary_buffer<char>>(&rcv.bufs)) { |
9f95a23c TL |
103 | _small_compressed_buffer_zeroes.emplace_back(std::move(*buffer)); |
104 | } else { | |
105 | _small_compressed_buffer_zeroes | |
f67539c2 | 106 | = std::move(std::get<std::vector<seastar::temporary_buffer<char>>>(rcv.bufs)); |
9f95a23c TL |
107 | } |
108 | ||
109 | auto bufs = std::vector<temporary_buffer<char>>{}; | |
110 | for (auto&& b : _large_buffer_random) { | |
111 | bufs.emplace_back(b.clone()); | |
112 | } | |
113 | rcv = _compressor.compress(0, seastar::rpc::snd_buf(std::move(bufs), large_buffer_size)); | |
f67539c2 | 114 | if (auto buffer = std::get_if<seastar::temporary_buffer<char>>(&rcv.bufs)) { |
9f95a23c TL |
115 | _large_compressed_buffer_random.emplace_back(std::move(*buffer)); |
116 | } else { | |
117 | _large_compressed_buffer_random | |
f67539c2 | 118 | = std::move(std::get<std::vector<seastar::temporary_buffer<char>>>(rcv.bufs)); |
9f95a23c TL |
119 | } |
120 | ||
121 | bufs = std::vector<temporary_buffer<char>>{}; | |
122 | for (auto&& b : _large_buffer_zeroes) { | |
123 | bufs.emplace_back(b.clone()); | |
124 | } | |
125 | rcv = _compressor.compress(0, seastar::rpc::snd_buf(std::move(bufs), large_buffer_size)); | |
f67539c2 | 126 | if (auto buffer = std::get_if<seastar::temporary_buffer<char>>(&rcv.bufs)) { |
9f95a23c TL |
127 | _large_compressed_buffer_zeroes.emplace_back(std::move(*buffer)); |
128 | } else { | |
129 | _large_compressed_buffer_zeroes | |
f67539c2 | 130 | = std::move(std::get<std::vector<seastar::temporary_buffer<char>>>(rcv.bufs)); |
9f95a23c TL |
131 | } |
132 | } | |
133 | ||
134 | Compressor& compressor() { return _compressor; } | |
135 | ||
136 | seastar::rpc::snd_buf small_buffer_random() { | |
137 | return get_snd_buf(_small_buffer_random); | |
138 | } | |
139 | seastar::rpc::snd_buf small_buffer_zeroes() { | |
140 | return get_snd_buf(_small_buffer_zeroes); | |
141 | } | |
142 | ||
143 | seastar::rpc::snd_buf large_buffer_random() { | |
144 | return get_snd_buf(_large_buffer_random); | |
145 | } | |
146 | seastar::rpc::snd_buf large_buffer_zeroes() { | |
147 | return get_snd_buf(_large_buffer_zeroes); | |
148 | } | |
149 | ||
150 | seastar::rpc::rcv_buf small_compressed_buffer_random() { | |
151 | return get_rcv_buf(_small_compressed_buffer_random); | |
152 | } | |
153 | seastar::rpc::rcv_buf small_compressed_buffer_zeroes() { | |
154 | return get_rcv_buf(_small_compressed_buffer_zeroes); | |
155 | } | |
156 | ||
157 | seastar::rpc::rcv_buf large_compressed_buffer_random() { | |
158 | return get_rcv_buf(_large_compressed_buffer_random); | |
159 | } | |
160 | seastar::rpc::rcv_buf large_compressed_buffer_zeroes() { | |
161 | return get_rcv_buf(_large_compressed_buffer_zeroes); | |
162 | } | |
163 | }; | |
164 | ||
165 | using lz4 = compression<seastar::rpc::lz4_compressor>; | |
166 | ||
167 | PERF_TEST_F(lz4, small_random_buffer_compress) { | |
168 | perf_tests::do_not_optimize( | |
169 | compressor().compress(0, small_buffer_random()) | |
170 | ); | |
171 | } | |
172 | ||
173 | PERF_TEST_F(lz4, small_zeroed_buffer_compress) { | |
174 | perf_tests::do_not_optimize( | |
175 | compressor().compress(0, small_buffer_zeroes()) | |
176 | ); | |
177 | } | |
178 | ||
179 | PERF_TEST_F(lz4, large_random_buffer_compress) { | |
180 | perf_tests::do_not_optimize( | |
181 | compressor().compress(0, large_buffer_random()) | |
182 | ); | |
183 | } | |
184 | ||
185 | PERF_TEST_F(lz4, large_zeroed_buffer_compress) { | |
186 | perf_tests::do_not_optimize( | |
187 | compressor().compress(0, large_buffer_zeroes()) | |
188 | ); | |
189 | } | |
190 | ||
191 | PERF_TEST_F(lz4, small_random_buffer_decompress) { | |
192 | perf_tests::do_not_optimize( | |
193 | compressor().decompress(small_compressed_buffer_random()) | |
194 | ); | |
195 | } | |
196 | ||
197 | PERF_TEST_F(lz4, small_zeroed_buffer_decompress) { | |
198 | perf_tests::do_not_optimize( | |
199 | compressor().decompress(small_compressed_buffer_zeroes()) | |
200 | ); | |
201 | } | |
202 | ||
203 | PERF_TEST_F(lz4, large_random_buffer_decompress) { | |
204 | perf_tests::do_not_optimize( | |
205 | compressor().decompress(large_compressed_buffer_random()) | |
206 | ); | |
207 | } | |
208 | ||
209 | PERF_TEST_F(lz4, large_zeroed_buffer_decompress) { | |
210 | perf_tests::do_not_optimize( | |
211 | compressor().decompress(large_compressed_buffer_zeroes()) | |
212 | ); | |
213 | } | |
214 | ||
215 | using lz4_fragmented = compression<seastar::rpc::lz4_fragmented_compressor>; | |
216 | ||
217 | PERF_TEST_F(lz4_fragmented, small_random_buffer_compress) { | |
218 | perf_tests::do_not_optimize( | |
219 | compressor().compress(0, small_buffer_random()) | |
220 | ); | |
221 | } | |
222 | ||
223 | PERF_TEST_F(lz4_fragmented, small_zeroed_buffer_compress) { | |
224 | perf_tests::do_not_optimize( | |
225 | compressor().compress(0, small_buffer_zeroes()) | |
226 | ); | |
227 | } | |
228 | ||
229 | PERF_TEST_F(lz4_fragmented, large_random_buffer_compress) { | |
230 | perf_tests::do_not_optimize( | |
231 | compressor().compress(0, large_buffer_random()) | |
232 | ); | |
233 | } | |
234 | ||
235 | PERF_TEST_F(lz4_fragmented, large_zeroed_buffer_compress) { | |
236 | perf_tests::do_not_optimize( | |
237 | compressor().compress(0, large_buffer_zeroes()) | |
238 | ); | |
239 | } | |
240 | ||
241 | PERF_TEST_F(lz4_fragmented, small_random_buffer_decompress) { | |
242 | perf_tests::do_not_optimize( | |
243 | compressor().decompress(small_compressed_buffer_random()) | |
244 | ); | |
245 | } | |
246 | ||
247 | PERF_TEST_F(lz4_fragmented, small_zeroed_buffer_decompress) { | |
248 | perf_tests::do_not_optimize( | |
249 | compressor().decompress(small_compressed_buffer_zeroes()) | |
250 | ); | |
251 | } | |
252 | ||
253 | PERF_TEST_F(lz4_fragmented, large_random_buffer_decompress) { | |
254 | perf_tests::do_not_optimize( | |
255 | compressor().decompress(large_compressed_buffer_random()) | |
256 | ); | |
257 | } | |
258 | ||
259 | PERF_TEST_F(lz4_fragmented, large_zeroed_buffer_decompress) { | |
260 | perf_tests::do_not_optimize( | |
261 | compressor().decompress(large_compressed_buffer_zeroes()) | |
262 | ); | |
263 | } |