src/consensus/gnunet-consensus-profiler.c

   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 successfull
 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 }