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

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