src/ats-tests/perf_ats.c

   1 /*
   2  This file is part of GNUnet.
   3  (C) 2010-2013 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  * @file ats/perf_ats.c
  22  * @brief ats benchmark: start peers and modify preferences, monitor change over time
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_testbed_service.h"
  29 #include "gnunet_ats_service.h"
  30 #include "gnunet_core_service.h"
  31 #include "perf_ats.h"
  32
  33
  34 #define TEST_ATS_PREFRENCE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  35 #define TEST_ATS_PREFRENCE_START 1.0
  36 #define TEST_ATS_PREFRENCE_DELTA 1.0
  37
  38 #define TEST_MESSAGE_TYPE_PING 12345
  39 #define TEST_MESSAGE_TYPE_PONG 12346
  40 #define TEST_MESSAGE_SIZE 1000
  41 #define TEST_MESSAGE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  42
  43 /**
  44  * Connect peers with testbed
  45  */
  46 struct TestbedConnectOperation
  47 {
  48   /**
  49    * The benchmarking master initiating this connection
  50    */
  51   struct BenchmarkPeer *master;
  52
  53   /**
  54    * The benchmarking slave to connect to
  55    */
  56   struct BenchmarkPeer *slave;
  57
  58   /**
  59    * Testbed operation to connect peers
  60    */
  61   struct GNUNET_TESTBED_Operation *connect_op;
  62 };
  63
  64 /**
  65  * Overall state of the performance benchmark
  66  */
  67 struct BenchmarkState
  68 {
  69   /**
  70    * Are we connected to ATS service of all peers: GNUNET_YES/NO
  71    */
  72   int connected_ATS_service;
  73
  74   /**
  75    * Are we connected to CORE service of all peers: GNUNET_YES/NO
  76    */
  77   int connected_COMM_service;
  78
  79   /**
  80    * Are we connected to all peers: GNUNET_YES/NO
  81    */
  82   int connected_PEERS;
  83
  84   /**
  85    * Are we connected to all slave peers on CORE level: GNUNET_YES/NO
  86    */
  87   int connected_CORE;
  88
  89   /**
  90    * Are we connected to CORE service of all peers: GNUNET_YES/NO
  91    */
  92   int benchmarking;
  93 };
  94
  95
  96 /**
  97  * Shutdown task
  98  */
  99 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
 100
 101 /**
 102  * Progress task
 103  */
 104 static GNUNET_SCHEDULER_TaskIdentifier progress_task;
 105
 106 /**
 107  * Test result
 108  */
 109 static int result;
 110
 111 /**
 112  * Test result logging
 113  */
 114 static int logging;
 115
 116 /**Test core (GNUNET_YES) or transport (GNUNET_NO)
 117  */
 118 static int test_core;
 119
 120 /**
 121  * Solver string
 122  */
 123 static char *solver;
 124
 125 /**
 126  * Preference string
 127  */
 128 static char *testname;
 129
 130 /**
 131  * Preference string
 132  */
 133 static char *pref_str;
 134
 135 /**
 136  * ATS preference value
 137  */
 138 static int pref_val;
 139
 140 /**
 141  * Number master peers
 142  */
 143 static unsigned int num_masters;
 144
 145 /**
 146  * Array of master peers
 147  */
 148 static struct BenchmarkPeer *mps;
 149
 150 /**
 151  * Number slave peers
 152  */
 153 static unsigned int num_slaves;
 154
 155 /**
 156  * Array of slave peers
 157  */
 158 static struct BenchmarkPeer *sps;
 159
 160 /**
 161  * Benchmark duration
 162  */
 163 static struct GNUNET_TIME_Relative perf_duration;
 164
 165 /**
 166  * Logging frequency
 167  */
 168 static struct GNUNET_TIME_Relative log_frequency;
 169
 170 /**
 171  * Benchmark state
 172  */
 173 static struct BenchmarkState state;
 174
 175 static void
 176 evaluate ()
 177 {
 178   int c_m;
 179   int c_s;
 180   unsigned int duration;
 181   struct BenchmarkPeer *mp;
 182   struct BenchmarkPartner *p;
 183
 184   duration = (perf_duration.rel_value_us / (1000 * 1000));
 185   for (c_m = 0; c_m < num_masters; c_m++)
 186   {
 187     mp = &mps[c_m];
 188     fprintf (stderr,
 189         _("Master [%u]: sent: %u KiB in %u sec. = %u KiB/s, received: %u KiB in %u sec. = %u KiB/s\n"),
 190         mp->no, mp->total_bytes_sent / 1024, duration,
 191         (mp->total_bytes_sent / 1024) / duration,
 192         mp->total_bytes_received / 1024, duration,
 193         (mp->total_bytes_received / 1024) / duration);
 194
 195     for (c_s = 0; c_s < num_slaves; c_s++)
 196     {
 197       p = &mp->partners[c_s];
 198       fprintf (stderr,
 199           "%c Master [%u] -> Slave [%u]: sent %u KiB/s (%.2f %%), received %u KiB/s (%.2f %%)\n",
 200           (mp->pref_partner == p->dest) ? '*' : ' ',
 201           mp->no, p->dest->no,
 202           (p->bytes_sent / 1024) / duration,
 203           ((double) p->bytes_sent * 100) / mp->total_bytes_sent,
 204           (p->bytes_received / 1024) / duration,
 205           ((double) p->bytes_received * 100) / mp->total_bytes_received );
 206       fprintf (stderr,
 207           "%c Master [%u] -> Slave [%u]: Average application layer RTT: %u ms\n",
 208           (mp->pref_partner == p->dest) ? '*' : ' ',
 209           mp->no, p->dest->no,
 210           p->total_app_rtt / (1000 * p->messages_sent));
 211     }
 212   }
 213 }
 214
 215 /**
 216  * Shutdown nicely
 217  *
 218  * @param cls NULL
 219  * @param tc the task context
 220  */
 221 static void
 222 do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 223 {
 224   int c_m;
 225   int c_s;
 226   int c_op;
 227   struct BenchmarkPeer *p;
 228
 229   if (GNUNET_YES == logging)
 230     perf_logging_stop();
 231
 232   shutdown_task = GNUNET_SCHEDULER_NO_TASK;
 233   if (GNUNET_SCHEDULER_NO_TASK != progress_task)
 234   {
 235     fprintf (stderr, "0\n");
 236     GNUNET_SCHEDULER_cancel (progress_task);
 237   }
 238   progress_task = GNUNET_SCHEDULER_NO_TASK;
 239
 240   evaluate ();
 241   state.benchmarking = GNUNET_NO;
 242   GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Benchmarking done\n"));
 243
 244   for (c_m = 0; c_m < num_masters; c_m++)
 245   {
 246     p = &mps[c_m];
 247     if (NULL != mps[c_m].peer_id_op)
 248     {
 249       GNUNET_TESTBED_operation_done (p->peer_id_op);
 250       p->peer_id_op = NULL;
 251     }
 252
 253     if (GNUNET_SCHEDULER_NO_TASK != p->ats_task)
 254       GNUNET_SCHEDULER_cancel (p->ats_task);
 255     p->ats_task = GNUNET_SCHEDULER_NO_TASK;
 256
 257     for (c_op = 0; c_op < p->num_partners; c_op++)
 258     {
 259       if (NULL != p->partners[c_op].cth)
 260       {
 261         GNUNET_CORE_notify_transmit_ready_cancel (p->partners[c_op].cth);
 262         p->partners[c_op].cth = NULL;
 263       }
 264       if (NULL != p->partners[c_op].tth)
 265       {
 266         GNUNET_TRANSPORT_notify_transmit_ready_cancel (p->partners[c_op].tth);
 267         p->partners[c_op].tth = NULL;
 268       }
 269       if (NULL != p->core_connect_ops[c_op].connect_op)
 270       {
 271         GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 272             _("Failed to connect peer 0 and %u\n"), c_op);
 273         GNUNET_TESTBED_operation_done (
 274             p->core_connect_ops[c_op].connect_op);
 275         p->core_connect_ops[c_op].connect_op = NULL;
 276         result = 1;
 277       }
 278     }
 279
 280     if (NULL != p->ats_perf_op)
 281     {
 282       GNUNET_TESTBED_operation_done (p->ats_perf_op);
 283       p->ats_perf_op = NULL;
 284     }
 285
 286     if (NULL != p->comm_op)
 287     {
 288       GNUNET_TESTBED_operation_done (p->comm_op);
 289       p->comm_op = NULL;
 290     }
 291     GNUNET_free(p->core_connect_ops);
 292     GNUNET_free(p->partners);
 293     p->partners = NULL;
 294   }
 295
 296   for (c_s = 0; c_s < num_slaves; c_s++)
 297   {
 298     p = &sps[c_s];
 299     if (NULL != p->peer_id_op)
 300     {
 301       GNUNET_TESTBED_operation_done (p->peer_id_op);
 302       p->peer_id_op = NULL;
 303     }
 304
 305     for (c_op = 0; c_op < p->num_partners; c_op++)
 306     {
 307       if (NULL != p->partners[c_op].cth)
 308       {
 309         GNUNET_CORE_notify_transmit_ready_cancel (p->partners[c_op].cth);
 310         p->partners[c_op].cth = NULL;
 311       }
 312       if (NULL != p->partners[c_op].tth)
 313       {
 314         GNUNET_TRANSPORT_notify_transmit_ready_cancel (p->partners[c_op].tth);
 315         p->partners[c_op].tth = NULL;
 316       }
 317     }
 318     if (NULL != p->ats_perf_op)
 319     {
 320       GNUNET_TESTBED_operation_done (p->ats_perf_op);
 321       p->ats_perf_op = NULL;
 322     }
 323     if (NULL != p->comm_op)
 324     {
 325       GNUNET_TESTBED_operation_done (p->comm_op);
 326       p->comm_op = NULL;
 327     }
 328     GNUNET_free(p->partners);
 329     p->partners = NULL;
 330   }
 331
 332   GNUNET_SCHEDULER_shutdown ();
 333 }
 334
 335 static struct BenchmarkPeer *
 336 find_peer (const struct GNUNET_PeerIdentity * peer)
 337 {
 338   int c_p;
 339
 340   for (c_p = 0; c_p < num_masters; c_p++)
 341   {
 342     if (0 == memcmp (&mps[c_p].id, peer, sizeof(struct GNUNET_PeerIdentity)))
 343       return &mps[c_p];
 344   }
 345
 346   for (c_p = 0; c_p < num_slaves; c_p++)
 347   {
 348     if (0 == memcmp (&sps[c_p].id, peer, sizeof(struct GNUNET_PeerIdentity)))
 349       return &sps[c_p];
 350   }
 351   return NULL ;
 352 }
 353
 354 /**
 355  * Controller event callback
 356  *
 357  * @param cls NULL
 358  * @param event the controller event
 359  */
 360 static void
 361 controller_event_cb (void *cls,
 362     const struct GNUNET_TESTBED_EventInformation *event)
 363 {
 364   //struct BenchmarkPeer *p = cls;
 365   switch (event->type)
 366   {
 367   case GNUNET_TESTBED_ET_CONNECT:
 368     break;
 369   case GNUNET_TESTBED_ET_OPERATION_FINISHED:
 370     break;
 371   default:
 372     GNUNET_break(0);
 373     result = 2;
 374     GNUNET_SCHEDULER_cancel (shutdown_task);
 375     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL );
 376   }
 377 }
 378
 379 static size_t
 380 comm_send_ready (void *cls, size_t size, void *buf)
 381 {
 382   static char msgbuf[TEST_MESSAGE_SIZE];
 383   struct BenchmarkPartner *p = cls;
 384   struct GNUNET_MessageHeader *msg;
 385
 386   if (GNUNET_YES == test_core)
 387     p->cth = NULL;
 388   else
 389     p->tth = NULL;
 390
 391   if (NULL == buf)
 392   {
 393     GNUNET_break (0);
 394     return 0;
 395   }
 396   if (size < TEST_MESSAGE_SIZE)
 397   {
 398     GNUNET_break (0);
 399     return 0;
 400   }
 401
 402   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Master [%u]: Sending PING to [%u]\n",
 403       p->me->no, p->dest->no);
 404
 405   p->messages_sent++;
 406   p->bytes_sent += TEST_MESSAGE_SIZE;
 407   p->me->total_messages_sent++;
 408   p->me->total_bytes_sent += TEST_MESSAGE_SIZE;
 409
 410   msg = (struct GNUNET_MessageHeader *) &msgbuf;
 411   memset (&msgbuf, 'a', TEST_MESSAGE_SIZE);
 412   msg->type = htons (TEST_MESSAGE_TYPE_PING);
 413   msg->size = htons (TEST_MESSAGE_SIZE);
 414   memcpy (buf, msg, TEST_MESSAGE_SIZE);
 415   return TEST_MESSAGE_SIZE;
 416 }
 417
 418 static void
 419 comm_schedule_send (struct BenchmarkPartner *p)
 420 {
 421   p->last_message_sent = GNUNET_TIME_absolute_get();
 422   if (GNUNET_YES == test_core)
 423   {
 424     p->cth = GNUNET_CORE_notify_transmit_ready (
 425       p->me->ch, GNUNET_NO, 0, GNUNET_TIME_UNIT_MINUTES, &p->dest->id,
 426       TEST_MESSAGE_SIZE, &comm_send_ready, p);
 427   }
 428   else
 429   {
 430     p->tth = GNUNET_TRANSPORT_notify_transmit_ready (
 431       p->me->th, &p->dest->id, TEST_MESSAGE_SIZE, 0,GNUNET_TIME_UNIT_MINUTES,
 432       &comm_send_ready, p);
 433   }
 434
 435 }
 436
 437 static void
 438 print_progress ()
 439 {
 440   static int calls;
 441   progress_task = GNUNET_SCHEDULER_NO_TASK;
 442
 443   fprintf (stderr, "%llu..",
 444       (long long unsigned) perf_duration.rel_value_us / (1000 * 1000) - calls);
 445   calls++;
 446
 447   progress_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 448       &print_progress, NULL );
 449 }
 450
 451 static void
 452 ats_pref_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 453 {
 454   struct BenchmarkPeer *me = cls;
 455
 456   me->ats_task = GNUNET_SCHEDULER_NO_TASK;
 457
 458   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, " Master [%u] set preference for slave [%u] to %f\n",
 459       me->no, me->pref_partner->no, me->pref_value);
 460   GNUNET_ATS_performance_change_preference (me->ats_perf_handle,
 461       &me->pref_partner->id,
 462       pref_val, me->pref_value, GNUNET_ATS_PREFERENCE_END);
 463   me->pref_value += TEST_ATS_PREFRENCE_DELTA;
 464   me->ats_task = GNUNET_SCHEDULER_add_delayed (TEST_ATS_PREFRENCE_FREQUENCY,
 465       &ats_pref_task, cls);
 466 }
 467
 468 static void
 469 do_benchmark ()
 470 {
 471   int c_m;
 472   int c_s;
 473
 474   if ((state.connected_ATS_service == GNUNET_NO)
 475       || (state.connected_COMM_service == GNUNET_NO)
 476       || (state.connected_PEERS == GNUNET_NO)
 477       || (state.connected_CORE == GNUNET_NO))
 478     return;
 479
 480   state.benchmarking = GNUNET_YES;
 481   GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Benchmarking start\n"));
 482
 483   if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
 484     GNUNET_SCHEDULER_cancel (shutdown_task);
 485   shutdown_task = GNUNET_SCHEDULER_add_delayed (perf_duration,
 486       &do_shutdown, NULL );
 487
 488   progress_task = GNUNET_SCHEDULER_add_now (&print_progress, NULL );
 489
 490   /* Start sending test messages */
 491   for (c_m = 0; c_m < num_masters; c_m++)
 492   {
 493     for (c_s = 0; c_s < num_slaves; c_s++)
 494       comm_schedule_send (&mps[c_m].partners[c_s]);
 495     if (pref_val != GNUNET_ATS_PREFERENCE_END)
 496       mps[c_m].ats_task = GNUNET_SCHEDULER_add_now (&ats_pref_task, &mps[c_m]);
 497   }
 498   if (GNUNET_YES == logging)
 499     perf_logging_start (log_frequency, testname, mps, num_masters);
 500
 501 }
 502
 503 static void
 504 connect_completion_callback (void *cls, struct GNUNET_TESTBED_Operation *op,
 505     const char *emsg)
 506 {
 507   struct TestbedConnectOperation *cop = cls;
 508   static int ops = 0;
 509   int c;
 510   if (NULL == emsg)
 511   {
 512     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 513         _("Connected master [%u] with slave [%u]\n"), cop->master->no,
 514         cop->slave->no);
 515   }
 516   else
 517   {
 518     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 519         _("Failed to connect master peer [%u] with slave [%u]\n"),
 520         cop->master->no, cop->slave->no);
 521     GNUNET_break(0);
 522     if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
 523       GNUNET_SCHEDULER_cancel (shutdown_task);
 524     shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL );
 525   }
 526   GNUNET_TESTBED_operation_done (op);
 527   ops++;
 528   for (c = 0; c < num_slaves; c++)
 529   {
 530     if (cop == &cop->master->core_connect_ops[c])
 531       cop->master->core_connect_ops[c].connect_op = NULL;
 532   }
 533   if (ops == num_masters * num_slaves)
 534   {
 535     state.connected_PEERS = GNUNET_YES;
 536     GNUNET_SCHEDULER_add_now (&do_benchmark, NULL );
 537   }
 538 }
 539
 540 static void
 541 do_connect_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 542 {
 543   int c_m;
 544   int c_s;
 545   struct BenchmarkPeer *p;
 546
 547   if ((state.connected_ATS_service == GNUNET_NO)
 548       || (state.connected_COMM_service == GNUNET_NO))
 549     return;
 550
 551   GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Connecting peers on CORE level\n"));
 552
 553   for (c_m = 0; c_m < num_masters; c_m++)
 554   {
 555     p = &mps[c_m];
 556     p->core_connect_ops = GNUNET_malloc (num_slaves *
 557         sizeof (struct TestbedConnectOperation));
 558
 559     for (c_s = 0; c_s < num_slaves; c_s++)
 560     {
 561       GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 562           _("Connecting master [%u] with slave [%u]\n"), p->no, sps[c_s].no);
 563       p->core_connect_ops[c_s].master = p;
 564       p->core_connect_ops[c_s].slave = &sps[c_s];
 565       p->core_connect_ops[c_s].connect_op = GNUNET_TESTBED_overlay_connect (
 566           NULL, &connect_completion_callback, &p->core_connect_ops[c_s],
 567           sps[c_s].peer, p->peer);
 568       if (NULL == p->core_connect_ops[c_s].connect_op)
 569       {
 570         GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 571             _("Could not connect master [%u] and slave [%u]\n"), p->no,
 572             sps[c_s].no);
 573         GNUNET_break(0);
 574         if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
 575           GNUNET_SCHEDULER_cancel (shutdown_task);
 576         shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL );
 577         return;
 578       }
 579     }
 580   }
 581 }
 582
 583 /**
 584  * Method called whenever a given peer connects.
 585  *
 586  * @param cls closure
 587  * @param peer peer identity this notification is about
 588  */
 589 static void
 590 comm_connect_cb (void *cls, const struct GNUNET_PeerIdentity * peer)
 591 {
 592   struct BenchmarkPeer *me = cls;
 593   struct BenchmarkPeer *remote;
 594   char *id;
 595   int c;
 596   int completed;
 597
 598   remote = find_peer (peer);
 599   if (NULL == remote)
 600   {
 601     GNUNET_break(0);
 602     return;
 603   }
 604
 605   id = GNUNET_strdup (GNUNET_i2s (&me->id));
 606   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s [%u] `%s' connected to %s [%u] %s\n",
 607       (me->master == GNUNET_YES) ? "Master": "Slave", me->no, id,
 608       (remote->master == GNUNET_YES) ? "Master": "Slave", remote->no,
 609       GNUNET_i2s (peer));
 610
 611   me->core_connections++;
 612   if ((GNUNET_YES == me->master) && (GNUNET_NO == remote->master)
 613       && (GNUNET_NO == state.connected_CORE))
 614   {
 615     me->core_slave_connections++;
 616
 617     if (me->core_slave_connections == num_slaves)
 618     {
 619       GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Master [%u] connected all slaves\n",
 620           me->no);
 621     }
 622     completed = GNUNET_YES;
 623     for (c = 0; c < num_masters; c++)
 624     {
 625       if (mps[c].core_slave_connections != num_slaves)
 626         completed = GNUNET_NO;
 627     }
 628     if (GNUNET_YES == completed)
 629     {
 630       GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 631           "All master peers connected all slave peers\n", id,
 632           GNUNET_i2s (peer));
 633       state.connected_CORE = GNUNET_YES;
 634       GNUNET_SCHEDULER_add_now (&do_benchmark, NULL );
 635     }
 636   }
 637   GNUNET_free(id);
 638 }
 639
 640 static struct BenchmarkPartner *
 641 find_partner (struct BenchmarkPeer *me, const struct GNUNET_PeerIdentity * peer)
 642 {
 643   int c_m;
 644   GNUNET_assert (NULL != me);
 645   GNUNET_assert (NULL != peer);
 646
 647   for (c_m = 0; c_m < me->num_partners; c_m++)
 648   {
 649     /* Find a partner with other as destination */
 650     if (0 == memcmp (peer, &me->partners[c_m].dest->id,
 651             sizeof(struct GNUNET_PeerIdentity)))
 652     {
 653       return &me->partners[c_m];
 654     }
 655   }
 656
 657   return NULL;
 658 }
 659
 660 static void
 661 comm_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity * peer)
 662 {
 663   struct BenchmarkPeer *me = cls;
 664   struct BenchmarkPartner *p;
 665   char *id;
 666
 667   if (NULL == (p = find_partner (me, peer)))
 668     return;
 669
 670   id = GNUNET_strdup (GNUNET_i2s (&me->id));
 671   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s disconnected from %s \n", id,
 672       GNUNET_i2s (peer));
 673   GNUNET_assert(me->core_connections > 0);
 674   me->core_connections--;
 675
 676   if ((GNUNET_YES == state.benchmarking)
 677       && ((GNUNET_YES == me->master) || (GNUNET_YES == p->dest->master)))
 678   {
 679     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 680         "%s disconnected from %s while benchmarking \n", id, GNUNET_i2s (peer));
 681     if (NULL != p->tth)
 682     {
 683       GNUNET_TRANSPORT_notify_transmit_ready_cancel (p->tth);
 684       p->tth = NULL;
 685     }
 686     if (NULL != p->cth)
 687     {
 688       GNUNET_CORE_notify_transmit_ready_cancel (p->cth);
 689       p->cth = NULL;
 690     }
 691   }
 692   GNUNET_free(id);
 693 }
 694
 695 static size_t
 696 comm_send_pong_ready (void *cls, size_t size, void *buf)
 697 {
 698   static char msgbuf[TEST_MESSAGE_SIZE];
 699   struct BenchmarkPartner *p = cls;
 700   struct GNUNET_MessageHeader *msg;
 701
 702   if (GNUNET_YES == test_core)
 703     p->cth = NULL;
 704   else
 705     p->tth = NULL;
 706
 707   p->messages_sent++;
 708   p->bytes_sent += TEST_MESSAGE_SIZE;
 709   p->me->total_messages_sent++;
 710   p->me->total_bytes_sent += TEST_MESSAGE_SIZE;
 711
 712   msg = (struct GNUNET_MessageHeader *) &msgbuf;
 713   memset (&msgbuf, 'a', TEST_MESSAGE_SIZE);
 714   msg->type = htons (TEST_MESSAGE_TYPE_PONG);
 715   msg->size = htons (TEST_MESSAGE_SIZE);
 716   memcpy (buf, msg, TEST_MESSAGE_SIZE);
 717
 718   return TEST_MESSAGE_SIZE;
 719 }
 720
 721 static int
 722 comm_handle_ping (void *cls, const struct GNUNET_PeerIdentity *other,
 723     const struct GNUNET_MessageHeader *message)
 724 {
 725
 726   struct BenchmarkPeer *me = cls;
 727   struct BenchmarkPartner *p = NULL;
 728
 729   if (NULL == (p = find_partner(me, other)))
 730   {
 731     GNUNET_break(0);
 732     return GNUNET_SYSERR;
 733   }
 734
 735   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 736       "Slave [%u]: Received PING from [%u], sending PONG\n", me->no,
 737       p->dest->no);
 738
 739   p->messages_received++;
 740   p->bytes_received += TEST_MESSAGE_SIZE;
 741   p->me->total_messages_received++;
 742   p->me->total_bytes_received += TEST_MESSAGE_SIZE;
 743
 744   if (GNUNET_YES == test_core)
 745   {
 746     GNUNET_assert (NULL == p->cth);
 747     p->cth = GNUNET_CORE_notify_transmit_ready (me->ch, GNUNET_NO, 0,
 748         GNUNET_TIME_UNIT_MINUTES, &p->dest->id, TEST_MESSAGE_SIZE,
 749         &comm_send_pong_ready, p);
 750   }
 751   else
 752   {
 753     GNUNET_assert (NULL == p->tth);
 754     p->tth = GNUNET_TRANSPORT_notify_transmit_ready (me->th, &p->dest->id,
 755         TEST_MESSAGE_SIZE, 0, GNUNET_TIME_UNIT_MINUTES, &comm_send_pong_ready,
 756         p);
 757   }
 758   return GNUNET_OK;
 759 }
 760
 761 static int
 762 comm_handle_pong (void *cls, const struct GNUNET_PeerIdentity *other,
 763     const struct GNUNET_MessageHeader *message)
 764 {
 765   struct BenchmarkPeer *me = cls;
 766   struct BenchmarkPartner *p = NULL;
 767
 768   if (NULL == (p = find_partner (me, other)))
 769   {
 770     GNUNET_break(0);
 771     return GNUNET_SYSERR;
 772   }
 773
 774   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 775       "Master [%u]: Received PONG from [%u], next message\n", me->no,
 776       p->dest->no);
 777
 778   p->messages_received++;
 779   p->bytes_received += TEST_MESSAGE_SIZE;
 780   p->me->total_messages_received++;
 781   p->me->total_bytes_received += TEST_MESSAGE_SIZE;
 782   p->total_app_rtt += GNUNET_TIME_absolute_get_difference(p->last_message_sent,
 783       GNUNET_TIME_absolute_get()).rel_value_us;
 784
 785   comm_schedule_send (p);
 786   return GNUNET_OK;
 787 }
 788
 789 static void *
 790 core_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 791 {
 792   struct BenchmarkPeer *me = cls;
 793
 794   static const struct GNUNET_CORE_MessageHandler handlers[] = { {
 795       &comm_handle_ping, TEST_MESSAGE_TYPE_PING, 0 }, { &comm_handle_pong,
 796       TEST_MESSAGE_TYPE_PONG, 0 }, { NULL, 0, 0 } };
 797
 798   me->ch = GNUNET_CORE_connect (cfg, me, NULL, comm_connect_cb,
 799       comm_disconnect_cb, NULL, GNUNET_NO, NULL, GNUNET_NO, handlers);
 800   if (NULL == me->ch)
 801     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to create core connection \n");
 802   return me->ch;
 803 }
 804
 805 static void
 806 core_disconnect_adapter (void *cls, void *op_result)
 807 {
 808   struct BenchmarkPeer *me = cls;
 809
 810   GNUNET_CORE_disconnect (me->ch);
 811   me->ch = NULL;
 812 }
 813
 814 static void
 815 comm_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
 816     void *ca_result, const char *emsg)
 817 {
 818   static int comm_done = 0;
 819   if ((NULL != emsg) || (NULL == ca_result))
 820   {
 821     GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Initialization failed, shutdown\n"));
 822     GNUNET_break(0);
 823     if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
 824       GNUNET_SCHEDULER_cancel (shutdown_task);
 825     shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL );
 826     return;
 827   }
 828   comm_done++;
 829
 830   if (comm_done == num_slaves + num_masters)
 831   {
 832     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connected to all %s services\n",
 833         (GNUNET_YES == test_core) ? "CORE" : "TRANSPORT");
 834     state.connected_COMM_service = GNUNET_YES;
 835     GNUNET_SCHEDULER_add_now (&do_connect_peers, NULL );
 836   }
 837 }
 838
 839 static void
 840 transport_recv_cb (void *cls,
 841                    const struct GNUNET_PeerIdentity * peer,
 842                    const struct GNUNET_MessageHeader * message)
 843 {
 844   if (TEST_MESSAGE_SIZE != ntohs (message->size) ||
 845       (TEST_MESSAGE_TYPE_PING != ntohs (message->type) &&
 846       TEST_MESSAGE_TYPE_PONG != ntohs (message->type)))
 847   {
 848     return;
 849   }
 850   if (TEST_MESSAGE_TYPE_PING == ntohs (message->type))
 851     comm_handle_ping (cls, peer, message);
 852
 853   if (TEST_MESSAGE_TYPE_PONG == ntohs (message->type))
 854     comm_handle_pong (cls, peer, message);
 855 }
 856
 857
 858 static void *
 859 transport_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 860 {
 861   struct BenchmarkPeer *me = cls;
 862
 863   me->th = GNUNET_TRANSPORT_connect (cfg, &me->id, me,  &transport_recv_cb,
 864       &comm_connect_cb, &comm_disconnect_cb);
 865   if (NULL == me->th)
 866     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to create transport connection \n");
 867   return me->th;
 868 }
 869
 870 static void
 871 transport_disconnect_adapter (void *cls, void *op_result)
 872 {
 873   struct BenchmarkPeer *me = cls;
 874
 875   GNUNET_TRANSPORT_disconnect (me->th);
 876   me->th = NULL;
 877 }
 878
 879 static void
 880 do_comm_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 881 {
 882   int c_s;
 883   int c_m;
 884   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connecting to all %s services\n",
 885       (GNUNET_YES == test_core) ? "CORE" : "TRANSPORT");
 886   for (c_m = 0; c_m < num_masters; c_m++)
 887   {
 888     if (GNUNET_YES == test_core)
 889       mps[c_m].comm_op = GNUNET_TESTBED_service_connect (NULL, mps[c_m].peer,
 890         "core", &comm_connect_completion_cb, NULL, &core_connect_adapter,
 891         &core_disconnect_adapter, &mps[c_m]);
 892     else
 893     {
 894       mps[c_m].comm_op = GNUNET_TESTBED_service_connect (NULL, mps[c_m].peer,
 895         "transport", &comm_connect_completion_cb, NULL, &transport_connect_adapter,
 896         &transport_disconnect_adapter, &mps[c_m]);
 897     }
 898   }
 899
 900   for (c_s = 0; c_s < num_slaves; c_s++)
 901   {
 902     if (GNUNET_YES == test_core)
 903       sps[c_s].comm_op = GNUNET_TESTBED_service_connect (NULL, sps[c_s].peer,
 904         "core", &comm_connect_completion_cb, NULL, &core_connect_adapter,
 905         &core_disconnect_adapter, &sps[c_s]);
 906     else
 907     {
 908       sps[c_s].comm_op = GNUNET_TESTBED_service_connect (NULL, sps[c_s].peer,
 909         "transport", &comm_connect_completion_cb, NULL, &transport_connect_adapter,
 910         &transport_disconnect_adapter, &sps[c_s]);
 911     }
 912   }
 913 }
 914
 915 static void
 916 ats_performance_info_cb (void *cls, const struct GNUNET_HELLO_Address *address,
 917     int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 918     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
 919     const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 920 {
 921   struct BenchmarkPeer *me = cls;
 922   struct BenchmarkPartner *p;
 923   int c_a;
 924   int log;
 925   char *peer_id;
 926
 927   p = find_partner (me, &address->peer);
 928   if (NULL == p)
 929   {
 930     /* This is not one of my partners
 931      * Will happen since the peers will connect to each other due to gossiping
 932      */
 933     return;
 934   }
 935   peer_id = GNUNET_strdup (GNUNET_i2s (&me->id));
 936
 937   log = GNUNET_NO;
 938   if ((p->bandwidth_in != ntohl (bandwidth_in.value__)) ||
 939       (p->bandwidth_out != ntohl (bandwidth_out.value__)))
 940       log = GNUNET_YES;
 941   p->bandwidth_in = ntohl (bandwidth_in.value__);
 942   p->bandwidth_out = ntohl (bandwidth_out.value__);
 943
 944   for (c_a = 0; c_a < ats_count; c_a++)
 945   {
 946     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s [%u] received ATS information: %s %s %u\n",
 947         (GNUNET_YES == p->me->master) ? "Master" : "Slave",
 948         p->me->no,
 949         GNUNET_i2s (&p->dest->id),
 950         GNUNET_ATS_print_property_type(ntohl(ats[c_a].type)),
 951         ntohl(ats[c_a].value));
 952     switch (ntohl (ats[c_a].type ))
 953     {
 954       case GNUNET_ATS_ARRAY_TERMINATOR:
 955         break;
 956       case GNUNET_ATS_UTILIZATION_OUT:
 957         if (p->ats_utilization_up != ntohl (ats[c_a].value))
 958             log = GNUNET_YES;
 959         p->ats_utilization_up = ntohl (ats[c_a].value);
 960
 961         break;
 962       case GNUNET_ATS_UTILIZATION_IN:
 963         if (p->ats_utilization_down != ntohl (ats[c_a].value))
 964             log = GNUNET_YES;
 965         p->ats_utilization_down = ntohl (ats[c_a].value);
 966         break;
 967       case GNUNET_ATS_NETWORK_TYPE:
 968         if (p->ats_network_type != ntohl (ats[c_a].value))
 969             log = GNUNET_YES;
 970         p->ats_network_type = ntohl (ats[c_a].value);
 971         break;
 972       case GNUNET_ATS_QUALITY_NET_DELAY:
 973         if (p->ats_delay != ntohl (ats[c_a].value))
 974             log = GNUNET_YES;
 975         p->ats_delay = ntohl (ats[c_a].value);
 976         break;
 977       case GNUNET_ATS_QUALITY_NET_DISTANCE:
 978         if (p->ats_distance != ntohl (ats[c_a].value))
 979             log = GNUNET_YES;
 980         p->ats_distance = ntohl (ats[c_a].value);
 981         GNUNET_break (0);
 982         break;
 983       case GNUNET_ATS_COST_WAN:
 984         if (p->ats_cost_wan != ntohl (ats[c_a].value))
 985             log = GNUNET_YES;
 986         p->ats_cost_wan = ntohl (ats[c_a].value);
 987         break;
 988       case GNUNET_ATS_COST_LAN:
 989         if (p->ats_cost_lan != ntohl (ats[c_a].value))
 990             log = GNUNET_YES;
 991         p->ats_cost_lan = ntohl (ats[c_a].value);
 992         break;
 993       case GNUNET_ATS_COST_WLAN:
 994         if (p->ats_cost_wlan != ntohl (ats[c_a].value))
 995             log = GNUNET_YES;
 996         p->ats_cost_wlan = ntohl (ats[c_a].value);
 997         break;
 998       default:
 999         break;
1000     }
1001   }
1002   if ((GNUNET_YES == logging) && (GNUNET_YES == log))
1003     collect_log_now();
1004   GNUNET_free(peer_id);
1005 }
1006
1007 static void *
1008 ats_perf_connect_adapter (void *cls,
1009     const struct GNUNET_CONFIGURATION_Handle *cfg)
1010 {
1011   struct BenchmarkPeer *me = cls;
1012
1013   me->ats_perf_handle = GNUNET_ATS_performance_init (cfg,
1014       &ats_performance_info_cb, me);
1015   if (NULL == me->ats_perf_handle)
1016     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
1017         "Failed to create ATS performance handle \n");
1018   return me->ats_perf_handle;
1019 }
1020
1021 static void
1022 ats_perf_disconnect_adapter (void *cls, void *op_result)
1023 {
1024   struct BenchmarkPeer *me = cls;
1025
1026   GNUNET_ATS_performance_done (me->ats_perf_handle);
1027   me->ats_perf_handle = NULL;
1028 }
1029
1030 static void
1031 ats_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
1032     void *ca_result, const char *emsg)
1033 {
1034   static int op_done = 0;
1035
1036   if ((NULL != emsg) || (NULL == ca_result))
1037   {
1038     GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Initialization failed, shutdown\n"));
1039     GNUNET_break(0);
1040     if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
1041       GNUNET_SCHEDULER_cancel (shutdown_task);
1042     shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL );
1043     return;
1044   }
1045   op_done++;
1046   if (op_done == (num_masters + num_slaves))
1047   {
1048     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connected to all ATS services\n");
1049     state.connected_ATS_service = GNUNET_YES;
1050     GNUNET_SCHEDULER_add_now (&do_comm_connect, NULL );
1051   }
1052 }
1053
1054 static void
1055 do_connect_ats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1056 {
1057   int c_m;
1058   int c_s;
1059
1060   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Connecting to all ATS services\n");
1061   for (c_m = 0; c_m < num_masters; c_m++)
1062   {
1063     mps[c_m].ats_perf_op = GNUNET_TESTBED_service_connect (NULL, mps[c_m].peer,
1064         "ats", ats_connect_completion_cb, NULL, &ats_perf_connect_adapter,
1065         &ats_perf_disconnect_adapter, &mps[c_m]);
1066
1067   }
1068
1069   for (c_s = 0; c_s < num_slaves; c_s++)
1070   {
1071     sps[c_s].ats_perf_op = GNUNET_TESTBED_service_connect (NULL, sps[c_s].peer,
1072         "ats", ats_connect_completion_cb, NULL, &ats_perf_connect_adapter,
1073         &ats_perf_disconnect_adapter, &sps[c_s]);
1074   }
1075
1076 }
1077
1078 static void
1079 peerinformation_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
1080     const struct GNUNET_TESTBED_PeerInformation*pinfo, const char *emsg)
1081 {
1082   struct BenchmarkPeer *p = cb_cls;
1083   static int done = 0;
1084
1085   GNUNET_assert(pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY);
1086
1087   p->id = *pinfo->result.id;
1088   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "%s [%u] has peer id `%s'\n",
1089       (p->master == GNUNET_YES) ? "Master" : "Slave", p->no,
1090       GNUNET_i2s (&p->id));
1091
1092   GNUNET_TESTBED_operation_done (op);
1093   p->peer_id_op = NULL;
1094   done++;
1095
1096   if (done == num_slaves + num_masters)
1097   {
1098     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
1099         "Retrieved all peer ID, connect to ATS\n");
1100     GNUNET_SCHEDULER_add_now (&do_connect_ats, NULL );
1101   }
1102 }
1103
1104 /**
1105  * Signature of a main function for a testcase.
1106  *
1107  * @param cls closure
1108  * @param num_peers number of peers in 'peers'
1109  * @param peers_ handle to peers run in the testbed
1110  * @param links_succeeded the number of overlay link connection attempts that
1111  *          succeeded
1112  * @param links_failed the number of overlay link connection attempts that
1113  *          failed
1114  */
1115 static void
1116 main_run (void *cls, struct GNUNET_TESTBED_RunHandle *h,
1117           unsigned int num_peers,
1118           struct GNUNET_TESTBED_Peer **peers_,
1119           unsigned int links_succeeded,
1120           unsigned int links_failed)
1121 {
1122   int c_m;
1123   int c_s;
1124   GNUNET_assert(NULL == cls);
1125   GNUNET_assert(num_masters + num_slaves == num_peers);
1126   GNUNET_assert(NULL != peers_);
1127
1128   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
1129       _("Benchmarking solver `%s' on preference `%s' with %u master and %u slave peers\n"),
1130       solver, pref_str, num_masters, num_slaves);
1131
1132   shutdown_task = GNUNET_SCHEDULER_add_delayed (
1133       GNUNET_TIME_relative_multiply (TEST_TIMEOUT, num_masters + num_slaves),
1134       &do_shutdown, NULL );
1135
1136   /* Setup master peers */
1137   for (c_m = 0; c_m < num_masters; c_m++)
1138   {
1139     GNUNET_assert(NULL != peers_[c_m]);
1140     mps[c_m].peer = peers_[c_m];
1141     mps[c_m].no = c_m;
1142     mps[c_m].master = GNUNET_YES;
1143     mps[c_m].pref_partner = &sps[c_m];
1144     mps[c_m].pref_value = TEST_ATS_PREFRENCE_START;
1145     mps[c_m].partners =
1146         GNUNET_malloc (num_slaves * sizeof (struct BenchmarkPartner));
1147     mps[c_m].num_partners = num_slaves;
1148     /* Initialize partners */
1149     for (c_s = 0; c_s < num_slaves; c_s++)
1150     {
1151       mps[c_m].partners[c_s].me = &mps[c_m];
1152       mps[c_m].partners[c_s].dest = &sps[c_s];
1153     }
1154     mps[c_m].peer_id_op = GNUNET_TESTBED_peer_get_information (mps[c_m].peer,
1155         GNUNET_TESTBED_PIT_IDENTITY, &peerinformation_cb, &mps[c_m]);
1156   }
1157
1158   /* Setup slave peers */
1159   for (c_s = 0; c_s < num_slaves; c_s++)
1160   {
1161     GNUNET_assert(NULL != peers_[c_s + num_masters]);
1162     sps[c_s].peer = peers_[c_s + num_masters];
1163     sps[c_s].no = c_s + num_masters;
1164     sps[c_s].master = GNUNET_NO;
1165     sps[c_s].partners =
1166         GNUNET_malloc (num_masters * sizeof (struct BenchmarkPartner));
1167     sps[c_s].num_partners = num_masters;
1168     /* Initialize partners */
1169     for (c_m = 0; c_m < num_masters; c_m++)
1170     {
1171       sps[c_s].partners[c_m].me = &sps[c_s];
1172       sps[c_s].partners[c_m].dest = &mps[c_m];
1173     }
1174     sps[c_s].peer_id_op = GNUNET_TESTBED_peer_get_information (sps[c_s].peer,
1175         GNUNET_TESTBED_PIT_IDENTITY, &peerinformation_cb, &sps[c_s]);
1176   }
1177 }
1178
1179 int
1180 main (int argc, char *argv[])
1181 {
1182   char *tmp;
1183   char *tmp_sep;
1184   char *test_name;
1185   char *conf_name;
1186   char *comm_name;
1187   char *dotexe;
1188   char *prefs[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString;
1189   int c;
1190
1191   result = 0;
1192
1193   /* figure out testname */
1194   tmp = strstr (argv[0], TESTNAME_PREFIX);
1195   if (NULL == tmp)
1196   {
1197     fprintf (stderr, "Unable to parse test name `%s'\n", argv[0]);
1198     return GNUNET_SYSERR;
1199   }
1200   tmp += strlen (TESTNAME_PREFIX);
1201   solver = GNUNET_strdup (tmp);
1202   if (NULL != (dotexe = strstr (solver, ".exe")) && dotexe[4] == '\0')
1203     dotexe[0] = '\0';
1204   tmp_sep = strchr (solver, '_');
1205   if (NULL == tmp_sep)
1206   {
1207     fprintf (stderr, "Unable to parse test name `%s'\n", argv[0]);
1208     GNUNET_free(solver);
1209     return GNUNET_SYSERR;
1210   }
1211   tmp_sep[0] = '\0';
1212   comm_name = GNUNET_strdup (&tmp_sep[1]);
1213   tmp_sep = strchr (comm_name, '_');
1214   if (NULL == tmp_sep)
1215   {
1216     fprintf (stderr, "Unable to parse test name `%s'\n", argv[0]);
1217     GNUNET_free(solver);
1218     return GNUNET_SYSERR;
1219   }
1220   tmp_sep[0] = '\0';
1221   for (c = 0; c <= strlen (comm_name); c++)
1222     comm_name[c] = toupper (comm_name[c]);
1223   if (0 == strcmp (comm_name, "CORE"))
1224     test_core = GNUNET_YES;
1225   else if (0 == strcmp (comm_name, "TRANSPORT"))
1226     test_core = GNUNET_NO;
1227   else
1228   {
1229     GNUNET_free (comm_name);
1230     GNUNET_free (solver);
1231     return GNUNET_SYSERR;
1232   }
1233
1234   pref_str = GNUNET_strdup(tmp_sep + 1);
1235
1236   GNUNET_asprintf (&conf_name, "%s%s_%s.conf", TESTNAME_PREFIX, solver,
1237       pref_str);
1238   GNUNET_asprintf (&test_name, "%s%s_%s", TESTNAME_PREFIX, solver, pref_str);
1239
1240   for (c = 0; c <= strlen (pref_str); c++)
1241     pref_str[c] = toupper (pref_str[c]);
1242   pref_val = -1;
1243
1244   if (0 != strcmp (pref_str, "NONE"))
1245   {
1246     for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
1247     {
1248       if (0 == strcmp (pref_str, prefs[c]))
1249       {
1250         pref_val = c;
1251         break;
1252       }
1253     }
1254   }
1255   else
1256   {
1257     /* abuse terminator to indicate no pref */
1258     pref_val = GNUNET_ATS_PREFERENCE_END;
1259   }
1260   if (-1 == pref_val)
1261   {
1262     fprintf (stderr, "Unknown preference: `%s'\n", pref_str);
1263     GNUNET_free(solver);
1264     GNUNET_free(pref_str);
1265     GNUNET_free (comm_name);
1266     return -1;
1267   }
1268
1269   for (c = 0; c < (argc - 1); c++)
1270   {
1271     if (0 == strcmp (argv[c], "-d"))
1272       break;
1273   }
1274   if (c < argc - 1)
1275   {
1276     if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative (argv[c + 1], &perf_duration))
1277         fprintf (stderr, "Failed to parse duration `%s'\n", argv[c + 1]);
1278   }
1279   else
1280   {
1281     perf_duration = BENCHMARK_DURATION;
1282   }
1283   fprintf (stderr, "Running benchmark for %llu secs\n", (unsigned long long) (perf_duration.rel_value_us) / (1000 * 1000));
1284
1285   for (c = 0; c < (argc - 1); c++)
1286   {
1287     if (0 == strcmp (argv[c], "-s"))
1288       break;
1289   }
1290   if (c < argc - 1)
1291   {
1292     if ((0L != (num_slaves = strtol (argv[c + 1], NULL, 10)))
1293         && (num_slaves >= 1))
1294       fprintf (stderr, "Starting %u slave peers\n", num_slaves);
1295     else
1296       num_slaves = DEFAULT_SLAVES_NUM;
1297   }
1298   else
1299     num_slaves = DEFAULT_SLAVES_NUM;
1300
1301   for (c = 0; c < (argc - 1); c++)
1302   {
1303     if (0 == strcmp (argv[c], "-m"))
1304       break;
1305   }
1306   if (c < argc - 1)
1307   {
1308     if ((0L != (num_masters = strtol (argv[c + 1], NULL, 10)))
1309         && (num_masters >= 2))
1310       fprintf (stderr, "Starting %u master peers\n", num_masters);
1311     else
1312       num_masters = DEFAULT_MASTERS_NUM;
1313   }
1314   else
1315     num_masters = DEFAULT_MASTERS_NUM;
1316
1317   logging = GNUNET_NO;
1318   for (c = 0; c < argc; c++)
1319   {
1320     if (0 == strcmp (argv[c], "-l"))
1321       logging = GNUNET_YES;
1322   }
1323
1324   if (GNUNET_YES == logging)
1325   {
1326     for (c = 0; c < (argc - 1); c++)
1327     {
1328       if (0 == strcmp (argv[c], "-f"))
1329         break;
1330     }
1331     if (c < argc - 1)
1332     {
1333       if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_relative (argv[c + 1], &log_frequency))
1334           fprintf (stderr, "Failed to parse duration `%s'\n", argv[c + 1]);
1335     }
1336     else
1337     {
1338       log_frequency = LOGGING_FREQUENCY;
1339     }
1340     fprintf (stderr, "Using log frequency %llu ms\n",
1341         (unsigned long long) (log_frequency.rel_value_us) / (1000));
1342   }
1343
1344   GNUNET_asprintf (&testname, "%s_%s_%s",solver, comm_name, pref_str);
1345
1346   if (num_slaves < num_masters)
1347   {
1348     fprintf (stderr, "Number of master peers is lower than slaves! exit...\n");
1349     GNUNET_free(test_name);
1350     GNUNET_free(solver);
1351     GNUNET_free(pref_str);
1352     GNUNET_free (comm_name);
1353     return GNUNET_SYSERR;
1354   }
1355
1356   state.connected_ATS_service = GNUNET_NO;
1357   state.connected_COMM_service = GNUNET_NO;
1358   state.connected_PEERS = GNUNET_NO;
1359   state.benchmarking = GNUNET_NO;
1360   state.connected_PEERS = GNUNET_NO;
1361
1362   mps = GNUNET_malloc (num_masters * sizeof (struct BenchmarkPeer));
1363   sps = GNUNET_malloc (num_slaves * sizeof (struct BenchmarkPeer));
1364
1365   /* Start topology */
1366   uint64_t event_mask;
1367   event_mask = 0;
1368   event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
1369   event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
1370   (void) GNUNET_TESTBED_test_run ("perf-ats", conf_name,
1371       num_slaves + num_masters, event_mask, &controller_event_cb, NULL,
1372       &main_run, NULL );
1373
1374   GNUNET_free(solver);
1375   GNUNET_free(pref_str);
1376   GNUNET_free(conf_name);
1377   GNUNET_free(test_name);
1378   GNUNET_free(testname);
1379   GNUNET_free (comm_name);
1380   GNUNET_free(mps);
1381   GNUNET_free(sps);
1382
1383   return result;
1384 }
1385
1386 /* end of file perf_ats.c */