manage preferences expressed by clients More...

#include "platform.h"
#include "gnunet-service-ats.h"
#include "gnunet-service-ats_addresses.h"
#include "gnunet-service-ats_performance.h"
#include "gnunet-service-ats_plugins.h"
#include "gnunet-service-ats_preferences.h"
#include "gnunet-service-ats_reservations.h"
#include "ats.h"

Include dependency graph for gnunet-service-ats_preferences.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PeerRelative
	Relative preferences for a peer. More...

struct	PreferencePeer
	Preference information per peer and client. More...

struct	PreferenceClient
	Preference client, as in a client that expressed preferences for peers. More...

struct	SumContext
	Closure for sum_relative_preferences(). More...

struct	AgeContext
	Closure for age_values(). More...

struct	UpdateContext
	Closure for update_rel_sum() and update_abs_sum(). More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "ats-preferences", __VA_ARGS__)

#define	PREF_AGING_INTERVAL
	How frequently do we age preference values? More...

#define	PREF_AGING_FACTOR 0.95
	By which factor do we age preferences expressed during each PREF_AGING_INTERVAL? More...

#define	PREF_EPSILON 0.01
	What is the lowest threshold up to which preference values are aged, and below which we consider them zero and thus no longer subject to aging? More...

Functions
static int	sum_relative_preferences (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Add the relative preference for the kind given to the closure. More...

static void	update_relative_values_for_peer (const struct GNUNET_PeerIdentity *id, enum GNUNET_ATS_PreferenceKind kind)
	Update the total relative preference for a peer by summing up the relative preferences all clients have for this peer. More...

static int	free_peer (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Free a peer's `struct PeerRelative`. More...

static int	free_preference (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Free `struct PreferencePeer` entry in map. More...

static int	age_values (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Age preference values of the given peer. More...

static void	preference_aging (void *cls)
	Reduce absolute preferences since they got old. More...

static int	update_abs_sum (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Compute updated absolute score for the client based on the current absolute scores for each peer. More...

static int	update_rel_sum (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Compute updated relative score for each peer based on the current absolute score given by this client. More...

static void	recalculate_relative_preferences (struct PreferenceClient *c, enum GNUNET_ATS_PreferenceKind kind)
	Recalculate preference for a specific ATS property. More...

static int	update_iterator (void cls, const struct GNUNET_PeerIdentity key, void *value)
	The relative preferences of one of the clients have changed, update the global preferences for the given peer and notify the plugin. More...

static void	update_preference (struct GNUNET_SERVICE_Client client, const struct GNUNET_PeerIdentity peer, enum GNUNET_ATS_PreferenceKind kind, float score_abs)
	Update the absolute preference and calculate the new relative preference value. More...

void	GAS_handle_preference_change (struct GNUNET_SERVICE_Client client, const struct ChangePreferenceMessage msg)
	Handle 'preference change' messages from clients. More...

void	GAS_preference_init ()
	Initialize preferences subsystem. More...

void	GAS_preference_done ()
	Shutdown preferences subsystem. More...

const double *	GAS_preference_get_by_peer (void cls, const struct GNUNET_PeerIdentity id)
	Get the normalized preference values for a specific peer or the default values if. More...

void	GAS_preference_client_disconnect (struct GNUNET_SERVICE_Client *client)
	A performance client disconnected. More...

Variables
static struct PeerRelative	defvalues
	Default values, returned as our preferences if we do not have any preferences expressed for a peer. More...

static struct GNUNET_CONTAINER_MultiPeerMap *	preference_peers
	Hashmap to store peer information for preference normalization. More...

static struct PreferenceClient *	pc_head
	Clients in DLL: head. More...

static struct PreferenceClient *	pc_tail
	Clients in DLL: tail. More...

static struct GNUNET_SCHEDULER_Task *	aging_task
	Handle for task we run periodically to age preferences over time. More...

Detailed Description

manage preferences expressed by clients

Author: Matthias Wachs; Christian Grothoff

Definition in file gnunet-service-ats_preferences.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "ats-preferences", __VA_ARGS__)

Definition at line 35 of file gnunet-service-ats_preferences.c.

◆ PREF_AGING_INTERVAL

#define PREF_AGING_INTERVAL

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_SECONDS, 10)

GNUNET_TIME_UNIT_SECONDS

#define GNUNET_TIME_UNIT_SECONDS

One second.

Definition: gnunet_time_lib.h:150

GNUNET_TIME_relative_multiply

struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)

Multiply relative time by a given factor.

Definition: time.c:484

How frequently do we age preference values?

Definition at line 40 of file gnunet-service-ats_preferences.c.

◆ PREF_AGING_FACTOR

#define PREF_AGING_FACTOR 0.95

By which factor do we age preferences expressed during each PREF_AGING_INTERVAL?

Definition at line 47 of file gnunet-service-ats_preferences.c.

◆ PREF_EPSILON

#define PREF_EPSILON 0.01

What is the lowest threshold up to which preference values are aged, and below which we consider them zero and thus no longer subject to aging?

Definition at line 54 of file gnunet-service-ats_preferences.c.

Function Documentation

◆ sum_relative_preferences()

static int sum_relative_preferences	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Add the relative preference for the kind given to the closure.

Parameters

cls	the `struct SumContext` with the kind and place to store the result
peer	ignored
value	the `struct PreferencePeer` for getting the rel pref.

Returns: GNUNET_OK

Definition at line 201 of file gnunet-service-ats_preferences.c.

 {
   struct SumContext *sum_ctx = cls;
   struct PreferencePeer *p_cur = value;
  
   sum_ctx->f_rel_total += p_cur->f_rel[sum_ctx->kind];
   return GNUNET_OK;
 }

References PreferencePeer::f_rel, SumContext::f_rel_total, GNUNET_OK, SumContext::kind, and value.

Referenced by update_relative_values_for_peer().

Here is the caller graph for this function:

◆ update_relative_values_for_peer()

static void update_relative_values_for_peer	(	const struct GNUNET_PeerIdentity *	id,
		enum GNUNET_ATS_PreferenceKind	kind
	)

static

Update the total relative preference for a peer by summing up the relative preferences all clients have for this peer.

Parameters

id	peer id of the peer for which we should do the update
kind	the kind of preference value to update

Returns: the new relative preference

Definition at line 222 of file gnunet-service-ats_preferences.c.

 {
   struct PreferenceClient *c_cur;
   struct SumContext sum_ctx;
   struct PeerRelative *rp;
  
   sum_ctx.f_rel_total = 0.0;
   sum_ctx.kind = kind;
   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
     GNUNET_CONTAINER_multipeermap_get_multiple (c_cur->peer2pref,
                                                 id,
                                                 &sum_relative_preferences,
                                                 &sum_ctx);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Total relative preference for peer `%s' for `%s' is %.3f\n",
        GNUNET_i2s (id),
        GNUNET_ATS_print_preference_type (kind),
        sum_ctx.f_rel_total);
   rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
                                           id);
   GNUNET_assert (NULL != rp);
   if (rp->f_rel[kind] != sum_ctx.f_rel_total)
   {
     rp->f_rel[kind] = sum_ctx.f_rel_total;
     GAS_plugin_notify_preference_changed (id,
                                           kind,
                                           rp->f_rel[kind]);
   }
 }

References SumContext::f_rel_total, GAS_plugin_notify_preference_changed(), GNUNET_assert, GNUNET_ATS_print_preference_type(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), SumContext::kind, LOG, PreferenceClient::next, pc_head, PreferenceClient::peer2pref, preference_peers, rp, and sum_relative_preferences().

Referenced by age_values(), and update_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_peer()

static int free_peer	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Free a peer's struct PeerRelative.

Parameters

cls	unused
key	the key
value	the `struct PeerRelative` to free.

Returns: GNUNET_OK to continue

Definition at line 263 of file gnunet-service-ats_preferences.c.

 {
   struct PeerRelative *rp = value;
  
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_remove (preference_peers,
                                                        key,
                                                        value));
   GNUNET_free (rp);
   return GNUNET_OK;
 }

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_YES, key, preference_peers, rp, and value.

Referenced by free_preference(), and GAS_preference_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_preference()

static int free_preference	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Free struct PreferencePeer entry in map.

Parameters

cls	the `struct PreferenceClient` with the map
key	the peer the entry is for
value	the `struct PreferencePeer` entry to free

Returns: GNUNET_OK (continue to iterate)

Definition at line 287 of file gnunet-service-ats_preferences.c.

 {
   struct PreferenceClient *pc = cls;
   struct PreferencePeer *p = value;
   struct PeerRelative *pr;
  
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_remove (pc->peer2pref,
                                                        key,
                                                        p));
   GNUNET_free (p);
   pr = GNUNET_CONTAINER_multipeermap_get (preference_peers,
                                           key);
   GNUNET_assert (NULL != pr);
   GNUNET_assert (pr->num_clients > 0);
   pr->num_clients--;
   if (0 == pr->num_clients)
   {
     free_peer (NULL,
                key,
                pr);
   }
   return GNUNET_OK;
 }

References free_peer(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, key, PeerRelative::num_clients, p, pc, preference_peers, and value.

Referenced by age_values(), GAS_preference_client_disconnect(), and GAS_preference_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ age_values()

static int age_values	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Age preference values of the given peer.

Parameters

cls	a `
peer	peer being aged
value	the `struct PreferencePeer` for the peer

Returns: GNUNET_OK (continue to iterate)

Definition at line 342 of file gnunet-service-ats_preferences.c.

 {
   struct AgeContext *ac = cls;
   struct PreferencePeer *p = value;
   unsigned int i;
   int dead;
  
   dead = GNUNET_YES;
   for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Aging preference for peer `%s'\n",
                 GNUNET_i2s (peer));
     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;
       p->f_rel[i] = DEFAULT_REL_PREFERENCE;
       update_relative_values_for_peer (peer,
                                        i);
     }
     else
     {
       ac->values_to_update++;
       dead = GNUNET_NO;
     }
   }
   if (GNUNET_YES == dead)
   {
     /* all preferences are zero, remove this entry */
     free_preference (ac->cur_client,
                      peer,
                      p);
   }
   return GNUNET_OK;
 }

