rps-sampler_common.c File Reference

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

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "rps-sampler_common.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.c:

Go to the source code of this file.

Data Structures
struct	SamplerNotifyUpdateCTX
	Context for a callback. More...
struct	RPS_SamplerRequestHandle
	Closure to _get_n_rand_peers_ready_cb() More...
struct	RPS_SamplerRequestHandleSingleInfo
	Closure to _get_rand_peer_info() More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "rps-sampler_common", __VA_ARGS__)

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...
unsigned int	RPS_sampler_get_size (struct RPS_Sampler *sampler)
	Get the size of the sampler. More...
static void	notify_update (struct RPS_Sampler *sampler)
	Notify about update of 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...
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...
static void	sampler_resize (struct RPS_Sampler *sampler, unsigned int new_size)
	Grow or shrink 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...
static void	sampler_empty (struct RPS_Sampler *sampler)
	Empty the sampler. More...
static void	check_n_peers_ready (void *cls, const struct GNUNET_PeerIdentity *id, double probability, uint32_t num_observed)
	Callback to _get_rand_peer() used by _get_n_rand_peers(). More...
static void	check_peer_info_ready (void *cls, const struct GNUNET_PeerIdentity *id, double probability, uint32_t num_observed)
	Callback to _get_rand_peer() used by _get_rand_peer_info(). 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...
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_sinlge_info_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.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "rps-sampler_common", __VA_ARGS__)

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

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

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

References RPS_Sampler::sampler_size.

Referenced by adapt_sizes(), and resize_wrapper().

Here is the caller graph for this function:

notify_update()

static void notify_update ( struct RPS_Sampler *  sampler )

static

Notify about update of the sampler.

Call the callbacks that are waiting for notification on updates to the sampler.

Parameters

sampler

The sampler the updates are waiting for

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

{
  struct SamplerNotifyUpdateCTX *tmp_notify_head;
  struct SamplerNotifyUpdateCTX *tmp_notify_tail;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Calling callbacks waiting for update notification.\n");
  tmp_notify_head = sampler->notify_ctx_head;
  tmp_notify_tail = sampler->notify_ctx_tail;
  sampler->notify_ctx_head = NULL;
  sampler->notify_ctx_tail = NULL;
  for (struct SamplerNotifyUpdateCTX *notify_iter = tmp_notify_head;
       NULL != tmp_notify_head;
       notify_iter = tmp_notify_head)
  {
    GNUNET_assert (NULL != notify_iter->notify_cb);
    GNUNET_CONTAINER_DLL_remove (tmp_notify_head,
                                 tmp_notify_tail,
                                 notify_iter);
    notify_iter->notify_cb (notify_iter->cls);
    GNUNET_free (notify_iter);
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, LOG, RPS_Sampler::notify_ctx_head, and RPS_Sampler::notify_ctx_tail.

Referenced by RPS_sampler_update().

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

References notify_update(), RPS_sampler_elem_next(), RPS_Sampler::sampler_elements, and RPS_Sampler::sampler_size.

Referenced by collect_peers_cb(), collect_peers_info_cb(), and insert_in_sampler().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

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

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcmp, LOG, RPS_SamplerElement::peer_id, RPS_sampler_elem_reinit(), RPS_Sampler::sampler_elements, and RPS_Sampler::sampler_size.

Referenced by remove_peer().

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

References EMPTY, GNUNET_memcmp, RPS_SamplerElement::is_empty, RPS_SamplerElement::peer_id, RPS_Sampler::sampler_elements, and RPS_Sampler::sampler_size.

Referenced by check_sending_channel_needed(), clean_peer(), and insert_in_sampler().

Here is the caller graph for this function:

sampler_resize()

static void sampler_resize ( struct RPS_Sampler *  sampler, unsigned int  new_size  )

static

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 362 of file rps-sampler_common.c.

{
  unsigned int old_size;
  uint32_t i;
 
  // TODO check min and max size
 
  old_size = sampler->sampler_size;
 
  if (old_size > new_size)
  {   /* Shrinking */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Shrinking sampler %d -> %d\n",
         old_size,
         new_size);
 
    for (i = new_size; i < old_size; i++)
    {
      RPS_sampler_elem_destroy (sampler->sampler_elements[i]);
    }
 
    GNUNET_array_grow (sampler->sampler_elements,
                       sampler->sampler_size,
                       new_size);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "sampler->sampler_elements now points to %p\n",
         sampler->sampler_elements);
  }
  else if (old_size < new_size)
  {   /* Growing */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Growing sampler %d -> %d\n",
         old_size,
         new_size);
 
    GNUNET_array_grow (sampler->sampler_elements,
                       sampler->sampler_size,
                       new_size);
 
    for (i = old_size; i < new_size; i++)
    {     /* Add new sampler elements */
      sampler->sampler_elements[i] = RPS_sampler_elem_create ();
    }
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Size remains the same -- nothing to do\n");
    return;
  }
 
  GNUNET_assert (sampler->sampler_size == new_size);
}

References GNUNET_array_grow, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, LOG, RPS_sampler_elem_create(), RPS_sampler_elem_destroy(), RPS_Sampler::sampler_elements, and RPS_Sampler::sampler_size.

Referenced by RPS_sampler_resize(), and sampler_empty().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GNUNET_assert, and sampler_resize().

Referenced by resize_wrapper(), RPS_sampler_init(), and RPS_sampler_mod_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sampler_empty()

static void sampler_empty ( struct RPS_Sampler *  sampler )

static

Empty the sampler.

Parameters

sampler

the sampler to empty.

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

{
  sampler_resize (sampler, 0);
}

References sampler_resize().

Referenced by RPS_sampler_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

check_n_peers_ready()

static void check_n_peers_ready ( void *  cls, const struct GNUNET_PeerIdentity *  id, double  probability, uint32_t  num_observed  )

static

Callback to _get_rand_peer() used by _get_n_rand_peers().

Implements RPS_sampler_rand_peer_ready_cont

Checks whether all n peers are available. If they are, give those back.

Parameters

cls	Closure
id	Peer ID
probability	The probability with which this sampler has seen all ids
num_observed	How many ids this sampler has observed

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

{
  struct RPS_SamplerRequestHandle *req_handle = cls;
 
  (void) id;
  RPS_sampler_n_rand_peers_ready_cb tmp_cb;
  struct GNUNET_PeerIdentity *peers;
  uint32_t num_peers;
  void *cb_cls;
  (void) probability;
  (void) num_observed;
 
  req_handle->cur_num_peers++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got %" PRIX32 ". of %" PRIX32 " peers\n",
       req_handle->cur_num_peers, req_handle->num_peers);
 
  if (req_handle->num_peers == req_handle->cur_num_peers)
  {   /* All peers are ready -- return those to the client */
    GNUNET_assert (NULL != req_handle->callback);
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "returning %" PRIX32 " peers to the client\n",
         req_handle->num_peers);
 
    /* Copy pointers and peers temporarily as they
    * might be deleted from within the callback */
    tmp_cb = req_handle->callback;
    num_peers = req_handle->num_peers;
    peers = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
    GNUNET_memcpy (peers,
                   req_handle->ids,
                   num_peers * sizeof(struct GNUNET_PeerIdentity));
    cb_cls = req_handle->cls;
    RPS_sampler_request_cancel (req_handle);
    req_handle = NULL;
    tmp_cb (peers, num_peers, cb_cls);
    GNUNET_free (peers);
  }
}

References RPS_SamplerRequestHandle::cls, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_memcpy, GNUNET_new_array, LOG, num_peers, peers, req_handle, and RPS_sampler_request_cancel().

Referenced by RPS_sampler_get_n_rand_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

check_peer_info_ready()

static void check_peer_info_ready ( void *  cls, const struct GNUNET_PeerIdentity *  id, double  probability, uint32_t  num_observed  )

static

Callback to _get_rand_peer() used by _get_rand_peer_info().

Implements RPS_sampler_rand_peer_ready_cont

Parameters

cls	Closure
id	Peer ID
probability	The probability with which this sampler has seen all ids
num_observed	How many ids this sampler has observed

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

{
  struct RPS_SamplerRequestHandleSingleInfo *req_handle = cls;
 
  (void) id;
  RPS_sampler_sinlge_info_ready_cb tmp_cb;
  struct GNUNET_PeerIdentity *peer;
  void *cb_cls;
  (void) probability;
  (void) num_observed;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got single peer with additional info\n");
 
  GNUNET_assert (NULL != req_handle->callback);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "returning single peer with info to the client\n");
 
  /* Copy pointers and peers temporarily as they
  * might be deleted from within the callback */
  tmp_cb = req_handle->callback;
  peer = GNUNET_new (struct GNUNET_PeerIdentity);
  GNUNET_memcpy (peer,
                 req_handle->id,
                 sizeof(struct GNUNET_PeerIdentity));
  cb_cls = req_handle->cls;
  RPS_sampler_request_single_info_cancel (req_handle);
  req_handle = NULL;
  tmp_cb (peer, cb_cls, probability, num_observed);
  GNUNET_free (peer);
}

References RPS_SamplerRequestHandleSingleInfo::cls, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_memcpy, GNUNET_new, LOG, req_handle, and RPS_sampler_request_single_info_cancel().

Referenced by RPS_sampler_get_rand_peer_info().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References check_n_peers_ready(), GetPeerCls::cont, GetPeerCls::cont_cls, GetPeerCls::get_peer_task, RPS_Sampler::get_peers, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_new_array, GNUNET_SCHEDULER_add_now(), GetPeerCls::id, LOG, num_peers, req_handle, GetPeerCls::req_handle, RPS_Sampler::req_handle_head, RPS_Sampler::req_handle_tail, GetPeerCls::req_single_info_handle, GNUNET_RPS_Request_Handle::sampler, and RPS_Sampler::sampler_size.

Referenced by do_round(), and GNUNET_RPS_request_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GetPeerCls::get_peer_task, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GetPeerCls::notify_ctx, RPS_Sampler::notify_ctx_head, RPS_Sampler::notify_ctx_tail, req_handle, RPS_Sampler::req_handle_head, RPS_Sampler::req_handle_tail, and GNUNET_RPS_Request_Handle::sampler.

Referenced by check_n_peers_ready(), GNUNET_RPS_request_cancel(), and RPS_sampler_destroy().

Here is the call graph for this function:

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_sinlge_info_ready_cb.

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

References GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG, RPS_Sampler::req_handle_head, RPS_sampler_request_cancel(), and sampler_empty().

Referenced by destroy_sub(), GNUNET_RPS_request_cancel(), and GNUNET_RPS_request_single_info_cancel().

Here is the call graph for this function:

Here is the caller graph for this function: