GNUnet 0.22.1
gnunet-service-rps_sampler.h File Reference

sampler implementation More...

#include <inttypes.h>
#include "rps-sampler_common.h"
Include dependency graph for gnunet-service-rps_sampler.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_SamplerRPS_sampler_init (size_t init_size, struct GNUNET_TIME_Relative max_round_interval)
 Initialise a tuple of samplers. 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_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...
 
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

sampler implementation

Author
Julius Bünger

Definition in file gnunet-service-rps_sampler.h.

Function Documentation

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

239{
240 return sampler->sampler_size;
241}
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:

◆ 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 (not 0)
samplerthe sampler to resize.
new_sizethe new size of the sampler

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

424{
425 GNUNET_assert (0 < new_size);
426 sampler_resize (sampler, new_size);
427}
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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:

◆ RPS_sampler_init()

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

Initialise a tuple of samplers.

Parameters
init_sizethe size the sampler is initialised with
max_round_intervalmaximum time a round takes
Returns
a handle to a sampler that consists of sampler elements.

Initialise a tuple of samplers.

Parameters
init_sizethe size the sampler is initialised with
max_round_intervalmaximum time a round takes
Returns
a handle to a sampler that consists of sampler elements.

Definition at line 196 of file gnunet-service-rps_sampler.c.

198{
199 struct RPS_Sampler *sampler;
200
201 /* Initialise context around extended sampler */
202 min_size = 10; // TODO make input to _samplers_init()
203 max_size = 1000; // TODO make input to _samplers_init()
204
205 sampler = GNUNET_new (struct RPS_Sampler);
206
209 // sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
210 // GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
211 RPS_sampler_resize (sampler, init_size);
212
214
215 // GNUNET_assert (init_size == sampler->sampler_size);
216 return sampler;
217}
static void sampler_get_rand_peer(void *cls)
Get one random peer out of the sampled peers.
static uint32_t client_get_index
The size the extended sampler elements currently have.
static size_t max_size
The maximal size the extended sampler elements should grow to.
static size_t min_size
‍**
void RPS_sampler_resize(struct RPS_Sampler *sampler, unsigned int new_size)
Grow or shrink the size of the sampler.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Sampler with its own array of SamplerElements.
RPS_get_peers_type get_peers
Stores the function to return peers.
struct GNUNET_TIME_Relative max_round_interval
Maximum time a round takes.

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

Referenced by new_sub().

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

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

287{
288 for (uint32_t i = 0; i < sampler->sampler_size; i++)
289 {
291 id);
292 }
293 notify_update (sampler);
294}
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 in.
idthe 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
samplerthe sampler to reinitialise a sampler element in.
idthe id of the sampler elements to update.

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

314{
315 uint32_t i;
316
317 for (i = 0; i < sampler->sampler_size; i++)
318 {
319 if (0 == GNUNET_memcmp (id,
320 &(sampler->sampler_elements[i]->peer_id)))
321 {
322 LOG (GNUNET_ERROR_TYPE_DEBUG, "Reinitialising sampler\n");
324 }
325 }
326}
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.
@ GNUNET_ERROR_TYPE_DEBUG
#define LOG(kind,...)
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_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
for_clientGNUNET_YES if result is used for client, GNUNET_NO if used internally
num_peersthe number of peers requested

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

553{
554 uint32_t i;
556 struct GetPeerCls *gpc;
557
558 GNUNET_assert (0 != sampler->sampler_size);
559 if (0 == num_peers)
560 return NULL;
561
562 // TODO check if we have too much (distinct) sampled peers
564 req_handle->num_peers = num_peers;
565 req_handle->cur_num_peers = 0;
567 req_handle->sampler = sampler;
568 req_handle->callback = cb;
569 req_handle->cls = cls;
571 sampler->req_handle_tail,
572 req_handle);
573
575 "Scheduling requests for %" PRIu32 " peers\n", num_peers);
576
577 for (i = 0; i < num_peers; i++)
578 {
579 gpc = GNUNET_new (struct GetPeerCls);
580 gpc->req_handle = req_handle;
581 gpc->req_single_info_handle = NULL;
583 gpc->cont_cls = req_handle;
584 gpc->id = &req_handle->ids[i];
585
587 req_handle->gpc_tail,
588 gpc);
589 // maybe add a little delay
591 gpc);
592 }
593 return req_handle;
594}
static struct GNUNET_RPS_Request_Handle * req_handle
Request handle.
Definition: gnunet-rps.c:41
static unsigned int num_peers
Number of peers.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
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:1303
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().
The identity of the host (wraps the signing key of the peer).
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.
Closure to _get_n_rand_peers_ready_cb()
struct RPS_SamplerRequestHandle * req_handle_head
Head and tail for the DLL to store the RPS_SamplerRequestHandle.
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_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 647 of file rps-sampler_common.c.

648{
649 struct GetPeerCls *i;
650
651 while (NULL != (i = req_handle->gpc_head))
652 {
654 req_handle->gpc_tail,
655 i);
656 if (NULL != i->get_peer_task)
657 {
659 }
660 if (NULL != i->notify_ctx)
661 {
664 i->notify_ctx);
666 i->notify_ctx = NULL;
667 }
668 GNUNET_free (i);
669 }
670 GNUNET_free (req_handle->ids);
671 req_handle->ids = NULL;
674 req_handle);
676}
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979
struct SamplerNotifyUpdateCTX * notify_ctx
Context to the given callback.
struct SamplerNotifyUpdateCTX * notify_ctx_head
struct SamplerNotifyUpdateCTX * notify_ctx_tail

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 GNUNET_RPS_request_cancel().

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

340{
341 uint32_t count;
342 uint32_t i;
343
344 count = 0;
345 for (i = 0; i < sampler->sampler_size; i++)
346 {
347 if ((0 == GNUNET_memcmp (&sampler->sampler_elements[i]->peer_id, id))
348 && (EMPTY != sampler->sampler_elements[i]->is_empty) )
349 count++;
350 }
351 return count;
352}
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:

◆ RPS_sampler_destroy()

void RPS_sampler_destroy ( struct RPS_Sampler sampler)

Cleans the samplers.

Parameters
samplerthe sampler to destroy.

Cleans the samplers.

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

727{
728 if (NULL != sampler->req_handle_head)
729 {
731 "There are still pending requests. Going to remove them.\n");
732 while (NULL != sampler->req_handle_head)
733 {
735 }
736 }
737 sampler_empty (sampler);
738 GNUNET_free (sampler);
739}
@ GNUNET_ERROR_TYPE_WARNING
void RPS_sampler_request_cancel(struct RPS_SamplerRequestHandle *req_handle)
Cancel a request issued through RPS_sampler_n_rand_peers_ready_cb.
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: