-only trigger check config if we actually need it
[oweals/gnunet.git] / src / ats / gnunet-ats-solver-eval.c
index 6bf640f21bc71d68891099cc16205e4bbfa06bea..613df52ad230e3dbe414f71ee4cff568eea765c2 100644 (file)
@@ -1,6 +1,6 @@
 /*
  This file is part of GNUnet.
- (C) 2010-2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2010-2013 GNUnet e.V.
 
  GNUnet is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published
@@ -14,8 +14,8 @@
 
  You should have received a copy of the GNU General Public License
  along with GNUnet; see the file COPYING.  If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
  */
 /**
  * @file ats-tests/ats-testing-experiment.c
@@ -27,7 +27,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet-ats-solver-eval.h"
 #include "gnunet-service-ats_normalization.h"
-#include "gnunet-service-ats_preferences.h"
+#include "gnunet-service-ats_preferences.c"
 
 #define BIG_M_STRING "unlimited"
 
@@ -87,8 +87,6 @@ static int res;
 static void
 end_now ();
 
-const double *
-get_property_cb (void *cls, const struct ATS_Address *address);
 
 static char *
 print_generator_type (enum GeneratorType g)
@@ -108,29 +106,6 @@ print_generator_type (enum GeneratorType g)
   }
 }
 
-struct AddressLookupCtx
-{
-  struct ATS_Address *res;
-  char *plugin;
-  char *addr;
-};
-
-
-int find_address_it (void *cls,
-                     const struct GNUNET_PeerIdentity *key,
-                     void *value)
-{
-  struct AddressLookupCtx *ctx = cls;
-  struct ATS_Address *addr = value;
-
-  if ( (0 == strcmp (ctx->plugin, addr->plugin)) &&
-       (0 == strcmp (ctx->addr, addr->addr)) )
-  {
-       ctx->res = addr;
-       return GNUNET_NO;
-  }
-  return GNUNET_YES;
-}
 
 static struct TestPeer *
 find_peer_by_id (int id)
@@ -163,23 +138,9 @@ find_address_by_id (struct TestPeer *peer, int aid)
 }
 
 
-static struct TestAddress *
-find_address_by_ats_address (struct TestPeer *p, const struct ATS_Address *addr)
-{
-  struct TestAddress *cur;
-  for (cur = p->addr_head; NULL != cur; cur = cur->next)
-    if ((0 == strcmp(cur->ats_addr->plugin, addr->plugin)) &&
-         (cur->ats_addr->addr_len == addr->addr_len) &&
-        (0 == memcmp (cur->ats_addr->addr, addr->addr, addr->addr_len)))
-      return cur;
-  return NULL;
-}
-
-
 /**
  * Logging
  */
-
 void
 GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
 {
@@ -205,7 +166,8 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
   /* Store logging data here */
   for (cur = peer_head; NULL != cur; cur = cur->next)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu\n", cur->id);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Logging peer id %llu\n", cur->id);
 
     log_p = GNUNET_new (struct LoggingPeer);
     log_p->id = cur->id;
@@ -215,30 +177,33 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
     {
       log_p->pref_abs[c] = cur->pref_abs[c];
       log_p->pref_norm[c] = cur->pref_norm[c];
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n",
-          GNUNET_ATS_print_preference_type(c),
-          log_p->pref_abs[c], log_p->pref_norm[c]);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t %s = %.2f %.2f [abs/rel]\n",
+                  GNUNET_ATS_print_preference_type(c),
+                  log_p->pref_abs[c], log_p->pref_norm[c]);
     }
     GNUNET_CONTAINER_DLL_insert_tail(lts->head, lts->tail, log_p);
 
     for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu address %llu \n",
-          cur->id, cur_addr->aid);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Logging peer id %llu address %llu\n",
+                  cur->id, cur_addr->aid);
       log_a = GNUNET_new (struct LoggingAddress);
       log_a->aid = cur_addr->aid;
       log_a->active = cur_addr->ats_addr->active;
       log_a->network = cur_addr->network;
