big ATS refactoring, no serious semantic changes should stem from this

1 files changed, 34 insertions, 696 deletions

diff --git a/src/ats/gnunet-service-ats_normalization.c b/src/ats/gnunet-service-ats_normalization.c
index b4051c9fa..7003f69e4 100644
--- a/src/ats/gnunet-service-ats_normalization.c
+++ b/src/ats/gnunet-service-ats_normalization.c
@@ -23,116 +23,18 @@
  * @brief ats service address: management of ATS properties and preferences normalization
  * @author Matthias Wachs
  * @author Christian Grothoff
+ *
+ * FIXME: rename to 'properties'!
  */
 #include "platform.h"
 #include "gnunet_ats_service.h"
 #include "gnunet-service-ats_addresses.h"
 #include "gnunet-service-ats_normalization.h"
+#include "gnunet-service-ats_plugins.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "ats-normalization",__VA_ARGS__)
 
-/**
- * Preference client
- */
-struct PreferenceClient
-{
-  /**
-   * Next in DLL
-   */
-  struct PreferenceClient *prev;
-
-  /**
-   * Next in DLL
-   */
-
-  struct PreferenceClient *next;
-
-  /**
-   * Client handle
-   */
-  void *client;
-
-  /**
-   * Array of sum of absolute preferences for this client
-   */
-  double f_abs_sum[GNUNET_ATS_PreferenceCount];
-
-  /**
-   * Array of sum of relative preferences for this client
-   */
-  double f_rel_sum[GNUNET_ATS_PreferenceCount];
-
-  /**
-   * List of peer preferences for this client
-   */
-
-  /**
-   * Head of peer list
-   */
-  struct PreferencePeer *p_head;
-
-  /**
-   * Tail of peer list
-   */
-  struct PreferencePeer *p_tail;
-};
-
-/**
- * Preference peer
- */
-struct PreferencePeer
-{
-  /**
-   * Next in DLL
-   */
-  struct PreferencePeer *next;
-
-  /**
-   * Previous in DLL
-   */
-  struct PreferencePeer *prev;
-
-  /**
-   * Client
-   */
-  struct PreferenceClient *client;
-
-  /**
-   * Peer id
-   */
-  struct GNUNET_PeerIdentity id;
 
-  /**
-   * Absolute preference values for all preference types
-   */
-  double f_abs[GNUNET_ATS_PreferenceCount];
-
-  /**
-   * Relative preference values for all preference types
-   */
-  double f_rel[GNUNET_ATS_PreferenceCount];
-
-  /**
-   * Absolute point of time of next aging process
-   */
-  struct GNUNET_TIME_Absolute next_aging[GNUNET_ATS_PreferenceCount];
-};
-
-/**
- * Relative preferences for a peer
- */
-struct PeerRelative
-{
-  /**
-   * Relative preference values
-   */
-  double f_rel[GNUNET_ATS_PreferenceCount];
-
-  /**
-   * Peer id
-   */
-  struct GNUNET_PeerIdentity id;
-};
 
 /**
  * Quality Normalization
@@ -147,490 +49,27 @@ struct Property
 
 static struct Property properties[GNUNET_ATS_QualityPropertiesCount];
 
-
-/**
- * Callback to call on changing preference values
- */
-static GAS_Normalization_preference_changed_cb pref_changed_cb;
-
-/**
- * Closure for callback to call on changing preference values
- */
-static void *pref_changed_cb_cls;
-
-/**
- * Callback to call on changing property values
- */
-static GAS_Normalization_property_changed_cb prop_ch_cb;
-
-/**
- * Closure for callback to call on changing property values
- */
-static void *prop_ch_cb_cls;
-
-/**
- * Hashmap to store peer information for preference normalization
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *preference_peers;
-
 /**
  * Hashmap to store peer information for property normalization
  * FIXME: this map is not used!
  */
 static struct GNUNET_CONTAINER_MultiPeerMap *property_peers;
 
