GNUnet  0.11.x
Data Structures | Macros | Functions
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 SamplerNotifyUpdateCTXsampler_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_SamplerRequestHandleRPS_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_SamplerRequestHandleSingleInfoRPS_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
samplerThe sampler to update
num_peersThe estimated value

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

171 {
172  sampler->num_peers_estim = num_peers;
173 }
static unsigned int num_peers
uint32_t num_peers_estim
The estimated total number of peers in the network.

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.

189 {
190  sampler->desired_probability = desired_probability;
191 }
double desired_probability
The desired probability with which we want to have observed all peers.

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

206 {
207  sampler->deficiency_factor = deficiency_factor;
208 }
double deficiency_factor
A factor that catches the 'bias' of a random stream of peer ids.

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
samplerThe sampler on which update it will be called
notify_cbThe callback
clsClosure given to the callback
Returns
The context containing callback and closure

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

225 {
226  struct SamplerNotifyUpdateCTX *notify_ctx;
227 
229  "Inserting new context for notification\n");
230  notify_ctx = GNUNET_new (struct SamplerNotifyUpdateCTX);
231  notify_ctx->notify_cb = notify_cb;
232  notify_ctx->cls = cls;
234  sampler->notify_ctx_tail,
235  notify_ctx);
236  return notify_ctx;
237 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define LOG(kind,...)
struct SamplerNotifyUpdateCTX * notify_ctx_head
struct SamplerNotifyUpdateCTX * notify_ctx_tail
SamplerNotifyUpdateCB notify_cb
The Callback to call on updates.
void * cls
The according closure.

References SamplerNotifyUpdateCTX::cls, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, LOG, SamplerNotifyUpdateCTX::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 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
samplerthe sampler to return the size of.
Returns
the size of the sampler

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

248 {
249  return sampler->sampler_size;
250 }
unsigned int sampler_size
Number of sampler elements we hold.

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
samplerThe sampler the updates are waiting for

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

263 {
264  struct SamplerNotifyUpdateCTX *tmp_notify_head;
265  struct SamplerNotifyUpdateCTX *tmp_notify_tail;
266 
268  "Calling callbacks waiting for update notification.\n");
269  tmp_notify_head = sampler->notify_ctx_head;
270  tmp_notify_tail = sampler->notify_ctx_tail;
271  sampler->notify_ctx_head = NULL;
272  sampler->notify_ctx_tail = NULL;
273  for (struct SamplerNotifyUpdateCTX *notify_iter = tmp_notify_head;
274  NULL != tmp_notify_head;
275  notify_iter = tmp_notify_head)
276  {
277  GNUNET_assert (NULL != notify_iter->notify_cb);
278  GNUNET_CONTAINER_DLL_remove (tmp_notify_head,
279  tmp_notify_tail,
280  notify_iter);
281  notify_iter->notify_cb (notify_iter->cls);
282  GNUNET_free (notify_iter);
283  }
284 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.

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
samplerthe sampler to update.
idthe PeerID that is put in the sampler

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

296 {
297  for (uint32_t i = 0; i < sampler->sampler_size; i++)
298  {
300  id);
301  }
302  notify_update (sampler);
303 }
void RPS_sampler_elem_next(struct RPS_SamplerElement *sampler_elem, const struct GNUNET_PeerIdentity *new_ID)
Update a sampler element with a PeerID.
static void notify_update(struct RPS_Sampler *sampler)
Notify about update of the sampler.
struct RPS_SamplerElement ** sampler_elements
All sampler elements in one array.

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
samplerthe sampler to reinitialise a sampler element in.
idthe id of the sampler elements to update.

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

323 {
324  uint32_t i;
325 
326  for (i = 0; i < sampler->sampler_size; i++)
327  {
328  if (0 == GNUNET_memcmp (id,
329  &(sampler->sampler_elements[i]->peer_id)))
330  {
331  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reinitialising sampler\n");
333  }
334  }
335 }
void RPS_sampler_elem_reinit(struct RPS_SamplerElement *sampler_elem)
Reinitialise a previously initialised sampler element.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_PeerIdentity peer_id
The PeerID this sampler currently samples.

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
samplerthe sampler to count ids in.
idthe PeerID to count.
Returns
the number of occurrences of id.

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

349 {
350  uint32_t count;
351  uint32_t i;
352 
353  count = 0;
354  for (i = 0; i < sampler->sampler_size; i++)
355  {
356  if ((0 == GNUNET_memcmp (&sampler->sampler_elements[i]->peer_id, id))
357  && (EMPTY != sampler->sampler_elements[i]->is_empty) )
358  count++;
359  }
360  return count;
361 }
enum RPS_SamplerEmpty is_empty
Flag that indicates that we are not holding a valid PeerID right now.

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
samplerthe sampler to resize.
new_sizethe new size of the sampler

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