-      log_a->used = cur_addr->ats_addr->used;
       log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in;
       log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out;
       for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
       {
         log_a->prop_abs[c] = cur_addr->prop_abs[c];
         log_a->prop_norm[c] = cur_addr->prop_norm[c];
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n",
-            GNUNET_ATS_print_property_type(c),
-            log_a->prop_abs[c], log_a->prop_norm[c]);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "\t %s = %.2f %.2f [abs/rel]\n",
+                    GNUNET_ATS_print_property_type(c),
+                    log_a->prop_abs[c],
+                    log_a->prop_norm[c]);
       }
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n", log_a->assigned_bw_in);
@@ -249,16 +214,17 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
   }
 }
 
+
 static void
-logging_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+logging_task (void *cls)
 {
   struct LoggingHandle *l = cls;
-  l->logging_task = NULL;
 
+  l->logging_task = NULL;
   GNUNET_ATS_solver_logging_now (l);
-
-  l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq, &logging_task, l);
-
+  l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq,
+                                                  &logging_task,
+                                                  l);
 }
 
 struct LoggingHandle *
@@ -435,7 +401,9 @@ GNUNET_ATS_solver_logging_write_to_disk (struct LoggingHandle *l, int add_time_s
               GNUNET_ATS_print_property_type(c),
               log_a->prop_abs[c], log_a->prop_norm[c]);*/
           GNUNET_asprintf(&propstring_tmp,"%s%.3f;%.3f;",
-              propstring, log_a->prop_abs[c], log_a->prop_norm[c]);
+                          propstring,
+                          log_a->prop_abs[c],
+                          log_a->prop_norm[c]);
           GNUNET_free (propstring);
           propstring = GNUNET_strdup(propstring_tmp);
           GNUNET_free (propstring_tmp);
@@ -559,10 +527,10 @@ GNUNET_ATS_solver_logging_free (struct LoggingHandle *l)
 /**
  * Property Generators
  */
-
 static struct PropertyGenerator *prop_gen_head;
 static struct PropertyGenerator *prop_gen_tail;
 
+
 static double
 get_property (struct PropertyGenerator *pg)
 {
@@ -622,7 +590,7 @@ get_property (struct PropertyGenerator *pg)
 
 
 static void
-set_prop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+set_prop_task (void *cls)
 {
   struct PropertyGenerator *pg = cls;
   struct TestPeer *p;
@@ -670,27 +638,26 @@ set_prop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   atsi.value = htonl ((uint32_t) prop_value);
 
   /* set performance here! */
-  sh->env.sf.s_bulk_start (sh->solver);
+  sh->sf->s_bulk_start (sh->sf->cls);
   if (GNUNET_YES == opt_disable_normalization)
   {
     a->prop_abs[pg->ats_property] = prop_value;
     a->prop_norm[pg->ats_property] = prop_value;
-    sh->env.sf.s_address_update_property (sh->solver, a->ats_addr,
+    sh->sf->s_address_update_property (sh->sf->cls, a->ats_addr,
         pg->ats_property, prop_value, prop_value);
   }
   else
-    GAS_normalization_normalize_property (pg->test_address->ats_addr, &atsi, 1);
-  sh->env.sf.s_bulk_stop (sh->solver);
+    GAS_normalization_update_property (pg->test_address->ats_addr, &atsi, 1);
+  sh->sf->s_bulk_stop (sh->sf->cls);
 
   pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
       &set_prop_task, pg);
-
 }
 
+
 /**
  * Set ats_property to 0 to find all pgs
  */
-
 static struct PropertyGenerator *
 find_prop_gen (unsigned int peer, unsigned int address,
     uint32_t ats_property)
@@ -810,7 +777,6 @@ GNUNET_ATS_solver_generate_property_start (unsigned int peer,
 }
 
 
-
 /**
  * Stop all preferences generators
  */
@@ -892,9 +858,9 @@ get_preference (struct PreferenceGenerator *pg)
   return pref_value;
 }
 
+
 static void
