rps-sampler_client.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "rps.h"
#include "rps-sampler_common.h"
#include "gnunet-service-rps_sampler.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_client.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", __VA_ARGS__)

Typedefs
typedef void(*	SamplerNotifyUpdateCB) (void *cls)
	Callback called each time a new peer was put into the sampler. More...
typedef void(*	RPS_get_peers_type) (void *cls)
	Type of function used to differentiate between modified and not modified Sampler. More...

Functions
static void	sampler_mod_get_rand_peer (void *cls)
	Get one random peer out of the sampled peers. 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...

Variables
static size_t	min_size
	‍** More...
static size_t	max_size
	The maximal size the extended sampler elements should grow to. More...
static uint32_t	client_get_index
	The size the extended sampler elements currently have. More...

Macro Definition Documentation

LOG

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

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

Typedef Documentation

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 63 of file rps-sampler_client.c.

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 99 of file rps-sampler_client.c.

Function Documentation

sampler_mod_get_rand_peer()

static void sampler_mod_get_rand_peer ( void *  cls )

static

Get one random peer out of the sampled peers.

We might want to reinitialise this sampler after giving the corrsponding peer to the client.

This reinitialises the queried sampler element.

• How many time remains untile the next round has started? *‍/
• check if probability is above desired *‍/

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

{
  struct GetPeerCls *gpc = cls;
  struct RPS_SamplerElement *s_elem;
  struct GNUNET_TIME_Relative last_request_diff;
  struct RPS_Sampler *sampler;
  double prob_observed_n;
  uint32_t num_observed;
 
  gpc->get_peer_task = NULL;
  gpc->notify_ctx = NULL;
  GNUNET_assert ((NULL != gpc->req_handle) ||
                 (NULL != gpc->req_single_info_handle));
  if (NULL != gpc->req_handle)
    sampler = gpc->req_handle->sampler;
  else
    sampler = gpc->req_single_info_handle->sampler;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Single peer was requested\n");
 
  /* Cycle the #client_get_index one step further */
  client_get_index = (client_get_index + 1) % sampler->sampler_size;
 
  s_elem = sampler->sampler_elements[client_get_index];
  *gpc->id = s_elem->peer_id;
  GNUNET_assert (NULL != s_elem);
 
  if (EMPTY == s_elem->is_empty)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sampler_mod element empty, rescheduling.\n");
    GNUNET_assert (NULL == gpc->notify_ctx);
    gpc->notify_ctx =
      sampler_notify_on_update (sampler,
                                &sampler_mod_get_rand_peer,
                                gpc);
    return;
  }
 
  /* Check whether we may use this sampler to give it back to the client */
  if (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us !=
      s_elem->last_client_request.abs_value_us)
  {
    // TODO remove this condition at least for the client sampler
    last_request_diff =
      GNUNET_TIME_absolute_get_difference (s_elem->last_client_request,
                                           GNUNET_TIME_absolute_get ());
    /* We're not going to give it back now if it was
     * already requested by a client this round */
    if (last_request_diff.rel_value_us <
        sampler->max_round_interval.rel_value_us)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Last client request on this sampler was less than max round interval ago -- scheduling for later\n");
      // inv_last_request_diff =
      //  GNUNET_TIME_absolute_get_difference (last_request_diff,
      //                                       sampler->max_round_interval);
      // add a little delay
      /* Schedule it one round later */
      GNUNET_assert (NULL == gpc->notify_ctx);
      gpc->notify_ctx =
        sampler_notify_on_update (sampler,
                                  &sampler_mod_get_rand_peer,
                                  gpc);
      return;
    }
  }
  if (2 > s_elem->num_peers)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "This s_elem saw less than two peers -- scheduling for later\n");
    GNUNET_assert (NULL == gpc->notify_ctx);
    gpc->notify_ctx =
      sampler_notify_on_update (sampler,
                                &sampler_mod_get_rand_peer,
                                gpc);
    return;
  }
  /* compute probability */
  /* FIXME: Currently disabled due to numerical limitations */
  prob_observed_n = 0; // Inititialise to some value
  // prob_observed_n = prob_observed_n_peers (sampler->num_peers_estim,
  //                                         s_elem->num_peers,
  //                                         sampler->deficiency_factor);
  // LOG (GNUNET_ERROR_TYPE_DEBUG,
  //    "Computed sample - prob %f, %" PRIu32 " peers, n: %" PRIu32 ", roh: %f\n",
  //    prob_observed_n,
  //    s_elem->num_peers,
  //    sampler->num_peers_estim,
  //    sampler->deficiency_factor);
  // if (prob_observed_n < sampler->desired_probability)
  // {
  //  LOG (GNUNET_ERROR_TYPE_DEBUG,
  //      "Probability of having observed all peers (%f) too small ( < %f).\n",
  //      prob_observed_n,
  //      sampler->desired_probability);
  //  GNUNET_assert (NULL == gpc->notify_ctx);
  //  gpc->notify_ctx =
  //    sampler_notify_on_update (sampler,
  //                              &sampler_mod_get_rand_peer,
  //                              gpc);
  //  return;
  // }
  /* More reasons to wait could be added here */
 
