src/rps/gnunet-service-rps_sampler.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C)
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20
  21 /**
  22  * @file rps/gnunet-service-rps_sampler.c
  23  * @brief sampler implementation
  24  * @author Julius Bünger
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_statistics_service.h"
  29 #include "rps.h"
  30
  31 #include "rps-sampler_common.h"
  32 #include "gnunet-service-rps_sampler.h"
  33 #include "gnunet-service-rps_sampler_elem.h"
  34
  35 #include <math.h>
  36 #include <inttypes.h>
  37
  38 #include "rps-test_util.h"
  39
  40 #define LOG(kind, ...) GNUNET_log_from(kind,"rps-sampler",__VA_ARGS__)
  41
  42
  43 // multiple 'clients'?
  44
  45 // TODO check for overflows
  46
  47 // TODO align message structs
  48
  49 // hist_size_init, hist_size_max
  50
  51 /***********************************************************************
  52  * WARNING: This section needs to be reviewed regarding the use of
  53  * functions providing (pseudo)randomness!
  54 ***********************************************************************/
  55
  56 // TODO care about invalid input of the caller (size 0 or less...)
  57
  58 /**
  59  * @brief Callback called each time a new peer was put into the sampler
  60  *
  61  * @param cls A possibly given closure
  62  */
  63 typedef void
  64 (*SamplerNotifyUpdateCB) (void *cls);
  65
  66 /**
  67  * @brief Context for a callback. Contains callback and closure.
  68  *
  69  * Meant to be an entry in an DLL.
  70  */
  71 struct SamplerNotifyUpdateCTX
  72 {
  73   /**
  74    * @brief The Callback to call on updates
  75    */
  76   SamplerNotifyUpdateCB notify_cb;
  77
  78   /**
  79    * @brief The according closure.
  80    */
  81   void *cls;
  82
  83   /**
  84    * @brief Next element in DLL.
  85    */
  86   struct SamplerNotifyUpdateCTX *next;
  87
  88   /**
  89    * @brief Previous element in DLL.
  90    */
  91   struct SamplerNotifyUpdateCTX *prev;
  92 };
  93
  94
  95 /**
  96  * Type of function used to differentiate between modified and not modified
  97  * Sampler.
  98  */
  99 typedef void
 100 (*RPS_get_peers_type) (void *cls);
 101
 102 /**
 103  * Get one random peer out of the sampled peers.
 104  *
 105  * We might want to reinitialise this sampler after giving the
 106  * corrsponding peer to the client.
 107  * Only used internally
 108  */
 109 static void
 110 sampler_get_rand_peer (void *cls);
 111
 112
 113 /**
 114  * Closure to _get_n_rand_peers_ready_cb()
 115  */
 116 struct RPS_SamplerRequestHandle
 117 {
 118   /**
 119    * DLL
 120    */
 121   struct RPS_SamplerRequestHandle *next;
 122   struct RPS_SamplerRequestHandle *prev;
 123
 124   /**
 125    * Number of peers we are waiting for.
 126    */
 127   uint32_t num_peers;
 128
 129   /**
 130    * Number of peers we currently have.
 131    */
 132   uint32_t cur_num_peers;
 133
 134   /**
 135    * Pointer to the array holding the ids.
 136    */
 137   struct GNUNET_PeerIdentity *ids;
 138
 139   /**
 140    * Head and tail for the DLL to store the tasks for single requests
 141    */
 142   struct GetPeerCls *gpc_head;
 143   struct GetPeerCls *gpc_tail;
 144
 145   /**
 146    * Sampler.
 147    */
 148   struct RPS_Sampler *sampler;
 149
 150   /**
 151    * Callback to be called when all ids are available.
 152    */
 153   RPS_sampler_n_rand_peers_ready_cb callback;
 154
 155   /**
 156    * Closure given to the callback
 157    */
 158   void *cls;
 159 };
 160
 161 ///**
 162 // * Global sampler variable.
 163 // */
 164 //struct RPS_Sampler *sampler;
 165
 166
 167 /**
 168  * The minimal size for the extended sampler elements.
 169  */
 170 static size_t min_size;
 171
 172 /**
 173  * The maximal size the extended sampler elements should grow to.
 174  */
 175 static size_t max_size;
 176
 177 /**
 178  * The size the extended sampler elements currently have.
 179  */
 180 //static size_t extra_size;
 181
 182 /**
 183  * Inedex to the sampler element that is the next to be returned
 184  */
 185 static uint32_t client_get_index;
 186
 187
 188 /**
 189  * Initialise a tuple of sampler elements.
 190  *
 191  * @param init_size the size the sampler is initialised with
 192  * @param max_round_interval maximum time a round takes
 193  * @return a handle to a sampler that consists of sampler elements.
 194  */
 195 struct RPS_Sampler *
 196 RPS_sampler_init (size_t init_size,
 197                   struct GNUNET_TIME_Relative max_round_interval)
 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
 207   sampler->max_round_interval = max_round_interval;
 208   sampler->get_peers = sampler_get_rand_peer;
 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
 213   client_get_index = 0;
 214
 215   //GNUNET_assert (init_size == sampler->sampler_size);
 216   return sampler;
 217 }
 218
 219 /**
 220  * Get one random peer out of the sampled peers.
 221  *
 222  * We might want to reinitialise this sampler after giving the
 223  * corrsponding peer to the client.
 224  * Only used internally
 225  */
 226 static void
 227 sampler_get_rand_peer (void *cls)
 228 {
 229   struct GetPeerCls *gpc = cls;
 230   uint32_t r_index;
 231   struct RPS_Sampler *sampler;
 232
 233   gpc->get_peer_task = NULL;
 234   gpc->notify_ctx = NULL;
 235   sampler = gpc->req_handle->sampler;
 236
 237   /**;
 238    * Choose the r_index of the peer we want to return
 239    * at random from the interval of the gossip list
 240    */
 241   r_index = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG,
 242       sampler->sampler_size);
 243
 244   if (EMPTY == sampler->sampler_elements[r_index]->is_empty)
 245   {
 246     //LOG (GNUNET_ERROR_TYPE_DEBUG,
 247     //     "Not returning randomly selected, empty PeerID. - Rescheduling.\n");
 248
 249     gpc->notify_ctx =
 250       sampler_notify_on_update (sampler,
 251                                 &sampler_get_rand_peer,
 252                                 gpc);
 253     return;
 254   }
 255
 256   GNUNET_CONTAINER_DLL_remove (gpc->req_handle->gpc_head,
 257                                gpc->req_handle->gpc_tail,
 258                                gpc);
 259   *gpc->id = sampler->sampler_elements[r_index]->peer_id;
 260   gpc->cont (gpc->cont_cls, gpc->id, 0, sampler->sampler_elements[r_index]->num_peers);
 261
 262   GNUNET_free (gpc);
 263 }
 264
 265
 266 /* end of gnunet-service-rps.c */