diff options
Diffstat (limited to 'src/crush/CrushTester.h')
| -rw-r--r-- | src/crush/CrushTester.h | 366 |
1 files changed, 366 insertions, 0 deletions
diff --git a/src/crush/CrushTester.h b/src/crush/CrushTester.h new file mode 100644 index 000000000..1bbc01a70 --- /dev/null +++ b/src/crush/CrushTester.h @@ -0,0 +1,366 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#ifndef CEPH_CRUSH_TESTER_H +#define CEPH_CRUSH_TESTER_H + +#include "crush/CrushWrapper.h" + +#include <fstream> + +class CrushTester { + CrushWrapper& crush; + std::ostream& err; + + std::map<int, int> device_weight; + int min_rule, max_rule; + int ruleset; + int min_x, max_x; + int min_rep, max_rep; + int64_t pool_id; + + int num_batches; + bool use_crush; + + float mark_down_device_ratio; + float mark_down_bucket_ratio; + + bool output_utilization; + bool output_utilization_all; + bool output_statistics; + bool output_mappings; + bool output_bad_mappings; + bool output_choose_tries; + + bool output_data_file; + bool output_csv; + + std::string output_data_file_name; + +/* + * mark a ratio of devices down, can be used to simulate placement distributions + * under degrated cluster conditions + */ + void adjust_weights(std::vector<__u32>& weight); + + /* + * Get the maximum number of devices that could be selected to satisfy ruleno. + */ + int get_maximum_affected_by_rule(int ruleno); + + /* + * for maps where in devices have non-sequential id numbers, return a mapping of device id + * to a sequential id number. For example, if we have devices with id's 0 1 4 5 6 return a map + * where: + * 0 = 0 + * 1 = 1 + * 4 = 2 + * 5 = 3 + * 6 = 4 + * + * which can help make post-processing easier + */ + std::map<int,int> get_collapsed_mapping(); + + /* + * Essentially a re-implementation of CRUSH. Given a vector of devices + * check that the vector represents a valid placement for a given ruleno. + */ + bool check_valid_placement(int ruleno, std::vector<int> in, const std::vector<__u32>& weight); + + /* + * Generate a random selection of devices which satisfies ruleno. Essentially a + * monte-carlo simulator for CRUSH placements which can be used to compare the + * statistical distribution of the CRUSH algorithm to a random number generator + */ + int random_placement(int ruleno, std::vector<int>& out, int maxout, std::vector<__u32>& weight); + + // scaffolding to store data for off-line processing + struct tester_data_set { + std::vector<std::string> device_utilization; + std::vector<std::string> device_utilization_all; + std::vector<std::string> placement_information; + std::vector<std::string> batch_device_utilization_all; + std::vector<std::string> batch_device_expected_utilization_all; + std::map<int, float> proportional_weights; + std::map<int, float> proportional_weights_all; + std::map<int, float> absolute_weights; + } ; + + void write_to_csv(std::ofstream& csv_file, std::vector<std::string>& payload) + { + if (csv_file.good()) + for (std::vector<std::string>::iterator it = payload.begin(); it != payload.end(); ++it) + csv_file << (*it); + } + + void write_to_csv(std::ofstream& csv_file, std::map<int, float>& payload) + { + if (csv_file.good()) + for (std::map<int, float>::iterator it = payload.begin(); it != payload.end(); ++it) + csv_file << (*it).first << ',' << (*it).second << std::endl; + } + + void write_data_set_to_csv(std::string user_tag, tester_data_set& tester_data) + { + + std::ofstream device_utilization_file((user_tag + (std::string)"-device_utilization.csv").c_str()); + std::ofstream device_utilization_all_file((user_tag + (std::string)"-device_utilization_all.csv").c_str()); + std::ofstream placement_information_file((user_tag + (std::string)"-placement_information.csv").c_str()); + std::ofstream proportional_weights_file((user_tag + (std::string)"-proportional_weights.csv").c_str()); + std::ofstream proportional_weights_all_file((user_tag + (std::string)"-proportional_weights_all.csv").c_str()); + std::ofstream absolute_weights_file((user_tag + (std::string)"-absolute_weights.csv").c_str()); + + // write the headers + device_utilization_file << "Device ID, Number of Objects Stored, Number of Objects Expected" << std::endl; + device_utilization_all_file << "Device ID, Number of Objects Stored, Number of Objects Expected" << std::endl; + proportional_weights_file << "Device ID, Proportional Weight" << std::endl; + proportional_weights_all_file << "Device ID, Proportional Weight" << std::endl; + absolute_weights_file << "Device ID, Absolute Weight" << std::endl; + + placement_information_file << "Input"; + for (int i = 0; i < max_rep; i++) { + placement_information_file << ", OSD" << i; + } + placement_information_file << std::endl; + + write_to_csv(device_utilization_file, tester_data.device_utilization); + write_to_csv(device_utilization_all_file, tester_data.device_utilization_all); + write_to_csv(placement_information_file, tester_data.placement_information); + write_to_csv(proportional_weights_file, tester_data.proportional_weights); + write_to_csv(proportional_weights_all_file, tester_data.proportional_weights_all); + write_to_csv(absolute_weights_file, tester_data.absolute_weights); + + device_utilization_file.close(); + device_utilization_all_file.close(); + placement_information_file.close(); + proportional_weights_file.close(); + absolute_weights_file.close(); + + if (num_batches > 1) { + std::ofstream batch_device_utilization_all_file ((user_tag + (std::string)"-batch_device_utilization_all.csv").c_str()); + std::ofstream batch_device_expected_utilization_all_file ((user_tag + (std::string)"-batch_device_expected_utilization_all.csv").c_str()); + + batch_device_utilization_all_file << "Batch Round"; + for (unsigned i = 0; i < tester_data.device_utilization.size(); i++) { + batch_device_utilization_all_file << ", Objects Stored on OSD" << i; + } + batch_device_utilization_all_file << std::endl; + + batch_device_expected_utilization_all_file << "Batch Round"; + for (unsigned i = 0; i < tester_data.device_utilization.size(); i++) { + batch_device_expected_utilization_all_file << ", Objects Expected on OSD" << i; + } + batch_device_expected_utilization_all_file << std::endl; + + write_to_csv(batch_device_utilization_all_file, tester_data.batch_device_utilization_all); + write_to_csv(batch_device_expected_utilization_all_file, tester_data.batch_device_expected_utilization_all); + batch_device_expected_utilization_all_file.close(); + batch_device_utilization_all_file.close(); + } + } + + void write_integer_indexed_vector_data_string(std::vector<std::string> &dst, int index, std::vector<int> vector_data); + void write_integer_indexed_vector_data_string(std::vector<std::string> &dst, int index, std::vector<float> vector_data); + void write_integer_indexed_scalar_data_string(std::vector<std::string> &dst, int index, int scalar_data); + void write_integer_indexed_scalar_data_string(std::vector<std::string> &dst, int index, float scalar_data); + +public: + CrushTester(CrushWrapper& c, std::ostream& eo) + : crush(c), err(eo), + min_rule(-1), max_rule(-1), + ruleset(-1), + min_x(-1), max_x(-1), + min_rep(-1), max_rep(-1), + pool_id(-1), + num_batches(1), + use_crush(true), + mark_down_device_ratio(0.0), + mark_down_bucket_ratio(1.0), + output_utilization(false), + output_utilization_all(false), + output_statistics(false), + output_mappings(false), + output_bad_mappings(false), + output_choose_tries(false), + output_data_file(false), + output_csv(false), + output_data_file_name("") + + { } + + void set_output_data_file_name(std::string name) { + output_data_file_name = name; + } + std::string get_output_data_file_name() const { + return output_data_file_name; + } + + void set_output_data_file(bool b) { + output_data_file = b; + } + bool get_output_data_file() const { + return output_data_file; + } + + void set_output_csv(bool b) { + output_csv = b; + } + bool get_output_csv() const { + return output_csv; + } + + void set_output_utilization(bool b) { + output_utilization = b; + } + bool get_output_utilization() const { + return output_utilization; + } + + void set_output_utilization_all(bool b) { + output_utilization_all = b; + } + bool get_output_utilization_all() const { + return output_utilization_all; + } + + void set_output_statistics(bool b) { + output_statistics = b; + } + bool get_output_statistics() const { + return output_statistics; + } + + void set_output_mappings(bool b) { + output_mappings = b; + } + bool get_output_mappings() const { + return output_mappings; + } + + void set_output_bad_mappings(bool b) { + output_bad_mappings = b; + } + bool get_output_bad_mappings() const { + return output_bad_mappings; + } + + void set_output_choose_tries(bool b) { + output_choose_tries = b; + } + bool get_output_choose_tries() const { + return output_choose_tries; + } + + void set_batches(int b) { + num_batches = b; + } + int get_batches() const { + return num_batches; + } + + void set_random_placement() { + use_crush = false; + } + bool get_random_placement() const { + return use_crush == false; + } + + void set_bucket_down_ratio(float bucket_ratio) { + mark_down_bucket_ratio = bucket_ratio; + } + float get_bucket_down_ratio() const { + return mark_down_bucket_ratio; + } + + void set_device_down_ratio(float device_ratio) { + mark_down_device_ratio = device_ratio; + } + float set_device_down_ratio() const { + return mark_down_device_ratio; + } + + void set_device_weight(int dev, float f); + + void set_min_rep(int r) { + min_rep = r; + } + int get_min_rep() const { + return min_rep; + } + + void set_max_rep(int r) { + max_rep = r; + } + int get_max_rep() const { + return max_rep; + } + + void set_num_rep(int r) { + min_rep = max_rep = r; + } + + void set_min_x(int x) { + min_x = x; + } + + void set_pool_id(int64_t x){ + pool_id = x; + } + + int get_min_x() const { + return min_x; + } + + void set_max_x(int x) { + max_x = x; + } + int get_max_x() const { + return max_x; + } + + void set_x(int x) { + min_x = max_x = x; + } + + void set_min_rule(int rule) { + min_rule = rule; + } + int get_min_rule() const { + return min_rule; + } + + void set_max_rule(int rule) { + max_rule = rule; + } + int get_max_rule() const { + return max_rule; + } + + void set_rule(int rule) { + min_rule = max_rule = rule; + } + + void set_ruleset(int rs) { + ruleset = rs; + } + + /** + * check if any bucket/nodes is referencing an unknown name or type + * @param max_id rejects any non-bucket items with id less than this number, + * pass 0 to disable this check + * @return false if an dangling name/type is referenced or an item id is too + * large, true otherwise + */ + bool check_name_maps(unsigned max_id = 0) const; + /** + * print out overlapped crush rules belonging to the same ruleset + */ + void check_overlapped_rules() const; + int test(); + int test_with_fork(int timeout); + + int compare(CrushWrapper& other); +}; + +#endif |