]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* |
2 | * Generate latency statistics for a configurable number of object map write | |
3 | * operations of configurable size. | |
4 | * | |
5 | * Created on: May 21, 2012 | |
6 | * Author: Eleanor Cawthon | |
7 | * | |
8 | * This is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU Lesser General Public | |
10 | * License version 2.1, as published by the Free Software | |
11 | * Foundation. See file COPYING. | |
12 | */ | |
13 | ||
14 | #ifndef OMAP_BENCH_HPP_ | |
15 | #define OMAP_BENCH_HPP_ | |
16 | ||
17 | #include "common/Mutex.h" | |
18 | #include "common/Cond.h" | |
19 | #include "include/rados/librados.hpp" | |
20 | #include <string> | |
21 | #include <map> | |
22 | #include <cfloat> | |
23 | ||
24 | using ceph::bufferlist; | |
25 | ||
26 | struct o_bench_data { | |
27 | double avg_latency; | |
28 | double min_latency; | |
29 | double max_latency; | |
30 | double total_latency; | |
31 | int started_ops; | |
32 | int completed_ops; | |
33 | std::map<int,int> freq_map; | |
34 | pair<int,int> mode; | |
35 | o_bench_data() | |
36 | : avg_latency(0.0), min_latency(DBL_MAX), max_latency(0.0), | |
37 | total_latency(0.0), | |
38 | started_ops(0), completed_ops(0) | |
39 | {} | |
40 | }; | |
41 | ||
42 | class OmapBench; | |
43 | ||
44 | typedef int (*omap_generator_t)(const int omap_entries, const int key_size, | |
45 | const int value_size, | |
46 | std::map<std::string,bufferlist> *out_omap); | |
47 | typedef int (OmapBench::*test_t)(omap_generator_t omap_gen); | |
48 | ||
49 | ||
50 | class Writer{ | |
51 | protected: | |
52 | string oid; | |
53 | utime_t begin_time; | |
54 | utime_t end_time; | |
55 | std::map<std::string,bufferlist> omap; | |
56 | OmapBench *ob; | |
57 | friend class OmapBench; | |
58 | public: | |
59 | Writer(OmapBench *omap_bench); | |
60 | virtual ~Writer(){}; | |
61 | virtual void start_time(); | |
62 | virtual void stop_time(); | |
63 | virtual double get_time(); | |
64 | virtual string get_oid(); | |
65 | virtual std::map<std::string,bufferlist> & get_omap(); | |
66 | }; | |
67 | ||
68 | class AioWriter : public Writer{ | |
69 | protected: | |
70 | librados::AioCompletion * aioc; | |
71 | friend class OmapBench; | |
72 | ||
73 | public: | |
74 | AioWriter(OmapBench *omap_bench); | |
75 | ~AioWriter() override; | |
76 | virtual librados::AioCompletion * get_aioc(); | |
77 | virtual void set_aioc(librados::callback_t complete, | |
78 | librados::callback_t safe); | |
79 | }; | |
80 | ||
81 | class OmapBench{ | |
82 | protected: | |
83 | librados::IoCtx io_ctx; | |
84 | librados::Rados rados; | |
85 | struct o_bench_data data; | |
86 | test_t test; | |
87 | omap_generator_t omap_generator; | |
88 | ||
89 | //aio things | |
90 | Cond thread_is_free; | |
91 | Mutex thread_is_free_lock; | |
92 | Mutex data_lock; | |
93 | int busythreads_count; | |
94 | librados::callback_t comp; | |
95 | librados::callback_t safe; | |
96 | ||
97 | string pool_name; | |
98 | string rados_id; | |
99 | string prefix; | |
100 | int threads; | |
101 | int objects; | |
102 | int entries_per_omap; | |
103 | int key_size; | |
104 | int value_size; | |
105 | double increment; | |
106 | ||
107 | friend class Writer; | |
108 | friend class AioWriter; | |
109 | ||
110 | public: | |
111 | OmapBench() | |
112 | : test(&OmapBench::test_write_objects_in_parallel), | |
113 | omap_generator(generate_uniform_omap), | |
114 | thread_is_free_lock("OmapBench::thread_is_free_lock"), | |
115 | data_lock("OmapBench::data_lock"), | |
116 | busythreads_count(0), | |
117 | comp(NULL), safe(aio_is_safe), | |
118 | pool_name("rbd"), | |
119 | rados_id("admin"), | |
120 | prefix(rados_id+".obj."), | |
121 | threads(3), objects(100), entries_per_omap(10), key_size(10), | |
122 | value_size(100), increment(10) | |
123 | {} | |
124 | /** | |
125 | * Parses command line args, initializes rados and ioctx | |
126 | */ | |
127 | int setup(int argc, const char** argv); | |
128 | ||
129 | /** | |
130 | * Callback for when an AioCompletion (called from an AioWriter) | |
131 | * is safe. deletes the AioWriter that called it, | |
132 | * Updates data, updates busythreads, and signals thread_is_free. | |
133 | * | |
134 | * @param c provided by aio_write - not used | |
135 | * @param arg the AioWriter that contains this AioCompletion | |
136 | */ | |
137 | static void aio_is_safe(rados_completion_t c, void *arg); | |
138 | ||
139 | /** | |
140 | * Generates a random string len characters long | |
141 | */ | |
142 | static string random_string(int len); | |
143 | ||
144 | /* | |
145 | * runs the test specified by test using the omap generator specified by | |
146 | * omap_generator | |
147 | * | |
148 | * @return error code | |
149 | */ | |
150 | int run(); | |
151 | ||
152 | /* | |
153 | * Prints all keys and values for all omap entries for all objects | |
154 | */ | |
155 | int print_written_omap(); | |
156 | ||
157 | /* | |
158 | * Displays relevant constants and the histogram generated through a test | |
159 | */ | |
160 | void print_results(); | |
161 | ||
162 | /** | |
163 | * Writes an object with the specified AioWriter. | |
164 | * | |
165 | * @param aiow the AioWriter to write with | |
166 | * @param omap the omap to write | |
167 | * @post: an asynchronous omap_set is launched | |
168 | */ | |
169 | int write_omap_asynchronously(AioWriter *aiow, | |
170 | const std::map<std::string,bufferlist> &map); | |
171 | ||
172 | ||
173 | /** | |
174 | * Generates an omap with omap_entries entries, each with keys key_size | |
175 | * characters long and with string values value_size characters long. | |
176 | * | |
177 | * @param out_map pointer to the map to be created | |
178 | * @return error code | |
179 | */ | |
180 | static int generate_uniform_omap(const int omap_entries, const int key_size, | |
181 | const int value_size, std::map<std::string,bufferlist> * out_omap); | |
182 | ||
183 | /** | |
184 | * The same as generate_uniform_omap except that string lengths are picked | |
185 | * randomly between 1 and the int arguments | |
186 | */ | |
187 | static int generate_non_uniform_omap(const int omap_entries, | |
188 | const int key_size, | |
189 | const int value_size, std::map<std::string,bufferlist> * out_omap); | |
190 | ||
191 | static int generate_small_non_random_omap(const int omap_entries, | |
192 | const int key_size, const int value_size, | |
193 | std::map<std::string,bufferlist> * out_omap); | |
194 | ||
195 | /* | |
196 | * Uses aio_write to write omaps generated by omap_gen to OBJECTS objects | |
197 | * using THREADS AioWriters at a time. | |
198 | * | |
199 | * @param omap_gen the method used to generate the omaps. | |
200 | */ | |
201 | int test_write_objects_in_parallel(omap_generator_t omap_gen); | |
202 | ||
203 | }; | |
204 | ||
205 | ||
206 | ||
207 | #endif /* OMAP_BENCH_HPP_ */ | |
208 |