rps-sampler_common.h File Reference

Code common to client and service sampler. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-rps_sampler_elem.h"
#include <math.h>
#include <inttypes.h>
#include "rps-test_util.h"

Include dependency graph for rps-sampler_common.h:

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

Go to the source code of this file.

Data Structures
struct	GetPeerCls
	Closure for sampler_mod_get_rand_peer() and sampler_get_rand_peer. More...
struct	RPS_Sampler
	Sampler with its own array of SamplerElements. More...

Typedefs
typedef void(*	RPS_sampler_rand_peer_ready_cont) (void *cls, const struct GNUNET_PeerIdentity *id, double probability, uint32_t num_observed)
	Callback that is called from _get_rand_peer() when the PeerID is ready. More...
typedef void(*	RPS_get_peers_type) (void *cls)
	Type of function used to differentiate between modified and not modified Sampler. More...
typedef void(*	RPS_sampler_n_rand_peers_ready_cb) (const struct GNUNET_PeerIdentity *ids, uint32_t num_peers, void *cls)
	Callback that is called from _get_n_rand_peers() when the PeerIDs are ready. More...
typedef void(*	RPS_sampler_sinlge_info_ready_cb) (const struct GNUNET_PeerIdentity *ids, void *cls, double probability, uint32_t num_observed)
	Callback that is called from _get_n_rand_peers() when the PeerIDs are ready. More...
typedef void(*	SamplerNotifyUpdateCB) (void *cls)
	Callback called each time a new peer was put into the sampler. More...

Functions
void	RPS_sampler_update_with_nw_size (struct RPS_Sampler *sampler, uint32_t num_peers)
	Update the current estimate of the network size stored at the sampler. More...
void	RPS_sampler_set_desired_probability (struct RPS_Sampler *sampler, double desired_probability)
	Set the probability that is needed at least with what a sampler element has to have observed all elements from the network. More...
void	RPS_sampler_set_deficiency_factor (struct RPS_Sampler *sampler, double deficiency_factor)
	Set the deficiency factor. More...
struct SamplerNotifyUpdateCTX *	sampler_notify_on_update (struct RPS_Sampler *sampler, SamplerNotifyUpdateCB notify_cb, void *cls)
	Add a callback that will be called when the next peer is inserted into the sampler. More...
void	RPS_sampler_update (struct RPS_Sampler *sampler, const struct GNUNET_PeerIdentity *id)
	Update every sampler element of this sampler with given peer. More...
void	RPS_sampler_reinitialise_by_value (struct RPS_Sampler *sampler, const struct GNUNET_PeerIdentity *id)
	Reinitialise all previously initialised sampler elements with the given value. More...
unsigned int	RPS_sampler_get_size (struct RPS_Sampler *sampler)
	Get the size of the sampler. More...
void	RPS_sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size)
	Grow or shrink the size of the sampler. More...
struct RPS_SamplerRequestHandle *	RPS_sampler_get_n_rand_peers (struct RPS_Sampler *sampler, uint32_t num_peers, RPS_sampler_n_rand_peers_ready_cb cb, void *cls)
	Get n random peers out of the sampled peers. More...
struct RPS_SamplerRequestHandleSingleInfo *	RPS_sampler_get_rand_peer_info (struct RPS_Sampler *sampler, RPS_sampler_sinlge_info_ready_cb cb, void *cls)
	Get one random peer with additional information. More...
uint32_t	RPS_sampler_count_id (struct RPS_Sampler *sampler, const struct GNUNET_PeerIdentity *id)
	Counts how many Samplers currently hold a given PeerID. More...
void	RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle)
	Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb. More...
void	RPS_sampler_request_single_info_cancel (struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle)
	Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb. More...
void	RPS_sampler_destroy (struct RPS_Sampler *sampler)
	Cleans the sampler. More...

Detailed Description

Code common to client and service sampler.

Author

Julius Bünger

Definition in file rps-sampler_common.h.

Typedef Documentation

RPS_sampler_rand_peer_ready_cont

typedef void(* RPS_sampler_rand_peer_ready_cont) (void *cls, const struct GNUNET_PeerIdentity *id, double probability, uint32_t num_observed)

Callback that is called from _get_rand_peer() when the PeerID is ready.

Parameters