-set_feedback_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+set_feedback_task (void *cls)
 {
   struct PreferenceGenerator *pg = cls;
   struct TestPeer *p;
@@ -949,7 +915,7 @@ set_feedback_task (void *cls,
       GNUNET_ATS_print_preference_type (pg->kind),
       feedback);
 
-  sh->env.sf.s_feedback (sh->solver, NULL + (pg->client_id), &p->peer_id,
+  sh->sf->s_feedback (sh->sf->cls, NULL + (pg->client_id), &p->peer_id,
       pg->feedback_frequency, pg->kind, feedback);
   pg->feedback_last = GNUNET_TIME_absolute_get();
 
@@ -968,8 +934,7 @@ set_feedback_task (void *cls,
 
 
 static void
-set_pref_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+set_pref_task (void *cls)
 {
   struct PreferenceGenerator *pg = cls;
   struct TestPeer *p;
@@ -1003,23 +968,24 @@ set_pref_task (void *cls,
       pg->peer, NULL + (pg->client_id),
       GNUNET_ATS_print_preference_type (pg->kind), pref_value);
 
-  sh->env.sf.s_bulk_start (sh->solver);
   if (GNUNET_YES == opt_disable_normalization)
   {
     p->pref_abs[pg->kind] = pref_value;
     p->pref_norm[pg->kind] = pref_value;
-    sh->env.sf.s_pref (sh->solver, &p->peer_id, pg->kind, pref_value);
+    sh->sf->s_pref (sh->sf->cls, &p->peer_id, pg->kind, pref_value);
   }
   else
-    GAS_normalization_normalize_preference (NULL + (pg->client_id),
-        &p->peer_id, pg->kind, pref_value);
-  sh->env.sf.s_bulk_stop (sh->solver);
+    update_preference (NULL + (pg->client_id),
+                       &p->peer_id,
+                       pg->kind,
+                       pref_value);
 
   pg->set_task = GNUNET_SCHEDULER_add_delayed (pg->frequency,
-      set_pref_task, pg);
-
+                                               &set_pref_task,
+                                               pg);
 }
 
+
 static struct PreferenceGenerator *
 find_pref_gen (unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)
 {
@@ -1056,7 +1022,8 @@ GNUNET_ATS_solver_generate_preferences_stop (struct PreferenceGenerator *pg)
   GNUNET_free (pg);
 }
 
-struct TestAddress*
+
+static struct TestAddress*
 find_active_address (struct TestPeer *p)
 {
   struct TestAddress *cur;
@@ -1066,6 +1033,7 @@ find_active_address (struct TestPeer *p)
   return NULL;
 }
 
+
 /**
  * Generate between the source master and the partner and set property with a
  * value depending on the generator.
@@ -1152,14 +1120,12 @@ GNUNET_ATS_solver_generate_preferences_start (unsigned int peer,
   if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != feedback_frequency.rel_value_us)
   {
     struct TestAddress * addr = find_active_address(p);
-    const double *properties = get_property_cb (NULL, addr->ats_addr);
 
     pg->last_assigned_bw_in = p->assigned_bw_in;
     pg->last_assigned_bw_out = p->assigned_bw_out;
     pg->feedback_bw_in_acc = 0;
     pg->feedback_bw_out_acc = 0;
-
-    pg->last_delay_value = properties[GNUNET_ATS_QUALITY_NET_DELAY];
+    pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY];
     pg->feedback_delay_acc = 0;
 
     pg->feedback_last_bw_update = GNUNET_TIME_absolute_get();
@@ -1195,8 +1161,7 @@ GNUNET_ATS_solver_generate_preferences_stop_all ()
 /**
  * Experiments
  */
-
-const char *
+static const char *
 print_op (enum OperationType op)
 {
   switch (op) {
@@ -1222,6 +1187,7 @@ print_op (enum OperationType op)
   return "";
 }
 
+
 static struct Experiment *
 create_experiment ()
 {
@@ -1233,6 +1199,7 @@ create_experiment ()
   return e;
 }
 
+
 static void
 free_experiment (struct Experiment *e)
 {
@@ -1391,6 +1358,7 @@ load_op_add_address (struct GNUNET_ATS_TEST_Operation *o,
   return GNUNET_OK;
 }
 
+
 static int
 load_op_del_address (struct GNUNET_ATS_TEST_Operation *o,
     struct Episode *e,
@@ -1470,6 +1438,7 @@ load_op_del_address (struct GNUNET_ATS_TEST_Operation *o,
   return GNUNET_OK;
 }
 
+
 static enum GNUNET_ATS_Property
 parse_preference_string (const char * str)
 {
@@ -1480,7 +1449,8 @@ parse_preference_string (const char * str)
     if (0 == strcmp(str, props[c]))
       return c;
   return 0;
-};
+}
+
 
 static int
 load_op_start_set_preference (struct GNUNET_ATS_TEST_Operation *o,
@@ -1651,6 +1621,7 @@ load_op_start_set_preference (struct GNUNET_ATS_TEST_Operation *o,
   return GNUNET_OK;
 }
 
+
 static int
 load_op_stop_set_preference (struct GNUNET_ATS_TEST_Operation *o,
     struct Episode *e,
@@ -2152,10 +2123,12 @@ load_episodes (struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
   return e_counter;
 }
 
+
 static void
-timeout_experiment (void *cls, const struct GNUNET_SCHEDULER_TaskContext* tc)
+timeout_experiment (void *cls)
 {
   struct Experiment *e = cls;
+
   e->experiment_timeout_task = NULL;
   fprintf (stderr, "Experiment timeout!\n");
 
@@ -2192,11 +2165,6 @@ create_ats_address (const struct GNUNET_PeerIdentity *peer,
   memcpy (&aa[1], plugin_addr, plugin_addr_len);
   memcpy (aa->plugin, plugin_name, strlen (plugin_name) + 1);
   aa->session_id = session_id;
-  aa->active = GNUNET_NO;
-  aa->used = GNUNET_NO;
-  aa->solver_information = NULL;
-  aa->assigned_bw_in = 0;
-  aa->assigned_bw_out = 0;
 
   return aa;
 }
@@ -2250,7 +2218,7 @@ enforce_add_address (struct GNUNET_ATS_TEST_Operation *op)
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Adding address %u for peer %u in network `%s'\n",
     op->address_id, op->peer_id, GNUNET_ATS_print_network_type(a->network));
 
-  sh->env.sf.s_add (sh->solver, a->ats_addr, op->address_network);
+  sh->sf->s_add (sh->sf->cls, a->ats_addr, op->address_network);
 
 }
 
@@ -2292,7 +2260,7 @@ enforce_del_address (struct GNUNET_ATS_TEST_Operation *op)
               op->address_id,
               op->peer_id);
 
-  sh->env.sf.s_del (sh->solver, a->ats_addr, GNUNET_NO);
+  sh->sf->s_del (sh->sf->cls, a->ats_addr);
 
   if (NULL != l)
   {
@@ -2423,7 +2391,6 @@ static void
 enforce_start_request (struct GNUNET_ATS_TEST_Operation *op)
 {
   struct TestPeer *p;
-  const struct ATS_Address *res;
 
   if (NULL == (p = find_peer_by_id (op->peer_id)))
   {
@@ -2437,18 +2404,10 @@ enforce_start_request (struct GNUNET_ATS_TEST_Operation *op)
       op->peer_id);
   p->is_requested = GNUNET_YES;
 
-  res = sh->env.sf.s_get (sh->solver, &p->peer_id);
-  if (NULL != res)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Suggested address for peer %u: %llu %llu\n",
-        op->peer_id,
-        res->assigned_bw_in,
-        res->assigned_bw_out);
-    if (NULL != l)
-      GNUNET_ATS_solver_logging_now (l);
-  }
+  sh->sf->s_get (sh->sf->cls, &p->peer_id);
 }
 
+
 static void
 enforce_stop_request (struct GNUNET_ATS_TEST_Operation *op)
 {
@@ -2462,14 +2421,13 @@ enforce_stop_request (struct GNUNET_ATS_TEST_Operation *op)
     return;
   }
 
-
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stop requesting address for peer %u\n",
-      op->peer_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Stop requesting address for peer %u\n",
+              op->peer_id);
   p->is_requested = GNUNET_NO;
   p->assigned_bw_in = 0;
   p->assigned_bw_out = 0;
-  sh->env.sf.s_get_stop (sh->solver, &p->peer_id);
+  sh->sf->s_get_stop (sh->sf->cls, &p->peer_id);
 
   if (NULL != l)
   {
@@ -2530,10 +2488,12 @@ static void enforce_episode (struct Episode *ep)
   }
 }
 
+
 static void
-timeout_episode (void *cls, const struct GNUNET_SCHEDULER_TaskContext* tc)
+timeout_episode (void *cls)
 {
   struct Experiment *e = cls;
+
   e->episode_timeout_task = NULL;
   if (NULL != e->ep_done_cb)
     e->ep_done_cb (e->cur);
@@ -2755,16 +2715,19 @@ GNUNET_ATS_solvers_solver_stop (struct SolverHandle *sh)
 {
  GNUNET_STATISTICS_destroy ((struct GNUNET_STATISTICS_Handle *) sh->env.stats,
      GNUNET_NO);
- GNUNET_PLUGIN_unload (sh->plugin, sh->solver);
-
+ GNUNET_PLUGIN_unload (sh->plugin, sh->sf);
+ sh->sf = NULL;
  GAS_normalization_stop();
 
- GNUNET_CONTAINER_multipeermap_iterate (sh->addresses, &free_all_it, NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (sh->addresses,
+                                        &free_all_it,
+                                        NULL);
  GNUNET_CONTAINER_multipeermap_destroy(sh->addresses);
  GNUNET_free (sh->plugin);
  GNUNET_free (sh);
 }
 
+
 /**
  * Load quotas for networks from configuration
  *
@@ -3048,27 +3011,8 @@ get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
     return p->pref_abs;
   }
   else
-    return GAS_normalization_get_preferences_by_peer (NULL,
-                                                     id);
-}
-
-
-const double *
-get_property_cb (void *cls, const struct ATS_Address *address)
-{
-  struct TestPeer *p;
-  struct TestAddress *a;
-
-  if (GNUNET_YES == opt_disable_normalization)
-  {
-    p = find_peer_by_pid (&address->peer);
-    if (NULL == p)
-      return NULL;
-    a = find_address_by_ats_address (p, address);
-    return a->prop_abs;
-  }
-  return GAS_normalization_get_properties (NULL,
-                                          address);
+    return GAS_preference_get_by_peer (NULL,
+                                       id);
 }
 
 
@@ -3077,7 +3021,6 @@ GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
 {
   struct SolverHandle *sh;
   char * solver_str;
-  int c;
 
   switch (type) {
     case GNUNET_ATS_SOLVER_PROPORTIONAL:
@@ -3096,8 +3039,9 @@ GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
   }
 
   sh = GNUNET_new (struct SolverHandle);
-  GNUNET_asprintf (&sh->plugin, "libgnunet_plugin_ats_%s", solver_str);
-
+  GNUNET_asprintf (&sh->plugin,
+                   "libgnunet_plugin_ats_%s",
+                   solver_str);
   sh->addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
 
   /* setup environment */
@@ -3106,15 +3050,9 @@ GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
   sh->env.addresses = sh->addresses;
   sh->env.bandwidth_changed_cb = &solver_bandwidth_changed_cb;
   sh->env.get_preferences = &get_preferences_cb;
-  sh->env.get_property = &get_property_cb;
   sh->env.network_count = GNUNET_ATS_NetworkTypeCount;
   sh->env.info_cb = &solver_info_cb;
-  sh->env.info_cb_cls = NULL;
   sh->env.network_count = GNUNET_ATS_NetworkTypeCount;
-  int networks[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
-  for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++)
-    sh->env.networks[c] = networks[c];
-
 
   /* start normalization */
   GAS_normalization_start ();
@@ -3130,8 +3068,8 @@ GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
     return NULL;
   }
 
-  sh->solver = GNUNET_PLUGIN_load (sh->plugin, &sh->env);
-  if (NULL == sh->solver)
+  sh->sf = GNUNET_PLUGIN_load (sh->plugin, &sh->env);
+  if (NULL == sh->sf)
   {
     fprintf (stderr, "Failed to load solver `%s'\n", sh->plugin);
     GNUNET_break(0);
@@ -3143,6 +3081,7 @@ GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
   return sh;
 }
 
+
 static void
 done ()
 {