]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | ||
4 | #ifndef CEPH_CRUSH_TESTER_H | |
5 | #define CEPH_CRUSH_TESTER_H | |
6 | ||
7 | #include "crush/CrushWrapper.h" | |
8 | ||
9 | #include <fstream> | |
7c673cae FG |
10 | |
11 | class CrushTester { | |
12 | CrushWrapper& crush; | |
13 | ostream& err; | |
14 | ||
15 | map<int, int> device_weight; | |
16 | int min_rule, max_rule; | |
17 | int ruleset; | |
18 | int min_x, max_x; | |
19 | int min_rep, max_rep; | |
20 | int64_t pool_id; | |
21 | ||
22 | int num_batches; | |
23 | bool use_crush; | |
24 | ||
25 | float mark_down_device_ratio; | |
26 | float mark_down_bucket_ratio; | |
27 | ||
28 | bool output_utilization; | |
29 | bool output_utilization_all; | |
30 | bool output_statistics; | |
31 | bool output_mappings; | |
32 | bool output_bad_mappings; | |
33 | bool output_choose_tries; | |
34 | ||
35 | bool output_data_file; | |
36 | bool output_csv; | |
37 | ||
38 | string output_data_file_name; | |
39 | ||
40 | /* | |
41 | * mark a ratio of devices down, can be used to simulate placement distributions | |
42 | * under degrated cluster conditions | |
43 | */ | |
44 | void adjust_weights(vector<__u32>& weight); | |
45 | ||
46 | /* | |
47 | * Get the maximum number of devices that could be selected to satisfy ruleno. | |
48 | */ | |
49 | int get_maximum_affected_by_rule(int ruleno); | |
50 | ||
51 | /* | |
52 | * for maps where in devices have non-sequential id numbers, return a mapping of device id | |
53 | * to a sequential id number. For example, if we have devices with id's 0 1 4 5 6 return a map | |
54 | * where: | |
55 | * 0 = 0 | |
56 | * 1 = 1 | |
57 | * 4 = 2 | |
58 | * 5 = 3 | |
59 | * 6 = 4 | |
60 | * | |
61 | * which can help make post-processing easier | |
62 | */ | |
63 | map<int,int> get_collapsed_mapping(); | |
64 | ||
65 | /* | |
66 | * Essentially a re-implementation of CRUSH. Given a vector of devices | |
67 | * check that the vector represents a valid placement for a given ruleno. | |
68 | */ | |
69 | bool check_valid_placement(int ruleno, vector<int> in, const vector<__u32>& weight); | |
70 | ||
71 | /* | |
72 | * Generate a random selection of devices which satisfies ruleno. Essentially a | |
73 | * monte-carlo simulator for CRUSH placements which can be used to compare the | |
74 | * statistical distribution of the CRUSH algorithm to a random number generator | |
75 | */ | |
76 | int random_placement(int ruleno, vector<int>& out, int maxout, vector<__u32>& weight); | |
77 | ||
78 | // scaffolding to store data for off-line processing | |
79 | struct tester_data_set { | |
80 | vector <string> device_utilization; | |
81 | vector <string> device_utilization_all; | |
82 | vector <string> placement_information; | |
83 | vector <string> batch_device_utilization_all; | |
84 | vector <string> batch_device_expected_utilization_all; | |
85 | map<int, float> proportional_weights; | |
86 | map<int, float> proportional_weights_all; | |
87 | map<int, float> absolute_weights; | |
88 | } ; | |
89 | ||
90 | void write_to_csv(ofstream& csv_file, vector<string>& payload) | |
91 | { | |
92 | if (csv_file.good()) | |
93 | for (vector<string>::iterator it = payload.begin(); it != payload.end(); ++it) | |
94 | csv_file << (*it); | |
95 | } | |
96 | ||
97 | void write_to_csv(ofstream& csv_file, map<int, float>& payload) | |
98 | { | |
99 | if (csv_file.good()) | |
100 | for (map<int, float>::iterator it = payload.begin(); it != payload.end(); ++it) | |
101 | csv_file << (*it).first << ',' << (*it).second << std::endl; | |
102 | } | |
103 | ||
104 | void write_data_set_to_csv(string user_tag, tester_data_set& tester_data) | |
105 | { | |
106 | ||
107 | ofstream device_utilization_file ((user_tag + (string)"-device_utilization.csv").c_str()); | |
108 | ofstream device_utilization_all_file ((user_tag + (string)"-device_utilization_all.csv").c_str()); | |
109 | ofstream placement_information_file ((user_tag + (string)"-placement_information.csv").c_str()); | |
110 | ofstream proportional_weights_file ((user_tag + (string)"-proportional_weights.csv").c_str()); | |
111 | ofstream proportional_weights_all_file ((user_tag + (string)"-proportional_weights_all.csv").c_str()); | |
112 | ofstream absolute_weights_file ((user_tag + (string)"-absolute_weights.csv").c_str()); | |
113 | ||
114 | // write the headers | |
115 | device_utilization_file << "Device ID, Number of Objects Stored, Number of Objects Expected" << std::endl; | |
116 | device_utilization_all_file << "Device ID, Number of Objects Stored, Number of Objects Expected" << std::endl; | |
117 | proportional_weights_file << "Device ID, Proportional Weight" << std::endl; | |
118 | proportional_weights_all_file << "Device ID, Proportional Weight" << std::endl; | |
119 | absolute_weights_file << "Device ID, Absolute Weight" << std::endl; | |
120 | ||
121 | placement_information_file << "Input"; | |
122 | for (int i = 0; i < max_rep; i++) { | |
123 | placement_information_file << ", OSD" << i; | |
124 | } | |
125 | placement_information_file << std::endl; | |
126 | ||
127 | write_to_csv(device_utilization_file, tester_data.device_utilization); | |
128 | write_to_csv(device_utilization_all_file, tester_data.device_utilization_all); | |
129 | write_to_csv(placement_information_file, tester_data.placement_information); | |
130 | write_to_csv(proportional_weights_file, tester_data.proportional_weights); | |
131 | write_to_csv(proportional_weights_all_file, tester_data.proportional_weights_all); | |
132 | write_to_csv(absolute_weights_file, tester_data.absolute_weights); | |
133 | ||
134 | device_utilization_file.close(); | |
135 | device_utilization_all_file.close(); | |
136 | placement_information_file.close(); | |
137 | proportional_weights_file.close(); | |
138 | absolute_weights_file.close(); | |
139 | ||
140 | if (num_batches > 1) { | |
141 | ofstream batch_device_utilization_all_file ((user_tag + (string)"-batch_device_utilization_all.csv").c_str()); | |
142 | ofstream batch_device_expected_utilization_all_file ((user_tag + (string)"-batch_device_expected_utilization_all.csv").c_str()); | |
143 | ||
144 | batch_device_utilization_all_file << "Batch Round"; | |
145 | for (unsigned i = 0; i < tester_data.device_utilization.size(); i++) { | |
146 | batch_device_utilization_all_file << ", Objects Stored on OSD" << i; | |
147 | } | |
148 | batch_device_utilization_all_file << std::endl; | |
149 | ||
150 | batch_device_expected_utilization_all_file << "Batch Round"; | |
151 | for (unsigned i = 0; i < tester_data.device_utilization.size(); i++) { | |
152 | batch_device_expected_utilization_all_file << ", Objects Expected on OSD" << i; | |
153 | } | |
154 | batch_device_expected_utilization_all_file << std::endl; | |
155 | ||
156 | write_to_csv(batch_device_utilization_all_file, tester_data.batch_device_utilization_all); | |
157 | write_to_csv(batch_device_expected_utilization_all_file, tester_data.batch_device_expected_utilization_all); | |
158 | batch_device_expected_utilization_all_file.close(); | |
159 | batch_device_utilization_all_file.close(); | |
160 | } | |
161 | } | |
162 | ||
163 | void write_integer_indexed_vector_data_string(vector<string> &dst, int index, vector<int> vector_data); | |
164 | void write_integer_indexed_vector_data_string(vector<string> &dst, int index, vector<float> vector_data); | |
165 | void write_integer_indexed_scalar_data_string(vector<string> &dst, int index, int scalar_data); | |
166 | void write_integer_indexed_scalar_data_string(vector<string> &dst, int index, float scalar_data); | |
167 | ||
168 | public: | |
169 | CrushTester(CrushWrapper& c, ostream& eo) | |
170 | : crush(c), err(eo), | |
171 | min_rule(-1), max_rule(-1), | |
172 | ruleset(-1), | |
173 | min_x(-1), max_x(-1), | |
174 | min_rep(-1), max_rep(-1), | |
175 | pool_id(-1), | |
176 | num_batches(1), | |
177 | use_crush(true), | |
178 | mark_down_device_ratio(0.0), | |
179 | mark_down_bucket_ratio(1.0), | |
180 | output_utilization(false), | |
181 | output_utilization_all(false), | |
182 | output_statistics(false), | |
183 | output_mappings(false), | |
184 | output_bad_mappings(false), | |
185 | output_choose_tries(false), | |
186 | output_data_file(false), | |
187 | output_csv(false), | |
188 | output_data_file_name("") | |
189 | ||
190 | { } | |
191 | ||
192 | void set_output_data_file_name(string name) { | |
193 | output_data_file_name = name; | |
194 | } | |
195 | string get_output_data_file_name() const { | |
196 | return output_data_file_name; | |
197 | } | |
198 | ||
199 | void set_output_data_file(bool b) { | |
200 | output_data_file = b; | |
201 | } | |
202 | bool get_output_data_file() const { | |
203 | return output_data_file; | |
204 | } | |
205 | ||
206 | void set_output_csv(bool b) { | |
207 | output_csv = b; | |
208 | } | |
209 | bool get_output_csv() const { | |
210 | return output_csv; | |
211 | } | |
212 | ||
213 | void set_output_utilization(bool b) { | |
214 | output_utilization = b; | |
215 | } | |
216 | bool get_output_utilization() const { | |
217 | return output_utilization; | |
218 | } | |
219 | ||
220 | void set_output_utilization_all(bool b) { | |
221 | output_utilization_all = b; | |
222 | } | |
223 | bool get_output_utilization_all() const { | |
224 | return output_utilization_all; | |
225 | } | |
226 | ||
227 | void set_output_statistics(bool b) { | |
228 | output_statistics = b; | |
229 | } | |
230 | bool get_output_statistics() const { | |
231 | return output_statistics; | |
232 | } | |
233 | ||
234 | void set_output_mappings(bool b) { | |
235 | output_mappings = b; | |
236 | } | |
237 | bool get_output_mappings() const { | |
238 | return output_mappings; | |
239 | } | |
240 | ||
241 | void set_output_bad_mappings(bool b) { | |
242 | output_bad_mappings = b; | |
243 | } | |
244 | bool get_output_bad_mappings() const { | |
245 | return output_bad_mappings; | |
246 | } | |
247 | ||
248 | void set_output_choose_tries(bool b) { | |
249 | output_choose_tries = b; | |
250 | } | |
251 | bool get_output_choose_tries() const { | |
252 | return output_choose_tries; | |
253 | } | |
254 | ||
255 | void set_batches(int b) { | |
256 | num_batches = b; | |
257 | } | |
258 | int get_batches() const { | |
259 | return num_batches; | |
260 | } | |
261 | ||
262 | void set_random_placement() { | |
263 | use_crush = false; | |
264 | } | |
265 | bool get_random_placement() const { | |
266 | return use_crush == false; | |
267 | } | |
268 | ||
269 | void set_bucket_down_ratio(float bucket_ratio) { | |
270 | mark_down_bucket_ratio = bucket_ratio; | |
271 | } | |
272 | float get_bucket_down_ratio() const { | |
273 | return mark_down_bucket_ratio; | |
274 | } | |
275 | ||
276 | void set_device_down_ratio(float device_ratio) { | |
277 | mark_down_device_ratio = device_ratio; | |
278 | } | |
279 | float set_device_down_ratio() const { | |
280 | return mark_down_device_ratio; | |
281 | } | |
282 | ||
283 | void set_device_weight(int dev, float f); | |
284 | ||
285 | void set_min_rep(int r) { | |
286 | min_rep = r; | |
287 | } | |
288 | int get_min_rep() const { | |
289 | return min_rep; | |
290 | } | |
291 | ||
292 | void set_max_rep(int r) { | |
293 | max_rep = r; | |
294 | } | |
295 | int get_max_rep() const { | |
296 | return max_rep; | |
297 | } | |
298 | ||
299 | void set_num_rep(int r) { | |
300 | min_rep = max_rep = r; | |
301 | } | |
302 | ||
303 | void set_min_x(int x) { | |
304 | min_x = x; | |
305 | } | |
306 | ||
307 | void set_pool_id(int64_t x){ | |
308 | pool_id = x; | |
309 | } | |
310 | ||
311 | int get_min_x() const { | |
312 | return min_x; | |
313 | } | |
314 | ||
315 | void set_max_x(int x) { | |
316 | max_x = x; | |
317 | } | |
318 | int get_max_x() const { | |
319 | return max_x; | |
320 | } | |
321 | ||
322 | void set_x(int x) { | |
323 | min_x = max_x = x; | |
324 | } | |
325 | ||
326 | void set_min_rule(int rule) { | |
327 | min_rule = rule; | |
328 | } | |
329 | int get_min_rule() const { | |
330 | return min_rule; | |
331 | } | |
332 | ||
333 | void set_max_rule(int rule) { | |
334 | max_rule = rule; | |
335 | } | |
336 | int get_max_rule() const { | |
337 | return max_rule; | |
338 | } | |
339 | ||
340 | void set_rule(int rule) { | |
341 | min_rule = max_rule = rule; | |
342 | } | |
343 | ||
344 | void set_ruleset(int rs) { | |
345 | ruleset = rs; | |
346 | } | |
347 | ||
348 | /** | |
349 | * check if any bucket/nodes is referencing an unknown name or type | |
350 | * @param max_id rejects any non-bucket items with id less than this number, | |
351 | * pass 0 to disable this check | |
352 | * @return false if an dangling name/type is referenced or an item id is too | |
353 | * large, true otherwise | |
354 | */ | |
355 | bool check_name_maps(unsigned max_id = 0) const; | |
356 | /** | |
357 | * print out overlapped crush rules belonging to the same ruleset | |
358 | */ | |
359 | void check_overlapped_rules() const; | |
360 | int test(); | |
224ce89b | 361 | int test_with_fork(int timeout); |
7c673cae FG |
362 | }; |
363 | ||
364 | #endif |