cls	the closure given alongside this function.
id	the PeerID that was returned
probability	The probability with which this sampler has seen all ids
num_observed	How many ids this sampler has observed

Definition at line 50 of file rps-sampler_common.h.

RPS_get_peers_type

typedef void(* RPS_get_peers_type) (void *cls)

Type of function used to differentiate between modified and not modified Sampler.

Definition at line 61 of file rps-sampler_common.h.

RPS_sampler_n_rand_peers_ready_cb

typedef void(* RPS_sampler_n_rand_peers_ready_cb) (const struct GNUNET_PeerIdentity *ids, uint32_t num_peers, void *cls)

Callback that is called from _get_n_rand_peers() when the PeerIDs are ready.

Parameters

cls	the closure given alongside this function.
ids	the PeerIDs that were returned to be freed

Definition at line 72 of file rps-sampler_common.h.

RPS_sampler_sinlge_info_ready_cb

typedef void(* RPS_sampler_sinlge_info_ready_cb) (const struct GNUNET_PeerIdentity *ids, void *cls, double probability, uint32_t num_observed)

Callback that is called from _get_n_rand_peers() when the PeerIDs are ready.

Parameters

cls	the closure given alongside this function.
probability	Probability with which all IDs have been observed
num_observed	Number of observed IDs
ids	the PeerIDs that were returned to be freed

Definition at line 87 of file rps-sampler_common.h.

SamplerNotifyUpdateCB

typedef void(* SamplerNotifyUpdateCB) (void *cls)

Callback called each time a new peer was put into the sampler.

Parameters

cls	A possibly given closure

Definition at line 99 of file rps-sampler_common.h.

Function Documentation

RPS_sampler_update_with_nw_size()

void RPS_sampler_update_with_nw_size	(	struct RPS_Sampler *	sampler,
		uint32_t	num_peers
	)

Update the current estimate of the network size stored at the sampler.

Used for computing the condition when to return elements to the client

Parameters

sampler	The sampler to update
num_peers	The estimated value

Used for computing the condition when to return elements to the client

Only used/useful with the client sampler (Maybe move to rps-sampler_client.{h|c} ?)

Parameters

sampler	The sampler to update
num_peers	The estimated value

Definition at line 169 of file rps-sampler_common.c.

{
  sampler->num_peers_estim = num_peers;
}

References num_peers, and RPS_Sampler::num_peers_estim.

Referenced by nse_cb().

Here is the caller graph for this function:

RPS_sampler_set_desired_probability()

void RPS_sampler_set_desired_probability	(	struct RPS_Sampler *	sampler,
		double	desired_probability
	)

Set the probability that is needed at least with what a sampler element has to have observed all elements from the network.

Only used/useful with the client sampler (Maybe move to rps-sampler_client.{h|c} ?)

Parameters

sampler
desired_probability

Definition at line 187 of file rps-sampler_common.c.

{
  sampler->desired_probability = desired_probability;
}

References RPS_Sampler::desired_probability.

Referenced by GNUNET_RPS_request_peer_info(), and GNUNET_RPS_request_peers().

Here is the caller graph for this function:

RPS_sampler_set_deficiency_factor()

void RPS_sampler_set_deficiency_factor	(	struct RPS_Sampler *	sampler,
		double	deficiency_factor
	)

Set the deficiency factor.

Only used/useful with the client sampler (Maybe move to rps-sampler_client.{h|c} ?)

Parameters

sampler
desired_probability

Definition at line 195 of file rps-sampler_common.c.

{
  sampler->deficiency_factor = deficiency_factor;
}

References RPS_Sampler::deficiency_factor.

Referenced by GNUNET_RPS_request_peer_info(), and GNUNET_RPS_request_peers().

Here is the caller graph for this function:

sampler_notify_on_update()

struct SamplerNotifyUpdateCTX * sampler_notify_on_update	(	struct RPS_Sampler *	sampler,
		SamplerNotifyUpdateCB	notify_cb,
		void *	cls
	)

Add a callback that will be called when the next peer is inserted into the sampler.

Parameters

sampler	The sampler on which update it will be called
notify_cb	The callback
cls	Closure given to the callback

Returns

The context containing callback and closure

Definition at line 213 of file rps-sampler_common.c.

