src/rps/rps-sampler_client.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
  19 /**
  20  * @file rps/gnunet-service-rps_sampler.c
  21  * @brief sampler implementation
  22  * @author Julius Bünger
  23  */
  24 #include "platform.h"
  25 #include "gnunet_util_lib.h"
  26 #include "gnunet_statistics_service.h"
  27 #include "rps.h"
  28
  29 #include "rps-sampler_common.h"
  30 #include "gnunet-service-rps_sampler.h"
  31 #include "gnunet-service-rps_sampler_elem.h"
  32
  33 #include <math.h>
  34 #include <inttypes.h>
  35
  36 #include "rps-test_util.h"
  37
  38 #define LOG(kind, ...) GNUNET_log_from(kind,"rps-sampler",__VA_ARGS__)
  39
  40
  41 // multiple 'clients'?
  42
  43 // TODO check for overflows
  44
  45 // TODO align message structs
  46
  47 // hist_size_init, hist_size_max
  48
  49 /***********************************************************************
  50  * WARNING: This section needs to be reviewed regarding the use of
  51  * functions providing (pseudo)randomness!
  52 ***********************************************************************/
  53
  54 // TODO care about invalid input of the caller (size 0 or less...)
  55
  56 /**
  57  * @brief Callback called each time a new peer was put into the sampler
  58  *
  59  * @param cls A possibly given closure
  60  */
  61 typedef void
  62 (*SamplerNotifyUpdateCB) (void *cls);
  63
  64 /**
  65  * @brief Context for a callback. Contains callback and closure.
  66  *
  67  * Meant to be an entry in an DLL.
  68  */
  69 struct SamplerNotifyUpdateCTX
  70 {
  71   /**
  72    * @brief The Callback to call on updates
  73    */
  74   SamplerNotifyUpdateCB notify_cb;
  75
  76   /**
  77    * @brief The according closure.
  78    */
  79   void *cls;
  80
  81   /**
  82    * @brief Next element in DLL.
  83    */
  84   struct SamplerNotifyUpdateCTX *next;
  85
  86   /**
  87    * @brief Previous element in DLL.
  88    */
  89   struct SamplerNotifyUpdateCTX *prev;
  90 };
  91
  92
  93 /**
  94  * Type of function used to differentiate between modified and not modified
  95  * Sampler.
  96  */
  97 typedef void
  98 (*RPS_get_peers_type) (void *cls);
  99
 100
 101 /**
 102  * Get one random peer out of the sampled peers.
 103  *
 104  * We might want to reinitialise this sampler after giving the
 105  * corrsponding peer to the client.
 106  */
 107 static void
 108 sampler_mod_get_rand_peer (void *cls);
 109
 110
 111 /**
 112  * Closure to _get_n_rand_peers_ready_cb()
 113  */
 114 struct RPS_SamplerRequestHandle
 115 {
 116   /**
 117    * DLL
 118    */
 119   struct RPS_SamplerRequestHandle *next;
 120   struct RPS_SamplerRequestHandle *prev;
 121
 122   /**
 123    * Number of peers we are waiting for.
 124    */
 125   uint32_t num_peers;
 126
 127   /**
 128    * Number of peers we currently have.
 129    */
 130   uint32_t cur_num_peers;
 131
 132   /**
 133    * Pointer to the array holding the ids.
 134    */
 135   struct GNUNET_PeerIdentity *ids;
 136
 137   /**
 138    * Head and tail for the DLL to store the tasks for single requests
 139    */
 140   struct GetPeerCls *gpc_head;
 141   struct GetPeerCls *gpc_tail;
 142
 143   /**
 144    * Sampler.
 145    */
 146   struct RPS_Sampler *sampler;
 147
 148   /**
 149    * Callback to be called when all ids are available.
 150    */
 151   RPS_sampler_n_rand_peers_ready_cb callback;
 152
 153   /**
 154    * Closure given to the callback
 155    */
 156   void *cls;
 157 };
 158
 159 ///**
 160 // * Global sampler variable.
 161 // */
 162 //struct RPS_Sampler *sampler;
 163
 164
 165 /**
 166  * The minimal size for the extended sampler elements.
 167  */
 168 static size_t min_size;
 169
 170 /**
 171  * The maximal size the extended sampler elements should grow to.
 172  */
 173 static size_t max_size;
 174
 175 /**
 176  * The size the extended sampler elements currently have.
 177  */
 178 //static size_t extra_size;
 179
 180 /**
 181  * Inedex to the sampler element that is the next to be returned
 182  */
 183 static uint32_t client_get_index;
 184
 185
 186 /**
 187  * Initialise a modified tuple of sampler elements.
 188  *
 189  * @param init_size the size the sampler is initialised with
 190  * @param max_round_interval maximum time a round takes
 191  * @return a handle to a sampler that consists of sampler elements.
 192  */
 193 struct RPS_Sampler *
 194 RPS_sampler_mod_init (size_t init_size,
 195                       struct GNUNET_TIME_Relative max_round_interval)
 196 {
 197   struct RPS_Sampler *sampler;
 198
 199   /* Initialise context around extended sampler */
 200   min_size = 10; // TODO make input to _samplers_init()
 201   max_size = 1000; // TODO make input to _samplers_init()
 202
 203   sampler = GNUNET_new (struct RPS_Sampler);
 204   sampler->max_round_interval = max_round_interval;
 205   sampler->get_peers = sampler_mod_get_rand_peer;
 206   //sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
 207   //GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
 208   RPS_sampler_resize (sampler, init_size);
 209
 210   client_get_index = 0;
 211
 212   //GNUNET_assert (init_size == sampler->sampler_size);
 213
 214 #ifdef TO_FILE
 215   sampler->file_name = create_file ("sampler-");
 216
 217   LOG (GNUNET_ERROR_TYPE_DEBUG,
 218        "Initialised modified sampler %s\n",
 219        sampler->file_name);
 220   to_file (sampler->file_name,
 221            "This is a modified sampler");
 222 #endif /* TO_FILE */
 223
 224   return sampler;
 225 }
 226
 227
 228 /**
 229  * Get one random peer out of the sampled peers.
 230  *
 231  * This reinitialises the queried sampler element.
 232  */
 233 static void
 234 sampler_mod_get_rand_peer (void *cls)
 235 {
 236   struct GetPeerCls *gpc = cls;
 237   struct RPS_SamplerElement *s_elem;
 238   struct GNUNET_TIME_Relative last_request_diff;
 239   struct RPS_Sampler *sampler;
 240
 241   gpc->get_peer_task = NULL;
 242   gpc->notify_ctx = NULL;
 243   sampler = gpc->req_handle->sampler;
 244
 245   LOG (GNUNET_ERROR_TYPE_DEBUG, "Single peer was requested\n");
 246
 247   /* Cycle the #client_get_index one step further */
 248   client_get_index = (client_get_index + 1) % sampler->sampler_size;
 249
 250   s_elem = sampler->sampler_elements[client_get_index];
 251   *gpc->id = s_elem->peer_id;
 252   GNUNET_assert (NULL != s_elem);
 253
 254   if (EMPTY == s_elem->is_empty)
 255   {
 256     LOG (GNUNET_ERROR_TYPE_DEBUG,
 257          "Sampler_mod element empty, rescheduling.\n");
 258     GNUNET_assert (NULL == gpc->notify_ctx);
 259     gpc->notify_ctx =
 260       sampler_notify_on_update (sampler,
 261                                 &sampler_mod_get_rand_peer,
 262                                 gpc);
 263     return;
 264   }
 265
 266   /* Check whether we may use this sampler to give it back to the client */
 267   if (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us != s_elem->last_client_request.abs_value_us)
 268   {
 269     // TODO remove this condition at least for the client sampler
 270     last_request_diff =
 271       GNUNET_TIME_absolute_get_difference (s_elem->last_client_request,
 272                                            GNUNET_TIME_absolute_get ());
 273     /* We're not going to give it back now if it was
 274      * already requested by a client this round */
 275     if (last_request_diff.rel_value_us < sampler->max_round_interval.rel_value_us)
 276     {
 277       LOG (GNUNET_ERROR_TYPE_DEBUG,
 278           "Last client request on this sampler was less than max round interval ago -- scheduling for later\n");
 279       ///* How many time remains untile the next round has started? */
 280       //inv_last_request_diff =
 281       //  GNUNET_TIME_absolute_get_difference (last_request_diff,
 282       //                                       sampler->max_round_interval);
 283       // add a little delay
 284       /* Schedule it one round later */
 285       GNUNET_assert (NULL == gpc->notify_ctx);
 286       gpc->notify_ctx =
 287         sampler_notify_on_update (sampler,
 288                                   &sampler_mod_get_rand_peer,
 289                                   gpc);
 290       return;
 291     }
 292   }
 293   if (2 > s_elem->num_peers)
 294   {
 295     LOG (GNUNET_ERROR_TYPE_DEBUG,
 296         "This s_elem saw less than two peers -- scheduling for later\n");
 297     GNUNET_assert (NULL == gpc->notify_ctx);
 298     gpc->notify_ctx =
 299       sampler_notify_on_update (sampler,
 300                                 &sampler_mod_get_rand_peer,
 301                                 gpc);
 302     return;
 303   }
 304   /* More reasons to wait could be added here */
 305
 306 //  GNUNET_STATISTICS_set (stats,
 307 //                         "# client sampler element input",
 308 //                         s_elem->num_peers,
 309 //                         GNUNET_NO);
 310 //  GNUNET_STATISTICS_set (stats,
 311 //                         "# client sampler element change",
 312 //                         s_elem->num_change,
 313 //                         GNUNET_NO);
 314
 315   RPS_sampler_elem_reinit (s_elem);
 316   s_elem->last_client_request = GNUNET_TIME_absolute_get ();
 317
 318   GNUNET_CONTAINER_DLL_remove (gpc->req_handle->gpc_head,
 319                                gpc->req_handle->gpc_tail,
 320                                gpc);
 321   gpc->cont (gpc->cont_cls, gpc->id);
 322   GNUNET_free (gpc);
 323 }
 324
 325
 326 /* end of gnunet-service-rps.c */
 327