src/fs/perf_gnunet_service_fs_p2p_trust.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010, 2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file fs/perf_gnunet_service_fs_p2p_trust.c
  23  * @brief profile P2P routing trust mechanism. Creates
  24  *        a clique of NUM_DAEMONS (i.e. 3) where two
  25  *        peers share (seed) different files and download
  26  *        them from each other while all the other peers
  27  *        just "leach" those files.  Ideally, the seeders
  28  *        "learn" that they contribute (to each other),
  29  *        and give the other seeder higher priority;
  30  *        naturally, this only happens nicely for larger
  31  *        files; finally, once the seeders are done, the
  32  *        leachers should see fast download rates as well.
  33  * @author Christian Grothoff
  34  *
  35  * Sample output:
  36  * - 10 MB, 3 peers, with delays:
  37  * Download speed of type `seeder 1' was 757 KiB/s
  38  * Download speed of type `seeder 2' was 613 KiB/s
  39  * Download speed of type `leach` was 539 KiB/s
  40  *
  41  * - 10 MB, 3 peers, without delays:
  42  * Download speed of type `seeder 1' was 1784 KiB/s
  43  * Download speed of type `seeder 2' was 1604 KiB/s
  44  * Download speed of type `leach` was 1384 KiB/s
  45  */
  46 #include "platform.h"
  47 #include "fs_test_lib.h"
  48 #include "gnunet_testing_lib.h"
  49
  50 #define VERBOSE GNUNET_EXTRA_LOGGING
  51
  52 /**
  53  * File-size we use for testing.
  54  */
  55 #define FILESIZE (1024 * 1024 * 1)
  56
  57 /**
  58  * How long until we give up on transmitting the message?
  59  */
  60 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
  61
  62 /**
  63  * Number of daemons in clique, must be at least 3 (!).
  64  */
  65 #define NUM_DAEMONS 3
  66
  67 /**
  68  * Seed for first file on offer.
  69  */
  70 #define SEED1 42
  71
  72 /**
  73  * Seed for second file on offer.
  74  */
  75 #define SEED2 43
  76
  77 static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS];
  78
  79 static int ok;
  80
  81 static struct GNUNET_TIME_Absolute start_time;
  82
  83 static const char *progname;
  84
  85 static struct GNUNET_FS_Uri *uri1;
  86
  87 static struct GNUNET_FS_Uri *uri2;
  88
  89 static void
  90 do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  91 {
  92   GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
  93 }
  94
  95
  96 /**
  97  * Master context for 'stat_run'.
  98  */
  99 struct StatMaster
 100 {
 101   struct GNUNET_STATISTICS_Handle *stat;
 102   unsigned int daemon;
 103   unsigned int value;
 104 };
 105
 106 struct StatValues
 107 {
 108   const char *subsystem;
 109   const char *name;
 110 };
 111
 112 /**
 113  * Statistics we print out.
 114  */
 115 static struct StatValues stats[] = {
 116   {"fs", "# artificial delays introduced (ms)"},
 117   {"fs", "# queries forwarded"},
 118   {"fs", "# replies received and matched"},
 119   {"fs", "# results found locally"},
 120   {"fs", "# requests forwarded due to high load"},
 121   {"fs", "# requests done for free (low load)"},
 122   {"fs", "# requests dropped, priority insufficient"},
 123   {"fs", "# requests done for a price (normal load)"},
 124   {"fs", "# requests dropped by datastore (queue length limit)"},
 125   {"fs", "# P2P searches received"},
 126   {"fs", "# P2P searches discarded (queue length bound)"},
 127   {"fs", "# replies received for local clients"},
 128   {"fs", "# queries retransmitted to same target"},
 129   {"core", "# bytes decrypted"},
 130   {"core", "# bytes encrypted"},
 131   {"core", "# discarded CORE_SEND requests"},
 132   {"core", "# discarded lower priority CORE_SEND requests"},
 133   {"transport", "# bytes received via TCP"},
 134   {"transport", "# bytes transmitted via TCP"},
 135   {"datacache", "# bytes stored"},
 136   {NULL, NULL}
 137 };
 138
 139
 140 /**
 141  * Callback function to process statistic values.
 142  *
 143  * @param cls closure
 144  * @param subsystem name of subsystem that created the statistic
 145  * @param name the name of the datum
 146  * @param value the current value
 147  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
 148  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
 149  */
 150 static int
 151 print_stat (void *cls, const char *subsystem, const char *name, uint64_t value,
 152             int is_persistent)
 153 {
 154   struct StatMaster *sm = cls;
 155
 156   FPRINTF (stderr, "Peer %2u: %12s/%50s = %12llu\n", sm->daemon, subsystem,
 157            name, (unsigned long long) value);
 158   return GNUNET_OK;
 159 }
 160
 161
 162 /**
 163  * Function that gathers stats from all daemons.
 164  */
 165 static void
 166 stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 167
 168
 169 /**
 170  * Function called when GET operation on stats is done.
 171  */
 172 static void
 173 get_done (void *cls, int success)
 174 {
 175   struct StatMaster *sm = cls;
 176
 177   GNUNET_break (GNUNET_OK == success);
 178   sm->value++;
 179   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 180 }
 181
 182
 183 /**
 184  * Function that gathers stats from all daemons.
 185  */
 186 static void
 187 stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 188 {
 189   struct StatMaster *sm = cls;
 190
 191   if (stats[sm->value].name != NULL)
 192   {
 193     GNUNET_STATISTICS_get (sm->stat,
 194 #if 0
 195                            NULL, NULL,
 196 #else
 197                            stats[sm->value].subsystem, stats[sm->value].name,
 198 #endif
 199                            GNUNET_TIME_UNIT_FOREVER_REL, &get_done, &print_stat,
 200                            sm);
 201     return;
 202   }
 203   GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO);
 204   sm->value = 0;
 205   sm->daemon++;
 206   if (sm->daemon == NUM_DAEMONS)
 207   {
 208     GNUNET_free (sm);
 209     GNUNET_SCHEDULER_add_now (&do_stop, NULL);
 210     return;
 211   }
 212   sm->stat =
 213       GNUNET_STATISTICS_create ("<driver>",
 214                                 GNUNET_FS_TEST_get_configuration (daemons,
 215                                                                   sm->daemon));
 216   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 217 }
 218
 219
 220 static void
 221 do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 222 {
 223   static int download_counter;
 224   const char *type = cls;
 225   struct GNUNET_TIME_Relative del;
 226   char *fancy;
 227   struct StatMaster *sm;
 228
 229   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
 230   {
 231     del = GNUNET_TIME_absolute_get_duration (start_time);
 232     if (del.rel_value == 0)
 233       del.rel_value = 1;
 234     fancy =
 235         GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
 236                                         1000LL / del.rel_value);
 237     FPRINTF (stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
 238     GNUNET_free (fancy);
 239     if (NUM_DAEMONS != ++download_counter)
 240       return;                   /* more downloads to come */
 241     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 242                 "Finished all downloads, shutting down\n",
 243                 (unsigned long long) FILESIZE);
 244     sm = GNUNET_malloc (sizeof (struct StatMaster));
 245     sm->stat =
 246         GNUNET_STATISTICS_create ("<driver>",
 247                                   GNUNET_FS_TEST_get_configuration (daemons,
 248                                                                     sm->daemon));
 249     GNUNET_SCHEDULER_add_now (&stat_run, sm);
 250   }
 251   else
 252   {
 253     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 254                 "Timeout during download for type `%s', shutting down with error\n",
 255                 type);
 256     ok = 1;
 257     GNUNET_SCHEDULER_add_now (&do_stop, NULL);
 258   }
 259 }
 260
 261
 262 static void
 263 do_downloads (void *cls, const struct GNUNET_FS_Uri *u2)
 264 {
 265   int anonymity;
 266   unsigned int i;
 267
 268   if (NULL == u2)
 269   {
 270     GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 271     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 272                 "Timeout during upload attempt, shutting down with error\n");
 273     ok = 1;
 274     return;
 275   }
 276   uri2 = GNUNET_FS_uri_dup (u2);
 277   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
 278               (unsigned long long) FILESIZE);
 279   start_time = GNUNET_TIME_absolute_get ();
 280   if (NULL != strstr (progname, "dht"))
 281     anonymity = 0;
 282   else
 283     anonymity = 1;
 284   /* (semi) leach-download(s); not true leaches since
 285    * these peers do participate in sharing, they just
 286    * don't have to offer anything *initially*.  */
 287   for (i = 0; i < NUM_DAEMONS - 2; i++)
 288     GNUNET_FS_TEST_download (daemons[i], TIMEOUT, anonymity,
 289                              0 == (i % 2) ? SEED1 : SEED2,
 290                              0 == (i % 2) ? uri1 : uri2, VERBOSE, &do_report,
 291                              "leach");
 292   /* mutual downloads of (primary) sharing peers */
 293   GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity, SEED1,
 294                            uri1, VERBOSE, &do_report, "seeder 2");
 295   GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity, SEED2,
 296                            uri2, VERBOSE, &do_report, "seeder 1");
 297 }
 298
 299
 300 static void
 301 do_publish2 (void *cls, const struct GNUNET_FS_Uri *u1)
 302 {
 303   int do_index;
 304   int anonymity;
 305
 306   if (NULL == u1)
 307   {
 308     GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 309     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 310                 "Timeout during upload attempt, shutting down with error\n");
 311     ok = 1;
 312     return;
 313   }
 314   uri1 = GNUNET_FS_uri_dup (u1);
 315   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
 316               (unsigned long long) FILESIZE);
 317   if (NULL != strstr (progname, "index"))
 318     do_index = GNUNET_YES;
 319   else
 320     do_index = GNUNET_NO;
 321   if (NULL != strstr (progname, "dht"))
 322     anonymity = 0;
 323   else
 324     anonymity = 1;
 325
 326   GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity,
 327                           do_index, FILESIZE, SEED2, VERBOSE, &do_downloads,
 328                           NULL);
 329 }
 330
 331 static void
 332 do_publish1 (void *cls, const char *emsg)
 333 {
 334   int do_index;
 335   int anonymity;
 336
 337   if (NULL != emsg)
 338   {
 339     GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 340     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
 341     ok = 1;
 342     return;
 343   }
 344   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
 345               (unsigned long long) FILESIZE);
 346   if (NULL != strstr (progname, "index"))
 347     do_index = GNUNET_YES;
 348   else
 349     do_index = GNUNET_NO;
 350   if (NULL != strstr (progname, "dht"))
 351     anonymity = 0;
 352   else
 353     anonymity = 1;
 354
 355   GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
 356                           do_index, FILESIZE, SEED1, VERBOSE, &do_publish2,
 357                           NULL);
 358 }
 359
 360
 361 static void
 362 do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 363 {
 364   struct GNUNET_TESTING_PeerGroup *pg;
 365
 366   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
 367   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 368               "Daemons started, will now try to connect them\n");
 369   pg = GNUNET_FS_TEST_get_group (daemons);
 370   GNUNET_TESTING_create_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE,
 371                                   GNUNET_TESTING_TOPOLOGY_NONE, NULL);
 372   GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE,
 373                                    GNUNET_TESTING_TOPOLOGY_OPTION_NONE, 0.0,
 374                                    TIMEOUT, NUM_DAEMONS, &do_publish1, NULL);
 375 }
 376
 377
 378 static void
 379 run (void *cls, char *const *args, const char *cfgfile,
 380      const struct GNUNET_CONFIGURATION_Handle *cfg)
 381 {
 382   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf", TIMEOUT, NUM_DAEMONS,
 383                                 daemons, &do_connect, NULL);
 384 }
 385
 386
 387 int
 388 main (int argc, char *argv[])
 389 {
 390   char *const argvx[] = {
 391     "perf-gnunet-service-fs-p2p",
 392     "-c",
 393     "fs_test_lib_data.conf",
 394 #if VERBOSE
 395     "-L", "DEBUG",
 396 #endif
 397     NULL
 398   };
 399   struct GNUNET_GETOPT_CommandLineOption options[] = {
 400     GNUNET_GETOPT_OPTION_END
 401   };
 402   progname = argv[0];
 403   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
 404   GNUNET_log_setup ("perf_gnunet_service_fs_p2p_trust",
 405 #if VERBOSE
 406                     "DEBUG",
 407 #else
 408                     "WARNING",
 409 #endif
 410                     NULL);
 411   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,
 412                       "perf-gnunet-service-fs-p2p-trust", "nohelp", options,
 413                       &run, NULL);
 414   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
 415   return ok;
 416 }
 417
 418 /* end of perf_gnunet_service_fs_p2p_trust.c */