/*
- This file is part of GNUnet.
- (C) 2011 Christian Grothoff (and other contributing authors)
+ This file is part of GNUnet.
+ Copyright (C) 2011-2015 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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
- 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.
-*/
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
/**
* @file ats/gnunet-service-ats_normalization.c
* @author Christian Grothoff
*/
#include "platform.h"
+#include <float.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
+ * Range information for normalization of quality properties.
*/
-struct PreferenceClient
+struct PropertyRange
{
/**
- * Next in DLL
- */
- struct PreferenceClient *prev;
-
- /**
- * Next in DLL
- */
-
- struct PreferenceClient *next;
-
- /**
- * Client handle
- */
- void *client;
-
- /**
- * Total preference for this peer
+ * Minimum value we see for this property across all addresses.
*/
- double f_total[GNUNET_ATS_PreferenceCount];
+ struct GNUNET_ATS_Properties min;
/**
- * List of peer preferences for this client
+ * Maximum value we see for this property across all addresses.
*/
+ struct GNUNET_ATS_Properties max;
+};
- /**
- * Head of peer list
- */
- struct PreferencePeer *p_head;
- /**
- * Tail of peer list
- */
- struct PreferencePeer *p_tail;
-};
+/**
+ * Range information for all quality properties we see.
+ */
+static struct PropertyRange property_range;
/**
- * Preference peer
+ * Add the value from @a atsi to the running average of the
+ * given @a ni quality property.
+ *
+ * @param current_val the updated value
+ * @param ni normalization information to update
*/
-struct PreferencePeer
+static void
+update_avg (uint64_t current_val,
+ struct GAS_NormalizationInfo *ni)
{
- /**
- * Next in DLL
- */
- struct PreferencePeer *next;
+ double sum;
+ uint32_t count;
+ unsigned int c1;
+
+ ni->atsi_abs[ni->avg_queue_index++] = current_val;
+ if (GAS_normalization_queue_length == ni->avg_queue_index)
+ ni->avg_queue_index = 0;
+ count = 0;
+ sum = 0.0;
+ for (c1 = 0; c1 < GAS_normalization_queue_length; c1++)
+ {
+ if (UINT64_MAX != ni->atsi_abs[c1])
+ {
+ count++;
+ sum += (double) ni->atsi_abs[c1];
+ }
+ }
+ if (0 == count)
+ ni->avg = current_val; /* must be UINT64_MAX */
+ else
+ ni->avg = sum / count;
+}
- /**
- * Previous in DLL
- */
- struct PreferencePeer *prev;
- /**
- * Client
- */
- struct PreferenceClient *client;
+/**
+ * Function called for all addresses and peers to find the minimum and
+ * maximum (averaged) values for a given quality property. Given
+ * those, we can then calculate the normalized score.
+ *
+ * @param cls the `struct PropertyRange`
+ * @param h which peer are we looking at (ignored)
+ * @param k the address for that peer
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+find_min_max_it (void *cls,
+ const struct GNUNET_PeerIdentity *h,
+ void *k)
+{
+ struct PropertyRange *pr = cls;
+ const struct ATS_Address *a = k;
+
+ pr->max.utilization_out = GNUNET_MAX (pr->max.utilization_out,
+ a->properties.utilization_out);
+ pr->max.utilization_in = GNUNET_MAX (pr->max.utilization_in,
+ a->properties.utilization_in);
+ pr->max.distance = GNUNET_MAX (pr->max.distance,
+ a->properties.distance);
+ pr->max.delay = GNUNET_TIME_relative_max (pr->max.delay,
+ a->properties.delay);
+ pr->min.utilization_out = GNUNET_MIN (pr->min.utilization_out,
+ a->properties.utilization_out);
+ pr->min.utilization_in = GNUNET_MIN (pr->min.utilization_in,
+ a->properties.utilization_in);
+ pr->min.distance = GNUNET_MIN (pr->min.distance,
+ a->properties.distance);
+ pr->min.delay = GNUNET_TIME_relative_min (pr->min.delay,
+ a->properties.delay);
+ return GNUNET_OK;
+}
- /**
- * Peer id
- */
- struct GNUNET_PeerIdentity id;
- /**
- * Preference Values
- */
- double f[GNUNET_ATS_PreferenceCount];
+/**
+ * Compute the normalized value from the given @a ni range
+ * data and the average value.
+ *
+ * @param min minimum value
+ * @param max maximum value
+ * @param ni normalization information to update
+ */
+static void
+update_norm (uint64_t min,
+ uint64_t max,
+ struct GAS_NormalizationInfo *ni)
+{
+ /* max - 2 * min + avg_value / (max - min) */
+ if (min < max)
+ ni->norm = DEFAULT_REL_QUALITY + (ni->avg - min) / (double) (max - min);
+ else
+ ni->norm = DEFAULT_REL_QUALITY;
+}
- /**
- * Relative Preference Values
- */
- double f_rel[GNUNET_ATS_PreferenceCount];
- /**
- * Relative Total Preference Value
- */
- double f_rel_total;
+/**
+ * Normalize the property value for a given address based
+ * on the range we know that property values have globally.
+ *
+ * @param cls NULL
+ * @param key which peer are we looking at (ignored)
+ * @param value the address for that peer, from where we get
+ * the original value and where we write the
+ * normalized value
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+normalize_address (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
+{
+ struct ATS_Address *address = value;
+
+ update_norm (property_range.min.delay.rel_value_us,
+ property_range.max.delay.rel_value_us,
+ &address->norm_delay);
+ update_norm (property_range.min.distance,
+ property_range.max.distance,
+ &address->norm_distance);
+ update_norm (property_range.min.utilization_in,
+ property_range.max.utilization_in,
+ &address->norm_utilization_in);
+ update_norm (property_range.min.utilization_out,
+ property_range.max.utilization_out,
+ &address->norm_utilization_out);
+ return GNUNET_OK;
+}
- GNUNET_SCHEDULER_TaskIdentifier aging_task;
-};
+/**
+ * Notify about change in normalized property.
+ *
+ * @param cls NULL
+ * @param key which peer are we looking at (ignored)
+ * @param value the address for that peer
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+notify_change (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
+{
+ struct ATS_Address *address = value;
+ GAS_plugin_notify_property_changed (address);
+ return GNUNET_OK;
+}
-struct PreferenceClient *pc_head;
-struct PreferenceClient *pc_tail;
+/**
+ * Initialize property range to the values corresponding
+ * to an empty set.
+ *
+ * @param pr range to initialize
+ */
static void
-preference_aging (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+init_range (struct PropertyRange *pr)
{
-
+ memset (pr, 0, sizeof (struct PropertyRange));
+ pr->min.utilization_out = UINT32_MAX;
+ pr->min.utilization_in = UINT32_MAX;
+ pr->min.distance = UINT32_MAX;
+ pr->min.delay = GNUNET_TIME_UNIT_FOREVER_REL;
}
+
/**
- * Changes the preferences for a peer in the problem
+ * Update and normalize atsi performance information
*
- * @param solver the solver handle
- * @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 the normalized score
+ * @param address the address to update
*/
-float
-GAS_normalization_change_preference (void *src,
- const struct GNUNET_PeerIdentity *peer,
- enum GNUNET_ATS_PreferenceKind kind,
- float score_abs)
+void
+GAS_normalization_update_property (struct ATS_Address *address)
{
- float score_rel = 1.0;
- struct PreferenceClient *c_cur;
- struct PreferencePeer *p_cur;
- int i;
-
-
- GNUNET_assert (NULL != src);
- GNUNET_assert (NULL != peer);
-/*
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Client %p changes preference for peer `%s' %s %f\n",
- src,
- GNUNET_i2s (peer),
- GNUNET_ATS_print_preference_type (kind),
- score_abs);
-*/
- if (kind >= GNUNET_ATS_PreferenceCount)
+ const struct GNUNET_ATS_Properties *prop = &address->properties;
+ struct PropertyRange range;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Updating properties for peer `%s'\n",
+ GNUNET_i2s (&address->peer));
+ GAS_plugin_solver_lock ();
+ update_avg (prop->delay.rel_value_us,
+ &address->norm_delay);
+ update_avg (prop->distance,
+ &address->norm_distance);
+ update_avg (prop->utilization_in,
+ &address->norm_utilization_in);
+ update_avg (prop->utilization_in,
+ &address->norm_utilization_out);
+
+ init_range (&range);
+ GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+ &find_min_max_it,
+ &range);
+ if (0 != memcmp (&range,
+ &property_range,
+ sizeof (struct PropertyRange)))
{
- GNUNET_break (0);
- return 0.0;
+ /* limits changed, (re)normalize all addresses */
+ property_range = range;
+ GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+ &normalize_address,
+ NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+ ¬ify_change,
+ NULL);
}
-
- /* Find preference client */
- for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
- {
- if (src == c_cur->client)
- break;
- }
- /* Not found: create new preference client */
- if (NULL == c_cur)
- {
- c_cur = GNUNET_malloc (sizeof (struct PreferenceClient));
- c_cur->client = src;
- GNUNET_CONTAINER_DLL_insert (pc_head, pc_tail, 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)
+ else
{
- p_cur = GNUNET_malloc (sizeof (struct PreferencePeer));
- p_cur->client = c_cur;
- p_cur->id = (*peer);
- for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
- {
- /* Default value per peer absolut preference for a quality:
- * No value set, so absolute preference 0 */
- p_cur->f[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->aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL, &preference_aging, p_cur);
- GNUNET_CONTAINER_DLL_insert (c_cur->p_head, c_cur->p_tail, p_cur);
+ /* renormalize just this one address */
+ normalize_address (NULL,
+ &address->peer,
+ address);
+ notify_change (NULL,
+ &address->peer,
+ address);
}
-// update_preference (p_cur, kind, score);
- return score_rel;
+ GAS_plugin_solver_unlock ();
}
+
+/**
+ * Start the normalization component
+ */
void
GAS_normalization_start ()
{
- return;
+ init_range (&property_range);
}
+
+/**
+ * Stop the normalization component and free all items
+ */
void
GAS_normalization_stop ()
{
- struct PreferenceClient *pc;
- struct PreferenceClient *next_pc;
- struct PreferencePeer *p;
- struct PreferencePeer *next_p;
-
- next_pc = pc_head;
- while (NULL != (pc = next_pc))
- {
- next_pc = pc->next;
- GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
- next_p = pc->p_head;
- while (NULL != (p = next_p))
- {
- next_p = p->next;
- if (GNUNET_SCHEDULER_NO_TASK != p->aging_task)
- {
- GNUNET_SCHEDULER_cancel(p->aging_task);
- p->aging_task = GNUNET_SCHEDULER_NO_TASK;
- }
- GNUNET_CONTAINER_DLL_remove (pc->p_head, pc->p_tail, p);
- GNUNET_free (p);
- }
- GNUNET_free (pc);
- }
- return;
+ /* nothing to do */
}
+
/* end of gnunet-service-ats_normalization.c */
projects / oweals / gnunet.git / blobdiff