/**
* Hashmap to store peer information for preference normalization
*/
-static struct GNUNET_CONTAINER_MultiHashMap *preference_peers;
+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_MultiHashMap *property_peers;
+static struct GNUNET_CONTAINER_MultiPeerMap *property_peers;
/**
* Clients in DLL: head
"%u clients have a total relative preference for peer `%s''s `%s' of %.3f\n",
count, GNUNET_i2s (id), GNUNET_ATS_print_preference_type (kind),
f_rel_total);
- if (NULL
- != (rp = GNUNET_CONTAINER_multihashmap_get (preference_peers,
- &id->hashPubKey)))
+ if (NULL != (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers, id)))
{
backup = rp->f_rel[kind];
if (0 < count)
{
/* Value did not chang, return old value*/
GNUNET_assert(
- NULL != (rp = GNUNET_CONTAINER_multihashmap_get (preference_peers, &p->id.hashPubKey)));
+ NULL != (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers, &p->id)));
ret = rp->f_rel[kind];
}
}
case GNUNET_ATS_PREFERENCE_BANDWIDTH:
case GNUNET_ATS_PREFERENCE_LATENCY:
p->f_abs[kind] = (p->f_abs[kind] + score) / 2;
- p->next_aging[kind] = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(),
+ p->next_aging[kind] = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
PREF_AGING_INTERVAL);
break;
case GNUNET_ATS_PREFERENCE_END:
values_to_update = 0;
cur_client = NULL;
- /*
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- "Before for: head: %08x cur_client %08x \n", pc_head, cur_client);
- */
-
- //for (cur_client = pc_head; NULL != cur_client; cur_client = cur_client->next);
- cur_client = pc_head;
- while (NULL != cur_client)
+ for (cur_client = pc_head; NULL != cur_client; cur_client = cur_client->next)
{
- /*
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- "Aging client head: %p cur_client %p\n", pc_head, cur_client);
- */
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)
+ 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));
+ 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]))
+ 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]);
recalculate_rel_preferences (p->client, p, i);
- p->next_aging[i] = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
- PREF_AGING_INTERVAL);
- values_to_update ++;
+ p->next_aging[i] = GNUNET_TIME_absolute_add (
+ GNUNET_TIME_absolute_get (), PREF_AGING_INTERVAL);
+ values_to_update++;
}
}
}
}
-
- cur_client = cur_client->next;
}
if (values_to_update > 0)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Rescheduling aging task due to %u elements to age\n", values_to_update);
+ 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);
+ &preference_aging, NULL );
}
else
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"No values to age left, not rescheduling aging task\n");
}
*/
void
GAS_normalization_normalize_preference (void *src,
- const struct GNUNET_PeerIdentity *peer,
- enum GNUNET_ATS_PreferenceKind kind,
+ const struct GNUNET_PeerIdentity *peer, enum GNUNET_ATS_PreferenceKind kind,
float score_abs)
{
struct PreferenceClient *c_cur;
/* Not found: create new preference client */
if (NULL == c_cur)
{
- c_cur = GNUNET_malloc (sizeof (struct PreferenceClient));
+ c_cur = GNUNET_new (struct PreferenceClient);
c_cur->client = src;
- GNUNET_CONTAINER_DLL_insert (pc_head, pc_tail, c_cur);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Adding new client %p \n", c_cur);
+ GNUNET_CONTAINER_DLL_insert(pc_head, pc_tail, c_cur);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding new client %p \n", c_cur);
}
/* Find entry for peer */
/* Not found: create new peer entry */
if (NULL == p_cur)
{
- p_cur = GNUNET_malloc (sizeof (struct PreferencePeer));
+ p_cur = GNUNET_new (struct PreferencePeer);
p_cur->client = c_cur;
p_cur->id = (*peer);
for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
GNUNET_CONTAINER_DLL_insert(c_cur->p_head, c_cur->p_tail, p_cur);
}
- if (NULL == GNUNET_CONTAINER_multihashmap_get (preference_peers,
- &peer->hashPubKey))
+ if (NULL == GNUNET_CONTAINER_multipeermap_get (preference_peers, peer))
{
- r_cur = GNUNET_malloc (sizeof (struct PeerRelative));
+ 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_CONTAINER_multihashmap_put (preference_peers, &r_cur->id.hashPubKey,
- r_cur, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multipeermap_put (preference_peers, &r_cur->id, r_cur,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
}
if (GNUNET_SCHEDULER_NO_TASK == aging_task)
aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
- &preference_aging, NULL);
+ &preference_aging, NULL );
update_preference (c_cur, p_cur, kind, score_abs);
}
* default preferences if peer does not exist
*/
const double *
-GAS_normalization_get_preferences (const struct GNUNET_PeerIdentity *id)
+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_multihashmap_get (preference_peers,
- &id->hashPubKey)))
+ 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
+ */
+const double
+GAS_normalization_get_preferences_by_client (const void *client,
+ 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
};
static int
-find_min_max_it (void *cls, const struct GNUNET_HashCode *h, void *k)
+find_min_max_it (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
{
- struct ATS_Address *a = (struct ATS_Address *) k;
struct FindMinMaxCtx *find_res = cls;
+ struct ATS_Address *a = k;
if (a->atsin[find_res->p->prop_type].avg > find_res->max)
find_res->max = a->atsin[find_res->p->prop_type].avg;
}
static int
-normalize_address (void *cls, const struct GNUNET_HashCode *h, void *k)
+normalize_address (void *cls, const struct GNUNET_PeerIdentity *h, void *k)
{
struct Property *p = cls;
- struct ATS_Address *address = (struct ATS_Address *) k;
+ struct ATS_Address *address = k;
double delta;
uint32_t avg_value = address->atsin[p->prop_type].avg;
* @param address the address
* @param avg_value the value to normalize
*/
-
static void
-property_normalize (struct GNUNET_CONTAINER_MultiHashMap *addresses,
+property_normalize (struct GNUNET_CONTAINER_MultiPeerMap *addresses,
struct Property *p, struct ATS_Address *address, uint32_t avg_value)
{
struct FindMinMaxCtx find_ctx;
find_ctx.p = p;
find_ctx.max = 0;
find_ctx.min = UINT32_MAX;
- addr_count = GNUNET_CONTAINER_multihashmap_iterate (addresses,
+ addr_count = GNUNET_CONTAINER_multipeermap_iterate (addresses,
&find_min_max_it, &find_ctx);
if (0 == addr_count)
{
if (GNUNET_NO == limits_changed)
{
/* normalize just this address */
- normalize_address (p, &address->peer.hashPubKey, address);
+ normalize_address (p, &address->peer, address);
return;
}
else
{
/* limits changed, normalize all addresses */
- GNUNET_CONTAINER_multihashmap_iterate (addresses, &normalize_address, p);
+ GNUNET_CONTAINER_multipeermap_iterate (addresses, &normalize_address, p);
return;
}
}
*/
void
GAS_normalization_normalize_property (
- struct GNUNET_CONTAINER_MultiHashMap *addresses,
+ struct GNUNET_CONTAINER_MultiPeerMap *addresses,
struct ATS_Address *address, const struct GNUNET_ATS_Information *atsi,
uint32_t atsi_count)
{
}
}
+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
*
{
int c1;
int i;
- preference_peers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
- property_peers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+ 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;
for (c1 = 0; c1 < GNUNET_ATS_QualityPropertiesCount; c1++)
* @param cls unused
* @param key the key
* @param value RelativePeer
- * @return GNUNET_OK to continue
+ * @return #GNUNET_OK to continue
*/
static int
-free_peer (void *cls, const struct GNUNET_HashCode * key, void *value)
+free_peer (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
{
struct PeerRelative *rp = value;
if (GNUNET_YES
- == GNUNET_CONTAINER_multihashmap_remove (preference_peers, key, value))
+ == GNUNET_CONTAINER_multipeermap_remove (preference_peers, key, value))
GNUNET_free(rp);
else
GNUNET_break(0);
{
struct PreferenceClient *pc;
struct PreferenceClient *next_pc;
- struct PreferencePeer *p;
- struct PreferencePeer *next_p;
if (GNUNET_SCHEDULER_NO_TASK != aging_task)
{
{
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;
- GNUNET_CONTAINER_DLL_remove(pc->p_head, pc->p_tail, p);
- GNUNET_free(p);
- }
- GNUNET_free(pc);
+ free_client (pc);
}
- GNUNET_CONTAINER_multihashmap_iterate (preference_peers, &free_peer, NULL );
- GNUNET_CONTAINER_multihashmap_destroy (preference_peers);
- GNUNET_CONTAINER_multihashmap_destroy (property_peers);
+ GNUNET_CONTAINER_multipeermap_iterate (preference_peers, &free_peer, NULL );
+ GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
+ GNUNET_CONTAINER_multipeermap_destroy (property_peers);
return;
}
projects / oweals / gnunet.git / blobdiff