{
  struct SamplerNotifyUpdateCTX *notify_ctx;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Inserting new context for notification\n");
  notify_ctx = GNUNET_new (struct SamplerNotifyUpdateCTX);
  notify_ctx->notify_cb = notify_cb;
  notify_ctx->cls = cls;
  GNUNET_CONTAINER_DLL_insert (sampler->notify_ctx_head,
                               sampler->notify_ctx_tail,
                               notify_ctx);
  return notify_ctx;
}

References SamplerNotifyUpdateCTX::cls, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, LOG, SamplerNotifyUpdateCTX::notify_cb, notify_cb(), RPS_Sampler::notify_ctx_head, and RPS_Sampler::notify_ctx_tail.

Referenced by sampler_get_rand_peer(), and sampler_mod_get_rand_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

RPS_sampler_update()

void RPS_sampler_update	(	struct RPS_Sampler *	sampler,
		const struct GNUNET_PeerIdentity *	id
	)

Update every sampler element of this sampler with given peer.

Parameters

sampler	the sampler to update.
id	the PeerID that is put in the sampler

Definition at line 285 of file rps-sampler_common.c.

{
  for (uint32_t i = 0; i < sampler->sampler_size; i++)
  {
    RPS_sampler_elem_next (sampler->sampler_elements[i],
                           id);
  }
  notify_update (sampler);
}

RPS_sampler_reinitialise_by_value()

void RPS_sampler_reinitialise_by_value	(	struct RPS_Sampler *	sampler,
		const struct GNUNET_PeerIdentity *	id
	)

Reinitialise all previously initialised sampler elements with the given value.

Used to get rid of a PeerID.

Parameters

sampler	the sampler to reinitialise a sampler element in.
id	the id of the sampler elements to update.

Used to get rid of a PeerID.

FIXME: This should also consider currently pending requests (Pending requests already collect peerids. As long as not all requested IDs have been collected, they are kept. Ideally, the id should be removed from all pending requests. This seems quite complicated.)

Parameters

sampler	the sampler to reinitialise a sampler element in.
id	the id of the sampler elements to update.

Definition at line 312 of file rps-sampler_common.c.

{
  uint32_t i;
 
  for (i = 0; i < sampler->sampler_size; i++)
  {
    if (0 == GNUNET_memcmp (id,
                            &(sampler->sampler_elements[i]->peer_id)))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG, "Reinitialising sampler\n");
      RPS_sampler_elem_reinit (sampler->sampler_elements[i]);
    }
  }
}

RPS_sampler_get_size()

unsigned int RPS_sampler_get_size

(

struct RPS_Sampler *

sampler

)

Get the size of the sampler.

Parameters

sampler

the sampler to return the size of.

Returns

the size of the sampler

Definition at line 238 of file rps-sampler_common.c.

{
  return sampler->sampler_size;
}

RPS_sampler_resize()

void RPS_sampler_resize	(	struct RPS_Sampler *	sampler,
		unsigned int	new_size
	)

Grow or shrink the size of the sampler.

Parameters

sampler	the sampler to resize.
new_size	the new size of the sampler

Definition at line 423 of file rps-sampler_common.c.

{
  GNUNET_assert (0 < new_size);
  sampler_resize (sampler, new_size);
}

RPS_sampler_get_n_rand_peers()

struct RPS_SamplerRequestHandle * RPS_sampler_get_n_rand_peers	(	struct RPS_Sampler *	sampler,
		uint32_t	num_peers,
		RPS_sampler_n_rand_peers_ready_cb	cb,
		void *	cls
	)

Get n random peers out of the sampled peers.

We might want to reinitialise this sampler after giving the corrsponding peer to the client. Random with or without consumption?

Parameters

sampler	the sampler to get peers from.
cb	callback that will be called once the ids are ready.
cls	closure given to cb
num_peers	the number of peers requested

We might want to reinitialise this sampler after giving the corrsponding peer to the client. Random with or without consumption?

Parameters

sampler	the sampler to get peers from.
cb	callback that will be called once the ids are ready.
cls	closure given to cb
for_client	GNUNET_YES if result is used for client, GNUNET_NO if used internally
num_peers	the number of peers requested

Definition at line 549 of file rps-sampler_common.c.

{
  uint32_t i;
  struct RPS_SamplerRequestHandle *req_handle;
  struct GetPeerCls *gpc;
 
  GNUNET_assert (0 != sampler->sampler_size);
  if (0 == num_peers)
    return NULL;
 
  // TODO check if we have too much (distinct) sampled peers
  req_handle = GNUNET_new (struct RPS_SamplerRequestHandle);
  req_handle->num_peers = num_peers;
  req_handle->cur_num_peers = 0;
  req_handle->ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
  req_handle->sampler = sampler;
  req_handle->callback = cb;
  req_handle->cls = cls;
  GNUNET_CONTAINER_DLL_insert (sampler->req_handle_head,
                               sampler->req_handle_tail,
                               req_handle);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Scheduling requests for %" PRIu32 " peers\n", num_peers);
 
  for (i = 0; i < num_peers; i++)
  {
    gpc = GNUNET_new (struct GetPeerCls);
    gpc->req_handle = req_handle;
    gpc->req_single_info_handle = NULL;
    gpc->cont = check_n_peers_ready;
    gpc->cont_cls = req_handle;
    gpc->id = &req_handle->ids[i];
 
    GNUNET_CONTAINER_DLL_insert (req_handle->gpc_head,
                                 req_handle->gpc_tail,
                                 gpc);
    // maybe add a little delay
    gpc->get_peer_task = GNUNET_SCHEDULER_add_now (sampler->get_peers,
                                                   gpc);
  }
  return req_handle;
}

RPS_sampler_get_rand_peer_info()

struct RPS_SamplerRequestHandleSingleInfo * RPS_sampler_get_rand_peer_info	(	struct RPS_Sampler *	sampler,
		RPS_sampler_sinlge_info_ready_cb	cb,
		void *	cls
	)

Get one random peer with additional information.

Parameters

sampler	the sampler to get peers from.
cb	callback that will be called once the ids are ready.
cls	closure given to cb

Definition at line 605 of file rps-sampler_common.c.

{
  struct RPS_SamplerRequestHandleSingleInfo *req_handle;
  struct GetPeerCls *gpc;
 
  GNUNET_assert (0 != sampler->sampler_size);
 
  // TODO check if we have too much (distinct) sampled peers
  req_handle = GNUNET_new (struct RPS_SamplerRequestHandleSingleInfo);
  req_handle->id = GNUNET_malloc (sizeof(struct GNUNET_PeerIdentity));
  req_handle->sampler = sampler;
  req_handle->callback = cb;
  req_handle->cls = cls;
  GNUNET_CONTAINER_DLL_insert (sampler->req_handle_single_head,
                               sampler->req_handle_single_tail,
                               req_handle);
 
  gpc = GNUNET_new (struct GetPeerCls);
  gpc->req_handle = NULL;
  gpc->req_single_info_handle = req_handle;
  gpc->cont = check_peer_info_ready;
  gpc->cont_cls = req_handle;
  gpc->id = req_handle->id;
 
  GNUNET_CONTAINER_DLL_insert (req_handle->gpc_head,
                               req_handle->gpc_tail,
                               gpc);
  // maybe add a little delay
  gpc->get_peer_task = GNUNET_SCHEDULER_add_now (sampler->get_peers,
                                                 gpc);
  return req_handle;
}

References check_peer_info_ready(), GetPeerCls::cont, GetPeerCls::cont_cls, GetPeerCls::get_peer_task, RPS_Sampler::get_peers, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_malloc, GNUNET_new, GNUNET_SCHEDULER_add_now(), GetPeerCls::id, req_handle, GetPeerCls::req_handle, RPS_Sampler::req_handle_single_head, RPS_Sampler::req_handle_single_tail, GetPeerCls::req_single_info_handle, GNUNET_RPS_Request_Handle::sampler, and RPS_Sampler::sampler_size.

Referenced by GNUNET_RPS_request_peer_info().

Here is the call graph for this function:

Here is the caller graph for this function:

RPS_sampler_count_id()

uint32_t RPS_sampler_count_id	(	struct RPS_Sampler *	sampler,
		const struct GNUNET_PeerIdentity *	id
	)

Counts how many Samplers currently hold a given PeerID.

Parameters

sampler	the sampler to count ids in.
id	the PeerID to count.

Returns

the number of occurrences of id.

Definition at line 338 of file rps-sampler_common.c.

{
  uint32_t count;
  uint32_t i;
 
  count = 0;
  for (i = 0; i < sampler->sampler_size; i++)
  {
    if ((0 == GNUNET_memcmp (&sampler->sampler_elements[i]->peer_id, id))
        && (EMPTY != sampler->sampler_elements[i]->is_empty) )
      count++;
  }
  return count;
}

RPS_sampler_request_cancel()

void RPS_sampler_request_cancel

(

struct RPS_SamplerRequestHandle *

req_handle

)

Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb.

Parameters

req_handle

the handle to the request

Definition at line 647 of file rps-sampler_common.c.

{
  struct GetPeerCls *i;
 
  while (NULL != (i = req_handle->gpc_head))
  {
    GNUNET_CONTAINER_DLL_remove (req_handle->gpc_head,
                                 req_handle->gpc_tail,
                                 i);
    if (NULL != i->get_peer_task)
    {
      GNUNET_SCHEDULER_cancel (i->get_peer_task);
    }
    if (NULL != i->notify_ctx)
    {
      GNUNET_CONTAINER_DLL_remove (req_handle->sampler->notify_ctx_head,
                                   req_handle->sampler->notify_ctx_tail,
                                   i->notify_ctx);
      GNUNET_free (i->notify_ctx);
      i->notify_ctx = NULL;
    }
    GNUNET_free (i);
  }
  GNUNET_free (req_handle->ids);
  req_handle->ids = NULL;
  GNUNET_CONTAINER_DLL_remove (req_handle->sampler->req_handle_head,
                               req_handle->sampler->req_handle_tail,
                               req_handle);
  GNUNET_free (req_handle);
}

Referenced by check_n_peers_ready(), and RPS_sampler_destroy().

Here is the caller graph for this function:

RPS_sampler_request_single_info_cancel()

void RPS_sampler_request_single_info_cancel

(

struct RPS_SamplerRequestHandleSingleInfo *

req_single_info_handle

)

Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb.

Parameters

req_handle

the handle to the request

Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb.

Parameters

req_handle

the handle to the request

Definition at line 685 of file rps-sampler_common.c.

{
  struct GetPeerCls *i;
 
  while (NULL != (i = req_single_info_handle->gpc_head))
  {
    GNUNET_CONTAINER_DLL_remove (req_single_info_handle->gpc_head,
                                 req_single_info_handle->gpc_tail,
                                 i);
    if (NULL != i->get_peer_task)
    {
      GNUNET_SCHEDULER_cancel (i->get_peer_task);
    }
    if (NULL != i->notify_ctx)
    {
      GNUNET_CONTAINER_DLL_remove (
        req_single_info_handle->sampler->notify_ctx_head,
        req_single_info_handle->sampler->
        notify_ctx_tail,
        i->notify_ctx);
      GNUNET_free (i->notify_ctx);
      i->notify_ctx = NULL;
    }
    GNUNET_free (i);
  }
  GNUNET_free (req_single_info_handle->id);
  req_single_info_handle->id = NULL;
  GNUNET_CONTAINER_DLL_remove (
    req_single_info_handle->sampler->req_handle_single_head,
    req_single_info_handle->sampler->
    req_handle_single_tail,
    req_single_info_handle);
  GNUNET_free (req_single_info_handle);
}

References GetPeerCls::get_peer_task, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), RPS_SamplerRequestHandleSingleInfo::gpc_head, RPS_SamplerRequestHandleSingleInfo::gpc_tail, RPS_SamplerRequestHandleSingleInfo::id, GetPeerCls::notify_ctx, RPS_Sampler::notify_ctx_head, RPS_Sampler::req_handle_single_head, GetPeerCls::req_single_info_handle, and RPS_SamplerRequestHandleSingleInfo::sampler.

Referenced by check_peer_info_ready(), and GNUNET_RPS_request_single_info_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

RPS_sampler_destroy()

void RPS_sampler_destroy

(

struct RPS_Sampler *

sampler

)

Cleans the sampler.

Cleans the samplers.

Definition at line 726 of file rps-sampler_common.c.

{
  if (NULL != sampler->req_handle_head)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "There are still pending requests. Going to remove them.\n");
    while (NULL != sampler->req_handle_head)
    {
      RPS_sampler_request_cancel (sampler->req_handle_head);
    }
  }
  sampler_empty (sampler);
  GNUNET_free (sampler);
}