372 {
373  unsigned int old_size;
374  uint32_t i;
375 
376  // TODO check min and max size
377 
378  old_size = sampler->sampler_size;
379 
380  if (old_size > new_size)
381  { /* Shrinking */
383  "Shrinking sampler %d -> %d\n",
384  old_size,
385  new_size);
386 
387  for (i = new_size; i < old_size; i++)
388  {
390  }
391 
393  sampler->sampler_size,
394  new_size);
396  "sampler->sampler_elements now points to %p\n",
397  sampler->sampler_elements);
398  }
399  else if (old_size < new_size)
400  { /* Growing */
402  "Growing sampler %d -> %d\n",
403  old_size,
404  new_size);
405 
407  sampler->sampler_size,
408  new_size);
409 
410  for (i = old_size; i < new_size; i++)
411  { /* Add new sampler elements */
412  sampler->sampler_elements[i] = RPS_sampler_elem_create ();
413  }
414  }
415  else
416  {
417  LOG (GNUNET_ERROR_TYPE_DEBUG, "Size remains the same -- nothing to do\n");
418  return;
419  }
420 
421  GNUNET_assert (sampler->sampler_size == new_size);
422 }
void RPS_sampler_elem_destroy(struct RPS_SamplerElement *sampler_elem)
Destroy a sampler element.
struct RPS_SamplerElement * RPS_sampler_elem_create(void)
Create a sampler element and initialise it.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.

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
samplerthe sampler to resize.
new_sizethe new size of the sampler

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

433 {
434  GNUNET_assert (0 < new_size);
435  sampler_resize (sampler, new_size);
436 }
static void sampler_resize(struct RPS_Sampler *sampler, unsigned int new_size)
Grow or shrink the size of the sampler.

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
samplerthe sampler to empty.
new_sizethe new size of the sampler

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

447 {
448  sampler_resize (sampler, 0);
449 }

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
clsClosure
idPeer ID
probabilityThe probability with which this sampler has seen all ids
num_observedHow many ids this sampler has observed

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

469 {
471 
472  (void) id;
474  struct GNUNET_PeerIdentity *peers;
475  uint32_t num_peers;
476  void *cb_cls;
477  (void) probability;
478  (void) num_observed;
479 
480  req_handle->cur_num_peers++;
482  "Got %" PRIX32 ". of %" PRIX32 " peers\n",
483  req_handle->cur_num_peers, req_handle->num_peers);
484 
485  if (req_handle->num_peers == req_handle->cur_num_peers)
486  { /* All peers are ready -- return those to the client */
487  GNUNET_assert (NULL != req_handle->callback);
488 
490  "returning %" PRIX32 " peers to the client\n",
491  req_handle->num_peers);
492 
493  /* Copy pointers and peers temporarily as they
494  * might be deleted from within the callback */
495  tmp_cb = req_handle->callback;
496  num_peers = req_handle->num_peers;
499  req_handle->ids,
500  num_peers * sizeof(struct GNUNET_PeerIdentity));
501  cb_cls = req_handle->cls;
503  req_handle = NULL;
504  tmp_cb (peers, num_peers, cb_cls);
505  GNUNET_free (peers);
506  }
507 }
static struct CadetPeer * peers
Operation to get peer ids.
static struct GNUNET_RPS_Request_Handle * req_handle
Request handle.
Definition: gnunet-rps.c:41
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
void RPS_sampler_request_cancel(struct RPS_SamplerRequestHandle *req_handle)
Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb.
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.
The identity of the host (wraps the signing key of the peer).
Closure to _get_n_rand_peers_ready_cb()
void * cls
Closure given to the callback.

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
clsClosure
idPeer ID
probabilityThe probability with which this sampler has seen all ids
num_observedHow many ids this sampler has observed

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

525 {
527 
528  (void) id;
530  struct GNUNET_PeerIdentity *peer;
531  void *cb_cls;
532  (void) probability;
533  (void) num_observed;
534 
536  "Got single peer with additional info\n");
537 
538  GNUNET_assert (NULL != req_handle->callback);
539 
541  "returning single peer with info to the client\n");
542 
543  /* Copy pointers and peers temporarily as they
544  * might be deleted from within the callback */
545  tmp_cb = req_handle->callback;
548  req_handle->id,
549  sizeof(struct GNUNET_PeerIdentity));
550  cb_cls = req_handle->cls;
552  req_handle = NULL;
553  tmp_cb (peer, cb_cls, probability, num_observed);
554  GNUNET_free (peer);
555 }
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.
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.
Closure to _get_rand_peer_info()
void * cls
Closure given to the callback.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References RPS_SamplerRequestHandleSingleInfo::cls, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_memcpy, GNUNET_new, LOG, peer, 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
samplerthe sampler to get peers from.
cbcallback that will be called once the ids are ready.
clsclosure given to cb
num_peersthe number of peers requested

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

