[GNUnet-SVN] r33108 - gnunet/src/ats

[gnunet]

Author: wachs
Date: 2014-04-17 18:40:30 +0200 (Thu, 17 Apr 2014)
New Revision: 33108

Modified:
   gnunet/src/ats/gnunet-ats-solver-eval.c
Log:
fix normalization logging


Modified: gnunet/src/ats/gnunet-ats-solver-eval.c
===================================================================
--- gnunet/src/ats/gnunet-ats-solver-eval.c     2014-04-17 14:16:38 UTC (rev 
33107)
+++ gnunet/src/ats/gnunet-ats-solver-eval.c     2014-04-17 16:40:30 UTC (rev 
33108)
@@ -38,6 +38,9 @@
 static struct TestPeer *peer_head;
 static struct TestPeer *peer_tail;
 
+static double default_properties[GNUNET_ATS_PropertyCount];
+static double default_preferences[GNUNET_ATS_PreferenceCount];
+
 /**
  * cmd option -e: experiment file
  */
@@ -149,7 +152,7 @@
 
 
 static struct TestAddress *
-find_address_by_ats_address (struct TestPeer *p, struct ATS_Address *addr)
+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)
@@ -307,9 +310,8 @@
   for (lts = l->head; NULL != lts; lts = lts->next)
   {
 
-    fprintf (stderr, "Log step %llu %llu: \n",
-        (long long unsigned int) lts->timestamp.abs_value_us,
-        (long long unsigned int) lts->delta.rel_value_us);
+    fprintf (stderr, "Writing log step %llu\n",
+        (long long unsigned int) lts->timestamp.abs_value_us);
 
     for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
     {
@@ -324,11 +326,13 @@
           cur->aid = log_a->aid;
           cur->pid = log_p->id;
 
-          fprintf (stderr, "Add logging for %i %i: \n",
-              cur->pid, cur->aid);
-
           GNUNET_asprintf (&filename, "%s_%s_%u_%u_%llu.log", e->log_prefix, 
opt_solver,
               cur->aid, cur->pid, l->head->timestamp.abs_value_us);
+
+          fprintf (stderr, "Add writing log data for %i %i to file `%s'\n",
+              cur->pid, cur->aid, filename);
+
+
           cur->f_hd = GNUNET_DISK_file_open (filename,
               GNUNET_DISK_OPEN_READWRITE |
               GNUNET_DISK_OPEN_CREATE |
@@ -364,25 +368,30 @@
         prefstring = GNUNET_strdup("");
         for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
         {
+          /*
           fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n",
               GNUNET_ATS_print_preference_type(c),
               log_p->pref_abs[c], log_p->pref_norm[c]);
+           */
+          GNUNET_asprintf(&prefstring_tmp,"%s|%.3f|%.3f",
+              prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
 
-          GNUNET_asprintf(&prefstring_tmp,"%s;%.3f;%.3f",
-              prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
+
           GNUNET_free (prefstring);
           prefstring = GNUNET_strdup(prefstring_tmp);
           GNUNET_free (prefstring_tmp);
         }
 
+
         propstring = GNUNET_strdup("");
         for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
         {
           if (GNUNET_ATS_NETWORK_TYPE == c)
             continue;
+          /*
           fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
               GNUNET_ATS_print_property_type(c),
-              log_a->prop_abs[c], log_a->prop_norm[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]);
           GNUNET_free (propstring);
@@ -390,14 +399,14 @@
           GNUNET_free (propstring_tmp);
         }
 
-
-        GNUNET_asprintf(&datastring,"%llu;%u;%i;%u;%u;%s\n",
+        GNUNET_asprintf(&datastring,"%llu;%u;%i;%u;%u;%s;%s\n",
             lts->timestamp.abs_value_us,
             log_a->network,
             log_a->active,
             ntohl (log_a->assigned_bw_in.value__),
             ntohl (log_a->assigned_bw_out.value__),
             propstring, prefstring);
+
         GNUNET_DISK_file_write (cur->f_hd, datastring, strlen(datastring));
         GNUNET_free (datastring);
         GNUNET_free (prefstring);
@@ -578,7 +587,7 @@
   struct PropertyGenerator *pg = cls;
   struct TestPeer *p;
   struct TestAddress *a;
-  double pref_value;
+  double prop_value;
   struct GNUNET_ATS_Information atsi;
 
   pg->set_task = GNUNET_SCHEDULER_NO_TASK;
@@ -605,22 +614,25 @@
         pg->peer);
   }
 
-  pref_value = get_property (pg);
-  a->prop_abs[pg->ats_property] = pref_value;
+  prop_value = get_property (pg);
+  a->prop_abs[pg->ats_property] = prop_value;
 
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
       "Setting property for peer [%u] address [%u] for %s to %f\n",
       pg->peer, pg->address_id,
-      GNUNET_ATS_print_property_type (pg->ats_property), pref_value);
+      GNUNET_ATS_print_property_type (pg->ats_property), prop_value);
 
   atsi.type = htonl (pg->ats_property);
-  atsi.value = htonl ((uint32_t) pref_value);
+  atsi.value = htonl ((uint32_t) prop_value);
 
   /* set performance here! */
   sh->env.sf.s_bulk_start (sh->solver);
   if (GNUNET_YES == opt_disable_normalization)
   {
-    GNUNET_break (0);
+    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,
+        pg->ats_property, prop_value, prop_value);
   }
   else
     GAS_normalization_normalize_property (sh->addresses,
@@ -866,7 +878,9 @@
   sh->env.sf.s_bulk_start (sh->solver);
   if (GNUNET_YES == opt_disable_normalization)
   {
-    GNUNET_break (0);
+    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);
   }
   else
     GAS_normalization_normalize_preference (NULL + (pg->client_id),
@@ -2053,12 +2067,19 @@
 {
   struct TestPeer *p;
   struct TestAddress *a;
+  int c;
 
   if (NULL == (p = find_peer_by_id (op->peer_id)))
   {
     p = GNUNET_new (struct TestPeer);
     p->id = op->peer_id;
     memset (&p->peer_id, op->peer_id, sizeof (p->peer_id));
+    for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
+    {
+      p->pref_abs[c] = DEFAULT_ABS_PREFERENCE;
+      p->pref_norm[c] = DEFAULT_REL_PREFERENCE;
+    }
+
     GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, p);
   }
 
@@ -2077,6 +2098,9 @@
   memset (&p->peer_id, op->peer_id, sizeof (p->peer_id));
   GNUNET_CONTAINER_DLL_insert (p->addr_head, p->addr_tail, a);
 
+  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
+    a->prop_norm[c] = DEFAULT_REL_QUALITY;
+
   GNUNET_CONTAINER_multipeermap_put (sh->addresses, &p->peer_id, a->ats_addr,
     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 
@@ -2771,11 +2795,12 @@
 const double *
 get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
 {
-
+  struct TestPeer *p;
   if (GNUNET_YES == opt_disable_normalization)
   {
-    GNUNET_break (0);
-    return NULL;
+    if (NULL == (p = find_peer_by_pid (id)))
+      return NULL;
+    return p->pref_abs;
   }
   else
     return GAS_normalization_get_preferences_by_peer (id);
@@ -2785,10 +2810,14 @@
 const double *
 get_property_cb (void *cls, const struct ATS_Address *address)
 {
+  struct TestPeer *p;
+  struct TestAddress *a;
+
   if (GNUNET_YES == opt_disable_normalization)
   {
-    GNUNET_break (0);
-    return NULL;
+    p = find_peer_by_pid (&address->peer);
+    a = find_address_by_ats_address (p, address);
+    return a->prop_abs;
   }
   else
     return GAS_normalization_get_properties ((struct ATS_Address *) address);
@@ -2812,7 +2841,7 @@
     return;
   }
   a->prop_norm[type] = prop_rel;
-  sh->env.sf.s_address_update_property (sh->solver, address, type, 0, 
prop_rel);
+  sh->env.sf.s_address_update_property (sh->solver, address, type, a->prop_abs 
[type], prop_rel);
 }
 
 
@@ -3041,6 +3070,7 @@
     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   enum GNUNET_ATS_Solvers solver;
+  int c;
 
   if (NULL == opt_exp_file)
   {
@@ -3078,6 +3108,12 @@
     return;
   }
 
+  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
+    default_properties[c] = DEFAULT_REL_QUALITY;
+
+  for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
+    default_preferences[c] = DEFAULT_REL_PREFERENCE;
+
   /* load experiment */
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Loading experiment\n");
   e = GNUNET_ATS_solvers_experimentation_load (opt_exp_file);