//  GNUNET_STATISTICS_set (stats,
//                         "# client sampler element input",
//                         s_elem->num_peers,
//                         GNUNET_NO);
//  GNUNET_STATISTICS_set (stats,
//                         "# client sampler element change",
//                         s_elem->num_change,
//                         GNUNET_NO);
 
  num_observed = s_elem->num_peers;
  RPS_sampler_elem_reinit (s_elem);
  s_elem->last_client_request = GNUNET_TIME_absolute_get ();
 
  if (NULL != gpc->req_handle)
  {
    GNUNET_CONTAINER_DLL_remove (gpc->req_handle->gpc_head,
                                 gpc->req_handle->gpc_tail,
                                 gpc);
  }
  else
  {
    GNUNET_CONTAINER_DLL_remove (gpc->req_single_info_handle->gpc_head,
                                 gpc->req_single_info_handle->gpc_tail,
                                 gpc);
  }
  gpc->cont (gpc->cont_cls, gpc->id, prob_observed_n, num_observed);
  GNUNET_free (gpc);
}

References GNUNET_TIME_Absolute::abs_value_us, client_get_index, GetPeerCls::cont, GetPeerCls::cont_cls, EMPTY, GetPeerCls::get_peer_task, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_UNIT_FOREVER_ABS, RPS_SamplerRequestHandle::gpc_head, RPS_SamplerRequestHandleSingleInfo::gpc_head, RPS_SamplerRequestHandle::gpc_tail, RPS_SamplerRequestHandleSingleInfo::gpc_tail, GetPeerCls::id, RPS_SamplerElement::is_empty, RPS_SamplerElement::last_client_request, LOG, RPS_Sampler::max_round_interval, GetPeerCls::notify_ctx, RPS_SamplerElement::num_peers, RPS_SamplerElement::peer_id, GNUNET_TIME_Relative::rel_value_us, GetPeerCls::req_handle, GetPeerCls::req_single_info_handle, RPS_sampler_elem_reinit(), RPS_SamplerRequestHandle::sampler, RPS_SamplerRequestHandleSingleInfo::sampler, RPS_Sampler::sampler_elements, sampler_mod_get_rand_peer(), sampler_notify_on_update(), and RPS_Sampler::sampler_size.

Referenced by RPS_sampler_mod_init(), and sampler_mod_get_rand_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

Variable Documentation

min_size

size_t min_size

static

‍**

The minimal size for the extended sampler elements.

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

Referenced by RPS_sampler_mod_init().

max_size

size_t max_size

static

The maximal size the extended sampler elements should grow to.

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

Referenced by RPS_sampler_mod_init().

client_get_index

uint32_t client_get_index

static

The size the extended sampler elements currently have.

Inedex to the sampler element that is the next to be returned

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

Referenced by RPS_sampler_mod_init(), and sampler_mod_get_rand_peer().