References ac, DEFAULT_ABS_PREFERENCE, DEFAULT_REL_PREFERENCE, free_preference(), GNUNET_ATS_PREFERENCE_END, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, p, peer, PREF_AGING_FACTOR, PREF_EPSILON, update_relative_values_for_peer(), and value.

Referenced by preference_aging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preference_aging()

static void preference_aging ( void * cls )

static

Reduce absolute preferences since they got old.

Parameters

cls unused

Definition at line 389 of file gnunet-service-ats_preferences.c.

 {
   struct AgeContext ac;
  
   aging_task = NULL;
   GAS_plugin_solver_lock ();
   ac.values_to_update = 0;
   for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client =
          ac.cur_client->next)
     GNUNET_CONTAINER_multipeermap_iterate (ac.cur_client->peer2pref,
                                            &age_values,
                                            &ac);
   GAS_plugin_solver_unlock ();
   if (ac.values_to_update > 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Rescheduling aging task due to %u elements remaining to age\n",
                 ac.values_to_update);
     if (NULL == aging_task)
       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");
   }
 }

References ac, age_values(), aging_task, GAS_plugin_solver_lock(), GAS_plugin_solver_unlock(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_MQ_Envelope::next, pc_head, and PREF_AGING_INTERVAL.

Referenced by update_preference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_abs_sum()

static int update_abs_sum	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Compute updated absolute score for the client based on the current absolute scores for each peer.

Parameters

cls	a `struct UpdateContext`
peer	peer being updated
value	the `struct PreferencePeer` for the peer

Returns: GNUNET_OK (continue to iterate)

Definition at line 447 of file gnunet-service-ats_preferences.c.

 {
   struct UpdateContext *uc = cls;
   struct PreferencePeer *p_cur = value;
  
   uc->pc->f_abs_sum[uc->kind] += p_cur->f_abs[uc->kind];
   return GNUNET_OK;
 }

References PreferencePeer::f_abs, GNUNET_OK, uc, and value.

Referenced by recalculate_relative_preferences().

Here is the caller graph for this function:

◆ update_rel_sum()

static int update_rel_sum	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Compute updated relative score for each peer based on the current absolute score given by this client.

Parameters

cls	a `struct UpdateContext`
peer	peer being updated
value	the `struct PreferencePeer` for the peer (updated)

Returns: GNUNET_OK (continue to iterate)

Definition at line 469 of file gnunet-service-ats_preferences.c.

 {
   struct UpdateContext *uc = cls;
   struct PreferencePeer *p_cur = value;
  
   p_cur->f_rel[uc->kind] = p_cur->f_abs[uc->kind] / uc->pc->f_abs_sum[uc->kind];
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Client has relative preference for %s for peer `%s' of %.3f\n",
        GNUNET_ATS_print_preference_type (uc->kind),
        GNUNET_i2s (peer),
        p_cur->f_rel[uc->kind]);
   return GNUNET_OK;
 }

References PreferencePeer::f_abs, PreferencePeer::f_rel, GNUNET_ATS_print_preference_type(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_OK, LOG, peer, uc, and value.

Referenced by recalculate_relative_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recalculate_relative_preferences()

static void recalculate_relative_preferences	(	struct PreferenceClient *	c,
		enum GNUNET_ATS_PreferenceKind	kind
	)

static

Recalculate preference for a specific ATS property.

Parameters

c	the preference client
kind	the preference kind

Returns: the result

Definition at line 494 of file gnunet-service-ats_preferences.c.

 {
   struct UpdateContext uc;
  
   /* For this client: sum of absolute preference values for this preference */
   uc.kind = kind;
   uc.pc = c;
   c->f_abs_sum[kind] = 0.0;
  
   /* For all peers: calculate sum of absolute preferences */
   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
                                          &update_abs_sum,
                                          &uc);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Client has sum of total preferences for %s of %.3f\n",
        GNUNET_ATS_print_preference_type (kind),
        c->f_abs_sum[kind]);
  
   /* For all peers: calculate relative preference */
   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
                                          &update_rel_sum,
                                          &uc);
 }

References PreferenceClient::f_abs_sum, GNUNET_ATS_print_preference_type(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, UpdateContext::kind, LOG, PreferenceClient::peer2pref, uc, update_abs_sum(), and update_rel_sum().

Referenced by update_preference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_iterator()

static int update_iterator	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

The relative preferences of one of the clients have changed, update the global preferences for the given peer and notify the plugin.

Parameters

cls	the kind of preference to calculate the new global relative preference values for
key	the peer to update relative preference values for
value	a `struct PeerRelative`, unused

Definition at line 531 of file gnunet-service-ats_preferences.c.

 {
   enum GNUNET_ATS_PreferenceKind *kind = cls;
  
   update_relative_values_for_peer (key,
                                    *kind);
   return GNUNET_OK;
 }

References GNUNET_OK, key, UpdateContext::kind, and update_relative_values_for_peer().

Referenced by update_preference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_preference()

static void update_preference	(	struct GNUNET_SERVICE_Client *	client,
		const struct GNUNET_PeerIdentity *	peer,
		enum GNUNET_ATS_PreferenceKind	kind,
		float	score_abs
	)

static

Update the absolute preference and calculate the new relative preference value.

Parameters

client	the client with this preference
peer	the peer to change the preference for
kind	the kind to change the preference
score_abs	the normalized score

Definition at line 553 of file gnunet-service-ats_preferences.c.

 {
   struct PreferenceClient *c_cur;
   struct PreferencePeer *p_cur;
   struct PeerRelative *r_cur;
   unsigned int i;
  
   if (kind >= GNUNET_ATS_PREFERENCE_END)
   {
     GNUNET_break (0);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Client changes preference for peer `%s' for `%s' to %.2f\n",
        GNUNET_i2s (peer),
        GNUNET_ATS_print_preference_type (kind),
        score_abs);
  
   /* 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;
     c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create (16,
                                                              GNUNET_NO);
     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
       c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
     GNUNET_CONTAINER_DLL_insert (pc_head,
                                  pc_tail,
                                  c_cur);
   }
  
   /* check global peer entry exists */
   if (NULL ==
       (r_cur = GNUNET_CONTAINER_multipeermap_get (preference_peers,
                                                   peer)))
   {
     /* Create struct for peer */
     r_cur = GNUNET_new (struct PeerRelative);
     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
       r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
     GNUNET_assert (GNUNET_OK ==
                    GNUNET_CONTAINER_multipeermap_put (preference_peers,
                                                       peer,
                                                       r_cur,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
  
   /* Find entry for peer */
   p_cur = GNUNET_CONTAINER_multipeermap_get (c_cur->peer2pref,
                                              peer);
   if (NULL == p_cur)
   {
     /* Not found: create new peer entry */
     p_cur = GNUNET_new (struct PreferencePeer);
     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     {
       /* Default value per peer absolute preference for a preference*/
       p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
       /* Default value per peer relative preference for a quality */
       p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
     }
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CONTAINER_multipeermap_put (c_cur->peer2pref,
                                                       peer,
                                                       p_cur,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
     r_cur->num_clients++;
   }
  
   p_cur->f_abs[kind] += score_abs;
   recalculate_relative_preferences (c_cur, kind);
   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
                                          &update_iterator,
                                          &kind);
  
   if (NULL == aging_task)
     aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
                                                &preference_aging,
                                                NULL);
 }

References aging_task, PreferenceClient::client, DEFAULT_ABS_PREFERENCE, DEFAULT_REL_PREFERENCE, PreferencePeer::f_abs, PreferenceClient::f_abs_sum, PeerRelative::f_rel, PreferencePeer::f_rel, GNUNET_assert, GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_print_preference_type(), GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, LOG, PreferenceClient::next, PeerRelative::num_clients, pc_head, pc_tail, peer, PreferenceClient::peer2pref, PREF_AGING_INTERVAL, preference_aging(), preference_peers, recalculate_relative_preferences(), and update_iterator().

Referenced by GAS_handle_preference_change(), and set_pref_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GAS_handle_preference_change()

void GAS_handle_preference_change	(	struct GNUNET_SERVICE_Client *	client,
		const struct ChangePreferenceMessage *	msg
	)

Handle 'preference change' messages from clients.

Parameters

client	the client that sent the request
msg	the request message

Definition at line 650 of file gnunet-service-ats_preferences.c.

 {
   const struct PreferenceInformation *pi;
   uint32_t nump;
  
   nump = ntohl (msg->num_preferences);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received PREFERENCE_CHANGE message for peer `%s'\n",
               GNUNET_i2s (&msg->peer));
   GNUNET_STATISTICS_update (GSA_stats,
                             "# preference change requests processed",
                             1,
                             GNUNET_NO);
   pi = (const struct PreferenceInformation *) &msg[1];
   GAS_plugin_solver_lock ();
   for (uint32_t i = 0; i < nump; i++)
     update_preference (client,
                        &msg->peer,
                        (enum GNUNET_ATS_PreferenceKind) ntohl (
                          pi[i].preference_kind),
                        pi[i].preference_value);
   GAS_plugin_solver_unlock ();
 }

References GAS_plugin_solver_lock(), GAS_plugin_solver_unlock(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GSA_stats, msg, pi, PreferenceInformation::preference_kind, PreferenceInformation::preference_value, and update_preference().

Referenced by handle_preference_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GAS_preference_init()

void GAS_preference_init ( void )

Initialize preferences subsystem.

Definition at line 680 of file gnunet-service-ats_preferences.c.

 {
   unsigned int i;
  
   preference_peers = GNUNET_CONTAINER_multipeermap_create (16,
                                                            GNUNET_NO);
   for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
 }

References DEFAULT_REL_PREFERENCE, defvalues, PeerRelative::f_rel, GNUNET_ATS_PREFERENCE_END, GNUNET_CONTAINER_multipeermap_create(), GNUNET_NO, and preference_peers.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GAS_preference_done()

void GAS_preference_done ( void )

Shutdown preferences subsystem.

Definition at line 695 of file gnunet-service-ats_preferences.c.

 {
   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);
     GNUNET_CONTAINER_multipeermap_iterate (pc->peer2pref,
                                            &free_preference,
                                            pc);
     GNUNET_CONTAINER_multipeermap_destroy (pc->peer2pref);
     GNUNET_free (pc);
   }
   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
                                          &free_peer,
                                          NULL);
   GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
 }

References aging_task, free_peer(), free_preference(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), pc, pc_head, pc_tail, and preference_peers.

Referenced by cleanup_task(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GAS_preference_get_by_peer()

const double* GAS_preference_get_by_peer	(	void *	cls,
		const struct GNUNET_PeerIdentity *	id
	)

Get the normalized preference values for a specific peer or the default values if.

Get the normalized preference values for a specific peer.

Parameters

cls	ignored
id	the peer

Returns: pointer to the values, can be indexed with GNUNET_ATS_PreferenceKind, default preferences if peer does not exist

Definition at line 735 of file gnunet-service-ats_preferences.c.

 {
   struct PeerRelative *rp;
  
   if (NULL ==
       (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
                                                id)))
   {
     return defvalues.f_rel;
   }
   return rp->f_rel;
 }

References defvalues, PeerRelative::f_rel, GNUNET_CONTAINER_multipeermap_get(), preference_peers, and rp.

Referenced by GAS_plugin_init(), and get_preferences_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GAS_preference_client_disconnect()

void GAS_preference_client_disconnect ( struct GNUNET_SERVICE_Client * client )

A performance client disconnected.

Parameters

client the disconnecting client

Definition at line 751 of file gnunet-service-ats_preferences.c.

 {
   struct PreferenceClient *c_cur;
  
   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);
   GNUNET_CONTAINER_multipeermap_iterate (c_cur->peer2pref,
                                          &free_preference,
                                          c_cur);
   GNUNET_CONTAINER_multipeermap_destroy (c_cur->peer2pref);
   GNUNET_free (c_cur);
 }