diff options
Diffstat (limited to 'src/consensus/gnunet-consensus-profiler.c')
-rw-r--r-- | src/consensus/gnunet-consensus-profiler.c | 586 |
1 files changed, 0 insertions, 586 deletions
diff --git a/src/consensus/gnunet-consensus-profiler.c b/src/consensus/gnunet-consensus-profiler.c deleted file mode 100644 index 07a536a2d..000000000 --- a/src/consensus/gnunet-consensus-profiler.c +++ /dev/null | |||
@@ -1,586 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2012 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file consensus/gnunet-consensus-profiler.c | ||
23 | * @brief profiling tool for gnunet-consensus | ||
24 | * @author Florian Dold | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_time_lib.h" | ||
29 | #include "gnunet_consensus_service.h" | ||
30 | #include "gnunet_testbed_service.h" | ||
31 | |||
32 | static unsigned int num_peers = 2; | ||
33 | |||
34 | static unsigned int replication = 1; | ||
35 | |||
36 | static unsigned int num_values = 5; | ||
37 | |||
38 | static struct GNUNET_TIME_Relative conclude_timeout; | ||
39 | |||
40 | static struct GNUNET_TIME_Relative consensus_delay; | ||
41 | |||
42 | static struct GNUNET_CONSENSUS_Handle **consensus_handles; | ||
43 | |||
44 | static struct GNUNET_TESTBED_Operation **testbed_operations; | ||
45 | |||
46 | static unsigned int num_connected_handles; | ||
47 | |||
48 | static struct GNUNET_TESTBED_Peer **peers; | ||
49 | |||
50 | static struct GNUNET_PeerIdentity *peer_ids; | ||
51 | |||
52 | static unsigned int num_retrieved_peer_ids; | ||
53 | |||
54 | static struct GNUNET_HashCode session_id; | ||
55 | |||
56 | static unsigned int peers_done = 0; | ||
57 | |||
58 | static int dist_static; | ||
59 | |||
60 | static unsigned *results_for_peer; | ||
61 | |||
62 | /** | ||
63 | * The profiler will write statistics | ||
64 | * for all peers to the file with this name. | ||
65 | */ | ||
66 | static char *statistics_filename; | ||
67 | |||
68 | /** | ||
69 | * The profiler will write statistics | ||
70 | * for all peers to this file. | ||
71 | */ | ||
72 | static FILE *statistics_file; | ||
73 | |||
74 | static int verbose; | ||
75 | |||
76 | /** | ||
77 | * Start time for all consensuses. | ||
78 | */ | ||
79 | static struct GNUNET_TIME_Absolute start; | ||
80 | |||
81 | /** | ||
82 | * Deadline for all consensuses. | ||
83 | */ | ||
84 | static struct GNUNET_TIME_Absolute deadline; | ||
85 | |||
86 | |||
87 | /** | ||
88 | * Signature of the event handler function called by the | ||
89 | * respective event controller. | ||
90 | * | ||
91 | * @param cls closure | ||
92 | * @param event information about the event | ||
93 | */ | ||
94 | static void | ||
95 | controller_cb (void *cls, | ||
96 | const struct GNUNET_TESTBED_EventInformation *event) | ||
97 | { | ||
98 | GNUNET_assert (0); | ||
99 | } | ||
100 | |||
101 | |||
102 | static void | ||
103 | statistics_done_cb (void *cls, | ||
104 | struct | ||
105 | GNUNET_TESTBED_Operation | ||
106 | *op, | ||
107 | const char *emsg) | ||
108 | { | ||
109 | GNUNET_assert (NULL == emsg); | ||
110 | GNUNET_TESTBED_operation_done (op); | ||
111 | if (NULL != statistics_file) | ||
112 | fclose (statistics_file); | ||
113 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got statistics, shutting down\n"); | ||
114 | GNUNET_SCHEDULER_shutdown (); | ||
115 | } | ||
116 | |||
117 | |||
118 | /** | ||
119 | * Callback function to process statistic values from all peers. | ||
120 | * | ||
121 | * @param cls closure | ||
122 | * @param peer the peer the statistic belong to | ||
123 | * @param subsystem name of subsystem that created the statistic | ||
124 | * @param name the name of the datum | ||
125 | * @param value the current value | ||
126 | * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not | ||
127 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | ||
128 | */ | ||
129 | static int | ||
130 | statistics_cb (void *cls, | ||
131 | const struct GNUNET_TESTBED_Peer *peer, | ||
132 | const char *subsystem, | ||
133 | const char *name, | ||
134 | uint64_t value, | ||
135 | int is_persistent) | ||
136 | { | ||
137 | if (NULL != statistics_file) | ||
138 | { | ||
139 | fprintf (statistics_file, "P%u\t%s\t%s\t%lu\n", GNUNET_TESTBED_get_index ( | ||
140 | peer), subsystem, name, (unsigned long) value); | ||
141 | } | ||
142 | return GNUNET_OK; | ||
143 | } | ||
144 | |||
145 | |||
146 | static void | ||
147 | destroy (void *cls) | ||
148 | { | ||
149 | struct GNUNET_CONSENSUS_Handle *consensus = cls; | ||
150 | |||
151 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
152 | "destroying consensus\n"); | ||
153 | GNUNET_CONSENSUS_destroy (consensus); | ||
154 | peers_done++; | ||
155 | if (peers_done == num_peers) | ||
156 | { | ||
157 | unsigned int i; | ||
158 | for (i = 0; i < num_peers; i++) | ||
159 | GNUNET_TESTBED_operation_done (testbed_operations[i]); | ||
160 | for (i = 0; i < num_peers; i++) | ||
161 | printf ("P%u got %u of %u elements\n", | ||
162 | i, | ||
163 | results_for_peer[i], | ||
164 | num_values); | ||
165 | if (NULL != statistics_filename) | ||
166 | statistics_file = fopen (statistics_filename, "w"); | ||
167 | GNUNET_TESTBED_get_statistics (num_peers, peers, NULL, NULL, | ||
168 | statistics_cb, | ||
169 | statistics_done_cb, | ||
170 | NULL); | ||
171 | } | ||
172 | } | ||
173 | |||
174 | |||
175 | /** | ||
176 | * Called when a conclusion was successful. | ||
177 | * | ||
178 | * @param cls closure, the consensus handle | ||
179 | * @return #GNUNET_YES if more consensus groups should be offered, | ||
180 | * #GNUNET_NO if not | ||
181 | */ | ||
182 | static void | ||
183 | conclude_cb (void *cls) | ||
184 | { | ||
185 | struct GNUNET_CONSENSUS_Handle **chp = cls; | ||
186 | |||
187 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
188 | "consensus %d done\n", | ||
189 | (int) (chp - consensus_handles)); | ||
190 | GNUNET_SCHEDULER_add_now (destroy, *chp); | ||
191 | } | ||
192 | |||
193 | |||
194 | static void | ||
195 | generate_indices (int *indices) | ||
196 | { | ||
197 | int j; | ||
198 | |||
199 | j = 0; | ||
200 | while (j < replication) | ||
201 | { | ||
202 | int n; | ||
203 | int k; | ||
204 | int repeat; | ||
205 | n = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | ||
206 | repeat = GNUNET_NO; | ||
207 | for (k = 0; k < j; k++) | ||
208 | if (indices[k] == n) | ||
209 | { | ||
210 | repeat = GNUNET_YES; | ||
211 | break; | ||
212 | } | ||
213 | if (GNUNET_NO == repeat) | ||
214 | indices[j++] = n; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | |||
219 | static void | ||
220 | do_consensus () | ||
221 | { | ||
222 | int unique_indices[replication]; | ||
223 | unsigned int i; | ||
224 | unsigned int j; | ||
225 | struct GNUNET_HashCode val; | ||
226 | struct GNUNET_SET_Element element; | ||
227 | |||
228 | if (dist_static) | ||
229 | { | ||
230 | for (i = 0; i < num_values; i++) | ||
231 | { | ||
232 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val); | ||
233 | |||
234 | element.data = &val; | ||
235 | element.size = sizeof(val); | ||
236 | for (j = 0; j < replication; j++) | ||
237 | { | ||
238 | GNUNET_CONSENSUS_insert (consensus_handles[j], | ||
239 | &element, | ||
240 | NULL, NULL); | ||
241 | } | ||
242 | } | ||
243 | } | ||
244 | else | ||
245 | { | ||
246 | for (i = 0; i < num_values; i++) | ||
247 | { | ||
248 | generate_indices (unique_indices); | ||
249 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val); | ||
250 | |||
251 | element.data = &val; | ||
252 | element.size = sizeof(val); | ||
253 | for (j = 0; j < replication; j++) | ||
254 | { | ||
255 | int cid; | ||
256 | |||
257 | cid = unique_indices[j]; | ||
258 | GNUNET_CONSENSUS_insert (consensus_handles[cid], | ||
259 | &element, | ||
260 | NULL, NULL); | ||
261 | } | ||
262 | } | ||
263 | } | ||
264 | |||
265 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
266 | "all elements inserted, calling conclude\n"); | ||
267 | |||
268 | for (i = 0; i < num_peers; i++) | ||
269 | GNUNET_CONSENSUS_conclude (consensus_handles[i], | ||
270 | conclude_cb, &consensus_handles[i]); | ||
271 | } | ||
272 | |||
273 | |||
274 | /** | ||
275 | * Callback to be called when a service connect operation is completed | ||
276 | * | ||
277 | * @param cls the callback closure from functions generating an operation | ||
278 | * @param op the operation that has been finished | ||
279 | * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter() | ||
280 | * @param emsg error message in case the operation has failed; will be NULL if | ||
281 | * operation has executed successfully. | ||
282 | */ | ||
283 | static void | ||
284 | connect_complete (void *cls, | ||
285 | struct GNUNET_TESTBED_Operation *op, | ||
286 | void *ca_result, | ||
287 | const char *emsg) | ||
288 | { | ||
289 | if (NULL != emsg) | ||
290 | { | ||
291 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
292 | "testbed connect emsg: %s\n", | ||
293 | emsg); | ||
294 | GNUNET_assert (0); | ||
295 | } | ||
296 | |||
297 | num_connected_handles++; | ||
298 | |||
299 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
300 | "connect complete\n"); | ||
301 | |||
302 | if (num_connected_handles == num_peers) | ||
303 | { | ||
304 | do_consensus (); | ||
305 | } | ||
306 | } | ||
307 | |||
308 | |||
309 | static void | ||
310 | new_element_cb (void *cls, | ||
311 | const struct GNUNET_SET_Element *element) | ||
312 | { | ||
313 | struct GNUNET_CONSENSUS_Handle **chp = cls; | ||
314 | int idx = chp - consensus_handles; | ||
315 | |||
316 | GNUNET_assert (NULL != cls); | ||
317 | |||
318 | results_for_peer[idx]++; | ||
319 | |||
320 | GNUNET_assert (sizeof(struct GNUNET_HashCode) == element->size); | ||
321 | |||
322 | if (GNUNET_YES == verbose) | ||
323 | { | ||
324 | printf ("P%d received %s\n", | ||
325 | idx, | ||
326 | GNUNET_h2s ((struct GNUNET_HashCode *) element->data)); | ||
327 | } | ||
328 | } | ||
329 | |||
330 | |||
331 | /** | ||
332 | * Adapter function called to establish a connection to | ||
333 | * a service. | ||
334 | * | ||
335 | * @param cls closure | ||
336 | * @param cfg configuration of the peer to connect to; will be available until | ||
337 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
338 | * from GNUNET_TESTBED_service_connect() | ||
339 | * @return service handle to return in 'op_result', NULL on error | ||
340 | */ | ||
341 | static void * | ||
342 | connect_adapter (void *cls, | ||
343 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
344 | { | ||
345 | struct GNUNET_CONSENSUS_Handle **chp = cls; | ||
346 | struct GNUNET_CONSENSUS_Handle *consensus; | ||
347 | |||
348 | chp = (struct GNUNET_CONSENSUS_Handle **) cls; | ||
349 | |||
350 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
351 | "connect adapter, %d peers\n", | ||
352 | num_peers); | ||
353 | consensus = GNUNET_CONSENSUS_create (cfg, | ||
354 | num_peers, peer_ids, | ||
355 | &session_id, | ||
356 | start, | ||
357 | deadline, | ||
358 | &new_element_cb, chp); | ||
359 | *chp = (struct GNUNET_CONSENSUS_Handle *) consensus; | ||
360 | return consensus; | ||
361 | } | ||
362 | |||
363 | |||
364 | /** | ||
365 | * Adapter function called to destroy a connection to | ||
366 | * a service. | ||
367 | * | ||
368 | * @param cls closure | ||
369 | * @param op_result service handle returned from the connect adapter | ||
370 | */ | ||
371 | static void | ||
372 | disconnect_adapter (void *cls, void *op_result) | ||
373 | { | ||
374 | /* FIXME: what to do here? */ | ||
375 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
376 | "disconnect adapter called\n"); | ||
377 | } | ||
378 | |||
379 | |||
380 | /** | ||
381 | * Callback to be called when the requested peer information is available | ||
382 | * | ||
383 | * @param cb_cls the closure from GNUNET_TETSBED_peer_get_information() | ||
384 | * @param op the operation this callback corresponds to | ||
385 | * @param pinfo the result; will be NULL if the operation has failed | ||
386 | * @param emsg error message if the operation has failed; will be NULL if the | ||
387 | * operation is successful | ||
388 | */ | ||
389 | static void | ||
390 | peer_info_cb (void *cb_cls, | ||
391 | struct GNUNET_TESTBED_Operation *op, | ||
392 | const struct GNUNET_TESTBED_PeerInformation *pinfo, | ||
393 | const char *emsg) | ||
394 | { | ||
395 | struct GNUNET_PeerIdentity *p; | ||
396 | int i; | ||
397 | |||
398 | GNUNET_assert (NULL == emsg); | ||
399 | |||
400 | p = (struct GNUNET_PeerIdentity *) cb_cls; | ||
401 | |||
402 | if (pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY) | ||
403 | { | ||
404 | *p = *pinfo->result.id; | ||
405 | num_retrieved_peer_ids++; | ||
406 | if (num_retrieved_peer_ids == num_peers) | ||
407 | for (i = 0; i < num_peers; i++) | ||
408 | testbed_operations[i] = | ||
409 | GNUNET_TESTBED_service_connect (NULL, peers[i], "consensus", | ||
410 | connect_complete, NULL, | ||
411 | connect_adapter, disconnect_adapter, | ||
412 | &consensus_handles[i]); | ||
413 | } | ||
414 | else | ||
415 | { | ||
416 | GNUNET_assert (0); | ||
417 | } | ||
418 | |||
419 | GNUNET_TESTBED_operation_done (op); | ||
420 | } | ||
421 | |||
422 | |||
423 | /** | ||
424 | * Signature of a main function for a testcase. | ||
425 | * | ||
426 | * @param cls closure | ||
427 | * @param h the run handle | ||
428 | * @param num_peers number of peers in 'peers' | ||
429 | * @param started_peers handle to peers run in the testbed. NULL upon timeout (see | ||
430 | * GNUNET_TESTBED_test_run()). | ||
431 | * @param links_succeeded the number of overlay link connection attempts that | ||
432 | * succeeded | ||
433 | * @param links_failed the number of overlay link connection attempts that | ||
434 | * failed | ||
435 | */ | ||
436 | static void | ||
437 | test_master (void *cls, | ||
438 | struct GNUNET_TESTBED_RunHandle *h, | ||
439 | unsigned int num_peers, | ||
440 | struct GNUNET_TESTBED_Peer **started_peers, | ||
441 | unsigned int links_succeeded, | ||
442 | unsigned int links_failed) | ||
443 | { | ||
444 | int i; | ||
445 | |||
446 | GNUNET_log_setup ("gnunet-consensus", "INFO", NULL); | ||
447 | |||
448 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "test master\n"); | ||
449 | |||
450 | peers = started_peers; | ||
451 | |||
452 | peer_ids = GNUNET_malloc (num_peers * sizeof(struct GNUNET_PeerIdentity)); | ||
453 | |||
454 | results_for_peer = GNUNET_malloc (num_peers * sizeof(unsigned int)); | ||
455 | consensus_handles = GNUNET_malloc (num_peers * sizeof(struct | ||
456 | ConsensusHandle *)); | ||
457 | testbed_operations = GNUNET_malloc (num_peers * sizeof(struct | ||
458 | ConsensusHandle *)); | ||
459 | |||
460 | for (i = 0; i < num_peers; i++) | ||
461 | GNUNET_TESTBED_peer_get_information (peers[i], | ||
462 | GNUNET_TESTBED_PIT_IDENTITY, | ||
463 | peer_info_cb, | ||
464 | &peer_ids[i]); | ||
465 | } | ||
466 | |||
467 | |||
468 | static void | ||
469 | run (void *cls, char *const *args, const char *cfgfile, | ||
470 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
471 | { | ||
472 | static char *session_str = "gnunet-consensus/test"; | ||
473 | char *topology; | ||
474 | int topology_cmp_result; | ||
475 | |||
476 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "testbed", | ||
477 | "OVERLAY_TOPOLOGY", | ||
478 | &topology)) | ||
479 | { | ||
480 | fprintf (stderr, | ||
481 | "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, " | ||
482 | "seems like you passed the wrong configuration file\n"); | ||
483 | return; | ||
484 | } | ||
485 | |||
486 | topology_cmp_result = strcasecmp (topology, "NONE"); | ||
487 | GNUNET_free (topology); | ||
488 | |||
489 | if (0 == topology_cmp_result) | ||
490 | { | ||
491 | fprintf (stderr, | ||
492 | "'OVERLAY_TOPOLOGY' set to 'NONE', " | ||
493 | "seems like you passed the wrong configuration file\n"); | ||
494 | return; | ||
495 | } | ||
496 | |||
497 | if (num_peers < replication) | ||
498 | { | ||
499 | fprintf (stderr, "k must be <=n\n"); | ||
500 | return; | ||
501 | } | ||
502 | |||
503 | start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), | ||
504 | consensus_delay); | ||
505 | deadline = GNUNET_TIME_absolute_add (start, conclude_timeout); | ||
506 | |||
507 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
508 | "running gnunet-consensus\n"); | ||
509 | |||
510 | GNUNET_CRYPTO_hash (session_str, strlen (session_str), &session_id); | ||
511 | |||
512 | (void) GNUNET_TESTBED_test_run ("gnunet-consensus", | ||
513 | cfgfile, | ||
514 | num_peers, | ||
515 | 0, | ||
516 | controller_cb, | ||
517 | NULL, | ||
518 | test_master, | ||
519 | NULL); | ||
520 | } | ||
521 | |||
522 | |||
523 | int | ||
524 | main (int argc, char **argv) | ||
525 | { | ||
526 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
527 | GNUNET_GETOPT_option_uint ('n', | ||
528 | "num-peers", | ||
529 | NULL, | ||
530 | gettext_noop ("number of peers in consensus"), | ||
531 | &num_peers), | ||
532 | |||
533 | GNUNET_GETOPT_option_uint ('k', | ||
534 | "value-replication", | ||
535 | NULL, | ||
536 | gettext_noop ( | ||
537 | "how many peers (random selection without replacement) receive one value?"), | ||
538 | &replication), | ||
539 | |||
540 | GNUNET_GETOPT_option_uint ('x', | ||
541 | "num-values", | ||
542 | NULL, | ||
543 | gettext_noop ("number of values"), | ||
544 | &num_values), | ||
545 | |||
546 | GNUNET_GETOPT_option_relative_time ('t', | ||
547 | "timeout", | ||
548 | NULL, | ||
549 | gettext_noop ("consensus timeout"), | ||
550 | &conclude_timeout), | ||
551 | |||
552 | |||
553 | GNUNET_GETOPT_option_relative_time ('d', | ||
554 | "delay", | ||
555 | NULL, | ||
556 | gettext_noop ( | ||
557 | "delay until consensus starts"), | ||
558 | &consensus_delay), | ||
559 | |||
560 | GNUNET_GETOPT_option_filename ('s', | ||
561 | "statistics", | ||
562 | "FILENAME", | ||
563 | gettext_noop ("write statistics to file"), | ||
564 | &statistics_filename), | ||
565 | |||
566 | GNUNET_GETOPT_option_flag ('S', | ||
567 | "dist-static", | ||
568 | gettext_noop ( | ||
569 | "distribute elements to a static subset of good peers"), | ||
570 | &dist_static), | ||
571 | |||
572 | GNUNET_GETOPT_option_flag ('V', | ||
573 | "verbose", | ||
574 | gettext_noop ( | ||
575 | "be more verbose (print received values)"), | ||
576 | &verbose), | ||
577 | |||
578 | GNUNET_GETOPT_OPTION_END | ||
579 | }; | ||
580 | |||
581 | conclude_timeout = GNUNET_TIME_UNIT_SECONDS; | ||
582 | GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus-profiler", | ||
583 | "help", | ||
584 | options, &run, NULL, GNUNET_YES); | ||
585 | return 0; | ||
586 | } | ||