src/ats/gnunet-ats-solver-eval.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2010-2013 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  * @file ats-tests/ats-testing-experiment.c
  22  * @brief ats benchmark: controlled experiment execution
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet-ats-solver-eval.h"
  29 #include "gnunet-service-ats_normalization.h"
  30 #include "gnunet-service-ats_preferences.c"
  31
  32 #define BIG_M_STRING "unlimited"
  33
  34 /**
  35  * Handle for statistics.
  36  */
  37 struct GNUNET_STATISTICS_Handle *GSA_stats;
  38
  39
  40 static struct Experiment *e;
  41
  42 static struct LoggingHandle *l;
  43
  44 static struct SolverHandle *sh;
  45
  46 static struct TestPeer *peer_head;
  47
  48 static struct TestPeer *peer_tail;
  49
  50 static double default_properties[GNUNET_ATS_PropertyCount];
  51 static double default_preferences[GNUNET_ATS_PreferenceCount];
  52
  53 /**
  54  * cmd option -e: experiment file
  55  */
  56 static char *opt_exp_file;
  57
  58 static char *opt_solver;
  59
  60 /**
  61  * cmd option -l: enable logging
  62  */
  63 static int opt_log;
  64
  65 /**
  66  * cmd option -p: enable plots
  67  */
  68 static int opt_save;
  69
  70 /**
  71  * cmd option -v: verbose logs
  72  */
  73 static int opt_verbose;
  74
  75 /**
  76  * cmd option -p: print logs
  77  */
  78 static int opt_print;
  79
  80 /**
  81  * cmd option -d: disable normalization
  82  */
  83 static int opt_disable_normalization;
  84
  85 static int res;
  86
  87 static void
  88 end_now ();
  89
  90
  91 static char *
  92 print_generator_type (enum GeneratorType g)
  93 {
  94   switch (g)
  95   {
  96   case GNUNET_ATS_TEST_TG_CONSTANT:
  97     return "CONSTANT";
  98
  99   case GNUNET_ATS_TEST_TG_LINEAR:
 100     return "LINEAR";
 101
 102   case GNUNET_ATS_TEST_TG_RANDOM:
 103     return "RANDOM";
 104
 105   case GNUNET_ATS_TEST_TG_SINUS:
 106     return "SINUS";
 107
 108   default:
 109     return "INVALID";
 110     break;
 111   }
 112 }
 113
 114
 115 static struct TestPeer *
 116 find_peer_by_id (int id)
 117 {
 118   struct TestPeer *cur;
 119
 120   for (cur = peer_head; NULL != cur; cur = cur->next)
 121     if (cur->id == id)
 122       return cur;
 123   return NULL;
 124 }
 125
 126
 127 static struct TestPeer *
 128 find_peer_by_pid (const struct GNUNET_PeerIdentity *pid)
 129 {
 130   struct TestPeer *cur;
 131
 132   for (cur = peer_head; NULL != cur; cur = cur->next)
 133     if (0 == GNUNET_memcmp (&cur->peer_id, pid))
 134       return cur;
 135   return NULL;
 136 }
 137
 138
 139 static struct TestAddress *
 140 find_address_by_id (struct TestPeer *peer, int aid)
 141 {
 142   struct TestAddress *cur;
 143
 144   for (cur = peer->addr_head; NULL != cur; cur = cur->next)
 145     if (cur->aid == aid)
 146       return cur;
 147   return NULL;
 148 }
 149
 150
 151 /**
 152  * Logging
 153  */
 154 void
 155 GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
 156 {
 157   struct LoggingTimeStep *lts;
 158   struct TestPeer *cur;
 159   struct TestAddress *cur_addr;
 160   struct LoggingPeer *log_p;
 161   struct LoggingAddress *log_a;
 162   int c;
 163
 164   lts = GNUNET_new (struct LoggingTimeStep);
 165   GNUNET_CONTAINER_DLL_insert_tail (l->head, l->tail, lts);
 166   lts->timestamp = GNUNET_TIME_absolute_get ();
 167   if (NULL == lts->prev)
 168     lts->delta = GNUNET_TIME_UNIT_ZERO;
 169   else
 170     lts->delta = GNUNET_TIME_absolute_get_duration (lts->prev->timestamp);
 171
 172   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging %llu, delta %llu\n",
 173               lts->timestamp.abs_value_us, lts->delta.rel_value_us);
 174
 175
 176   /* Store logging data here */
 177   for (cur = peer_head; NULL != cur; cur = cur->next)
 178   {
 179     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 180                 "Logging peer id %llu\n", cur->id);
 181
 182     log_p = GNUNET_new (struct LoggingPeer);
 183     log_p->id = cur->id;
 184     log_p->peer_id = cur->peer_id;
 185     log_p->is_requested = cur->is_requested;
 186     for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
 187     {
 188       log_p->pref_abs[c] = cur->pref_abs[c];
 189       log_p->pref_norm[c] = cur->pref_norm[c];
 190       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 191                   "\t %s = %.2f %.2f [abs/rel]\n",
 192                   GNUNET_ATS_print_preference_type (c),
 193                   log_p->pref_abs[c], log_p->pref_norm[c]);
 194     }
 195     GNUNET_CONTAINER_DLL_insert_tail (lts->head, lts->tail, log_p);
 196
 197     for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
 198     {
 199       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 200                   "Logging peer id %llu address %llu\n",
 201                   cur->id, cur_addr->aid);
 202       log_a = GNUNET_new (struct LoggingAddress);
 203       log_a->aid = cur_addr->aid;
 204       log_a->active = cur_addr->ats_addr->active;
 205       log_a->network = cur_addr->network;
 206       log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in;
 207       log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out;
 208       for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
 209       {
 210         log_a->prop_abs[c] = cur_addr->prop_abs[c];
 211         log_a->prop_norm[c] = cur_addr->prop_norm[c];
 212         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 213                     "\t %s = %.2f %.2f [abs/rel]\n",
 214                     GNUNET_ATS_print_property_type (c),
 215                     log_a->prop_abs[c],
 216                     log_a->prop_norm[c]);
 217       }
 218       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
 219       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n",
 220                   log_a->assigned_bw_in);
 221       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "\t BW out = %llu\n",
 222                   log_a->assigned_bw_out);
 223
 224       GNUNET_CONTAINER_DLL_insert_tail (log_p->addr_head, log_p->addr_tail,
 225                                         log_a);
 226     }
 227   }
 228 }
 229
 230
 231 static void
 232 logging_task (void *cls)
 233 {
 234   struct LoggingHandle *l = cls;
 235
 236   l->logging_task = NULL;
 237   GNUNET_ATS_solver_logging_now (l);
 238   l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq,
 239                                                   &logging_task,
 240                                                   l);
 241 }
 242
 243
 244 struct LoggingHandle *
 245 GNUNET_ATS_solver_logging_start (struct GNUNET_TIME_Relative freq)
 246 {
 247   struct LoggingHandle *l;
 248
 249   l = GNUNET_new (struct LoggingHandle);
 250
 251   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start logging every  %s\n",
 252               GNUNET_STRINGS_relative_time_to_string (freq, GNUNET_NO));
 253   l->log_freq = freq;
 254   l->logging_task = GNUNET_SCHEDULER_add_now (&logging_task, l);
 255   return l;
 256 }
 257
 258
 259 void
 260 GNUNET_ATS_solver_logging_stop (struct LoggingHandle *l)
 261 {
 262   if (NULL != l->logging_task)
 263     GNUNET_SCHEDULER_cancel (l->logging_task);
 264
 265   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stop logging\n");
 266
 267   l->logging_task = NULL;
 268 }
 269
 270
 271 static struct LoggingFileHandle *
 272 find_logging_file_handle (struct LoggingFileHandle *lf_head,
 273                           struct LoggingFileHandle *lf_tail,
 274                           int peer_id, int address_id)
 275 {
 276   struct LoggingFileHandle *res;
 277
 278   for (res = lf_head; NULL != res; res = res->next)
 279     if ((res->pid == peer_id) && (res->aid == address_id))
 280       return res;
 281   return NULL;
 282 }
 283
 284
 285 void
 286 GNUNET_ATS_solver_logging_write_to_disk (struct LoggingHandle *l, int
 287                                          add_time_stamp,
 288                                          char *output_dir)
 289 {
 290   struct LoggingTimeStep *lts;
 291   struct LoggingPeer *log_p;
 292   struct LoggingAddress *log_a;
 293   struct LoggingFileHandle *lf_head;
 294   struct LoggingFileHandle *lf_tail;
 295   struct LoggingFileHandle *cur;
 296   struct LoggingFileHandle *next;
 297   char *filename;
 298   char *datastring;
 299   char *propstring;
 300   char *propstring_tmp;
 301   char *prefstring;
 302   char *prefstring_tmp;
 303   int c;
 304   int use_dir;
 305
 306   use_dir = GNUNET_NO;
 307   if (NULL != output_dir)
 308   {
 309     if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (output_dir))
 310     {
 311       fprintf (stderr, "Failed to create directory `%s'\n", output_dir);
 312       return;
 313     }
 314     else
 315     {
 316       fprintf (stderr, "Created directory `%s'\n", output_dir);
 317       use_dir = GNUNET_YES;
 318     }
 319   }
 320
 321   lf_head = NULL;
 322   lf_tail = NULL;
 323
 324   for (lts = l->head; NULL != lts; lts = lts->next)
 325   {
 326     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing log step %llu\n",
 327                 (long long unsigned int) lts->timestamp.abs_value_us);
 328
 329     for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
 330     {
 331       for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
 332       {
 333         cur = find_logging_file_handle (lf_head, lf_tail, log_p->id,
 334                                         log_a->aid);
 335         if (NULL == cur)
 336         {
 337           cur = GNUNET_new (struct LoggingFileHandle);
 338           cur->aid = log_a->aid;
 339           cur->pid = log_p->id;
 340
 341           if (GNUNET_YES == add_time_stamp)
 342             GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u_%llu.log",
 343                              (GNUNET_YES == use_dir) ? output_dir : "",
 344                              (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
 345                              e->log_prefix,
 346                              opt_solver,
 347                              cur->pid,
 348                              cur->aid,
 349                              l->head->timestamp.abs_value_us);
 350           else
 351             GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u.log",
 352                              (GNUNET_YES == use_dir) ? output_dir : "",
 353                              (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
 354                              e->log_prefix,
 355                              opt_solver,
 356                              cur->pid,
 357                              cur->aid);
 358
 359           fprintf (stderr,
 360                    "Add writing log data for peer %llu address %llu to file `%s'\n",
 361                    cur->pid, cur->aid, filename);
 362
 363
 364           cur->f_hd = GNUNET_DISK_file_open (filename,
 365                                              GNUNET_DISK_OPEN_READWRITE
 366                                              | GNUNET_DISK_OPEN_CREATE
 367                                              | GNUNET_DISK_OPEN_TRUNCATE,
 368                                              GNUNET_DISK_PERM_USER_READ
 369                                              | GNUNET_DISK_PERM_USER_WRITE
 370                                              | GNUNET_DISK_PERM_GROUP_READ
 371                                              | GNUNET_DISK_PERM_OTHER_READ);
 372           if (NULL == cur->f_hd)
 373           {
 374             fprintf (stderr, "Cannot open `%s' to write log data!\n", filename);
 375             GNUNET_free (filename);
 376             GNUNET_free (cur);
 377             goto cleanup;
 378           }
 379           GNUNET_free (filename);
 380           GNUNET_CONTAINER_DLL_insert (lf_head, lf_tail, cur);
 381
 382           GNUNET_asprintf (&datastring,
 383                            "#time delta;log duration;peer_requested;addr net; addr_active; bw in; bw out; " \
 384                            "UTILIZATION_UP [abs/rel]; UTILIZATION_UP; UTILIZATION_DOWN; UTILIZATION_DOWN; " \
 385                            "UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_DOWN; UTILIZATION_PAYLOAD_DOWN;" \
 386                            "DELAY; DELAY; " \
 387                            "DISTANCE ;DISTANCE ; COST_WAN; COST_WAN; COST_LAN; COST_LAN; " \
 388                            "COST_WLAN; COST_WLAN;COST_BT; COST_BT; PREF BW abs; PREF BW rel; PREF LATENCY abs; PREF LATENCY rel;\n");
 389           GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
 390           GNUNET_free (datastring);
 391         }
 392
 393         prefstring = GNUNET_strdup ("");
 394         for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
 395         {
 396           /*
 397              fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n",
 398               GNUNET_ATS_print_preference_type(c),
 399               log_p->pref_abs[c], log_p->pref_norm[c]);
 400            */GNUNET_asprintf (&prefstring_tmp, "%s;%.3f;%.3f",
 401                            prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
 402
 403
 404           GNUNET_free (prefstring);
 405           prefstring = GNUNET_strdup (prefstring_tmp);
 406           GNUNET_free (prefstring_tmp);
 407         }
 408
 409
 410         propstring = GNUNET_strdup ("");
 411         for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
 412         {
 413           if (GNUNET_ATS_NETWORK_TYPE == c)
 414             continue;
 415           /*
 416              fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
 417               GNUNET_ATS_print_property_type(c),
 418               log_a->prop_abs[c], log_a->prop_norm[c]);*/
 419           GNUNET_asprintf (&propstring_tmp, "%s%.3f;%.3f;",
 420                            propstring,
 421                            log_a->prop_abs[c],
 422                            log_a->prop_norm[c]);
 423           GNUNET_free (propstring);
 424           propstring = GNUNET_strdup (propstring_tmp);
 425           GNUNET_free (propstring_tmp);
 426         }
 427         GNUNET_asprintf (&datastring, "%llu;%llu;%u;%u;%i;%u;%u;%s;%s\n",
 428                          GNUNET_TIME_absolute_get_difference (
 429                            l->head->timestamp,
 430                            lts->timestamp).
 431                          rel_value_us / 1000, lts->delta,
 432                          log_p->is_requested, log_a->network, log_a->active,
 433                          log_a->assigned_bw_in, log_a->assigned_bw_out,
 434                          propstring,
 435                          prefstring);
 436
 437         GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
 438         GNUNET_free (datastring);
 439         GNUNET_free (prefstring);
 440         GNUNET_free (propstring);
 441       }
 442     }
 443   }
 444
 445 cleanup:
 446   next = lf_head;
 447   for (cur = next; NULL != cur; cur = next)
 448   {
 449     next = cur->next;
 450     GNUNET_CONTAINER_DLL_remove (lf_head, lf_tail, cur);
 451     if (NULL != cur->f_hd)
 452       GNUNET_DISK_file_close (cur->f_hd);
 453     GNUNET_free (cur);
 454   }
 455 }
 456
 457
 458 void
 459 GNUNET_ATS_solver_logging_eval (struct LoggingHandle *l)
 460 {
 461   struct LoggingTimeStep *lts;
 462   struct LoggingPeer *log_p;
 463   struct LoggingAddress *log_a;
 464   int c;
 465
 466   for (lts = l->head; NULL != lts; lts = lts->next)
 467   {
 468     fprintf (stderr, "Log step %llu %llu: \n",
 469              (long long unsigned int) lts->timestamp.abs_value_us,
 470              (long long unsigned int) lts->delta.rel_value_us);
 471
 472     for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
 473     {
 474       fprintf (stderr, "\tLogging peer pid %llu\n", log_p->id);
 475       for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
 476       {
 477         fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
 478                  GNUNET_ATS_print_preference_type (c),
 479                  log_p->pref_abs[c], log_p->pref_norm[c]);
 480       }
 481
 482       for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
 483       {
 484         fprintf (stderr, "\tPeer pid %llu address %llu: %u %u %u\n",
 485                  log_p->id, log_a->aid, log_a->active,
 486                  log_a->assigned_bw_in,
 487                  log_a->assigned_bw_out);
 488
 489         for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
 490         {
 491           if (GNUNET_ATS_NETWORK_TYPE == c)
 492             continue;
 493           fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
 494                    GNUNET_ATS_print_property_type (c),
 495                    log_a->prop_abs[c], log_a->prop_norm[c]);
 496         }
 497       }
 498     }
 499   }
 500 }
 501
 502
 503 void
 504 GNUNET_ATS_solver_logging_free (struct LoggingHandle *l)
 505 {
 506   struct LoggingTimeStep *lts_cur;
 507   struct LoggingTimeStep *lts_next;
 508   struct LoggingPeer *log_p_cur;
 509   struct LoggingPeer *log_p_next;
 510   struct LoggingAddress *log_a_cur;
 511   struct LoggingAddress *log_a_next;
 512
 513   if (NULL != l->logging_task)
 514     GNUNET_SCHEDULER_cancel (l->logging_task);
 515   l->logging_task = NULL;
 516
 517   lts_next = l->head;
 518   while (NULL != (lts_cur = lts_next))
 519   {
 520     lts_next = lts_cur->next;
 521
 522     log_p_next = lts_cur->head;
 523     while (NULL != (log_p_cur = log_p_next))
 524     {
 525       log_p_next = log_p_cur->next;
 526
 527       log_a_next = log_p_cur->addr_head;
 528       while (NULL != (log_a_cur = log_a_next))
 529       {
 530         log_a_next = log_a_cur->next;
 531
 532         GNUNET_CONTAINER_DLL_remove (log_p_cur->addr_head, log_p_cur->addr_tail,
 533                                      log_a_cur);
 534         GNUNET_free (log_a_cur);
 535       }
 536
 537       GNUNET_CONTAINER_DLL_remove (lts_cur->head, lts_cur->tail, log_p_cur);
 538       GNUNET_free (log_p_cur);
 539     }
 540
 541     GNUNET_CONTAINER_DLL_remove (l->head, l->tail, lts_cur);
 542     GNUNET_free (lts_cur);
 543   }
 544
 545   GNUNET_free (l);
 546 }
 547
 548
 549 /**
 550  * Property Generators
 551  */
 552 static struct PropertyGenerator *prop_gen_head;
 553 static struct PropertyGenerator *prop_gen_tail;
 554
 555
 556 static double
 557 get_property (struct PropertyGenerator *pg)
 558 {
 559   struct GNUNET_TIME_Relative time_delta;
 560   double delta_value;
 561   double pref_value;
 562
 563   /* Calculate the current preference value */
 564   switch (pg->type)
 565   {
 566   case GNUNET_ATS_TEST_TG_CONSTANT:
 567     pref_value = pg->base_value;
 568     break;
 569
 570   case GNUNET_ATS_TEST_TG_LINEAR:
 571     time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
 572     /* Calculate point of time in the current period */
 573     time_delta.rel_value_us = time_delta.rel_value_us
 574                               % pg->duration_period.rel_value_us;
 575     delta_value = ((double) time_delta.rel_value_us
 576                    / pg->duration_period.rel_value_us) * (pg->max_value
 577                                                           - pg->base_value);
 578     if ((pg->max_value < pg->base_value) &&
 579         ((pg->max_value - pg->base_value) > pg->base_value))
 580     {
 581       /* This will cause an underflow */
 582       GNUNET_break (0);
 583     }
 584     pref_value = pg->base_value + delta_value;
 585     break;
 586
 587   case GNUNET_ATS_TEST_TG_RANDOM:
 588     delta_value = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
 589                                                      10000 * (pg->max_value
 590                                                               - pg->base_value))
 591                   / 10000;
 592     pref_value = pg->base_value + delta_value;
 593     break;
 594
 595   case GNUNET_ATS_TEST_TG_SINUS:
 596     time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
 597     /* Calculate point of time in the current period */
 598     time_delta.rel_value_us = time_delta.rel_value_us
 599                               % pg->duration_period.rel_value_us;
 600     if ((pg->max_value - pg->base_value) > pg->base_value)
 601     {
 602       /* This will cause an underflow for second half of sinus period,
 603        * will be detected in general when experiments are loaded */
 604       GNUNET_break (0);
 605     }
 606     delta_value = (pg->max_value - pg->base_value)
 607                   * sin ((2 * M_PI)
 608                          / ((double) pg->duration_period.rel_value_us)
 609                          * time_delta.rel_value_us);
 610     pref_value = pg->base_value + delta_value;
 611     break;
 612
 613   default:
 614     pref_value = 0.0;
 615     break;
 616   }
 617   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current property value is %f\n",
 618               pref_value);
 619   return pref_value;
 620 }
 621
 622
 623 static void
 624 set_prop_task (void *cls)
 625 {
 626   struct PropertyGenerator *pg = cls;
 627   struct TestPeer *p;
 628   struct TestAddress *a;
 629   double prop_value;
 630   struct GNUNET_ATS_Information atsi;
 631
 632   pg->set_task = NULL;
 633
 634   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains_value (sh->addresses,
 635                                                                  &pg->test_peer
 636                                                                  ->peer_id,
 637                                                                  pg->
 638                                                                  test_address->
 639                                                                  ats_addr))
 640   {
 641     GNUNET_break (0);
 642     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 643                 "Setting property generation for unknown address [%u:%u]\n",
 644                 pg->peer, pg->address_id);
 645     return;
 646   }
 647   if (NULL == (p = find_peer_by_id (pg->peer)))
 648   {
 649     GNUNET_break (0);
 650     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 651                 "Setting property generation for unknown peer %u\n",
 652                 pg->peer);
 653     return;
 654   }
 655   if (NULL == (a = find_address_by_id (p, pg->address_id)))
 656   {
 657     GNUNET_break (0);
 658     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 659                 "Setting property generation for unknown peer %u\n",
 660                 pg->peer);
 661     return;
 662   }
 663
 664   prop_value = get_property (pg);
 665   a->prop_abs[pg->ats_property] = prop_value;
 666
 667   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 668               "Setting property for peer [%u] address [%u] for %s to %f\n",
 669               pg->peer, pg->address_id,
 670               GNUNET_ATS_print_property_type (pg->ats_property), prop_value);
 671
 672   atsi.type = htonl (pg->ats_property);
 673   atsi.value = htonl ((uint32_t) prop_value);
 674
 675   /* set performance here! */
 676   sh->sf->s_bulk_start (sh->sf->cls);
 677   if (GNUNET_YES == opt_disable_normalization)
 678   {
 679     a->prop_abs[pg->ats_property] = prop_value;
 680     a->prop_norm[pg->ats_property] = prop_value;
 681     sh->sf->s_address_update_property (sh->sf->cls, a->ats_addr,
 682                                        pg->ats_property, prop_value,
 683                                        prop_value);
 684   }
 685   else
 686     GAS_normalization_update_property (pg->test_address->ats_addr, &atsi, 1);
 687   sh->sf->s_bulk_stop (sh->sf->cls);
 688
 689   pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
 690                                                &set_prop_task, pg);
 691 }
 692
 693
 694 /**
 695  * Set ats_property to 0 to find all pgs
 696  */
 697 static struct PropertyGenerator *
 698 find_prop_gen (unsigned int peer, unsigned int address,
 699                uint32_t ats_property)
 700 {
 701   struct PropertyGenerator *cur;
 702
 703   for (cur = prop_gen_head; NULL != cur; cur = cur->next)
 704     if ((cur->peer == peer) && (cur->address_id == address))
 705     {
 706       if ((cur->ats_property == ats_property) || (0 == ats_property))
 707         return cur;
 708     }
 709   return NULL;
 710 }
 711
 712
 713 void
 714 GNUNET_ATS_solver_generate_property_stop (struct PropertyGenerator *pg)
 715 {
 716   GNUNET_CONTAINER_DLL_remove (prop_gen_head, prop_gen_tail, pg);
 717
 718   if (NULL != pg->set_task)
 719   {
 720     GNUNET_SCHEDULER_cancel (pg->set_task);
 721     pg->set_task = NULL;
 722   }
 723   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 724               "Removing old up preference generator peer [%u] address [%u] `%s'\n",
 725               pg->peer, pg->address_id,
 726               GNUNET_ATS_print_property_type (pg->ats_property));
 727
 728   GNUNET_free (pg);
 729 }
 730
 731
 732 /**
 733  * Generate between the source master and the partner and set property with a
 734  * value depending on the generator.
 735  *
 736  * @param peer source
 737  * @param address_id partner
 738  * @param test_peer the peer
 739  * @param test_address the address
 740  * @param type type of generator
 741  * @param base_value base value
 742  * @param value_rate maximum value
 743  * @param period duration of a period of generation (~ 1/frequency)
 744  * @param frequency how long to generate property
 745  * @param ats_property ATS property to generate
 746  * @return the property generator
 747  */
 748 struct PropertyGenerator *
 749 GNUNET_ATS_solver_generate_property_start (unsigned int peer,
 750                                            unsigned int address_id,
 751                                            struct TestPeer *test_peer,
 752                                            struct TestAddress *test_address,
 753                                            enum GeneratorType type,
 754                                            long int base_value,
 755                                            long int value_rate,
 756                                            struct GNUNET_TIME_Relative period,
 757                                            struct GNUNET_TIME_Relative
 758                                            frequency,
 759                                            uint32_t ats_property)
 760 {
 761   struct PropertyGenerator *pg;
 762
 763   pg = GNUNET_new (struct PropertyGenerator);
 764   GNUNET_CONTAINER_DLL_insert (prop_gen_head, prop_gen_tail, pg);
 765   pg->type = type;
 766   pg->peer = peer;
 767   pg->test_address = test_address;
 768   pg->test_peer = test_peer;
 769   pg->address_id = address_id;
 770   pg->ats_property = ats_property;
 771   pg->base_value = base_value;
 772   pg->max_value = value_rate;
 773   pg->duration_period = period;
 774   pg->frequency = frequency;
 775   pg->time_start = GNUNET_TIME_absolute_get ();
 776
 777   switch (type)
 778   {
 779   case GNUNET_ATS_TEST_TG_CONSTANT:
 780     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 781                 "Setting up %s property generator peer [%u] address [%u] `%s'" \
 782                 "max %u Bips\n",
 783                 print_generator_type (type), pg->peer, pg->address_id,
 784                 GNUNET_ATS_print_property_type (ats_property),
 785                 base_value);
 786     break;
 787
 788   case GNUNET_ATS_TEST_TG_LINEAR:
 789     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 790                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
 791                 "min %u Bips max %u Bips\n",
 792                 print_generator_type (type), pg->peer, pg->address_id,
 793                 GNUNET_ATS_print_property_type (ats_property),
 794                 base_value, value_rate);
 795     break;
 796
 797   case GNUNET_ATS_TEST_TG_SINUS:
 798     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 799                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
 800                 "baserate %u Bips, amplitude %u Bps\n",
 801                 print_generator_type (type), pg->peer, pg->address_id,
 802                 GNUNET_ATS_print_property_type (ats_property),
 803                 base_value, value_rate);
 804     break;
 805
 806   case GNUNET_ATS_TEST_TG_RANDOM:
 807     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 808                 "Setting up %s property generator peer [%u] address [%u] `%s' " \
 809                 "min %u Bips max %u Bps\n",
 810                 print_generator_type (type), pg->peer, pg->address_id,
 811                 GNUNET_ATS_print_property_type (ats_property),
 812                 base_value, value_rate);
 813     break;
 814
 815   default:
 816     break;
 817   }
 818
 819   pg->set_task = GNUNET_SCHEDULER_add_now (&set_prop_task, pg);
 820   return pg;
 821 }
 822
 823
 824 /**
 825  * Stop all preferences generators
 826  */
 827 void
 828 GNUNET_ATS_solver_generate_property_stop_all ()
 829 {
 830   struct PropertyGenerator *cur;
 831   struct PropertyGenerator *next;
 832
 833   next = prop_gen_head;
 834   for (cur = next; NULL != cur; cur = next)
 835   {
 836     next = cur->next;
 837     GNUNET_ATS_solver_generate_property_stop (cur);
 838   }
 839 }
 840
 841
 842 /**
 843  * Preference Generators
 844  */
 845 static struct PreferenceGenerator *pref_gen_head;
 846 static struct PreferenceGenerator *pref_gen_tail;
 847
 848
 849 static double
 850 get_preference (struct PreferenceGenerator *pg)
 851 {
 852   struct GNUNET_TIME_Relative time_delta;
 853   double delta_value;
 854   double pref_value;
 855
 856   /* Calculate the current preference value */
 857   switch (pg->type)
 858   {
 859   case GNUNET_ATS_TEST_TG_CONSTANT:
 860     pref_value = pg->base_value;
 861     break;
 862
 863   case GNUNET_ATS_TEST_TG_LINEAR:
 864     time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
 865     /* Calculate point of time in the current period */
 866     time_delta.rel_value_us = time_delta.rel_value_us
 867                               % pg->duration_period.rel_value_us;
 868     delta_value = ((double) time_delta.rel_value_us
 869                    / pg->duration_period.rel_value_us) * (pg->max_value
 870                                                           - pg->base_value);
 871     if ((pg->max_value < pg->base_value) &&
 872         ((pg->max_value - pg->base_value) > pg->base_value))
 873     {
 874       /* This will cause an underflow */
 875       GNUNET_break (0);
 876     }
 877     pref_value = pg->base_value + delta_value;
 878     break;
 879
 880   case GNUNET_ATS_TEST_TG_RANDOM:
 881     delta_value = (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
 882                                                      10000 * (pg->max_value
 883                                                               - pg->base_value))
 884                   / 10000;
 885     pref_value = pg->base_value + delta_value;
 886     break;
 887
 888   case GNUNET_ATS_TEST_TG_SINUS:
 889     time_delta = GNUNET_TIME_absolute_get_duration (pg->time_start);
 890     /* Calculate point of time in the current period */
 891     time_delta.rel_value_us = time_delta.rel_value_us
 892                               % pg->duration_period.rel_value_us;
 893     if ((pg->max_value - pg->base_value) > pg->base_value)
 894     {
 895       /* This will cause an underflow for second half of sinus period,
 896        * will be detected in general when experiments are loaded */
 897       GNUNET_break (0);
 898     }
 899     delta_value = (pg->max_value - pg->base_value)
 900                   * sin ((2 * M_PI)
 901                          / ((double) pg->duration_period.rel_value_us)
 902                          * time_delta.rel_value_us);
 903     pref_value = pg->base_value + delta_value;
 904     break;
 905
 906   default:
 907     pref_value = 0.0;
 908     break;
 909   }
 910   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n",
 911               pref_value);
 912   return pref_value;
 913 }
 914
 915
 916 static void
 917 set_feedback_task (void *cls)
 918 {
 919   struct PreferenceGenerator *pg = cls;
 920   struct TestPeer *p;
 921   double feedback;
 922   uint32_t bw_acc_out;
 923   uint32_t bw_acc_in;
 924   uint32_t delay_acc_in;
 925   struct GNUNET_TIME_Relative dur;
 926   double p_new;
 927
 928   pg->feedback_task = NULL;
 929
 930   if (NULL == (p = find_peer_by_id (pg->peer)))
 931   {
 932     GNUNET_break (0);
 933     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 934                 "Setting feedback for unknown peer %u\n", pg->peer);
 935     return;
 936   }
 937
 938   switch (pg->kind)
 939   {
 940   case GNUNET_ATS_PREFERENCE_BANDWIDTH:
 941     dur = GNUNET_TIME_absolute_get_duration (pg->feedback_last_bw_update);
 942     bw_acc_in = dur.rel_value_us * pg->last_assigned_bw_in
 943                 + pg->feedback_bw_in_acc;
 944     pg->feedback_bw_in_acc = 0;
 945
 946     bw_acc_out = dur.rel_value_us * pg->last_assigned_bw_out
 947                  + pg->feedback_bw_out_acc;
 948     p_new = get_preference (pg);
 949     feedback = (p_new / pg->pref_bw_old) * (bw_acc_in + bw_acc_out)
 950                / (2 * GNUNET_TIME_absolute_get_duration (
 951                     pg->feedback_last).rel_value_us);
 952
 953     break;
 954
 955   case GNUNET_ATS_PREFERENCE_LATENCY:
 956     dur = GNUNET_TIME_absolute_get_duration (pg->feedback_last_delay_update);
 957     delay_acc_in = dur.rel_value_us * pg->last_delay_value
 958                    + pg->feedback_delay_acc;
 959     pg->feedback_delay_acc = 0;
 960
 961     p_new = get_preference (pg);
 962     feedback = (p_new / pg->pref_latency_old) * (delay_acc_in)
 963                / (GNUNET_TIME_absolute_get_duration (
 964                     pg->feedback_last).rel_value_us);
 965
 966     break;
 967
 968   default:
 969     GNUNET_break (0);
 970     feedback = 0.0;
 971     break;
 972   }
 973   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 974               "Giving feedback for peer [%u] for client %p pref %s of %.3f\n",
 975               pg->peer, NULL + (pg->client_id),
 976               GNUNET_ATS_print_preference_type (pg->kind),
 977               feedback);
 978
 979   sh->sf->s_feedback (sh->sf->cls, NULL + (pg->client_id), &p->peer_id,
 980                       pg->feedback_frequency, pg->kind, feedback);
 981   pg->feedback_last = GNUNET_TIME_absolute_get ();
 982
 983
 984   pg->feedback_bw_out_acc = 0;
 985   pg->feedback_bw_in_acc = 0;
 986   pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
 987
 988   pg->feedback_delay_acc = 0;
 989   pg->feedback_last_delay_update = GNUNET_TIME_absolute_get ();
 990
 991
 992   pg->feedback_task = GNUNET_SCHEDULER_add_delayed (pg->feedback_frequency,
 993                                                     &set_feedback_task, pg);
 994 }
 995
 996
 997 static void
 998 set_pref_task (void *cls)
 999 {
1000   struct PreferenceGenerator *pg = cls;
1001   struct TestPeer *p;
1002   double pref_value;
1003
1004   pg->set_task = NULL;
1005
1006   if (NULL == (p = find_peer_by_id (pg->peer)))
1007   {
1008     GNUNET_break (0);
1009     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1010                 "Setting preference for unknown peer %u\n", pg->peer);
1011     return;
1012   }
1013
1014   pref_value = get_preference (pg);
1015   switch (pg->kind)
1016   {
1017   case GNUNET_ATS_PREFERENCE_BANDWIDTH:
1018     pg->pref_bw_old = pref_value;
1019     break;
1020
1021   case GNUNET_ATS_PREFERENCE_LATENCY:
1022     pg->pref_latency_old = pref_value;
1023     break;
1024
1025   default:
1026     break;
1027   }
1028
1029   p->pref_abs[pg->kind] = pref_value;
1030
1031   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1032               "Setting preference for peer [%u] for client %p pref %s to %f\n",
1033               pg->peer, NULL + (pg->client_id),
1034               GNUNET_ATS_print_preference_type (pg->kind), pref_value);
1035
1036   if (GNUNET_YES == opt_disable_normalization)
1037   {
1038     p->pref_abs[pg->kind] = pref_value;
1039     p->pref_norm[pg->kind] = pref_value;
1040     sh->sf->s_pref (sh->sf->cls, &p->peer_id, pg->kind, pref_value);
1041   }
1042   else
1043     update_preference (NULL + (pg->client_id),
1044                        &p->peer_id,
1045                        pg->kind,
1046                        pref_value);
1047
1048   pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
1049                                                &set_pref_task,
1050                                                pg);
1051 }
1052
1053
1054 static struct PreferenceGenerator *
1055 find_pref_gen (unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)
1056 {
1057   struct PreferenceGenerator *cur;
1058
1059   for (cur = pref_gen_head; NULL != cur; cur = cur->next)
1060     if (cur->peer == peer)
1061     {
1062       if ((cur->kind == kind) || (GNUNET_ATS_PREFERENCE_END == kind))
1063         return cur;
1064     }
1065   return NULL;
1066 }
1067
1068
1069 void
1070 GNUNET_ATS_solver_generate_preferences_stop (struct PreferenceGenerator *pg)
1071 {
1072   GNUNET_CONTAINER_DLL_remove (pref_gen_head, pref_gen_tail, pg);
1073
1074   if (NULL != pg->feedback_task)
1075   {
1076     GNUNET_SCHEDULER_cancel (pg->feedback_task);
1077     pg->feedback_task = NULL;
1078   }
1079
1080   if (NULL != pg->set_task)
1081   {
1082     GNUNET_SCHEDULER_cancel (pg->set_task);
1083     pg->set_task = NULL;
1084   }
1085   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1086               "Removing old up preference generator peer [%u] `%s'\n",
1087               pg->peer, GNUNET_ATS_print_preference_type (pg->kind));
1088
1089   GNUNET_free (pg);
1090 }
1091
1092
1093 static struct TestAddress*
1094 find_active_address (struct TestPeer *p)
1095 {
1096   struct TestAddress *cur;
1097
1098   for (cur = p->addr_head; NULL != cur; cur = cur->next)
1099     if (GNUNET_YES == cur->ats_addr->active)
1100       return cur;
1101   return NULL;
1102 }
1103
1104
1105 /**
1106  * Generate between the source master and the partner and set property with a
1107  * value depending on the generator.
1108  *
1109  * @param peer source
1110  * @param address_id partner
1111  * @param client_id the client
1112  * @param type type of generator
1113  * @param base_value base value
1114  * @param value_rate maximum value
1115  * @param period duration of a period of generation (~ 1/frequency)
1116  * @param frequency how long to generate property
1117  * @param kind ATS preference to generate
1118  * @param feedback_frequency how often to give feedback
1119  * @return the preference generator
1120  */
1121 struct PreferenceGenerator *
1122 GNUNET_ATS_solver_generate_preferences_start (unsigned int peer,
1123                                               unsigned int address_id,
1124                                               unsigned int client_id,
1125                                               enum GeneratorType type,
1126                                               long int base_value,
1127                                               long int value_rate,
1128                                               struct GNUNET_TIME_Relative
1129                                               period,
1130                                               struct GNUNET_TIME_Relative
1131                                               frequency,
1132                                               enum GNUNET_ATS_PreferenceKind
1133                                               kind,
1134                                               struct GNUNET_TIME_Relative
1135                                               feedback_frequency)
1136 {
1137   struct PreferenceGenerator *pg;
1138   struct TestPeer *p;
1139
1140   if (NULL == (p = find_peer_by_id (peer)))
1141   {
1142     GNUNET_break (0);
1143     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1144                 "Starting preference for unknown peer %u\n", peer);
1145     return NULL;
1146   }
1147
1148   pg = GNUNET_new (struct PreferenceGenerator);
1149   GNUNET_CONTAINER_DLL_insert (pref_gen_head, pref_gen_tail, pg);
1150   pg->type = type;
1151   pg->peer = peer;
1152   pg->client_id = client_id;
1153   pg->kind = kind;
1154   pg->base_value = base_value;
1155   pg->max_value = value_rate;
1156   pg->duration_period = period;
1157   pg->frequency = frequency;
1158   pg->time_start = GNUNET_TIME_absolute_get ();
1159   pg->feedback_frequency = feedback_frequency;
1160
1161   switch (type)
1162   {
1163   case GNUNET_ATS_TEST_TG_CONSTANT:
1164     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1165                 "Setting up %s preference generator peer [%u] `%s' max %u Bips\n",
1166                 print_generator_type (type), pg->peer,
1167                 GNUNET_ATS_print_preference_type (kind),
1168                 base_value);
1169     break;
1170
1171   case GNUNET_ATS_TEST_TG_LINEAR:
1172     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1173                 "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bips\n",
1174                 print_generator_type (type), pg->peer,
1175                 GNUNET_ATS_print_preference_type (kind),
1176                 base_value, value_rate);
1177     break;
1178
1179   case GNUNET_ATS_TEST_TG_SINUS:
1180     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1181                 "Setting up %s preference generator peer [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
1182                 print_generator_type (type), pg->peer,
1183                 GNUNET_ATS_print_preference_type (kind),
1184                 base_value, value_rate);
1185     break;
1186
1187   case GNUNET_ATS_TEST_TG_RANDOM:
1188     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1189                 "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bps\n",
1190                 print_generator_type (type), pg->peer,
1191                 GNUNET_ATS_print_preference_type (kind),
1192                 base_value, value_rate);
1193     break;
1194
1195   default:
1196     break;
1197   }
1198
1199   pg->set_task = GNUNET_SCHEDULER_add_now (&set_pref_task, pg);
1200   if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
1201       feedback_frequency.rel_value_us)
1202   {
1203     struct TestAddress *addr = find_active_address (p);
1204
1205     pg->last_assigned_bw_in = p->assigned_bw_in;
1206     pg->last_assigned_bw_out = p->assigned_bw_out;
1207     pg->feedback_bw_in_acc = 0;
1208     pg->feedback_bw_out_acc = 0;
1209     pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY];
1210     pg->feedback_delay_acc = 0;
1211
1212     pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
1213     pg->feedback_last_delay_update = GNUNET_TIME_absolute_get ();
1214     pg->feedback_last = GNUNET_TIME_absolute_get ();
1215     pg->feedback_task = GNUNET_SCHEDULER_add_delayed (feedback_frequency,
1216                                                       &set_feedback_task, pg);
1217   }
1218
1219   return pg;
1220 }
1221
1222
1223 /**
1224  * Stop all preferences generators
1225  */
1226 void
1227 GNUNET_ATS_solver_generate_preferences_stop_all ()
1228 {
1229   struct PreferenceGenerator *cur;
1230   struct PreferenceGenerator *next;
1231
1232   next = pref_gen_head;
1233   for (cur = next; NULL != cur; cur = next)
1234   {
1235     next = cur->next;
1236     GNUNET_ATS_solver_generate_preferences_stop (cur);
1237   }
1238 }
1239
1240
1241 /**
1242  * Experiments
1243  */
1244 static const char *
1245 print_op (enum OperationType op)
1246 {
1247   switch (op)
1248   {
1249   case SOLVER_OP_ADD_ADDRESS:
1250     return "ADD_ADDRESS";
1251
1252   case SOLVER_OP_DEL_ADDRESS:
1253     return "DEL_ADDRESS";
1254
1255   case SOLVER_OP_START_SET_PREFERENCE:
1256     return "START_SET_PREFERENCE";
1257
1258   case SOLVER_OP_STOP_SET_PREFERENCE:
1259     return "STOP_STOP_PREFERENCE";
1260
1261   case SOLVER_OP_START_SET_PROPERTY:
1262     return "START_SET_PROPERTY";
1263
1264   case SOLVER_OP_STOP_SET_PROPERTY:
1265     return "STOP_SET_PROPERTY";
1266
1267   case SOLVER_OP_START_REQUEST:
1268     return "START_REQUEST";
1269
1270   case SOLVER_OP_STOP_REQUEST:
1271     return "STOP_REQUEST";
1272
1273   default:
1274     break;
1275   }
1276   return "";
1277 }
1278
1279
1280 static struct Experiment *
1281 create_experiment ()
1282 {
1283   struct Experiment *e;
1284
1285   e = GNUNET_new (struct Experiment);
1286   e->name = NULL;
1287   e->start = NULL;
1288   e->total_duration = GNUNET_TIME_UNIT_ZERO;
1289   return e;
1290 }
1291
1292
1293 static void
1294 free_experiment (struct Experiment *e)
1295 {
1296   struct Episode *cur;
1297   struct Episode *next;
1298   struct GNUNET_ATS_TEST_Operation *cur_o;
1299   struct GNUNET_ATS_TEST_Operation *next_o;
1300
1301   next = e->start;
1302   for (cur = next; NULL != cur; cur = next)
1303   {
1304     next = cur->next;
1305
1306     next_o = cur->head;
1307     for (cur_o = next_o; NULL != cur_o; cur_o = next_o)
1308     {
1309       next_o = cur_o->next;
1310       GNUNET_free_non_null (cur_o->address);
1311       GNUNET_free_non_null (cur_o->plugin);
1312       GNUNET_free (cur_o);
1313     }
1314     GNUNET_free (cur);
1315   }
1316
1317   GNUNET_free_non_null (e->name);
1318   GNUNET_free_non_null (e->log_prefix);
1319   GNUNET_free_non_null (e->log_output_dir);
1320   GNUNET_free_non_null (e->cfg_file);
1321   GNUNET_free (e);
1322 }
1323
1324
1325 static int
1326 load_op_add_address (struct GNUNET_ATS_TEST_Operation *o,
1327                      struct Episode *e,
1328                      int op_counter,
1329                      char *sec_name,
1330                      const struct GNUNET_CONFIGURATION_Handle *cfg)
1331 {
1332   char *op_name;
1333   char *op_network;
1334
1335   /* peer pid */
1336   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1337   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1338                                                               sec_name, op_name,
1339                                                               &o->peer_id))
1340   {
1341     fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1342              op_counter, "ADD_ADDRESS", op_name);
1343     GNUNET_free (op_name);
1344     return GNUNET_SYSERR;
1345   }
1346   GNUNET_free (op_name);
1347
1348   /* address pid */
1349   GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1350   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1351                                                               sec_name, op_name,
1352                                                               &o->address_id))
1353   {
1354     fprintf (stderr,
1355              "Missing address-id in operation %u `%s' in episode `%s'\n",
1356              op_counter, "ADD_ADDRESS", op_name);
1357     GNUNET_free (op_name);
1358     return GNUNET_SYSERR;
1359   }
1360   GNUNET_free (op_name);
1361
1362   /* plugin */
1363   GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
1364   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1365                                                               sec_name, op_name,
1366                                                               &o->plugin))
1367   {
1368     fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
1369              op_counter, "ADD_ADDRESS", op_name);
1370     GNUNET_free (op_name);
1371     return GNUNET_SYSERR;
1372   }
1373   GNUNET_free (op_name);
1374
1375   /* address  */
1376   GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
1377   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1378                                                               sec_name, op_name,
1379                                                               &o->address))
1380   {
1381     fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
1382              op_counter, "ADD_ADDRESS", op_name);
1383     GNUNET_free (op_name);
1384     return GNUNET_SYSERR;
1385   }
1386   GNUNET_free (op_name);
1387
1388   /* session */
1389   GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
1390   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1391                                                               sec_name, op_name,
1392                                                               &o->
1393                                                               address_session))
1394   {
1395     fprintf (stderr,
1396              "Missing address-session in operation %u `%s' in episode `%s'\n",
1397              op_counter, "ADD_ADDRESS", op_name);
1398     GNUNET_free (op_name);
1399     return GNUNET_SYSERR;
1400   }
1401   GNUNET_free (op_name);
1402
1403   /* network */
1404   GNUNET_asprintf (&op_name, "op-%u-address-network", op_counter);
1405   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1406                                                               sec_name, op_name,
1407                                                               &op_network))
1408   {
1409     fprintf (stderr,
1410              "Missing address-network in operation %u `%s' in episode `%s'\n",
1411              op_counter, "ADD_ADDRESS", op_name);
1412     GNUNET_free (op_name);
1413     return GNUNET_SYSERR;
1414   }
1415   else
1416   {
1417     GNUNET_STRINGS_utf8_toupper (op_network, op_network);
1418     if (0 == strcmp (op_network, "UNSPECIFIED"))
1419     {
1420       o->address_network = GNUNET_NT_UNSPECIFIED;
1421     }
1422     else if (0 == strcmp (op_network, "LOOPBACK"))
1423     {
1424       o->address_network = GNUNET_NT_LOOPBACK;
1425     }
1426     else if (0 == strcmp (op_network, "LAN"))
1427     {
1428       o->address_network = GNUNET_NT_LAN;
1429     }
1430     else if (0 == strcmp (op_network, "WAN"))
1431     {
1432       o->address_network = GNUNET_NT_WAN;
1433     }
1434     else if (0 == strcmp (op_network, "WLAN"))
1435     {
1436       o->address_network = GNUNET_NT_WLAN;
1437     }
1438     else if (0 == strcmp (op_network, "BT"))
1439     {
1440       o->address_network = GNUNET_NT_BT;
1441     }
1442     else
1443     {
1444       fprintf (stderr,
1445                "Invalid address-network in operation %u `%s' in episode `%s': `%s'\n",
1446                op_counter, "ADD_ADDRESS", op_name, op_network);
1447       GNUNET_free (op_network);
1448       GNUNET_free (op_name);
1449       return GNUNET_SYSERR;
1450     }
1451   }
1452   GNUNET_free (op_network);
1453   GNUNET_free (op_name);
1454
1455   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1456               "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
1457               "ADD_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
1458
1459   return GNUNET_OK;
1460 }
1461
1462
1463 static int
1464 load_op_del_address (struct GNUNET_ATS_TEST_Operation *o,
1465                      struct Episode *e,
1466                      int op_counter,
1467                      char *sec_name,
1468                      const struct GNUNET_CONFIGURATION_Handle *cfg)
1469 {
1470   char *op_name;
1471
1472   // char *op_network;
1473
1474   /* peer pid */
1475   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1476   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1477                                                               sec_name, op_name,
1478                                                               &o->peer_id))
1479   {
1480     fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1481              op_counter, "DEL_ADDRESS", op_name);
1482     GNUNET_free (op_name);
1483     return GNUNET_SYSERR;
1484   }
1485   GNUNET_free (op_name);
1486
1487   /* address pid */
1488   GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1489   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1490                                                               sec_name, op_name,
1491                                                               &o->address_id))
1492   {
1493     fprintf (stderr,
1494              "Missing address-id in operation %u `%s' in episode `%s'\n",
1495              op_counter, "DEL_ADDRESS", op_name);
1496     GNUNET_free (op_name);
1497     return GNUNET_SYSERR;
1498   }
1499   GNUNET_free (op_name);
1500
1501 #if 0
1502   /* plugin */
1503   GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
1504   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1505                                                               sec_name, op_name,
1506                                                               &o->plugin))
1507   {
1508     fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
1509              op_counter, "DEL_ADDRESS", op_name);
1510     GNUNET_free (op_name);
1511     return GNUNET_SYSERR;
1512   }
1513   GNUNET_free (op_name);
1514
1515   /* address  */
1516   GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
1517   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1518                                                               sec_name, op_name,
1519                                                               &o->address))
1520   {
1521     fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
1522              op_counter, "DEL_ADDRESS", op_name);
1523     GNUNET_free (op_name);
1524     return GNUNET_SYSERR;
1525   }
1526   GNUNET_free (op_name);
1527
1528   /* session */
1529   GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
1530   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1531                                                               sec_name, op_name,
1532                                                               &o->
1533                                                               address_session))
1534   {
1535     fprintf (stderr,
1536              "Missing address-session in operation %u `%s' in episode `%s'\n",
1537              op_counter, "DEL_ADDRESS", op_name);
1538     GNUNET_free (op_name);
1539     return GNUNET_SYSERR;
1540   }
1541   GNUNET_free (op_name);
1542 #endif
1543
1544   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1545               "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
1546               "DEL_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
1547
1548   return GNUNET_OK;
1549 }
1550
1551
1552 static enum GNUNET_ATS_Property
1553 parse_preference_string (const char *str)
1554 {
1555   int c = 0;
1556   char *props[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString;
1557
1558   for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
1559     if (0 == strcmp (str, props[c]))
1560       return c;
1561   return 0;
1562 }
1563
1564
1565 static int
1566 load_op_start_set_preference (struct GNUNET_ATS_TEST_Operation *o,
1567                               struct Episode *e,
1568                               int op_counter,
1569                               char *sec_name,
1570                               const struct GNUNET_CONFIGURATION_Handle *cfg)
1571 {
1572   char *op_name;
1573   char *type;
1574   char *pref;
1575
1576   /* peer pid */
1577   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1578   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1579                                                               sec_name, op_name,
1580                                                               &o->peer_id))
1581   {
1582     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
1583              op_counter, "START_SET_PREFERENCE", op_name);
1584     GNUNET_free (op_name);
1585     return GNUNET_SYSERR;
1586   }
1587   GNUNET_free (op_name);
1588
1589   /* address pid */
1590   GNUNET_asprintf (&op_name, "op-%u-client-id", op_counter);
1591   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1592                                                               sec_name, op_name,
1593                                                               &o->client_id))
1594   {
1595     fprintf (stderr, "Missing client-id in operation %u `%s' in episode `%s'\n",
1596              op_counter, "START_SET_PREFERENCE", op_name);
1597     GNUNET_free (op_name);
1598     return GNUNET_SYSERR;
1599   }
1600   GNUNET_free (op_name);
1601
1602   /* generator */
1603   GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
1604   if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1605                                                                sec_name,
1606                                                                op_name, &type)))
1607   {
1608     fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
1609              op_counter, "START_SET_PREFERENCE", op_name);
1610     GNUNET_free (op_name);
1611     return GNUNET_SYSERR;
1612   }
1613
1614   /* Load arguments for set_rate, start_send, set_preference */
1615   if (0 == strcmp (type, "constant"))
1616   {
1617     o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
1618   }
1619   else if (0 == strcmp (type, "linear"))
1620   {
1621     o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
1622   }
1623   else if (0 == strcmp (type, "sinus"))
1624   {
1625     o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
1626   }
1627   else if (0 == strcmp (type, "random"))
1628   {
1629     o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
1630   }
1631   else
1632   {
1633     fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
1634              op_counter, op_name, e->id);
1635     GNUNET_free (type);
1636     GNUNET_free (op_name);
1637     return GNUNET_SYSERR;
1638   }
1639   GNUNET_free (type);
1640   GNUNET_free (op_name);
1641
1642
1643   /* Get base rate */
1644   GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
1645   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1646                                                               sec_name, op_name,
1647                                                               &o->base_rate))
1648   {
1649     fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
1650              op_counter, op_name, e->id);
1651     GNUNET_free (op_name);
1652     return GNUNET_SYSERR;
1653   }
1654   GNUNET_free (op_name);
1655
1656
1657   /* Get max rate */
1658   GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
1659   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1660                                                               sec_name, op_name,
1661                                                               &o->max_rate))
1662   {
1663     if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
1664         (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
1665         (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
1666     {
1667       fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
1668                op_counter, op_name, e->id);
1669       GNUNET_free (op_name);
1670       return GNUNET_SYSERR;
1671     }
1672   }
1673   GNUNET_free (op_name);
1674
1675   /* Get period */
1676   GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
1677   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
1678                                                             sec_name, op_name,
1679                                                             &o->period))
1680   {
1681     o->period = e->duration;
1682   }
1683   GNUNET_free (op_name);
1684
1685   /* Get frequency */
1686   GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
1687   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
1688                                                             sec_name, op_name,
1689                                                             &o->frequency))
1690   {
1691     fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
1692              op_counter, op_name, e->id);
1693     GNUNET_free (op_name);
1694     return GNUNET_SYSERR;
1695   }
1696   GNUNET_free (op_name);
1697
1698   /* Get preference */
1699   GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
1700   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1701                                                               sec_name, op_name,
1702                                                               &pref))
1703   {
1704     fprintf (stderr, "Missing preference in operation %u `%s' in episode %u\n",
1705              op_counter, op_name, e->id);
1706     GNUNET_free (op_name);
1707     return GNUNET_SYSERR;
1708   }
1709
1710   if (0 == (o->pref_type = parse_preference_string (pref)))
1711   {
1712     fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
1713              op_counter, op_name, e->id);
1714     GNUNET_free (op_name);
1715     GNUNET_free (pref);
1716     return GNUNET_SYSERR;
1717   }
1718   GNUNET_free (pref);
1719   GNUNET_free (op_name);
1720
1721   /* Get feedback delay */
1722   GNUNET_asprintf (&op_name, "op-%u-feedback_delay", op_counter);
1723   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (cfg,
1724                                                         sec_name, op_name,
1725                                                         &o->feedback_delay))
1726   {
1727     fprintf (stderr,
1728              "Using feedback delay %llu in operation %u `%s' in episode %u\n",
1729              (long long unsigned int) o->feedback_delay.rel_value_us,
1730              op_counter, op_name, e->id);
1731   }
1732   else
1733     o->feedback_delay = GNUNET_TIME_UNIT_FOREVER_REL;
1734   GNUNET_free (op_name);
1735
1736   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1737               "Found operation %s: [%llu:%llu]: %s = %llu\n",
1738               "START_SET_PREFERENCE", o->peer_id, o->address_id,
1739               GNUNET_ATS_print_preference_type (o->pref_type), o->base_rate);
1740
1741   return GNUNET_OK;
1742 }
1743
1744
1745 static int
1746 load_op_stop_set_preference (struct GNUNET_ATS_TEST_Operation *o,
1747                              struct Episode *e,
1748                              int op_counter,
1749                              char *sec_name,
1750                              const struct GNUNET_CONFIGURATION_Handle *cfg)
1751 {
1752   char *op_name;
1753   char *pref;
1754
1755   /* peer pid */
1756   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1757   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1758                                                               sec_name, op_name,
1759                                                               &o->peer_id))
1760   {
1761     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
1762              op_counter, "STOP_SET_PREFERENCE", op_name);
1763     GNUNET_free (op_name);
1764     return GNUNET_SYSERR;
1765   }
1766   GNUNET_free (op_name);
1767
1768   /* address pid */
1769   GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1770   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1771                                                               sec_name, op_name,
1772                                                               &o->address_id))
1773   {
1774     fprintf (stderr,
1775              "Missing address-id in operation %u `%s' in episode `%s'\n",
1776              op_counter, "STOP_SET_PREFERENCE", op_name);
1777     GNUNET_free (op_name);
1778     return GNUNET_SYSERR;
1779   }
1780   GNUNET_free (op_name);
1781
1782   /* Get preference */
1783   GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
1784   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1785                                                               sec_name, op_name,
1786                                                               &pref))
1787   {
1788     fprintf (stderr,
1789              "Missing preference in operation %u `%s' in episode `%s'\n",
1790              op_counter, "STOP_SET_PREFERENCE", op_name);
1791     GNUNET_free (op_name);
1792     return GNUNET_SYSERR;
1793   }
1794
1795   if (0 == (o->pref_type = parse_preference_string (pref)))
1796   {
1797     fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
1798              op_counter, op_name, e->id);
1799     GNUNET_free (op_name);
1800     GNUNET_free (pref);
1801     return GNUNET_SYSERR;
1802   }
1803   GNUNET_free (pref);
1804   GNUNET_free (op_name);
1805
1806   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1807               "Found operation %s: [%llu:%llu]: %s\n",
1808               "STOP_SET_PREFERENCE", o->peer_id, o->address_id,
1809               GNUNET_ATS_print_preference_type (o->pref_type));
1810   return GNUNET_OK;
1811 }
1812
1813
1814 static enum GNUNET_ATS_Property
1815 parse_property_string (const char *str)
1816 {
1817   enum GNUNET_ATS_Property c;
1818
1819   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
1820     if (0 == strcmp (str,
1821                      GNUNET_ATS_print_property_type (c)))
1822       return c;
1823   return 0;
1824 }
1825
1826
1827 static int
1828 load_op_start_set_property (struct GNUNET_ATS_TEST_Operation *o,
1829                             struct Episode *e,
1830                             int op_counter,
1831                             char *sec_name,
1832                             const struct GNUNET_CONFIGURATION_Handle *cfg)
1833 {
1834   char *op_name;
1835   char *type;
1836   char *prop;
1837
1838   /* peer pid */
1839   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1840   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1841                                                               sec_name, op_name,
1842                                                               &o->peer_id))
1843   {
1844     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
1845              op_counter, "START_SET_PROPERTY", op_name);
1846     GNUNET_free (op_name);
1847     return GNUNET_SYSERR;
1848   }
1849   GNUNET_free (op_name);
1850
1851   /* address pid */
1852   GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1853   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1854                                                               sec_name, op_name,
1855                                                               &o->address_id))
1856   {
1857     fprintf (stderr,
1858              "Missing address-id in operation %u `%s' in episode `%s'\n",
1859              op_counter, "START_SET_PROPERTY", op_name);
1860     GNUNET_free (op_name);
1861     return GNUNET_SYSERR;
1862   }
1863   GNUNET_free (op_name);
1864
1865   /* generator */
1866   GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
1867   if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1868                                                                sec_name,
1869                                                                op_name, &type)))
1870   {
1871     fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
1872              op_counter, "START_SET_PROPERTY", op_name);
1873     GNUNET_free (op_name);
1874     return GNUNET_SYSERR;
1875   }
1876
1877   /* Load arguments for set_rate, start_send, set_preference */
1878   if (0 == strcmp (type, "constant"))
1879   {
1880     o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT;
1881   }
1882   else if (0 == strcmp (type, "linear"))
1883   {
1884     o->gen_type = GNUNET_ATS_TEST_TG_LINEAR;
1885   }
1886   else if (0 == strcmp (type, "sinus"))
1887   {
1888     o->gen_type = GNUNET_ATS_TEST_TG_SINUS;
1889   }
1890   else if (0 == strcmp (type, "random"))
1891   {
1892     o->gen_type = GNUNET_ATS_TEST_TG_RANDOM;
1893   }
1894   else
1895   {
1896     fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
1897              op_counter, op_name, e->id);
1898     GNUNET_free (type);
1899     GNUNET_free (op_name);
1900     return GNUNET_SYSERR;
1901   }
1902   GNUNET_free (type);
1903   GNUNET_free (op_name);
1904
1905
1906   /* Get base rate */
1907   GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
1908   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1909                                                               sec_name, op_name,
1910                                                               &o->base_rate))
1911   {
1912     fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
1913              op_counter, op_name, e->id);
1914     GNUNET_free (op_name);
1915     return GNUNET_SYSERR;
1916   }
1917   GNUNET_free (op_name);
1918
1919
1920   /* Get max rate */
1921   GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
1922   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
1923                                                               sec_name, op_name,
1924                                                               &o->max_rate))
1925   {
1926     if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
1927         (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) ||
1928         (GNUNET_ATS_TEST_TG_SINUS == o->gen_type))
1929     {
1930       fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
1931                op_counter, op_name, e->id);
1932       GNUNET_free (op_name);
1933       return GNUNET_SYSERR;
1934     }
1935   }
1936   GNUNET_free (op_name);
1937
1938   /* Get period */
1939   GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
1940   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
1941                                                             sec_name, op_name,
1942                                                             &o->period))
1943   {
1944     o->period = e->duration;
1945   }
1946   GNUNET_free (op_name);
1947
1948   /* Get frequency */
1949   GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
1950   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
1951                                                             sec_name, op_name,
1952                                                             &o->frequency))
1953   {
1954     fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
1955              op_counter, op_name, e->id);
1956     GNUNET_free (op_name);
1957     return GNUNET_SYSERR;
1958   }
1959   GNUNET_free (op_name);
1960
1961   /* Get preference */
1962   GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
1963   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
1964                                                               sec_name, op_name,
1965                                                               &prop))
1966   {
1967     fprintf (stderr, "Missing property in operation %u `%s' in episode %u\n",
1968              op_counter, op_name, e->id);
1969     GNUNET_free (op_name);
1970     GNUNET_free_non_null (prop);
1971     return GNUNET_SYSERR;
1972   }
1973
1974   if (0 == (o->prop_type = parse_property_string (prop)))
1975   {
1976     fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
1977              op_counter, op_name, e->id);
1978     GNUNET_free (op_name);
1979     GNUNET_free (prop);
1980     return GNUNET_SYSERR;
1981   }
1982
1983   GNUNET_free (prop);
1984   GNUNET_free (op_name);
1985
1986   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1987               "Found operation %s: [%llu:%llu] %s = %llu\n",
1988               "START_SET_PROPERTY", o->peer_id, o->address_id,
1989               GNUNET_ATS_print_property_type (o->prop_type), o->base_rate);
1990
1991   return GNUNET_OK;
1992 }
1993
1994
1995 static int
1996 load_op_stop_set_property (struct GNUNET_ATS_TEST_Operation *o,
1997                            struct Episode *e,
1998                            int op_counter,
1999                            char *sec_name,
2000                            const struct GNUNET_CONFIGURATION_Handle *cfg)
2001 {
2002   char *op_name;
2003   char *pref;
2004
2005   /* peer pid */
2006   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2007   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
2008                                                               sec_name, op_name,
2009                                                               &o->peer_id))
2010   {
2011     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
2012              op_counter, "STOP_SET_PROPERTY", op_name);
2013     GNUNET_free (op_name);
2014     return GNUNET_SYSERR;
2015   }
2016   GNUNET_free (op_name);
2017
2018   /* address pid */
2019   GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
2020   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
2021                                                               sec_name, op_name,
2022                                                               &o->address_id))
2023   {
2024     fprintf (stderr,
2025              "Missing address-id in operation %u `%s' in episode `%s'\n",
2026              op_counter, "STOP_SET_PROPERTY", op_name);
2027     GNUNET_free (op_name);
2028     return GNUNET_SYSERR;
2029   }
2030   GNUNET_free (op_name);
2031
2032   /* Get property */
2033   GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
2034   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
2035                                                               sec_name, op_name,
2036                                                               &pref))
2037   {
2038     fprintf (stderr, "Missing property in operation %u `%s' in episode `%s'\n",
2039              op_counter, "STOP_SET_PROPERTY", op_name);
2040     GNUNET_free (op_name);
2041     GNUNET_free_non_null (pref);
2042     return GNUNET_SYSERR;
2043   }
2044
2045   if (0 == (o->prop_type = parse_property_string (pref)))
2046   {
2047     fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
2048              op_counter, op_name, e->id);
2049     GNUNET_free (op_name);
2050     GNUNET_free_non_null (pref);
2051     return GNUNET_SYSERR;
2052   }
2053
2054   GNUNET_free (pref);
2055   GNUNET_free (op_name);
2056
2057   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2058               "Found operation %s: [%llu:%llu] %s\n",
2059               "STOP_SET_PROPERTY", o->peer_id, o->address_id,
2060               GNUNET_ATS_print_property_type (o->prop_type));
2061
2062   return GNUNET_OK;
2063 }
2064
2065
2066 static int
2067 load_op_start_request (struct GNUNET_ATS_TEST_Operation *o,
2068                        struct Episode *e,
2069                        int op_counter,
2070                        char *sec_name,
2071                        const struct GNUNET_CONFIGURATION_Handle *cfg)
2072 {
2073   char *op_name;
2074
2075   /* peer pid */
2076   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2077   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
2078                                                               sec_name, op_name,
2079                                                               &o->peer_id))
2080   {
2081     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
2082              op_counter, "START_REQUEST", op_name);
2083     GNUNET_free (op_name);
2084     return GNUNET_SYSERR;
2085   }
2086   GNUNET_free (op_name);
2087   return GNUNET_OK;
2088 }
2089
2090
2091 static int
2092 load_op_stop_request (struct GNUNET_ATS_TEST_Operation *o,
2093                       struct Episode *e,
2094                       int op_counter,
2095                       char *sec_name,
2096                       const struct GNUNET_CONFIGURATION_Handle *cfg)
2097 {
2098   char *op_name;
2099
2100   /* peer pid */
2101   GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2102   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg,
2103                                                               sec_name, op_name,
2104                                                               &o->peer_id))
2105   {
2106     fprintf (stderr, "Missing peer-id in operation %u  `%s' in episode `%s'\n",
2107              op_counter, "STOP_REQUEST", op_name);
2108     GNUNET_free (op_name);
2109     return GNUNET_SYSERR;
2110   }
2111   GNUNET_free (op_name);
2112   return GNUNET_OK;
2113 }
2114
2115
2116 static int
2117 load_episode (struct Experiment *e, struct Episode *cur,
2118               struct GNUNET_CONFIGURATION_Handle *cfg)
2119 {
2120   struct GNUNET_ATS_TEST_Operation *o;
2121   char *sec_name;
2122   char *op_name;
2123   char *op;
2124   int op_counter = 0;
2125   int res;
2126
2127   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Parsing episode %u\n", cur->id);
2128   GNUNET_asprintf (&sec_name, "episode-%u", cur->id);
2129
2130   while (1)
2131   {
2132     /* Load operation */
2133     GNUNET_asprintf (&op_name, "op-%u-operation", op_counter);
2134     if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg,
2135                                                                 sec_name,
2136                                                                 op_name, &op))
2137     {
2138       GNUNET_free (op_name);
2139       break;
2140     }
2141     o = GNUNET_new (struct GNUNET_ATS_TEST_Operation);
2142     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "==== Parsing operation %u: `%s'\n",
2143                 cur->id, op_name);
2144
2145     /* operations = set_rate, start_send, stop_send, set_preference */
2146     if (0 == strcmp (op, "address_add"))
2147     {
2148       o->type = SOLVER_OP_ADD_ADDRESS;
2149       res = load_op_add_address (o, cur,
2150                                  op_counter, sec_name, cfg);
2151     }
2152     else if (0 == strcmp (op, "address_del"))
2153     {
2154       o->type = SOLVER_OP_DEL_ADDRESS;
2155       res = load_op_del_address (o, cur,
2156                                  op_counter, sec_name, cfg);
2157     }
2158     else if (0 == strcmp (op, "start_set_property"))
2159     {
2160       o->type = SOLVER_OP_START_SET_PROPERTY;
2161       res = load_op_start_set_property (o, cur,
2162                                         op_counter, sec_name, cfg);
2163     }
2164     else if (0 == strcmp (op, "stop_set_property"))
2165     {
2166       o->type = SOLVER_OP_STOP_SET_PROPERTY;
2167       res = load_op_stop_set_property (o, cur,
2168                                        op_counter, sec_name, cfg);
2169     }
2170     else if (0 == strcmp (op, "start_set_preference"))
2171     {
2172       o->type = SOLVER_OP_START_SET_PREFERENCE;
2173       res = load_op_start_set_preference (o, cur,
2174                                           op_counter, sec_name, cfg);
2175     }
2176     else if (0 == strcmp (op, "stop_set_preference"))
2177     {
2178       o->type = SOLVER_OP_STOP_SET_PREFERENCE;
2179       res = load_op_stop_set_preference (o, cur,
2180                                          op_counter, sec_name, cfg);
2181     }
2182     else if (0 == strcmp (op, "start_request"))
2183     {
2184       o->type = SOLVER_OP_START_REQUEST;
2185       res = load_op_start_request (o, cur,
2186                                    op_counter, sec_name, cfg);
2187     }
2188     else if (0 == strcmp (op, "stop_request"))
2189     {
2190       o->type = SOLVER_OP_STOP_REQUEST;
2191       res = load_op_stop_request (o, cur,
2192                                   op_counter, sec_name, cfg);
2193     }
2194     else
2195     {
2196       fprintf (stderr, "Invalid operation %u `%s' in episode %u\n",
2197                op_counter, op, cur->id);
2198       res = GNUNET_SYSERR;
2199     }
2200
2201     GNUNET_free (op);
2202     GNUNET_free (op_name);
2203
2204     if (GNUNET_SYSERR == res)
2205     {
2206       GNUNET_free (o);
2207       GNUNET_free (sec_name);
2208       return GNUNET_SYSERR;
2209     }
2210
2211     GNUNET_CONTAINER_DLL_insert_tail (cur->head, cur->tail, o);
2212     op_counter++;
2213   }
2214   GNUNET_free (sec_name);
2215   return GNUNET_OK;
2216 }
2217
2218
2219 static int
2220 load_episodes (struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
2221 {
2222   int e_counter = 0;
2223   char *sec_name;
2224   struct GNUNET_TIME_Relative e_duration;
2225   struct Episode *cur;
2226   struct Episode *last;
2227
2228   e_counter = 0;
2229   last = NULL;
2230   while (1)
2231   {
2232     GNUNET_asprintf (&sec_name, "episode-%u", e_counter);
2233     if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg,
2234                                                               sec_name,
2235                                                               "duration",
2236                                                               &e_duration))
2237     {
2238       GNUNET_free (sec_name);
2239       break;
2240     }
2241
2242     cur = GNUNET_new (struct Episode);
2243     cur->duration = e_duration;
2244     cur->id = e_counter;
2245
2246     if (GNUNET_OK != load_episode (e, cur, cfg))
2247     {
2248       GNUNET_free (sec_name);
2249       GNUNET_free (cur);
2250       return GNUNET_SYSERR;
2251     }
2252
2253     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Found episode %u with duration %s \n",
2254                 e_counter,
2255                 GNUNET_STRINGS_relative_time_to_string (cur->duration,
2256                                                         GNUNET_YES));
2257
2258     /* Update experiment */
2259     e->num_episodes++;
2260     e->total_duration = GNUNET_TIME_relative_add (e->total_duration,
2261                                                   cur->duration);
2262     /* Put in linked list */
2263     if (NULL == last)
2264       e->start = cur;
2265     else
2266       last->next = cur;
2267
2268     GNUNET_free (sec_name);
2269     e_counter++;
2270     last = cur;
2271   }
2272   return e_counter;
2273 }
2274
2275
2276 static void
2277 timeout_experiment (void *cls)
2278 {
2279   struct Experiment *e = cls;
2280
2281   e->experiment_timeout_task = NULL;
2282   fprintf (stderr, "Experiment timeout!\n");
2283
2284   if (NULL != e->episode_timeout_task)
2285   {
2286     GNUNET_SCHEDULER_cancel (e->episode_timeout_task);
2287     e->episode_timeout_task = NULL;
2288   }
2289
2290   e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time),
2291                 GNUNET_SYSERR);
2292 }
2293
2294
2295 struct ATS_Address *
2296 create_ats_address (const struct GNUNET_PeerIdentity *peer,
2297                     const char *plugin_name,
2298                     const void *plugin_addr,
2299                     size_t plugin_addr_len,
2300                     uint32_t session_id,
2301                     uint32_t network)
2302 {
2303   struct ATS_Address *aa = NULL;
2304
2305   aa = GNUNET_malloc (sizeof(struct ATS_Address) + plugin_addr_len + strlen (
2306                         plugin_name) + 1);
2307   aa->atsi = GNUNET_new (struct GNUNET_ATS_Information);
2308   aa->atsi[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
2309   aa->atsi[0].value = htonl (network);
2310   aa->atsi_count = 1;
2311
2312   aa->peer = *peer;
2313   aa->addr_len = plugin_addr_len;
2314   aa->addr = &aa[1];
2315   aa->plugin = (char *) &aa[1] + plugin_addr_len;
2316   GNUNET_memcpy (&aa[1], plugin_addr, plugin_addr_len);
2317   GNUNET_memcpy (aa->plugin, plugin_name, strlen (plugin_name) + 1);
2318   aa->session_id = session_id;
2319
2320   return aa;
2321 }
2322
2323
2324 static void
2325 enforce_add_address (struct GNUNET_ATS_TEST_Operation *op)
2326 {
2327   struct TestPeer *p;
2328   struct TestAddress *a;
2329   int c;
2330
2331   if (NULL == (p = find_peer_by_id (op->peer_id)))
2332   {
2333     p = GNUNET_new (struct TestPeer);
2334     p->id = op->peer_id;
2335     p->assigned_bw_in = 0;
2336     p->assigned_bw_out = 0;
2337     memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
2338     for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
2339     {
2340       p->pref_abs[c] = DEFAULT_ABS_PREFERENCE;
2341       p->pref_norm[c] = DEFAULT_REL_PREFERENCE;
2342     }
2343
2344     GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, p);
2345   }
2346
2347   if (NULL != (find_address_by_id (p, op->address_id)))
2348   {
2349     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Duplicate address %u for peer %u\n",
2350                 op->address_id, op->peer_id);
2351     return;
2352   }
2353
2354   a = GNUNET_new (struct TestAddress);
2355   a->aid = op->address_id;
2356   a->network = op->address_network;
2357   a->ats_addr = create_ats_address (&p->peer_id, op->plugin, op->address,
2358                                     strlen (op->address) + 1,
2359                                     op->address_session, op->address_network);
2360   memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
2361   GNUNET_CONTAINER_DLL_insert_tail (p->addr_head, p->addr_tail, a);
2362
2363   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
2364     a->prop_norm[c] = DEFAULT_REL_QUALITY;
2365
2366   GNUNET_CONTAINER_multipeermap_put (sh->addresses, &p->peer_id, a->ats_addr,
2367                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
2368
2369   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2370               "Adding address %u for peer %u in network `%s'\n",
2371               op->address_id, op->peer_id, GNUNET_NT_to_string (a->network));
2372
2373   sh->sf->s_add (sh->sf->cls, a->ats_addr, op->address_network);
2374 }
2375
2376
2377 static void
2378 enforce_del_address (struct GNUNET_ATS_TEST_Operation *op)
2379 {
2380   struct TestPeer *p;
2381   struct TestAddress *a;
2382   struct PropertyGenerator *pg;
2383
2384   if (NULL == (p = find_peer_by_id (op->peer_id)))
2385   {
2386     GNUNET_break (0);
2387     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2388                 "Deleting address for unknown peer %u\n", op->peer_id);
2389     return;
2390   }
2391
2392   if (NULL == (a = find_address_by_id (p, op->address_id)))
2393   {
2394     GNUNET_break (0);
2395     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2396                 "Deleting address for unknown peer %u\n", op->peer_id);
2397     return;
2398   }
2399
2400   while (NULL != (pg = find_prop_gen (p->id, a->aid, 0)))
2401   {
2402     GNUNET_ATS_solver_generate_property_stop (pg);
2403   }
2404
2405   GNUNET_assert (GNUNET_YES ==
2406                  GNUNET_CONTAINER_multipeermap_remove (sh->addresses,
2407                                                        &p->peer_id,
2408                                                        a->ats_addr));
2409   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2410               "Removing address %u for peer %u\n",
2411               op->address_id,
2412               op->peer_id);
2413
2414   sh->sf->s_del (sh->sf->cls, a->ats_addr);
2415
2416   if (NULL != l)
2417   {
2418     GNUNET_ATS_solver_logging_now (l);
2419   }
2420   GNUNET_CONTAINER_DLL_remove (p->addr_head, p->addr_tail, a);
2421
2422   GNUNET_free_non_null (a->ats_addr->atsi);
2423   GNUNET_free (a->ats_addr);
2424   GNUNET_free (a);
2425 }
2426
2427
2428 static void
2429 enforce_start_property (struct GNUNET_ATS_TEST_Operation *op)
2430 {
2431   struct PropertyGenerator *pg;
2432   struct TestPeer *p;
2433   struct TestAddress *a;
2434
2435   if (NULL != (pg = find_prop_gen (op->peer_id, op->address_id, op->prop_type)))
2436   {
2437     GNUNET_ATS_solver_generate_property_stop (pg);
2438     GNUNET_free (pg);
2439   }
2440
2441   if (NULL == (p = find_peer_by_id (op->peer_id)))
2442   {
2443     GNUNET_break (0);
2444     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2445                 "Starting property generation for unknown peer %u\n",
2446                 op->peer_id);
2447     return;
2448   }
2449
2450   if (NULL == (a = find_address_by_id (p, op->address_id)))
2451   {
2452     GNUNET_break (0);
2453     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2454                 "Setting property for unknown address %u\n", op->peer_id);
2455     return;
2456   }
2457
2458   GNUNET_ATS_solver_generate_property_start (op->peer_id,
2459                                              op->address_id,
2460                                              p, a,
2461                                              op->gen_type,
2462                                              op->base_rate,
2463                                              op->max_rate,
2464                                              op->period,
2465                                              op->frequency,
2466                                              op->prop_type);
2467 }
2468
2469
2470 static void
2471 enforce_stop_property (struct GNUNET_ATS_TEST_Operation *op)
2472 {
2473   struct PropertyGenerator *pg = find_prop_gen (op->peer_id, op->address_id,
2474                                                 op->prop_type);
2475
2476   if (NULL != pg)
2477   {
2478     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2479                 "Stopping preference generation for peer %u address %u\n",
2480                 op->peer_id,
2481                 op->address_id);
2482     GNUNET_ATS_solver_generate_property_stop (pg);
2483   }
2484   else
2485   {
2486     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2487                 "Cannot find preference generator for peer %u address %u\n",
2488                 op->peer_id, op->address_id);
2489     GNUNET_break (0);
2490   }
2491 }
2492
2493
2494 static void
2495 enforce_start_preference (struct GNUNET_ATS_TEST_Operation *op)
2496 {
2497   struct PreferenceGenerator *pg;
2498
2499   if (NULL != (pg = find_pref_gen (op->peer_id, op->pref_type)))
2500   {
2501     GNUNET_ATS_solver_generate_preferences_stop (pg);
2502     GNUNET_free (pg);
2503   }
2504
2505   if (NULL == (find_peer_by_id (op->peer_id)))
2506   {
2507     GNUNET_break (0);
2508     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2509                 "Starting preference generation for unknown peer %u\n",
2510                 op->peer_id);
2511     return;
2512   }
2513
2514   GNUNET_ATS_solver_generate_preferences_start (op->peer_id,
2515                                                 op->address_id,
2516                                                 op->client_id,
2517                                                 op->gen_type,
2518                                                 op->base_rate,
2519                                                 op->max_rate,
2520                                                 op->period,
2521                                                 op->frequency,
2522                                                 op->pref_type,
2523                                                 op->frequency);
2524 }
2525
2526
2527 static void
2528 enforce_stop_preference (struct GNUNET_ATS_TEST_Operation *op)
2529 {
2530   struct PreferenceGenerator *pg = find_pref_gen (op->peer_id,
2531                                                   op->pref_type);
2532
2533   if (NULL != pg)
2534   {
2535     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2536                 "Stopping property generation for peer %u address %u\n",
2537                 op->peer_id,
2538                 op->address_id);
2539     GNUNET_ATS_solver_generate_preferences_stop (pg);
2540   }
2541   else
2542   {
2543     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2544                 "Cannot find preference generator for peer %u address %u\n",
2545                 op->peer_id, op->address_id);
2546     GNUNET_break (0);
2547   }
2548 }
2549
2550
2551 static void
2552 enforce_start_request (struct GNUNET_ATS_TEST_Operation *op)
2553 {
2554   struct TestPeer *p;
2555
2556   if (NULL == (p = find_peer_by_id (op->peer_id)))
2557   {
2558     GNUNET_break (0);
2559     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2560                 "Requesting address for unknown peer %u\n", op->peer_id);
2561     return;
2562   }
2563
2564   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Requesting address for peer %u\n",
2565               op->peer_id);
2566   p->is_requested = GNUNET_YES;
2567
2568   sh->sf->s_get (sh->sf->cls, &p->peer_id);
2569 }
2570
2571
2572 static void
2573 enforce_stop_request (struct GNUNET_ATS_TEST_Operation *op)
2574 {
2575   struct TestPeer *p;
2576
2577   if (NULL == (p = find_peer_by_id (op->peer_id)))
2578   {
2579     GNUNET_break (0);
2580     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2581                 "Requesting address for unknown peer %u\n", op->peer_id);
2582     return;
2583   }
2584
2585   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2586               "Stop requesting address for peer %u\n",
2587               op->peer_id);
2588   p->is_requested = GNUNET_NO;
2589   p->assigned_bw_in = 0;
2590   p->assigned_bw_out = 0;
2591   sh->sf->s_get_stop (sh->sf->cls, &p->peer_id);
2592
2593   if (NULL != l)
2594   {
2595     GNUNET_ATS_solver_logging_now (l);
2596   }
2597 }
2598
2599
2600 static void
2601 enforce_episode (struct Episode *ep)
2602 {
2603   struct GNUNET_ATS_TEST_Operation *cur;
2604
2605   for (cur = ep->head; NULL != cur; cur = cur->next)
2606   {
2607     switch (cur->type)
2608     {
2609     case SOLVER_OP_ADD_ADDRESS:
2610       fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
2611                print_op (cur->type), cur->peer_id, cur->address_id);
2612       enforce_add_address (cur);
2613       break;
2614
2615     case SOLVER_OP_DEL_ADDRESS:
2616       fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
2617                print_op (cur->type), cur->peer_id, cur->address_id);
2618       enforce_del_address (cur);
2619       break;
2620
2621     case SOLVER_OP_START_SET_PROPERTY:
2622       fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2623                print_op (cur->type), cur->peer_id, cur->address_id,
2624                cur->base_rate);
2625       enforce_start_property (cur);
2626       break;
2627
2628     case SOLVER_OP_STOP_SET_PROPERTY:
2629       fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2630                print_op (cur->type), cur->peer_id, cur->address_id,
2631                cur->base_rate);
2632       enforce_stop_property (cur);
2633       break;
2634
2635     case SOLVER_OP_START_SET_PREFERENCE:
2636       fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2637                print_op (cur->type), cur->peer_id, cur->address_id,
2638                cur->base_rate);
2639       enforce_start_preference (cur);
2640       break;
2641
2642     case SOLVER_OP_STOP_SET_PREFERENCE:
2643       fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2644                print_op (cur->type), cur->peer_id, cur->address_id,
2645                cur->base_rate);
2646       enforce_stop_preference (cur);
2647       break;
2648
2649     case SOLVER_OP_START_REQUEST:
2650       fprintf (stderr, "Enforcing operation: %s [%llu]\n",
2651                print_op (cur->type), cur->peer_id);
2652       enforce_start_request (cur);
2653       break;
2654
2655     case SOLVER_OP_STOP_REQUEST:
2656       fprintf (stderr, "Enforcing operation: %s [%llu]\n",
2657                print_op (cur->type), cur->peer_id);
2658       enforce_stop_request (cur);
2659       break;
2660
2661     default:
2662       break;
2663     }
2664   }
2665 }
2666
2667
2668 static void
2669 timeout_episode (void *cls)
2670 {
2671   struct Experiment *e = cls;
2672
2673   e->episode_timeout_task = NULL;
2674   if (NULL != e->ep_done_cb)
2675     e->ep_done_cb (e->cur);
2676
2677   /* Scheduling next */
2678   e->cur = e->cur->next;
2679   if (NULL == e->cur)
2680   {
2681     /* done */
2682     fprintf (stderr, "Last episode done!\n");
2683     if (NULL != e->experiment_timeout_task)
2684     {
2685       GNUNET_SCHEDULER_cancel (e->experiment_timeout_task);
2686       e->experiment_timeout_task = NULL;
2687     }
2688     e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time),
2689                   GNUNET_OK);
2690     return;
2691   }
2692
2693   fprintf (stderr, "Running episode %u with timeout %s\n",
2694            e->cur->id,
2695            GNUNET_STRINGS_relative_time_to_string (e->cur->duration,
2696                                                    GNUNET_YES));
2697   e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration,
2698                                                           &timeout_episode, e);
2699   enforce_episode (e->cur);
2700 }
2701
2702
2703 void
2704 GNUNET_ATS_solvers_experimentation_run (struct Experiment *e,
2705                                         GNUNET_ATS_TESTING_EpisodeDoneCallback
2706                                         ep_done_cb,
2707                                         GNUNET_ATS_TESTING_ExperimentDoneCallback
2708                                         e_done_cb)
2709 {
2710   fprintf (stderr, "Running experiment `%s'  with timeout %s\n", e->name,
2711            GNUNET_STRINGS_relative_time_to_string (e->max_duration,
2712                                                    GNUNET_YES));
2713   e->e_done_cb = e_done_cb;
2714   e->ep_done_cb = ep_done_cb;
2715   e->start_time = GNUNET_TIME_absolute_get ();
2716
2717   /* Start total time out */
2718   e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed (e->max_duration,
2719                                                              &timeout_experiment,
2720                                                              e);
2721
2722   /* Start */
2723   if (NULL == e->start)
2724   {
2725     GNUNET_break (0);
2726     return;
2727   }
2728
2729   e->cur = e->start;
2730   fprintf (stderr, "Running episode %u with timeout %s\n",
2731            e->cur->id,
2732            GNUNET_STRINGS_relative_time_to_string (e->cur->duration,
2733                                                    GNUNET_YES));
2734   e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration,
2735                                                           &timeout_episode, e);
2736   enforce_episode (e->cur);
2737 }
2738
2739
2740 void
2741 GNUNET_ATS_solvers_experimentation_stop (struct Experiment *e)
2742 {
2743   if (NULL != e->experiment_timeout_task)
2744   {
2745     GNUNET_SCHEDULER_cancel (e->experiment_timeout_task);
2746     e->experiment_timeout_task = NULL;
2747   }
2748   if (NULL != e->episode_timeout_task)
2749   {
2750     GNUNET_SCHEDULER_cancel (e->episode_timeout_task);
2751     e->episode_timeout_task = NULL;
2752   }
2753   if (NULL != e->cfg)
2754   {
2755     GNUNET_CONFIGURATION_destroy (e->cfg);
2756     e->cfg = NULL;
2757   }
2758   free_experiment (e);
2759 }
2760
2761
2762 struct Experiment *
2763 GNUNET_ATS_solvers_experimentation_load (char *filename)
2764 {
2765   struct Experiment *e;
2766   struct GNUNET_CONFIGURATION_Handle *cfg;
2767
2768   e = NULL;
2769
2770   cfg = GNUNET_CONFIGURATION_create ();
2771   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, filename))
2772   {
2773     fprintf (stderr, "Failed to load `%s'\n", filename);
2774     GNUNET_CONFIGURATION_destroy (cfg);
2775     return NULL;
2776   }
2777
2778   e = create_experiment ();
2779
2780   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "experiment",
2781                                                               "name", &e->name))
2782   {
2783     fprintf (stderr, "Invalid %s \n", "name");
2784     free_experiment (e);
2785     return NULL;
2786   }
2787   else
2788     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment name: `%s'\n", e->name);
2789
2790   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "experiment",
2791                                                               "log_prefix",
2792                                                               &e->log_prefix))
2793   {
2794     fprintf (stderr, "Invalid %s \n", "log_prefix");
2795     free_experiment (e);
2796     return NULL;
2797   }
2798   else
2799     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging prefix: `%s'\n",
2800                 e->log_prefix);
2801
2802   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename (cfg,
2803                                                                 "experiment",
2804                                                                 "log_output_dir",
2805                                                                 &e->
2806                                                                 log_output_dir))
2807   {
2808     e->log_output_dir = NULL;
2809   }
2810   else
2811     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2812                 "Experiment logging output directory: `%s'\n",
2813                 e->log_output_dir);
2814
2815
2816   if (GNUNET_SYSERR == (e->log_append_time_stamp =
2817                           GNUNET_CONFIGURATION_get_value_yesno (cfg,
2818                                                                 "experiment",
2819                                                                 "log_append_time_stamp")))
2820     e->log_append_time_stamp = GNUNET_YES;
2821   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2822               "Experiment logging append timestamp: `%s'\n",
2823               (GNUNET_YES == e->log_append_time_stamp) ? "yes" : "no");
2824
2825
2826   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename (cfg,
2827                                                                 "experiment",
2828                                                                 "cfg_file",
2829                                                                 &e->cfg_file))
2830   {
2831     fprintf (stderr, "Invalid %s \n", "cfg_file");
2832     free_experiment (e);
2833     return NULL;
2834   }
2835   else
2836   {
2837     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment configuration: `%s'\n",
2838                 e->cfg_file);
2839     e->cfg = GNUNET_CONFIGURATION_create ();
2840     if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (e->cfg, e->cfg_file))
2841     {
2842       fprintf (stderr, "Invalid configuration %s \n", "cfg_file");
2843       free_experiment (e);
2844       return NULL;
2845     }
2846   }
2847
2848   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment",
2849                                                             "log_freq",
2850                                                             &e->log_freq))
2851   {
2852     fprintf (stderr, "Invalid %s \n", "log_freq");
2853     free_experiment (e);
2854     return NULL;
2855   }
2856   else
2857     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging frequency: `%s'\n",
2858                 GNUNET_STRINGS_relative_time_to_string (e->log_freq,
2859                                                         GNUNET_YES));
2860
2861   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment",
2862                                                             "max_duration",
2863                                                             &e->max_duration))
2864   {
2865     fprintf (stderr, "Invalid %s", "max_duration");
2866     free_experiment (e);
2867     return NULL;
2868   }
2869   else
2870     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment duration: `%s'\n",
2871                 GNUNET_STRINGS_relative_time_to_string (e->max_duration,
2872                                                         GNUNET_YES));
2873
2874   if (GNUNET_SYSERR == load_episodes (e, cfg))
2875   {
2876     GNUNET_ATS_solvers_experimentation_stop (e);
2877     GNUNET_CONFIGURATION_destroy (cfg);
2878     e = NULL;
2879     fprintf (stderr, "Failed to load experiment\n");
2880     return NULL;
2881   }
2882   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2883               "Loaded %u episodes with total duration %s\n",
2884               e->num_episodes,
2885               GNUNET_STRINGS_relative_time_to_string (e->total_duration,
2886                                                       GNUNET_YES));
2887
2888   GNUNET_CONFIGURATION_destroy (cfg);
2889   return e;
2890 }
2891
2892
2893 /**
2894  * Solver
2895  */
2896
2897 static int
2898 free_all_it (void *cls,
2899              const struct GNUNET_PeerIdentity *key,
2900              void *value)
2901 {
2902   struct ATS_Address *address = value;
2903
2904   GNUNET_break (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (
2905                   sh->env.addresses,
2906                   key, value));
2907   GNUNET_free (address);
2908
2909   return GNUNET_OK;
2910 }
2911
2912
2913 void
2914 GNUNET_ATS_solvers_solver_stop (struct SolverHandle *sh)
2915 {
2916   GNUNET_STATISTICS_destroy ((struct GNUNET_STATISTICS_Handle *) sh->env.stats,
2917                              GNUNET_NO);
2918   GNUNET_PLUGIN_unload (sh->plugin, sh->sf);
2919   sh->sf = NULL;
2920   GAS_normalization_stop ();
2921
2922   GNUNET_CONTAINER_multipeermap_iterate (sh->addresses,
2923                                          &free_all_it,
2924                                          NULL);
2925   GNUNET_CONTAINER_multipeermap_destroy (sh->addresses);
2926   GNUNET_free (sh->plugin);
2927   GNUNET_free (sh);
2928 }
2929
2930
2931 /**
2932  * Load quotas for networks from configuration
2933  *
2934  * @param cfg configuration handle
2935  * @param out_dest where to write outbound quotas
2936  * @param in_dest where to write inbound quotas
2937  * @param dest_length length of inbound and outbound arrays
2938  * @return number of networks loaded
2939  */
2940 unsigned int
2941 GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
2942                                 unsigned long long *out_dest,
2943                                 unsigned long long *in_dest,
2944                                 int dest_length)
2945 {
2946   char *entry_in = NULL;
2947   char *entry_out = NULL;
2948   char *quota_out_str;
2949   char *quota_in_str;
2950   int c;
2951   int res;
2952
2953   for (c = 0; (c < GNUNET_NT_COUNT) && (c < dest_length); c++)
2954   {
2955     in_dest[c] = 0;
2956     out_dest[c] = 0;
2957     GNUNET_asprintf (&entry_out,
2958                      "%s_QUOTA_OUT",
2959                      GNUNET_NT_to_string (c));
2960     GNUNET_asprintf (&entry_in,
2961                      "%s_QUOTA_IN",
2962                      GNUNET_NT_to_string (c));
2963
2964     /* quota out */
2965     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "ats",
2966                                                             entry_out,
2967                                                             &quota_out_str))
2968     {
2969       res = GNUNET_NO;
2970       if (0 == strcmp (quota_out_str, BIG_M_STRING))
2971       {
2972         out_dest[c] = GNUNET_ATS_MaxBandwidth;
2973         res = GNUNET_YES;
2974       }
2975       if ((GNUNET_NO == res) && (GNUNET_OK ==
2976                                  GNUNET_STRINGS_fancy_size_to_bytes (
2977                                    quota_out_str, &out_dest[c])))
2978         res = GNUNET_YES;
2979       if ((GNUNET_NO == res) && (GNUNET_OK ==
2980                                  GNUNET_CONFIGURATION_get_value_number (cfg,
2981                                                                         "ats",
2982                                                                         entry_out,
2983                                                                         &
2984                                                                         out_dest
2985                                                                         [c])))
2986         res = GNUNET_YES;
2987
2988       if (GNUNET_NO == res)
2989       {
2990         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2991                     _ (
2992                       "Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
2993                     GNUNET_NT_to_string (c),
2994                     quota_out_str,
2995                     GNUNET_ATS_DefaultBandwidth);
2996         out_dest[c] = GNUNET_ATS_DefaultBandwidth;
2997       }
2998       else
2999       {
3000         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3001                     "Outbound quota configure for network `%s' is %llu\n",
3002                     GNUNET_NT_to_string (c),
3003                     out_dest[c]);
3004       }
3005       GNUNET_free (quota_out_str);
3006     }
3007     else
3008     {
3009       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3010                   _ (
3011                     "No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
3012                   GNUNET_NT_to_string (c),
3013                   GNUNET_ATS_DefaultBandwidth);
3014       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
3015     }
3016
3017     /* quota in */
3018     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "ats",
3019                                                             entry_in,
3020                                                             &quota_in_str))
3021     {
3022       res = GNUNET_NO;
3023       if (0 == strcmp (quota_in_str, BIG_M_STRING))
3024       {
3025         in_dest[c] = GNUNET_ATS_MaxBandwidth;
3026         res = GNUNET_YES;
3027       }
3028       if ((GNUNET_NO == res) && (GNUNET_OK ==
3029                                  GNUNET_STRINGS_fancy_size_to_bytes (
3030                                    quota_in_str, &in_dest[c])))
3031         res = GNUNET_YES;
3032       if ((GNUNET_NO == res) && (GNUNET_OK ==
3033                                  GNUNET_CONFIGURATION_get_value_number (cfg,
3034                                                                         "ats",
3035                                                                         entry_in,
3036                                                                         &in_dest
3037                                                                         [c])))
3038         res = GNUNET_YES;
3039
3040       if (GNUNET_NO == res)
3041       {
3042         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3043                     _ (
3044                       "Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
3045                     GNUNET_NT_to_string (c),
3046                     quota_in_str,
3047                     GNUNET_ATS_DefaultBandwidth);
3048         in_dest[c] = GNUNET_ATS_DefaultBandwidth;
3049       }
3050       else
3051       {
3052         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3053                     "Inbound quota configured for network `%s' is %llu\n",
3054                     GNUNET_NT_to_string (c),
3055                     in_dest[c]);
3056       }
3057       GNUNET_free (quota_in_str);
3058     }
3059     else
3060     {
3061       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3062                   _ (
3063                     "No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
3064                   GNUNET_NT_to_string (c),
3065                   GNUNET_ATS_DefaultBandwidth);
3066       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
3067     }
3068     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3069                 "Loaded quota for network `%s' (in/out): %llu %llu\n",
3070                 GNUNET_NT_to_string (c),
3071                 in_dest[c],
3072                 out_dest[c]);
3073     GNUNET_free (entry_out);
3074     GNUNET_free (entry_in);
3075   }
3076   return GNUNET_NT_COUNT;
3077 }
3078
3079
3080 /**
3081  * Information callback for the solver
3082  *
3083  * @param cls the closure
3084  * @param op the solver operation
3085  * @param stat status of the solver operation
3086  * @param add additional solver information
3087  */
3088 static void
3089 solver_info_cb (void *cls,
3090                 enum GAS_Solver_Operation op,
3091                 enum GAS_Solver_Status stat,
3092                 enum GAS_Solver_Additional_Information add)
3093 {
3094   char *add_info;
3095
3096   switch (add)
3097   {
3098   case GAS_INFO_NONE:
3099     add_info = "GAS_INFO_NONE";
3100     break;
3101
3102   case GAS_INFO_FULL:
3103     add_info = "GAS_INFO_MLP_FULL";
3104     break;
3105
3106   case GAS_INFO_UPDATED:
3107     add_info = "GAS_INFO_MLP_UPDATED";
3108     break;
3109
3110   case GAS_INFO_PROP_ALL:
3111     add_info = "GAS_INFO_PROP_ALL";
3112     break;
3113
3114   case GAS_INFO_PROP_SINGLE:
3115     add_info = "GAS_INFO_PROP_SINGLE";
3116     break;
3117
3118   default:
3119     add_info = "INVALID";
3120     break;
3121   }
3122
3123   switch (op)
3124   {
3125   case GAS_OP_SOLVE_START:
3126     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3127                 "Solver notifies `%s' with result `%s' `%s'\n",
3128                 "GAS_OP_SOLVE_START",
3129                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
3130     return;
3131
3132   case GAS_OP_SOLVE_STOP:
3133     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3134                 "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP",
3135                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
3136     return;
3137
3138   case GAS_OP_SOLVE_SETUP_START:
3139     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3140                 "Solver notifies `%s' with result `%s'\n",
3141                 "GAS_OP_SOLVE_SETUP_START",
3142                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3143     return;
3144
3145   case GAS_OP_SOLVE_SETUP_STOP:
3146     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3147                 "Solver notifies `%s' with result `%s'\n",
3148                 "GAS_OP_SOLVE_SETUP_STOP",
3149                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3150     return;
3151
3152   case GAS_OP_SOLVE_MLP_LP_START:
3153     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3154                 "Solver notifies `%s' with result `%s'\n",
3155                 "GAS_OP_SOLVE_LP_START",
3156                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3157     return;
3158
3159   case GAS_OP_SOLVE_MLP_LP_STOP:
3160     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3161                 "Solver notifies `%s' with result `%s'\n",
3162                 "GAS_OP_SOLVE_LP_STOP",
3163                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3164     return;
3165
3166   case GAS_OP_SOLVE_MLP_MLP_START:
3167     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3168                 "Solver notifies `%s' with result `%s'\n",
3169                 "GAS_OP_SOLVE_MLP_START",
3170                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3171     return;
3172
3173   case GAS_OP_SOLVE_MLP_MLP_STOP:
3174     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3175                 "Solver notifies `%s' with result `%s'\n",
3176                 "GAS_OP_SOLVE_MLP_STOP",
3177                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3178     return;
3179
3180   case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
3181     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3182                 "Solver notifies `%s' with result `%s'\n",
3183                 "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
3184                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3185     return;
3186
3187   case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
3188     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3189                 "Solver notifies `%s' with result `%s'\n",
3190                 "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
3191                 (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3192     return;
3193
3194   default:
3195     break;
3196   }
3197 }
3198
3199
3200 static void
3201 solver_bandwidth_changed_cb (void *cls, struct ATS_Address *address)
3202 {
3203   struct GNUNET_TIME_Relative duration;
3204   struct TestPeer *p;
3205   static struct PreferenceGenerator *pg;
3206   uint32_t delta;
3207
3208   if ((0 == address->assigned_bw_out) && (0 == address->assigned_bw_in))
3209   {
3210     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3211                 "Solver notified to disconnect peer `%s'\n",
3212                 GNUNET_i2s (&address->peer));
3213   }
3214   p = find_peer_by_pid (&address->peer);
3215   if (NULL == p)
3216     return;
3217   p->assigned_bw_out = address->assigned_bw_out;
3218   p->assigned_bw_in = address->assigned_bw_in;
3219
3220   for (pg = pref_gen_head; NULL != pg; pg = pg->next)
3221   {
3222     if (pg->peer == p->id)
3223     {
3224       duration = GNUNET_TIME_absolute_get_duration (
3225         pg->feedback_last_bw_update);
3226       delta = duration.rel_value_us * pg->last_assigned_bw_out;
3227       pg->feedback_bw_out_acc += delta;
3228
3229       delta = duration.rel_value_us * pg->last_assigned_bw_in;
3230       pg->feedback_bw_in_acc += delta;
3231
3232       pg->last_assigned_bw_in = address->assigned_bw_in;
3233       pg->last_assigned_bw_out = address->assigned_bw_out;
3234       pg->feedback_last_bw_update = GNUNET_TIME_absolute_get ();
3235     }
3236   }
3237
3238   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3239               "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n",
3240               GNUNET_i2s (&address->peer),
3241               address,
3242               address->assigned_bw_out,
3243               address->assigned_bw_in);
3244
3245   if (NULL != l)
3246     GNUNET_ATS_solver_logging_now (l);
3247
3248   return;
3249 }
3250
3251
3252 const double *
3253 get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
3254 {
3255   struct TestPeer *p;
3256
3257   if (GNUNET_YES == opt_disable_normalization)
3258   {
3259     if (NULL == (p = find_peer_by_pid (id)))
3260       return NULL;
3261     return p->pref_abs;
3262   }
3263   else
3264     return GAS_preference_get_by_peer (NULL,
3265                                        id);
3266 }
3267
3268
3269 struct SolverHandle *
3270 GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
3271 {
3272   struct SolverHandle *sh;
3273   char *solver_str;
3274
3275   switch (type)
3276   {
3277   case GNUNET_ATS_SOLVER_PROPORTIONAL:
3278     solver_str = "proportional";
3279     break;
3280
3281   case GNUNET_ATS_SOLVER_MLP:
3282     solver_str = "mlp";
3283     break;
3284
3285   case GNUNET_ATS_SOLVER_RIL:
3286     solver_str = "ril";
3287     break;
3288
3289   default:
3290     GNUNET_break (0);
3291     return NULL;
3292     break;
3293   }
3294
3295   sh = GNUNET_new (struct SolverHandle);
3296   GNUNET_asprintf (&sh->plugin,
3297                    "libgnunet_plugin_ats_%s",
3298                    solver_str);
3299   sh->addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
3300
3301   /* setup environment */
3302   sh->env.cfg = e->cfg;
3303   sh->env.stats = GNUNET_STATISTICS_create ("ats", e->cfg);
3304   sh->env.addresses = sh->addresses;
3305   sh->env.bandwidth_changed_cb = &solver_bandwidth_changed_cb;
3306   sh->env.get_preferences = &get_preferences_cb;
3307   sh->env.network_count = GNUNET_NT_COUNT;
3308   sh->env.info_cb = &solver_info_cb;
3309   sh->env.network_count = GNUNET_NT_COUNT;
3310
3311   /* start normalization */
3312   GAS_normalization_start ();
3313
3314   /* load quotas */
3315   if (GNUNET_NT_COUNT != GNUNET_ATS_solvers_load_quotas (e->cfg,
3316                                                          sh->env.out_quota,
3317                                                          sh->env.in_quota,
3318                                                          GNUNET_NT_COUNT))
3319   {
3320     GNUNET_break (0);
3321     GNUNET_free (sh->plugin);
3322     GNUNET_free (sh);
3323     end_now ();
3324     return NULL;
3325   }
3326
3327   sh->sf = GNUNET_PLUGIN_load (sh->plugin, &sh->env);
3328   if (NULL == sh->sf)
3329   {
3330     fprintf (stderr, "Failed to load solver `%s'\n", sh->plugin);
3331     GNUNET_break (0);
3332     GNUNET_free (sh->plugin);
3333     GNUNET_free (sh);
3334     end_now ();
3335     return NULL;
3336   }
3337   return sh;
3338 }
3339
3340
3341 static void
3342 done ()
3343 {
3344   struct TestPeer *cur;
3345   struct TestPeer *next;
3346
3347   struct TestAddress *cur_a;
3348   struct TestAddress *next_a;
3349
3350   /* Stop logging */
3351   GNUNET_ATS_solver_logging_stop (l);
3352
3353   /* Stop all preference generation */
3354   GNUNET_ATS_solver_generate_preferences_stop_all ();
3355
3356   /* Stop all property generation */
3357   GNUNET_ATS_solver_generate_property_stop_all ();
3358
3359   if (opt_print)
3360   {
3361     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "== Printing log information \n");
3362     GNUNET_ATS_solver_logging_eval (l);
3363   }
3364   if (opt_save)
3365   {
3366     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "== Saving log information \n");
3367     GNUNET_ATS_solver_logging_write_to_disk (l, e->log_append_time_stamp,
3368                                              e->log_output_dir);
3369   }
3370
3371   if (NULL != l)
3372   {
3373     GNUNET_ATS_solver_logging_free (l);
3374     l = NULL;
3375   }
3376
3377   /* Clean up experiment */
3378   if (NULL != e)
3379   {
3380     GNUNET_ATS_solvers_experimentation_stop (e);
3381     e = NULL;
3382   }
3383
3384   next = peer_head;
3385   while (NULL != (cur = next))
3386   {
3387     next = cur->next;
3388     GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, cur);
3389     next_a = cur->addr_head;
3390     while (NULL != (cur_a = next_a))
3391     {
3392       next_a = cur_a->next;
3393       GNUNET_CONTAINER_DLL_remove (cur->addr_head, cur->addr_tail, cur_a);
3394       GNUNET_free (cur_a);
3395     }
3396     GNUNET_free (cur);
3397   }
3398   if (NULL != sh)
3399   {
3400     GNUNET_ATS_solvers_solver_stop (sh);
3401     sh = NULL;
3402   }
3403
3404   /* Shutdown */
3405   end_now ();
3406 }
3407
3408
3409 static void
3410 experiment_done_cb (struct Experiment *e, struct GNUNET_TIME_Relative duration,
3411                     int success)
3412 {
3413   if (GNUNET_OK == success)
3414     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment done successful in %s\n",
3415                 GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
3416   else
3417     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment failed \n");
3418
3419   GNUNET_SCHEDULER_add_now (&done, NULL);
3420 }
3421
3422
3423 static void
3424 episode_done_cb (struct Episode *ep)
3425 {
3426   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Episode %u done\n", ep->id);
3427 }
3428
3429
3430 /**
3431  * Do shutdown
3432  */
3433 static void
3434 end_now ()
3435 {
3436   if (NULL != e)
3437   {
3438     GNUNET_ATS_solvers_experimentation_stop (e);
3439     e = NULL;
3440   }
3441   if (NULL != sh)
3442   {
3443     GNUNET_ATS_solvers_solver_stop (sh);
3444     sh = NULL;
3445   }
3446 }
3447
3448
3449 static void
3450 run (void *cls, char *const *args, const char *cfgfile,
3451      const struct GNUNET_CONFIGURATION_Handle *cfg)
3452 {
3453   enum GNUNET_ATS_Solvers solver;
3454   int c;
3455
3456   if (NULL == opt_exp_file)
3457   {
3458     fprintf (stderr, "No experiment given ...\n");
3459     res = 1;
3460     end_now ();
3461     return;
3462   }
3463
3464   if (NULL == opt_solver)
3465   {
3466     fprintf (stderr, "No solver given ...\n");
3467     res = 1;
3468     end_now ();
3469     return;
3470   }
3471
3472   if (0 == strcmp (opt_solver, "mlp"))
3473   {
3474     solver = GNUNET_ATS_SOLVER_MLP;
3475   }
3476   else if (0 == strcmp (opt_solver, "proportional"))
3477   {
3478     solver = GNUNET_ATS_SOLVER_PROPORTIONAL;
3479   }
3480   else if (0 == strcmp (opt_solver, "ril"))
3481   {
3482     solver = GNUNET_ATS_SOLVER_RIL;
3483   }
3484   else
3485   {
3486     fprintf (stderr, "No solver given ...");
3487     res = 1;
3488     end_now ();
3489     return;
3490   }
3491
3492   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
3493     default_properties[c] = DEFAULT_REL_QUALITY;
3494
3495   for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
3496     default_preferences[c] = DEFAULT_REL_PREFERENCE;
3497
3498   /* load experiment */
3499   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Loading experiment\n");
3500   e = GNUNET_ATS_solvers_experimentation_load (opt_exp_file);
3501   if (NULL == e)
3502   {
3503     fprintf (stderr, "Failed to load experiment ...\n");
3504     res = 1;
3505     end_now ();
3506     return;
3507   }
3508
3509   /* load solver */
3510   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Loading solver\n");
3511   sh = GNUNET_ATS_solvers_solver_start (solver);
3512   if (NULL == sh)
3513   {
3514     fprintf (stderr, "Failed to start solver ...\n");
3515     end_now ();
3516     res = 1;
3517     return;
3518   }
3519
3520   /* start logging */
3521   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Start logging \n");
3522   l = GNUNET_ATS_solver_logging_start (e->log_freq);
3523
3524   /* run experiment */
3525   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Running experiment \n");
3526   GNUNET_ATS_solvers_experimentation_run (e, episode_done_cb,
3527                                           experiment_done_cb);
3528
3529   /* WAIT */
3530 }
3531
3532
3533 /**
3534  * Main function of the benchmark
3535  *
3536  * @param argc argument count
3537  * @param argv argument values
3538  */
3539 int
3540 main (int argc, char *argv[])
3541 {
3542   opt_exp_file = NULL;
3543   opt_solver = NULL;
3544   opt_log = GNUNET_NO;
3545   opt_save = GNUNET_NO;
3546
3547   res = 0;
3548
3549   static struct GNUNET_GETOPT_CommandLineOption options[] = {
3550     GNUNET_GETOPT_option_string ('s',
3551                                  "solver",
3552                                  gettext_noop ("solver to use"),
3553                                  &opt_solver),
3554
3555     GNUNET_GETOPT_option_string ('e',
3556                                  "experiment"
3557                                  gettext_noop ("experiment to use"),
3558                                  &opt_exp_file),
3559
3560     GNUNET_GETOPT_option_verbose (&opt_verbose),
3561
3562     GNUNET_GETOPT_option_flag ('p',
3563                                "print",
3564                                gettext_noop ("print logging"),
3565                                &opt_print),
3566
3567     GNUNET_GETOPT_option_flag ('f',
3568                                "file",
3569                                gettext_noop ("save logging to disk"),
3570                                &opt_save),
3571
3572     GNUNET_GETOPT_option_flag ('d',
3573                                "dn",
3574                                gettext_noop ("disable normalization"),
3575                                &opt_disable_normalization),
3576
3577     GNUNET_GETOPT_OPTION_END
3578   };
3579
3580   GNUNET_PROGRAM_run (argc, argv, "gnunet-ats-solver-eval",
3581                       NULL, options, &run, argv[0]);
3582
3583   return res;
3584 }
3585
3586
3587 /* end of file ats-testing-experiment.c*/