-/**
- * Clients in DLL: head
- */
-static struct PreferenceClient *pc_head;
-
-/**
- * Clients in DLL: tail
- */
-static struct PreferenceClient *pc_tail;
-
-/**
- * Default values
- */
-static struct PeerRelative defvalues;
-
-static struct GNUNET_SCHEDULER_Task * aging_task;
-
-
-/**
- * Update a peer
- *
- * @param id peer id
- * @param kind the kind
- * @param rp the relative peer struct
- * @return the new relative preference
- */
-static void
-update_relative_values_for_peer (const struct GNUNET_PeerIdentity *id,
-    enum GNUNET_ATS_PreferenceKind kind, struct PeerRelative *rp)
-{
-  struct PreferenceClient *c_cur;
-  struct PreferencePeer *p_cur;
-  double f_rel_total;
-  double f_rel_sum;
-  double backup;
-  unsigned int peer_count;
-
-  f_rel_sum = 0.0;
-  f_rel_total = 0.0;
-  peer_count = 0;
-
-  /* For all clients */
-  for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
-  {
-    /* For peer entries with this id */
-    for (p_cur = c_cur->p_head; NULL != p_cur; p_cur = p_cur->next)
-    {
-      f_rel_sum += p_cur->f_rel[kind];
-      if (0 == memcmp (id, &p_cur->id, sizeof(struct GNUNET_PeerIdentity)))
-      {
-        peer_count ++;
-        f_rel_total += p_cur->f_rel[kind];
-      }
-
-    }
-  }
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "%u clients have a total relative preference for peer `%s' `%s' of %.3f and for %s in total %.3f\n",
-      peer_count, GNUNET_i2s (id),
-      GNUNET_ATS_print_preference_type (kind),
-      f_rel_total,
-      GNUNET_ATS_print_preference_type (kind),
-      f_rel_sum);
-
-  /* Find entry for the peer containing relative values in the hashmap */
-  if (NULL != rp)
-  {
-    backup = rp->f_rel[kind];
-    if (f_rel_sum > 0)
-      rp->f_rel[kind] = f_rel_total / f_rel_sum;
-    else
-    {
-      /* No client had any preferences for this type and any peer */
-      rp->f_rel[kind] = DEFAULT_REL_PREFERENCE;
-    }
-    if ((backup != rp->f_rel[kind]) && (NULL != pref_changed_cb))
-    {
-      pref_changed_cb (pref_changed_cb_cls, &rp->id, kind, rp->f_rel[kind]);
-    }
-  }
-}
-
-
-/**
- * Recalculate preference for a specific ATS property
- *
- * @param c the preference client
- * @param kind the preference kind
- * @return the result
- */
-static void
-recalculate_relative_preferences (struct PreferenceClient *c,
-                                  enum GNUNET_ATS_PreferenceKind kind)
-{
-  struct PreferencePeer *p_cur;
-
-  /* For this client: sum of absolute preference values for this preference */
-  c->f_abs_sum[kind] = 0.0;
-  /* For this client: sum of relative preference values for this preference
-   *
-   * Note: this value should also be 1.0, but:
-   * if no preferences exist due to aging, this value can be 0.0
-   * and the client can be removed */
-  c->f_rel_sum[kind] = 0.0;
-
-  for (p_cur = c->p_head; NULL != p_cur; p_cur = p_cur->next)
-    c->f_abs_sum[kind] += p_cur->f_abs[kind];
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Client %p has sum of total preferences for %s of %.3f\n",
-      c->client, GNUNET_ATS_print_preference_type (kind), c->f_abs_sum[kind]);
-
-  /* For all peers: calculate relative preference */
-  for (p_cur = c->p_head; NULL != p_cur; p_cur = p_cur->next)
-  {
-    /* Calculate relative preference for specific kind */
-
-    /* Every application has a preference for each peer between
-     * [0 .. 1] in relative values
-     * and [0 .. inf] in absolute values */
-    p_cur->f_rel[kind] =  p_cur->f_abs[kind] / c->f_abs_sum[kind];
-    c->f_rel_sum[kind] += p_cur->f_rel[kind];
-
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Client %p has relative preference for %s for peer `%s' of %.3f\n",
-        c->client,
-        GNUNET_ATS_print_preference_type (kind),
-        GNUNET_i2s (&p_cur->id),
-        p_cur->f_rel[kind]);
-  }
-
-}
-
-
-/**
- * Update the absolute preference value for a peer
- * @param c the client
- * @param p the peer
- * @param kind the preference kind
- * @param score_abs the absolute value
- * @return the new relative preference value
- */
-static void
-update_abs_preference (struct PreferenceClient *c,
-                       struct PreferencePeer *p,
-                       enum GNUNET_ATS_PreferenceKind kind,
-                       float score_abs)
-{
-  double score = score_abs;
-
-  /* Update preference value according to type */
-  switch (kind)
-  {
-  case GNUNET_ATS_PREFERENCE_BANDWIDTH:
-  case GNUNET_ATS_PREFERENCE_LATENCY:
-    p->f_abs[kind] = score;
-    /* p->f_abs[kind] = (p->f_abs[kind] + score) / 2;  */
-    p->next_aging[kind] = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
-        PREF_AGING_INTERVAL);
-    break;
-  case GNUNET_ATS_PREFERENCE_END:
-    break;
-  default:
-    break;
-  }
-}
-
-
-static int
-update_iterator (void *cls,
-                 const struct GNUNET_PeerIdentity *key,
-                 void *value)
-{
-  enum GNUNET_ATS_PreferenceKind *kind = cls;
-  struct PeerRelative *pr = value;
-
-  update_relative_values_for_peer (key,
-                                   (*kind),
-                                   pr);
-  return GNUNET_OK;
-}
-
-
-static void
-run_preference_update (struct PreferenceClient *c_cur,
-                       struct PreferencePeer *p_cur,
-                       enum GNUNET_ATS_PreferenceKind kind,
-                       float score_abs)
-{
-  double old_value;
 
-  /* Update relative value */
-  old_value = p_cur->f_rel[kind];
-  recalculate_relative_preferences (c_cur, kind);
-  if (p_cur->f_rel[kind] == old_value)
-    return;
-
-  /* Relative preference value changed, recalculate for all peers */
-  GNUNET_CONTAINER_multipeermap_iterate (preference_peers, &update_iterator, &kind);
-}
-
-
-/**
- * Reduce absolute preferences since they got old
- *
- * @param cls the PreferencePeer
- * @param tc context
- */
-static void
-preference_aging (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct PreferencePeer *p;
-  struct PreferenceClient *cur_client;
-  int i;
-  int values_to_update;
-  double backup;
-
-  aging_task = NULL;
-  values_to_update = 0;
-  cur_client = NULL;
-
-  for (cur_client = pc_head; NULL != cur_client; cur_client = cur_client->next)
-  {
-    for (p = cur_client->p_head; NULL != p; p = p->next)
-    {
-      /* Aging absolute values: */
-      for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
-      {
-        if (0
-            == GNUNET_TIME_absolute_get_remaining (p->next_aging[i]).rel_value_us)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-              "Aging preference for peer `%s'\n", GNUNET_i2s (&p->id));
-          backup = p->f_abs[i];
-          if (p->f_abs[i] > DEFAULT_ABS_PREFERENCE)
-            p->f_abs[i] *= PREF_AGING_FACTOR;
-
-          if (p->f_abs[i] <= DEFAULT_ABS_PREFERENCE + PREF_EPSILON)
-            p->f_abs[i] = DEFAULT_ABS_PREFERENCE;
-
-          if ( (p->f_abs[i] != DEFAULT_ABS_PREFERENCE) &&
-               (backup != p->f_abs[i]) )
-          {
-            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                "Aged preference for peer `%s' from %.3f to %.3f\n",
-                GNUNET_i2s (&p->id), backup, p->f_abs[i]);
-
-            run_preference_update(cur_client, p, i, p->f_abs[i]);
-
-            p->next_aging[i] = GNUNET_TIME_absolute_add (
-                GNUNET_TIME_absolute_get (), PREF_AGING_INTERVAL);
-            values_to_update++;
-          }
-        }
-      }
-    }
-  }
-
-  if (values_to_update > 0)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-        "Rescheduling aging task due to %u elements to age\n",
-        values_to_update);
-    aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
-        &preference_aging, NULL );
-  }
-  else
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-        "No values to age left, not rescheduling aging task\n");
-
-}
-
-
-/**
- * Normalize an updated preference value
- *
- * @param client the client with this preference
- * @param peer the peer to change the preference for
- * @param kind the kind to change the preference
- * @param score_abs the normalized score
- */
-void
-GAS_normalization_normalize_preference (void *client,
-                                        const struct GNUNET_PeerIdentity *peer,
-                                        enum GNUNET_ATS_PreferenceKind kind,
-                                        float score_abs)
-{
-  struct PreferenceClient *c_cur;
-  struct PreferencePeer *p_cur;
-  struct PeerRelative *r_cur;
-  double old_value;
-  int i;
-
-  GNUNET_assert(NULL != client);
-  GNUNET_assert(NULL != peer);
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Client %p changes preference for peer `%s' for `%s' to %.2f\n",
-      client,
-      GNUNET_i2s (peer),
-      GNUNET_ATS_print_preference_type (kind),
-      score_abs);
-
-  if (kind >= GNUNET_ATS_PreferenceCount)
-  {
-    GNUNET_break(0);
-    return;
-  }
-
-  /* Find preference client */
-  for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
-  {
-    if (client == c_cur->client)
-      break;
-  }
-  /* Not found: create new preference client */
-  if (NULL == c_cur)
-  {
-    c_cur = GNUNET_new (struct PreferenceClient);
-    c_cur->client = client;
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
-    {
-      c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
-      c_cur->f_rel_sum[i] = DEFAULT_REL_PREFERENCE;
-    }
-
-    GNUNET_CONTAINER_DLL_insert(pc_head, pc_tail, c_cur);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding new client %p \n", c_cur);
-  }
-
-  /* Find entry for peer */
-  for (p_cur = c_cur->p_head; NULL != p_cur; p_cur = p_cur->next)
-    if (0 == memcmp (&p_cur->id, peer, sizeof(p_cur->id)))
-      break;
-
-  /* Not found: create new peer entry */
-  if (NULL == p_cur)
-  {
-    p_cur = GNUNET_new (struct PreferencePeer);
-    p_cur->client = c_cur;
-    p_cur->id = (*peer);
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
-    {
-      /* Default value per peer absolute preference for a preference: 0 */
-      p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
-      /* Default value per peer relative preference for a quality: 1.0 */
-      p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
-      p_cur->next_aging[i] = GNUNET_TIME_UNIT_FOREVER_ABS;
-    }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding new peer %p for client %p \n",
-        p_cur, c_cur);
-    GNUNET_CONTAINER_DLL_insert(c_cur->p_head, c_cur->p_tail, p_cur);
-  }
-
-  /* Create struct for peer */
-  if (NULL == GNUNET_CONTAINER_multipeermap_get (preference_peers, peer))
-  {
-    r_cur = GNUNET_new (struct PeerRelative);
-    r_cur->id = (*peer);
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
-      r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
-    GNUNET_assert(
-        GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (preference_peers,
-            &r_cur->id, r_cur, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  }
-
-  /* Update absolute value */
-  old_value = p_cur->f_abs[kind];
-  update_abs_preference (c_cur, p_cur, kind, score_abs);
-  if (p_cur->f_abs[kind] == old_value)
-    return;
-
-  run_preference_update (c_cur, p_cur, kind, score_abs);
-
-  /* Start aging task */
-  if (NULL == aging_task)
-    aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
-        &preference_aging, NULL );
-
-}
-
-
-/**
- * Get the normalized preference values for a specific peer or
- * the default values if
- *
- * @param id the peer
- * @return pointer to the values, can be indexed with GNUNET_ATS_PreferenceKind,
- * default preferences if peer does not exist
- */
-const double *
-GAS_normalization_get_preferences_by_peer (const struct GNUNET_PeerIdentity *id)
-{
-  GNUNET_assert(NULL != preference_peers);
-  GNUNET_assert(NULL != id);
-
-  struct PeerRelative *rp;
-  if (NULL == (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers, id)))
-  {
-    return defvalues.f_rel;
-  }
-  return rp->f_rel;
-}
-
-
-/**
- * Get the normalized preference values for a specific client and peer
- *
- * @param client client
- * @param peer the peer
- * @param pref the preference type
- * @return the value
- */
-double
-GAS_normalization_get_preferences_by_client (const void *client,
-                                             const struct GNUNET_PeerIdentity *peer,
-                                             enum GNUNET_ATS_PreferenceKind pref)
-{
-  struct PreferenceClient *c_cur;
-  struct PreferencePeer *p_cur;
-
-  /* Find preference client */
-  for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
-  {
-    if (client == c_cur->client)
-      break;
-  }
-  if (NULL == c_cur)
-    return -1.0;
-
-  for (p_cur = c_cur->p_head; NULL != p_cur; p_cur = p_cur->next)
-  {
-    if (0 == memcmp (peer, &p_cur->id, sizeof (struct GNUNET_PeerIdentity)))
-      break;
-  }
-  if (NULL == p_cur)
-    return DEFAULT_REL_PREFERENCE; /* Not found, return default */
-
-  return p_cur->f_rel[pref];
-}
 
 
 /**
  * Get the normalized properties values for a specific peer or
  * the default values if
  *
+ * @param cls ignored
  * @param address the address
  * @return pointer to the values, can be indexed with GNUNET_ATS_PreferenceKind,
  * default preferences if peer does not exist
  */
 const double *
-GAS_normalization_get_properties (const struct ATS_Address *address)
+GAS_normalization_get_properties (void *cls,
+                                  const struct ATS_Address *address)
 {
   static double norm_values[GNUNET_ATS_QualityPropertiesCount];
   int i;
@@ -742,7 +181,9 @@ find_min_max_it (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
 
 
 static int
-normalize_address (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
+normalize_address (void *cls,
+                   const struct GNUNET_PeerIdentity *h, 
+                   void *k)
 {
   struct Property *p = cls;
   struct ATS_Address *address = k;
@@ -769,9 +210,9 @@ normalize_address (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
       address->atsin[p->prop_type].avg, p->min, p->max,
       address->atsin[p->prop_type].norm);
 
-  if (NULL != prop_ch_cb)
-    prop_ch_cb (prop_ch_cb_cls, address, p->atsi_type,
-        address->atsin[p->prop_type].norm);
+  GAS_normalized_property_changed (address, 
+                                   p->atsi_type,
+                                   address->atsin[p->prop_type].norm);
 
   return GNUNET_OK;
 }
@@ -781,14 +222,14 @@ normalize_address (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
  * Normalize avg_value to a range of values between [1.0, 2.0]
  * based on min max values currently known.
  *
- * @param addresses the address hashmap
  * @param p the property
  * @param address the address
  * @param avg_value the value to normalize
  */
 static void
-property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
-    struct Property *p, struct ATS_Address *address, uint32_t avg_value)
+property_normalize (struct Property *p, 
+                    struct ATS_Address *address, 
+                    uint32_t avg_value)
 {
   struct FindMinMaxCtx find_ctx;
   int addr_count;
@@ -797,8 +238,9 @@ property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
   find_ctx.p = p;
   find_ctx.max = 0;
   find_ctx.min = UINT32_MAX;
-  addr_count = GNUNET_CONTAINER_multipeermap_iterate (addresses,
-      &find_min_max_it, &find_ctx);
+  addr_count = GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                                      &find_min_max_it, 
+                                                      &find_ctx);
   if (0 == addr_count)
   {
     GNUNET_break(0);
@@ -808,19 +250,21 @@ property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
   limits_changed = GNUNET_NO;
   if (find_ctx.max != p->max)
   {
-    LOG(GNUNET_ERROR_TYPE_DEBUG,
-        "Normalizing %s: new maximum %u -> recalculate all values\n",
-        GNUNET_ATS_print_property_type (p->atsi_type), find_ctx.max);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Normalizing %s: new maximum %u -> recalculate all values\n",
+         GNUNET_ATS_print_property_type (p->atsi_type), 
+         find_ctx.max);
     p->max = find_ctx.max;
     limits_changed = GNUNET_YES;
   }
 
   if ((find_ctx.min != p->min) && (find_ctx.min < p->max))
   {
-    LOG(GNUNET_ERROR_TYPE_DEBUG,
-        "Normalizing %s: new minimum %u -> recalculate all values\n",
-        GNUNET_ATS_print_property_type (p->atsi_type), find_ctx.min,
-        find_ctx.max);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Normalizing %s: new minimum %u -> recalculate all values\n",
+         GNUNET_ATS_print_property_type (p->atsi_type),
+         find_ctx.min,
+         find_ctx.max);
     p->min = find_ctx.min;
     limits_changed = GNUNET_YES;
   }
@@ -835,13 +279,13 @@ property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
   {
     /* normalize just this  address */
     normalize_address (p, &address->peer, address);
-    return;
   }
   else
   {
     /* limits changed, normalize all addresses */
-    GNUNET_CONTAINER_multipeermap_iterate (addresses, &normalize_address, p);
-    return;
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &normalize_address, 
+                                           p);
   }
 }
 
@@ -849,14 +293,12 @@ property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
 /**
  * Update and normalize atsi performance information
  *
- * @param addresses hashmap containing all addresses
  * @param address the address to update
  * @param atsi the array of performance information
  * @param atsi_count the number of atsi information in the array
  */
 void
-GAS_normalization_normalize_property (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
-                                      struct ATS_Address *address,
+GAS_normalization_normalize_property (struct ATS_Address *address,
                                       const struct GNUNET_ATS_Information *atsi,
                                       uint32_t atsi_count)
 {
@@ -867,9 +309,6 @@ GAS_normalization_normalize_property (struct GNUNET_CONTAINER_MultiPeerMap *addr
   uint32_t current_val;
   unsigned int existing_properties[] = GNUNET_ATS_QualityProperties;
 
-  GNUNET_assert (NULL != address);
-  GNUNET_assert (NULL != atsi);
-
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Updating %u elements for peer `%s'\n",
        atsi_count,
@@ -901,70 +340,22 @@ GAS_normalization_normalize_property (struct GNUNET_CONTAINER_MultiPeerMap *addr
     /* Normalizing */
     /* Check min, max */
     cur_prop = &properties[c2];
-    property_normalize (addresses, cur_prop, address, current_val);
+    property_normalize (cur_prop, address, current_val);
   }
 }
 
 
-static void
-free_client (struct PreferenceClient *pc)
-{
-  struct PreferencePeer *next_p;
-  struct PreferencePeer *p;
-  next_p = pc->p_head;
-  while (NULL != (p = next_p))
-  {
-    next_p = p->next;
-    GNUNET_CONTAINER_DLL_remove(pc->p_head, pc->p_tail, p);
-    GNUNET_free(p);
-  }
-  GNUNET_free(pc);
-}
-
-
-/**
- * A performance client disconnected
- *
- * @param client the client
- */
-void
-GAS_normalization_preference_client_disconnect (void *client)
-{
-  struct PreferenceClient *c_cur;
-  /* Find preference client */
-
-  for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
-  {
-    if (client == c_cur->client)
-      break;
-  }
-  if (NULL == c_cur)
-    return;
-
-  GNUNET_CONTAINER_DLL_remove(pc_head, pc_tail, c_cur);
-  free_client (c_cur);
-}
-
 
 /**
  * Start the normalization component
- *
- * @param pref_ch_cb callback to call on relative preference changing
- * @param pref_ch_cb_cls cls for the preference callback
- * @param property_ch_cb callback to call on relative property changing
- * @param property_ch_cb_cls cls for the property callback
  */
 void
-GAS_normalization_start (GAS_Normalization_preference_changed_cb pref_ch_cb,
-    void *pref_ch_cb_cls, GAS_Normalization_property_changed_cb property_ch_cb,
-    void *property_ch_cb_cls)
+GAS_normalization_start ()
 {
   int c1;
-  int i;
-  preference_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
-  property_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
   unsigned int existing_properties[] = GNUNET_ATS_QualityProperties;
 
+  property_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
   for (c1 = 0; c1 < GNUNET_ATS_QualityPropertiesCount; c1++)
   {
     properties[c1].prop_type = c1;
@@ -972,42 +363,9 @@ GAS_normalization_start (GAS_Normalization_preference_changed_cb pref_ch_cb,
     properties[c1].min = 0;
     properties[c1].max = 0;
   }
-
-  pref_changed_cb = pref_ch_cb;
-  pref_changed_cb_cls = pref_ch_cb_cls;
-  prop_ch_cb = property_ch_cb;
-  prop_ch_cb_cls = pref_ch_cb_cls;
-
-  pc_head = NULL;
-  pc_tail = NULL;
-
-  for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
-    defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
-  aging_task = NULL;
-  return;
 }
 
 
-/**
- * Free a peer
- *
- * @param cls unused
- * @param key the key
- * @param value RelativePeer
- * @return #GNUNET_OK to continue
- */
-static int
-free_peer (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
-{
-  struct PeerRelative *rp = value;
-  if (GNUNET_YES
-      == GNUNET_CONTAINER_multipeermap_remove (preference_peers, key, value))
-    GNUNET_free(rp);
-  else
-    GNUNET_break(0);
-  return GNUNET_OK;
-}
-
 
 /**
  * Stop the normalization component and free all items
@@ -1015,27 +373,7 @@ free_peer (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 void
 GAS_normalization_stop ()
 {
-  struct PreferenceClient *pc;
-  struct PreferenceClient *next_pc;
-
-  if (NULL != aging_task)
-  {
-    GNUNET_SCHEDULER_cancel (aging_task);
-    aging_task = NULL;
-  }
-
-  next_pc = pc_head;
-  while (NULL != (pc = next_pc))
-  {
-    next_pc = pc->next;
-    GNUNET_CONTAINER_DLL_remove(pc_head, pc_tail, pc);
-    free_client (pc);
-  }
-
-  GNUNET_CONTAINER_multipeermap_iterate (preference_peers, &free_peer, NULL );
-  GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
   GNUNET_CONTAINER_multipeermap_destroy (property_peers);
-  return;
 }
 
 /* end of gnunet-service-ats_normalization.c */