575 {
576  uint32_t i;
578  struct GetPeerCls *gpc;
579 
580  GNUNET_assert (0 != sampler->sampler_size);
581  if (0 == num_peers)
582  return NULL;
583 
584  // TODO check if we have too much (distinct) sampled peers
586  req_handle->num_peers = num_peers;
587  req_handle->cur_num_peers = 0;
589  req_handle->sampler = sampler;
590  req_handle->callback = cb;
591  req_handle->cls = cls;
593  sampler->req_handle_tail,
594  req_handle);
595 
597  "Scheduling requests for %" PRIu32 " peers\n", num_peers);
598 
599  for (i = 0; i < num_peers; i++)
600  {
601  gpc = GNUNET_new (struct GetPeerCls);
602  gpc->req_handle = req_handle;
603  gpc->req_single_info_handle = NULL;
604  gpc->cont = check_n_peers_ready;
605  gpc->cont_cls = req_handle;
606  gpc->id = &req_handle->ids[i];
607 
609  req_handle->gpc_tail,
610  gpc);
611  // maybe add a little delay
613  gpc);
614  }
615  return req_handle;
616 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
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().
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:174
Closure for sampler_mod_get_rand_peer() and sampler_get_rand_peer.
struct RPS_SamplerRequestHandleSingleInfo * req_single_info_handle
The RPS_SamplerRequestHandleSingleInfo this single request belongs to.
struct GNUNET_PeerIdentity * id
The address of the id to be stored at.
RPS_sampler_rand_peer_ready_cont cont
The callback.
struct RPS_SamplerRequestHandle * req_handle
The RPS_SamplerRequestHandle this single request belongs to.
struct GNUNET_SCHEDULER_Task * get_peer_task
The task for this function.
void * cont_cls
The closure to the callback cont.
struct RPS_SamplerRequestHandle * req_handle_head
Head and tail for the DLL to store the RPS_SamplerRequestHandle.
RPS_get_peers_type get_peers
Stores the function to return peers.
struct RPS_SamplerRequestHandle * req_handle_tail

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
samplerthe sampler to get peers from.
cbcallback that will be called once the ids are ready.
clsclosure given to cb

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

630 {
632  struct GetPeerCls *gpc;
633 
634  GNUNET_assert (0 != sampler->sampler_size);
635 
636  // TODO check if we have too much (distinct) sampled peers
638  req_handle->id = GNUNET_malloc (sizeof(struct GNUNET_PeerIdentity));
639  req_handle->sampler = sampler;
640  req_handle->callback = cb;
641  req_handle->cls = cls;
643  sampler->req_handle_single_tail,
644  req_handle);
645 
646  gpc = GNUNET_new (struct GetPeerCls);
647  gpc->req_handle = NULL;
650  gpc->cont_cls = req_handle;
651  gpc->id = req_handle->id;
652 
654  req_handle->gpc_tail,
655  gpc);
656  // maybe add a little delay
658  gpc);
659  return req_handle;
660 }
#define GNUNET_malloc(size)
Wrapper around malloc.
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().
struct RPS_SamplerRequestHandleSingleInfo * req_handle_single_tail
struct RPS_SamplerRequestHandleSingleInfo * req_handle_single_head
Head and tail for the DLL to store the RPS_SamplerRequestHandleSingleInfo.

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_handlethe handle to the request

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

670 {
671  struct GetPeerCls *i;
672 
673  while (NULL != (i = req_handle->gpc_head))
674  {
676  req_handle->gpc_tail,
677  i);
678  if (NULL != i->get_peer_task)
679  {
681  }
682  if (NULL != i->notify_ctx)
683  {
686  i->notify_ctx);
687  GNUNET_free (i->notify_ctx);
688  i->notify_ctx = NULL;
689  }
690  GNUNET_free (i);
691  }
692  GNUNET_free (req_handle->ids);
693  req_handle->ids = NULL;
696  req_handle);
698 }
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct SamplerNotifyUpdateCTX * notify_ctx
Context to the given callback.

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_handlethe handle to the request

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

709 {
710  struct GetPeerCls *i;
711 
712  while (NULL != (i = req_single_info_handle->gpc_head))
713  {
716  i);
717  if (NULL != i->get_peer_task)
718  {
720  }
721  if (NULL != i->notify_ctx)
722  {
726  notify_ctx_tail,
727  i->notify_ctx);
728  GNUNET_free (i->notify_ctx);
729  i->notify_ctx = NULL;
730  }
731  GNUNET_free (i);
732  }
734  req_single_info_handle->id = NULL;
738  req_handle_single_tail,
741 }
struct RPS_Sampler * sampler
Sampler.
struct GetPeerCls * gpc_head
Head and tail for the DLL to store the tasks for single requests.
struct GNUNET_PeerIdentity * id
Pointer to the id.

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

749 {
750  if (NULL != sampler->req_handle_head)
751  {
753  "There are still pending requests. Going to remove them.\n");
754  while (NULL != sampler->req_handle_head)
755  {
757  }
758  }
759  sampler_empty (sampler);
760  GNUNET_free (sampler);
761 }
@ GNUNET_ERROR_TYPE_WARNING
static void sampler_empty(struct RPS_Sampler *sampler)
Empty the 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: