rps-sampler_client.h File Reference

client sampler implementation More...

#include <inttypes.h>
#include "rps-sampler_common.h"

Include dependency graph for rps-sampler_client.h:

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

Go to the source code of this file.

Functions
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_Sampler *	RPS_sampler_mod_init (size_t init_size, struct GNUNET_TIME_Relative max_round_interval)
	Initialise a modified tuple of sampler elements. 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...
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...
void	RPS_sampler_request_cancel (struct RPS_SamplerRequestHandle *req_handle)
	Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb. 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_destroy (struct RPS_Sampler *sampler)
	Cleans the samplers. More...

Detailed Description

client sampler implementation

Author

Julius Bünger

Definition in file rps-sampler_client.h.

Function Documentation

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 (not 0)
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_mod_init()

struct RPS_Sampler * RPS_sampler_mod_init	(	size_t	init_size,
		struct GNUNET_TIME_Relative	max_round_interval
	)

Initialise a modified tuple of sampler elements.

Parameters

init_size	the size the sampler is initialised with
max_round_interval	maximum time a round takes

Returns

a handle to a sampler that consists of sampler elements.

Definition at line 236 of file rps-sampler_client.c.

{
  struct RPS_Sampler *sampler;
 
  /* Initialise context around extended sampler */
  min_size = 10; // TODO make input to _samplers_init()
  max_size = 1000; // TODO make input to _samplers_init()
 
  sampler = GNUNET_new (struct RPS_Sampler);
  sampler->max_round_interval = max_round_interval;
  sampler->get_peers = sampler_mod_get_rand_peer;
  // sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
  // GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
 
  client_get_index = 0;
 
  // GNUNET_assert (init_size == sampler->sampler_size);
 
  RPS_sampler_resize (sampler, init_size);
 
  return sampler;
}

References client_get_index, RPS_Sampler::get_peers, GNUNET_new, RPS_Sampler::max_round_interval, max_size, min_size, RPS_sampler_resize(), and sampler_mod_get_rand_peer().

Referenced by GNUNET_RPS_request_peer_info(), and GNUNET_RPS_request_peers().

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 in.
id	the id of the samplers 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_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_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);
}

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_destroy()

void RPS_sampler_destroy

(

struct RPS_Sampler *

sampler

)

Cleans the samplers.

Parameters

sampler

the sampler to destroy.

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);
}