diff options
Diffstat (limited to 'src/setu/perf_setu_api.c')
-rw-r--r-- | src/setu/perf_setu_api.c | 571 |
1 files changed, 308 insertions, 263 deletions
diff --git a/src/setu/perf_setu_api.c b/src/setu/perf_setu_api.c index b273f9c71..af84994f8 100644 --- a/src/setu/perf_setu_api.c +++ b/src/setu/perf_setu_api.c | |||
@@ -22,11 +22,14 @@ | |||
22 | * @file set/test_setu_api.c | 22 | * @file set/test_setu_api.c |
23 | * @brief testcase for setu_api.c | 23 | * @brief testcase for setu_api.c |
24 | * @author Florian Dold | 24 | * @author Florian Dold |
25 | * @author Elias Summermatter | ||
25 | */ | 26 | */ |
26 | #include "platform.h" | 27 | #include "platform.h" |
27 | #include "gnunet_util_lib.h" | 28 | #include "gnunet_util_lib.h" |
28 | #include "gnunet_testing_lib.h" | 29 | #include "gnunet_testing_lib.h" |
29 | #include "gnunet_setu_service.h" | 30 | #include "gnunet_setu_service.h" |
31 | #include <sys/sysinfo.h> | ||
32 | #include <pthread.h> | ||
30 | 33 | ||
31 | 34 | ||
32 | static struct GNUNET_PeerIdentity local_id; | 35 | static struct GNUNET_PeerIdentity local_id; |
@@ -50,6 +53,12 @@ static int ret; | |||
50 | static struct GNUNET_SCHEDULER_Task *tt; | 53 | static struct GNUNET_SCHEDULER_Task *tt; |
51 | 54 | ||
52 | 55 | ||
56 | /** | ||
57 | * Handles configuration file for setu performance test | ||
58 | * | ||
59 | */ | ||
60 | static struct GNUNET_CONFIGURATION_Handle *setu_cfg; | ||
61 | |||
53 | 62 | ||
54 | static void | 63 | static void |
55 | result_cb_set1 (void *cls, | 64 | result_cb_set1 (void *cls, |
@@ -57,44 +66,44 @@ result_cb_set1 (void *cls, | |||
57 | uint64_t size, | 66 | uint64_t size, |
58 | enum GNUNET_SETU_Status status) | 67 | enum GNUNET_SETU_Status status) |
59 | { | 68 | { |
60 | switch (status) | 69 | switch (status) |
70 | { | ||
71 | case GNUNET_SETU_STATUS_ADD_LOCAL: | ||
72 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); | ||
73 | break; | ||
74 | |||
75 | case GNUNET_SETU_STATUS_FAILURE: | ||
76 | GNUNET_break (0); | ||
77 | oh1 = NULL; | ||
78 | fprintf (stderr, "set 1: received failure status!\n"); | ||
79 | ret = 1; | ||
80 | if (NULL != tt) | ||
81 | { | ||
82 | GNUNET_SCHEDULER_cancel (tt); | ||
83 | tt = NULL; | ||
84 | } | ||
85 | GNUNET_SCHEDULER_shutdown (); | ||
86 | break; | ||
87 | |||
88 | case GNUNET_SETU_STATUS_DONE: | ||
89 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); | ||
90 | oh1 = NULL; | ||
91 | if (NULL != set1) | ||
61 | { | 92 | { |
62 | case GNUNET_SETU_STATUS_ADD_LOCAL: | 93 | GNUNET_SETU_destroy (set1); |
63 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); | 94 | set1 = NULL; |
64 | break; | ||
65 | |||
66 | case GNUNET_SETU_STATUS_FAILURE: | ||
67 | GNUNET_break (0); | ||
68 | oh1 = NULL; | ||
69 | fprintf (stderr, "set 1: received failure status!\n"); | ||
70 | ret = 1; | ||
71 | if (NULL != tt) | ||
72 | { | ||
73 | GNUNET_SCHEDULER_cancel (tt); | ||
74 | tt = NULL; | ||
75 | } | ||
76 | GNUNET_SCHEDULER_shutdown (); | ||
77 | break; | ||
78 | |||
79 | case GNUNET_SETU_STATUS_DONE: | ||
80 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); | ||
81 | oh1 = NULL; | ||
82 | if (NULL != set1) | ||
83 | { | ||
84 | GNUNET_SETU_destroy (set1); | ||
85 | set1 = NULL; | ||
86 | } | ||
87 | if (NULL == set2) | ||
88 | { | ||
89 | GNUNET_SCHEDULER_cancel (tt); | ||
90 | tt = NULL; | ||
91 | GNUNET_SCHEDULER_shutdown (); | ||
92 | } | ||
93 | break; | ||
94 | |||
95 | default: | ||
96 | GNUNET_assert (0); | ||
97 | } | 95 | } |
96 | if (NULL == set2) | ||
97 | { | ||
98 | GNUNET_SCHEDULER_cancel (tt); | ||
99 | tt = NULL; | ||
100 | GNUNET_SCHEDULER_shutdown (); | ||
101 | } | ||
102 | break; | ||
103 | |||
104 | default: | ||
105 | GNUNET_assert (0); | ||
106 | } | ||
98 | } | 107 | } |
99 | 108 | ||
100 | 109 | ||
@@ -104,36 +113,36 @@ result_cb_set2 (void *cls, | |||
104 | uint64_t size, | 113 | uint64_t size, |
105 | enum GNUNET_SETU_Status status) | 114 | enum GNUNET_SETU_Status status) |
106 | { | 115 | { |
107 | switch (status) | 116 | switch (status) |
117 | { | ||
118 | case GNUNET_SETU_STATUS_ADD_LOCAL: | ||
119 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); | ||
120 | break; | ||
121 | |||
122 | case GNUNET_SETU_STATUS_FAILURE: | ||
123 | GNUNET_break (0); | ||
124 | oh2 = NULL; | ||
125 | fprintf (stderr, "set 2: received failure status\n"); | ||
126 | GNUNET_SCHEDULER_shutdown (); | ||
127 | ret = 1; | ||
128 | break; | ||
129 | |||
130 | case GNUNET_SETU_STATUS_DONE: | ||
131 | oh2 = NULL; | ||
132 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
133 | GNUNET_SETU_destroy (set2); | ||
134 | set2 = NULL; | ||
135 | if (NULL == set1) | ||
108 | { | 136 | { |
109 | case GNUNET_SETU_STATUS_ADD_LOCAL: | 137 | GNUNET_SCHEDULER_cancel (tt); |
110 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); | 138 | tt = NULL; |
111 | break; | 139 | GNUNET_SCHEDULER_shutdown (); |
112 | |||
113 | case GNUNET_SETU_STATUS_FAILURE: | ||
114 | GNUNET_break (0); | ||
115 | oh2 = NULL; | ||
116 | fprintf (stderr, "set 2: received failure status\n"); | ||
117 | GNUNET_SCHEDULER_shutdown (); | ||
118 | ret = 1; | ||
119 | break; | ||
120 | |||
121 | case GNUNET_SETU_STATUS_DONE: | ||
122 | oh2 = NULL; | ||
123 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
124 | GNUNET_SETU_destroy (set2); | ||
125 | set2 = NULL; | ||
126 | if (NULL == set1) | ||
127 | { | ||
128 | GNUNET_SCHEDULER_cancel (tt); | ||
129 | tt = NULL; | ||
130 | GNUNET_SCHEDULER_shutdown (); | ||
131 | } | ||
132 | break; | ||
133 | |||
134 | default: | ||
135 | GNUNET_assert (0); | ||
136 | } | 140 | } |
141 | break; | ||
142 | |||
143 | default: | ||
144 | GNUNET_assert (0); | ||
145 | } | ||
137 | } | 146 | } |
138 | 147 | ||
139 | 148 | ||
@@ -143,14 +152,14 @@ listen_cb (void *cls, | |||
143 | const struct GNUNET_MessageHeader *context_msg, | 152 | const struct GNUNET_MessageHeader *context_msg, |
144 | struct GNUNET_SETU_Request *request) | 153 | struct GNUNET_SETU_Request *request) |
145 | { | 154 | { |
146 | GNUNET_assert (NULL != context_msg); | 155 | GNUNET_assert (NULL != context_msg); |
147 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 156 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); | 157 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); |
149 | oh2 = GNUNET_SETU_accept (request, | 158 | oh2 = GNUNET_SETU_accept (request, |
150 | (struct GNUNET_SETU_Option[]){ 0 }, | 159 | (struct GNUNET_SETU_Option[]){ 0 }, |
151 | &result_cb_set2, | 160 | &result_cb_set2, |
152 | NULL); | 161 | NULL); |
153 | GNUNET_SETU_commit (oh2, set2); | 162 | GNUNET_SETU_commit (oh2, set2); |
154 | } | 163 | } |
155 | 164 | ||
156 | 165 | ||
@@ -162,122 +171,89 @@ listen_cb (void *cls, | |||
162 | static void | 171 | static void |
163 | start (void *cls) | 172 | start (void *cls) |
164 | { | 173 | { |
165 | struct GNUNET_MessageHeader context_msg; | 174 | struct GNUNET_MessageHeader context_msg; |
166 | 175 | ||
167 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); | 176 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); |
168 | context_msg.size = htons (sizeof context_msg); | 177 | context_msg.size = htons (sizeof context_msg); |
169 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); | 178 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); |
170 | listen_handle = GNUNET_SETU_listen (config, | 179 | listen_handle = GNUNET_SETU_listen (config, |
171 | &app_id, | 180 | &app_id, |
172 | &listen_cb, | 181 | &listen_cb, |
173 | NULL); | 182 | NULL); |
174 | oh1 = GNUNET_SETU_prepare (&local_id, | 183 | oh1 = GNUNET_SETU_prepare (&local_id, |
175 | &app_id, | 184 | &app_id, |
176 | &context_msg, | 185 | &context_msg, |
177 | (struct GNUNET_SETU_Option[]){ 0 }, | 186 | (struct GNUNET_SETU_Option[]){ 0 }, |
178 | &result_cb_set1, | 187 | &result_cb_set1, |
179 | NULL); | 188 | NULL); |
180 | GNUNET_SETU_commit (oh1, set1); | 189 | GNUNET_SETU_commit (oh1, set1); |
181 | } | 190 | } |
182 | 191 | ||
183 | 192 | ||
184 | /** | 193 | /** |
185 | * Initialize the second set, continue | ||
186 | * | ||
187 | * @param cls closure, unused | ||
188 | */ | ||
189 | static void | ||
190 | init_set2 (void *cls) | ||
191 | { | ||
192 | struct GNUNET_SETU_Element element; | ||
193 | |||
194 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n"); | ||
195 | |||
196 | element.element_type = 0; | ||
197 | element.data = "hello1"; | ||
198 | element.size = strlen (element.data); | ||
199 | GNUNET_SETU_add_element (set2, &element, NULL, NULL); | ||
200 | element.data = "quux"; | ||
201 | element.size = strlen (element.data); | ||
202 | GNUNET_SETU_add_element (set2, &element, NULL, NULL); | ||
203 | element.data = "baz"; | ||
204 | element.size = strlen (element.data); | ||
205 | GNUNET_SETU_add_element (set2, &element, &start, NULL); | ||
206 | } | ||
207 | |||
208 | /** | ||
209 | * Generate random byte stream | 194 | * Generate random byte stream |
210 | */ | 195 | */ |
211 | 196 | ||
212 | unsigned char *gen_rdm_bytestream (size_t num_bytes) | 197 | unsigned char * |
198 | gen_rdm_bytestream (size_t num_bytes) | ||
213 | { | 199 | { |
214 | unsigned char *stream = GNUNET_malloc (num_bytes); | 200 | unsigned char *stream = GNUNET_malloc (num_bytes); |
215 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, stream, num_bytes); | 201 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, stream, num_bytes); |
216 | return stream; | 202 | return stream; |
217 | } | 203 | } |
218 | 204 | ||
205 | |||
219 | /** | 206 | /** |
220 | * Generate random sets | 207 | * Generate random sets |
221 | */ | 208 | */ |
222 | 209 | ||
223 | static void | 210 | static void |
224 | initRandomSets(int overlap, int set1_size, int set2_size, int element_size_in_bytes) | 211 | initRandomSets (int overlap, int set1_size, int set2_size, int |
212 | element_size_in_bytes) | ||
225 | { | 213 | { |
226 | struct GNUNET_SETU_Element element; | 214 | struct GNUNET_SETU_Element element; |
227 | element.element_type = 0; | 215 | element.element_type = 0; |
228 | 216 | ||
229 | // Add elements to both sets | 217 | // Add elements to both sets |
230 | for (int i = 0; i < overlap; i++) { | 218 | for (int i = 0; i < overlap; i++) |
231 | element.data = gen_rdm_bytestream(element_size_in_bytes); | 219 | { |
232 | element.size = element_size_in_bytes; | 220 | element.data = gen_rdm_bytestream (element_size_in_bytes); |
233 | GNUNET_SETU_add_element (set1, &element, NULL, NULL); | 221 | element.size = element_size_in_bytes; |
234 | GNUNET_SETU_add_element (set2, &element, NULL, NULL); | 222 | GNUNET_SETU_add_element (set1, &element, NULL, NULL); |
235 | set1_size--; | 223 | GNUNET_SETU_add_element (set2, &element, NULL, NULL); |
236 | set2_size--; | 224 | set1_size--; |
237 | } | 225 | set2_size--; |
238 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in both sets\n"); | 226 | } |
239 | 227 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in both sets\n"); | |
240 | // Add other elements to set 1 | 228 | |
241 | while(set1_size>0) { | 229 | // Add other elements to set 1 |
242 | element.data = gen_rdm_bytestream(element_size_in_bytes); | 230 | while (set1_size>0) |
243 | element.size = element_size_in_bytes; | 231 | { |
244 | GNUNET_SETU_add_element (set1, &element, NULL, NULL); | 232 | element.data = gen_rdm_bytestream (element_size_in_bytes); |
245 | set1_size--; | 233 | element.size = element_size_in_bytes; |
246 | } | 234 | GNUNET_SETU_add_element (set1, &element, NULL, NULL); |
247 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set1\n"); | 235 | set1_size--; |
248 | 236 | } | |
249 | // Add other elements to set 2 | 237 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set1\n"); |
250 | while(set2_size > 0) { | ||
251 | element.data = gen_rdm_bytestream(element_size_in_bytes); | ||
252 | element.size = element_size_in_bytes; | ||
253 | 238 | ||
254 | if(set2_size != 1) { | 239 | // Add other elements to set 2 |
255 | GNUNET_SETU_add_element (set2, &element,NULL, NULL); | 240 | while (set2_size > 0) |
256 | } else { | 241 | { |
257 | GNUNET_SETU_add_element (set2, &element,&start, NULL); | 242 | element.data = gen_rdm_bytestream (element_size_in_bytes); |
258 | } | 243 | element.size = element_size_in_bytes; |
259 | 244 | ||
260 | set2_size--; | 245 | if (set2_size != 1) |
246 | { | ||
247 | GNUNET_SETU_add_element (set2, &element,NULL, NULL); | ||
248 | } | ||
249 | else | ||
250 | { | ||
251 | GNUNET_SETU_add_element (set2, &element,&start, NULL); | ||
261 | } | 252 | } |
262 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set2\n"); | ||
263 | } | ||
264 | |||
265 | /** | ||
266 | * Initialize the first set, continue. | ||
267 | */ | ||
268 | static void | ||
269 | init_set1 (void) | ||
270 | { | ||
271 | struct GNUNET_SETU_Element element; | ||
272 | 253 | ||
273 | element.element_type = 0; | 254 | set2_size--; |
274 | element.data = "hello"; | 255 | } |
275 | element.size = strlen (element.data); | 256 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized elements in set2\n"); |
276 | GNUNET_SETU_add_element (set1, &element, NULL, NULL); | ||
277 | element.data = "bar"; | ||
278 | element.size = strlen (element.data); | ||
279 | GNUNET_SETU_add_element (set1, &element, &init_set2, NULL); | ||
280 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n"); | ||
281 | } | 257 | } |
282 | 258 | ||
283 | 259 | ||
@@ -289,10 +265,10 @@ init_set1 (void) | |||
289 | static void | 265 | static void |
290 | timeout_fail (void *cls) | 266 | timeout_fail (void *cls) |
291 | { | 267 | { |
292 | tt = NULL; | 268 | tt = NULL; |
293 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); | 269 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); |
294 | GNUNET_SCHEDULER_shutdown (); | 270 | GNUNET_SCHEDULER_shutdown (); |
295 | ret = 1; | 271 | ret = 1; |
296 | } | 272 | } |
297 | 273 | ||
298 | 274 | ||
@@ -304,36 +280,36 @@ timeout_fail (void *cls) | |||
304 | static void | 280 | static void |
305 | do_shutdown (void *cls) | 281 | do_shutdown (void *cls) |
306 | { | 282 | { |
307 | if (NULL != tt) | 283 | if (NULL != tt) |
308 | { | 284 | { |
309 | GNUNET_SCHEDULER_cancel (tt); | 285 | GNUNET_SCHEDULER_cancel (tt); |
310 | tt = NULL; | 286 | tt = NULL; |
311 | } | 287 | } |
312 | if (NULL != oh1) | 288 | if (NULL != oh1) |
313 | { | 289 | { |
314 | GNUNET_SETU_operation_cancel (oh1); | 290 | GNUNET_SETU_operation_cancel (oh1); |
315 | oh1 = NULL; | 291 | oh1 = NULL; |
316 | } | 292 | } |
317 | if (NULL != oh2) | 293 | if (NULL != oh2) |
318 | { | 294 | { |
319 | GNUNET_SETU_operation_cancel (oh2); | 295 | GNUNET_SETU_operation_cancel (oh2); |
320 | oh2 = NULL; | 296 | oh2 = NULL; |
321 | } | 297 | } |
322 | if (NULL != set1) | 298 | if (NULL != set1) |
323 | { | 299 | { |
324 | GNUNET_SETU_destroy (set1); | 300 | GNUNET_SETU_destroy (set1); |
325 | set1 = NULL; | 301 | set1 = NULL; |
326 | } | 302 | } |
327 | if (NULL != set2) | 303 | if (NULL != set2) |
328 | { | 304 | { |
329 | GNUNET_SETU_destroy (set2); | 305 | GNUNET_SETU_destroy (set2); |
330 | set2 = NULL; | 306 | set2 = NULL; |
331 | } | 307 | } |
332 | if (NULL != listen_handle) | 308 | if (NULL != listen_handle) |
333 | { | 309 | { |
334 | GNUNET_SETU_listen_cancel (listen_handle); | 310 | GNUNET_SETU_listen_cancel (listen_handle); |
335 | listen_handle = NULL; | 311 | listen_handle = NULL; |
336 | } | 312 | } |
337 | } | 313 | } |
338 | 314 | ||
339 | 315 | ||
@@ -350,79 +326,148 @@ run (void *cls, | |||
350 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 326 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
351 | struct GNUNET_TESTING_Peer *peer) | 327 | struct GNUNET_TESTING_Peer *peer) |
352 | { | 328 | { |
353 | struct GNUNET_SETU_OperationHandle *my_oh; | 329 | struct GNUNET_SETU_OperationHandle *my_oh; |
354 | 330 | ||
355 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 331 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
356 | "Running preparatory tests\n"); | 332 | "Running preparatory tests\n"); |
357 | tt = GNUNET_SCHEDULER_add_delayed ( | 333 | tt = GNUNET_SCHEDULER_add_delayed ( |
358 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), | 334 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), |
359 | &timeout_fail, | 335 | &timeout_fail, |
360 | NULL); | 336 | NULL); |
361 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); | 337 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); |
362 | 338 | ||
363 | config = cfg; | 339 | config = cfg; |
364 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg, | 340 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg, |
365 | &local_id)); | 341 | &local_id)); |
366 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 342 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
367 | "my id (from CRYPTO): %s\n", | 343 | "my id (from CRYPTO): %s\n", |
368 | GNUNET_i2s (&local_id)); | 344 | GNUNET_i2s (&local_id)); |
369 | GNUNET_TESTING_peer_get_identity (peer, | 345 | GNUNET_TESTING_peer_get_identity (peer, |
370 | &local_id); | 346 | &local_id); |
371 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 347 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
372 | "my id (from TESTING): %s\n", | 348 | "my id (from TESTING): %s\n", |
373 | GNUNET_i2s (&local_id)); | 349 | GNUNET_i2s (&local_id)); |
374 | set1 = GNUNET_SETU_create (cfg); | 350 | set1 = GNUNET_SETU_create (cfg); |
375 | set2 = GNUNET_SETU_create (cfg); | 351 | set2 = GNUNET_SETU_create (cfg); |
376 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 352 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
377 | "Created sets %p and %p for union operation\n", | 353 | "Created sets %p and %p for union operation\n", |
378 | set1, | 354 | set1, |
379 | set2); | 355 | set2); |
380 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); | 356 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); |
381 | 357 | ||
382 | /* test if canceling an uncommitted request works! */ | 358 | /* test if canceling an uncommited request works! */ |
383 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 359 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
384 | "Launching and instantly stopping set operation\n"); | 360 | "Launching and instantly stopping set operation\n"); |
385 | my_oh = GNUNET_SETU_prepare (&local_id, | 361 | my_oh = GNUNET_SETU_prepare (&local_id, |
386 | &app_id, | 362 | &app_id, |
387 | NULL, | 363 | NULL, |
388 | (struct GNUNET_SETU_Option[]){ 0 }, | 364 | (struct GNUNET_SETU_Option[]){ 0 }, |
389 | NULL, | 365 | NULL, |
390 | NULL); | 366 | NULL); |
391 | GNUNET_SETU_operation_cancel (my_oh); | 367 | GNUNET_SETU_operation_cancel (my_oh); |
392 | 368 | ||
393 | /* test the real set reconciliation */ | 369 | /* test the real set reconciliation */ |
394 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 370 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
395 | "Running real set-reconciliation\n"); | 371 | "Running real set-reconciliation\n"); |
396 | //init_set1 (); | 372 | // init_set1 (); |
397 | // limit ~23800 element total | 373 | // limit ~23800 element total |
398 | initRandomSets(50,100,100,128); | 374 | initRandomSets (490, 500,500,32); |
399 | } | 375 | } |
400 | 376 | ||
401 | static void execute_perf() | 377 | |
378 | void | ||
379 | perf_thread () | ||
402 | { | 380 | { |
403 | for( int repeat_ctr = 0; repeat_ctr<1; repeat_ctr++ ) { | 381 | GNUNET_TESTING_service_run ("perf_setu_api", |
382 | "arm", | ||
383 | "test_setu.conf", | ||
384 | &run, | ||
385 | NULL); | ||
386 | |||
387 | } | ||
404 | 388 | ||
405 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
406 | "Executing perf round %d\n", repeat_ctr); | ||
407 | 389 | ||
408 | GNUNET_TESTING_service_run ("perf_setu_api", | 390 | static void |
409 | "arm", | 391 | run_petf_thread (int total_runs) |
410 | "test_setu.conf", | 392 | { |
411 | &run, | 393 | int core_count = get_nprocs_conf (); |
412 | NULL); | 394 | pid_t child_pid, wpid; |
395 | int status = 0; | ||
396 | |||
397 | // Father code (before child processes start) | ||
398 | for (int processed = 0; processed < total_runs;) | ||
399 | { | ||
400 | for (int id = 0; id < core_count; id++) | ||
401 | { | ||
402 | if (processed >= total_runs) | ||
403 | break; | ||
404 | |||
405 | if ((child_pid = fork ()) == 0) | ||
406 | { | ||
407 | perf_thread (); | ||
408 | exit (0); | ||
409 | } | ||
410 | processed += 1; | ||
413 | } | 411 | } |
414 | return 0; | 412 | while ((wpid = wait (&status)) > 0) |
413 | ; | ||
414 | |||
415 | } | ||
415 | } | 416 | } |
416 | 417 | ||
417 | 418 | ||
419 | static void | ||
420 | execute_perf () | ||
421 | { | ||
422 | |||
423 | /** | ||
424 | * Erase statfile | ||
425 | */ | ||
426 | remove ("perf_stats.csv"); | ||
427 | remove ("perf_failure_bucket_number_factor.csv"); | ||
428 | for (int out_out_ctr = 3; out_out_ctr <= 3; out_out_ctr++) | ||
429 | { | ||
430 | |||
431 | for (int out_ctr = 20; out_ctr <= 20; out_ctr++) | ||
432 | { | ||
433 | float base = 0.1; | ||
434 | float x = out_ctr * base; | ||
435 | char factor[10]; | ||
436 | char *buffer = gcvt (x, 4, factor); | ||
437 | setu_cfg = GNUNET_CONFIGURATION_create (); | ||
438 | GNUNET_CONFIGURATION_set_value_string (setu_cfg, "IBF", | ||
439 | "BUCKET_NUMBER_FACTOR", | ||
440 | buffer); // Factor default=4 | ||
441 | GNUNET_CONFIGURATION_set_value_number (setu_cfg, "IBF", | ||
442 | "NUMBER_PER_BUCKET", 3); // K default=4 | ||
443 | GNUNET_CONFIGURATION_set_value_string (setu_cfg, "PERFORMANCE", | ||
444 | "TRADEOFF", "2"); // default=0.25 | ||
445 | GNUNET_CONFIGURATION_set_value_string (setu_cfg, "PERFORMANCE", | ||
446 | "MAX_SET_DIFF_FACTOR_DIFFERENTIAL", | ||
447 | "20000"); // default=0.25 | ||
448 | GNUNET_CONFIGURATION_set_value_number (setu_cfg, "BOUNDARIES", | ||
449 | "UPPER_ELEMENT", 5000); | ||
450 | |||
451 | |||
452 | if (GNUNET_OK != GNUNET_CONFIGURATION_write (setu_cfg, "perf_setu.conf")) | ||
453 | GNUNET_log ( | ||
454 | GNUNET_ERROR_TYPE_ERROR, | ||
455 | _ ("Failed to write subsystem default identifier map'.\n")); | ||
456 | run_petf_thread (100); | ||
457 | } | ||
458 | |||
459 | } | ||
460 | return; | ||
461 | } | ||
462 | |||
418 | 463 | ||
419 | int | 464 | int |
420 | main (int argc, char **argv) | 465 | main (int argc, char **argv) |
421 | { | 466 | { |
422 | GNUNET_log_setup ("perf_setu_api", | ||
423 | "WARNING", | ||
424 | NULL); | ||
425 | 467 | ||
426 | execute_perf(); | 468 | GNUNET_log_setup ("perf_setu_api", |
427 | return 0; | 469 | "WARNING", |
470 | NULL); | ||
471 | execute_perf (); | ||
472 | return 0; | ||
428 | } | 473 | } |