src/rps/gnunet-service-rps_sampler.c

   1 /*
   2      This file is part of GNUnet.
   3      (C)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  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 "rps.h"
  29
  30 #include "gnunet-service-rps_sampler.h"
  31
  32 #include <math.h>
  33 #include <inttypes.h>
  34
  35 #define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
  36
  37 // multiple 'clients'?
  38
  39 // TODO check for overflows
  40
  41 // TODO align message structs
  42
  43 // hist_size_init, hist_size_max
  44
  45 /***********************************************************************
  46  * WARNING: This section needs to be reviewed regarding the use of
  47  * functions providing (pseudo)randomness!
  48 ***********************************************************************/
  49
  50 // TODO care about invalid input of the caller (size 0 or less...)
  51
  52 enum RPS_SamplerEmpty
  53 {
  54   NOT_EMPTY = 0x0,
  55       EMPTY = 0x1
  56 };
  57
  58 /**
  59  * A sampler element sampling one PeerID at a time.
  60  */
  61 struct RPS_SamplerElement
  62 {
  63   /**
  64    * Min-wise linear permutation used by this sampler.
  65    *
  66    * This is an key later used by a hmac.
  67    */
  68   struct GNUNET_CRYPTO_AuthKey auth_key;
  69
  70   /**
  71    * The PeerID this sampler currently samples.
  72    */
  73   struct GNUNET_PeerIdentity peer_id;
  74
  75   /**
  76    * The according hash value of this PeerID.
  77    */
  78   struct GNUNET_HashCode peer_id_hash;
  79
  80   /**
  81    * Time of last request.
  82    */
  83   struct GNUNET_TIME_Absolute last_request;
  84
  85   /**
  86    * Flag that indicates that we are not holding a valid PeerID right now.
  87    */
  88   enum RPS_SamplerEmpty is_empty;
  89 };
  90
  91 /**
  92  * Sampler with its own array of SamplerElements
  93  */
  94 struct RPS_Sampler
  95 {
  96   /**
  97    * Number of sampler elements we hold.
  98    */
  99   unsigned int sampler_size;
 100   //size_t size;
 101
 102   /**
 103    * All Samplers in one array.
 104    */
 105   struct RPS_SamplerElement **sampler_elements;
 106
 107   /**
 108    * Index to a sampler element.
 109    *
 110    * Gets cycled on every hist_request.
 111    */
 112   uint64_t sampler_elem_index;
 113
 114   /**
 115    * Callback to be called when a peer gets inserted into a sampler.
 116    */
 117   RPS_sampler_insert_cb insert_cb;
 118
 119   /**
 120    * Closure to the insert_cb.
 121    */
 122   void *insert_cls;
 123
 124   /**
 125    * Callback to be called when a peer gets inserted into a sampler.
 126    */
 127   RPS_sampler_remove_cb remove_cb;
 128
 129   /**
 130    * Closure to the remove_cb.
 131    */
 132   void *remove_cls;
 133 };
 134
 135 /**
 136  * Global sampler variable.
 137  */
 138 struct RPS_Sampler *sampler;
 139
 140
 141 /**
 142  * The minimal size for the extended sampler elements.
 143  */
 144 static size_t min_size;
 145
 146 /**
 147  * The maximal size the extended sampler elements should grow to.
 148  */
 149 static size_t max_size;
 150
 151 /**
 152  * The size the extended sampler elements currently have.
 153  */
 154 //static size_t extra_size;
 155
 156 /**
 157  * Inedex to the sampler element that is the next to be returned
 158  */
 159 static uint64_t extended_samplers_index;
 160
 161 /**
 162  * Request counter.
 163  *
 164  * Only needed in the beginning to check how many of the 64 deltas
 165  * we already have
 166  */
 167 static unsigned int req_counter;
 168
 169 /**
 170  * Time of the last request we received.
 171  *
 172  * Used to compute the expected request rate.
 173  */
 174 static struct GNUNET_TIME_Absolute last_request;
 175
 176 /**
 177  * Last 64 deltas between requests
 178  */
 179 static struct GNUNET_TIME_Relative request_deltas[64];
 180
 181 /**
 182  * The prediction of the rate of requests
 183  */
 184 static struct GNUNET_TIME_Relative  request_rate;
 185
 186
 187 /**
 188  * Sum all time relatives of an array.
 189  */
 190   struct GNUNET_TIME_Relative
 191 T_relative_sum (const struct GNUNET_TIME_Relative *rel_array, uint64_t arr_size)
 192 {
 193   struct GNUNET_TIME_Relative sum;
 194   uint64_t i;
 195
 196   sum = GNUNET_TIME_UNIT_ZERO;
 197   for ( i = 0 ; i < arr_size ; i++ )
 198   {
 199     sum = GNUNET_TIME_relative_add (sum, rel_array[i]);
 200   }
 201   return sum;
 202 }
 203
 204 /**
 205  * Compute the average of given time relatives.
 206  */
 207   struct GNUNET_TIME_Relative
 208 T_relative_avg (const struct GNUNET_TIME_Relative *rel_array, uint64_t arr_size)
 209 {
 210   return T_relative_sum (rel_array, arr_size); // FIXME find a way to devide that by arr_size
 211 }
 212
 213
 214
 215 /**
 216  * Reinitialise a previously initialised sampler element.
 217  *
 218  * @param sampler pointer to the memory that keeps the value.
 219  */
 220   static void
 221 RPS_sampler_elem_reinit (struct RPS_SamplerElement *sampler_el)
 222 {
 223   sampler_el->is_empty = EMPTY;
 224
 225   // I guess I don't need to call GNUNET_CRYPTO_hmac_derive_key()...
 226   GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_STRONG,
 227                              &(sampler_el->auth_key.key),
 228                              GNUNET_CRYPTO_HASH_LENGTH);
 229
 230   sampler_el->last_request = GNUNET_TIME_UNIT_FOREVER_ABS;
 231
 232   /* We might want to keep the previous peer */
 233
 234   //GNUNET_CRYPTO_hmac(&sampler_el->auth_key, sampler_el->peer_id,
 235   //                   sizeof(struct GNUNET_PeerIdentity),
 236   //                   &sampler_el->peer_id_hash);
 237 }
 238
 239
 240 /**
 241  * (Re)Initialise given Sampler with random min-wise independent function.
 242  *
 243  * In this implementation this means choosing an auth_key for later use in
 244  * a hmac at random.
 245  *
 246  * @return a newly created RPS_SamplerElement which currently holds no id.
 247  */
 248   struct RPS_SamplerElement *
 249 RPS_sampler_elem_create (void)
 250 {
 251   struct RPS_SamplerElement *s;
 252
 253   s = GNUNET_new (struct RPS_SamplerElement);
 254
 255   RPS_sampler_elem_reinit (s);
 256   LOG (GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: initialised with empty PeerID\n");
 257
 258   return s;
 259 }
 260
 261
 262 /**
 263  * Input an PeerID into the given sampler.
 264  */
 265   static void
 266 RPS_sampler_elem_next (struct RPS_SamplerElement *s_elem, const struct GNUNET_PeerIdentity *other,
 267     RPS_sampler_insert_cb insert_cb, void *insert_cls,
 268     RPS_sampler_remove_cb remove_cb, void *remove_cls)
 269 {
 270   struct GNUNET_HashCode other_hash;
 271
 272   if ( 0 == GNUNET_CRYPTO_cmp_peer_identity(other, &(s_elem->peer_id)) )
 273   {
 274     LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER:          Got PeerID %s\n",
 275         GNUNET_i2s(other));
 276     LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Have already PeerID %s\n",
 277         GNUNET_i2s(&(s_elem->peer_id)));
 278   }
 279   else
 280   {
 281     GNUNET_CRYPTO_hmac(&s_elem->auth_key,
 282         other,
 283         sizeof(struct GNUNET_PeerIdentity),
 284         &other_hash);
 285
 286     if ( EMPTY == s_elem->is_empty )
 287     { // Or whatever is a valid way to say
 288       // "we have no PeerID at the moment"
 289       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Got PeerID %s; Simply accepting (was empty previously).\n",
 290           GNUNET_i2s(other));
 291       s_elem->peer_id = *other;
 292       //s_elem->peer_id = other;
 293       s_elem->peer_id_hash = other_hash;
 294       if (NULL != sampler->insert_cb)
 295       {
 296         sampler->insert_cb(sampler->insert_cls, &(s_elem->peer_id));
 297       }
 298     }
 299     else if ( 0 > GNUNET_CRYPTO_hash_cmp(&other_hash, &s_elem->peer_id_hash) )
 300     {
 301       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER:            Got PeerID %s\n",
 302           GNUNET_i2s(other));
 303       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Discarding old PeerID %s\n",
 304           GNUNET_i2s(&s_elem->peer_id));
 305
 306       if ( NULL != sampler->remove_cb )
 307       {
 308         LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Removing old PeerID %s with the remove callback.\n",
 309             GNUNET_i2s(&s_elem->peer_id));
 310         sampler->remove_cb(sampler->remove_cls, &s_elem->peer_id);
 311       }
 312
 313       memcpy(&s_elem->peer_id, other, sizeof(struct GNUNET_PeerIdentity));
 314       //s_elem->peer_id = other;
 315       s_elem->peer_id_hash = other_hash;
 316
 317       if ( NULL != sampler->insert_cb )
 318       {
 319         LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Inserting new PeerID %s with the insert callback.\n",
 320             GNUNET_i2s(&s_elem->peer_id));
 321         sampler->insert_cb(sampler->insert_cls, &s_elem->peer_id);
 322       }
 323     }
 324     else
 325     {
 326       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER:         Got PeerID %s\n",
 327           GNUNET_i2s(other));
 328       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Keeping old PeerID %s\n",
 329           GNUNET_i2s(&s_elem->peer_id));
 330     }
 331   }
 332   s_elem->is_empty = NOT_EMPTY;
 333 }
 334
 335
 336 /**
 337  * Grow or shrink the size of the sampler.
 338  *
 339  * @param new_size the new size of the sampler
 340  */
 341   void
 342 RPS_sampler_resize (unsigned int new_size)
 343 {
 344   unsigned int old_size;
 345   uint64_t i;
 346   struct RPS_SamplerElement **rem_list;
 347
 348   // TODO check min and max size
 349
 350   old_size = sampler->sampler_size;
 351
 352   if (old_size > new_size)
 353   { /* Shrinking */
 354     /* Temporary store those to properly call the removeCB on those later */
 355     rem_list = GNUNET_malloc ((old_size - new_size) * sizeof (struct RPS_SamplerElement *));
 356     memcpy (rem_list,
 357         &sampler->sampler_elements[new_size],
 358         (old_size - new_size) * sizeof (struct RPS_SamplerElement *));
 359
 360     LOG (GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Shrinking sampler %d -> %d\n", old_size, new_size);
 361     GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, new_size);
 362     LOG (GNUNET_ERROR_TYPE_DEBUG,
 363         "SAMPLER: sampler->sampler_elements now points to %p\n",
 364         sampler->sampler_elements);
 365
 366     for (i = 0 ; i < old_size - new_size ; i++)
 367     {/* Remove unneeded rest */
 368       LOG (GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Removing %" PRIX64 ". sampler\n", i);
 369       if (NULL != sampler->remove_cb)
 370         sampler->remove_cb (sampler->remove_cls, &rem_list[i]->peer_id);
 371       GNUNET_free (rem_list[i]);
 372     }
 373   }
 374   else if (old_size < new_size)
 375   { /* Growing */
 376     LOG (GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Growing sampler %d -> %d\n", old_size, new_size);
 377     GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, new_size);
 378     LOG (GNUNET_ERROR_TYPE_DEBUG,
 379         "SAMPLER: sampler->sampler_elements now points to %p\n",
 380         sampler->sampler_elements);
 381
 382     for ( i = old_size ; i < new_size ; i++ )
 383     { /* Add new sampler elements */
 384       sampler->sampler_elements[i] = RPS_sampler_elem_create ();
 385       if (NULL != sampler->insert_cb)
 386         sampler->insert_cb (sampler->insert_cls, &sampler->sampler_elements[i]->peer_id);
 387       LOG (GNUNET_ERROR_TYPE_DEBUG,
 388           "SAMPLER: Added %" PRIX64 ". sampler, now pointing to %p, contains %s\n",
 389           i, &sampler->sampler_elements[i], GNUNET_i2s (&sampler->sampler_elements[i]->peer_id));
 390     }
 391   }
 392   else
 393   {
 394     LOG (GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Size remains the same -- nothing to do\n");
 395     return;
 396   }
 397
 398   GNUNET_assert(sampler->sampler_size == new_size);
 399   LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Finished growing/shrinking.\n"); // remove
 400 }
 401
 402
 403 /**
 404  * Initialise a tuple of sampler elements.
 405  *
 406  * @param init_size the size the sampler is initialised with
 407  * @param id with which all newly created sampler elements are initialised
 408  * @param ins_cb the callback that will be called on every PeerID that is
 409  *               newly inserted into a sampler element
 410  * @param ins_cls the closure given to #ins_cb
 411  * @param rem_cb the callback that will be called on every PeerID that is
 412  *               removed from a sampler element
 413  * @param rem_cls the closure given to #rem_cb
 414  */
 415   void
 416 RPS_sampler_init (size_t init_size, const struct GNUNET_PeerIdentity *id,
 417     RPS_sampler_insert_cb ins_cb, void *ins_cls,
 418     RPS_sampler_remove_cb rem_cb, void *rem_cls)
 419 {
 420   //struct RPS_Sampler *sampler;
 421   //uint64_t i;
 422
 423   /* Initialise context around extended sampler */
 424   min_size = 10; // TODO make input to _samplers_init()
 425   max_size = 1000; // TODO make input to _samplers_init()
 426   GNUNET_new_array (64, struct GNUNET_TIME_Relative);
 427
 428   sampler = GNUNET_new (struct RPS_Sampler);
 429   sampler->sampler_size = 0;
 430   sampler->sampler_elements = NULL;
 431   sampler->insert_cb = ins_cb;
 432   sampler->insert_cls = ins_cls;
 433   sampler->remove_cb = rem_cb;
 434   sampler->remove_cls = rem_cls;
 435   //sampler->sampler_elements = GNUNET_new_array(init_size, struct GNUNET_PeerIdentity);
 436   //GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, min_size);
 437   RPS_sampler_resize (init_size);
 438   RPS_sampler_update_list (id); // no super nice desing but ok for the moment
 439
 440   extended_samplers_index = 0;
 441
 442   //GNUNET_assert (init_size == sampler->sampler_size);
 443 }
 444
 445
 446 /**
 447  * A fuction to update every sampler in the given list
 448  *
 449  * @param id the PeerID that is put in the sampler
 450  */
 451   void
 452 RPS_sampler_update_list (const struct GNUNET_PeerIdentity *id)
 453 {
 454   uint64_t i;
 455
 456   for ( i = 0 ; i < sampler->sampler_size ; i++ )
 457     RPS_sampler_elem_next (sampler->sampler_elements[i], id,
 458         sampler->insert_cb, sampler->insert_cls,
 459         sampler->remove_cb, sampler->remove_cls);
 460 }
 461
 462
 463 /**
 464  * Reinitialise all previously initialised sampler elements with the given value.
 465  *
 466  * Used to get rid of a PeerID.
 467  *
 468  * @param id the id of the sampler elements to update.
 469  */
 470   void
 471 RPS_sampler_reinitialise_by_value (const struct GNUNET_PeerIdentity *id)
 472 {
 473   uint64_t i;
 474
 475   for ( i = 0 ; i < sampler->sampler_size ; i++ )
 476   {
 477     if ( 0 == GNUNET_CRYPTO_cmp_peer_identity(id, &(sampler->sampler_elements[i]->peer_id)) )
 478     {
 479       LOG(GNUNET_ERROR_TYPE_DEBUG, "SAMPLER: Reinitialising sampler\n");
 480       RPS_sampler_elem_reinit (sampler->sampler_elements[i]);
 481     }
 482   }
 483 }
 484
 485
 486 /**
 487  * Get one random peer out of the sampled peers.
 488  *
 489  * We might want to reinitialise this sampler after giving the
 490  * corrsponding peer to the client.
 491  * Only used internally
 492  */
 493   const struct GNUNET_PeerIdentity *
 494 RPS_sampler_get_rand_peer_ ()
 495 {
 496   uint64_t r_index;
 497   const struct GNUNET_PeerIdentity *peer; // do we have to malloc that?
 498
 499   // TODO implement extra logic
 500
 501   /**;
 502    * Choose the r_index of the peer we want to return
 503    * at random from the interval of the gossip list
 504    */
 505   r_index = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_STRONG,
 506       sampler->sampler_size);
 507
 508   //if ( EMPTY == sampler->sampler_elements[r_index]->is_empty )
 509   //  // TODO schedule for later
 510   //  peer = NULL;
 511   //else
 512     peer = &(sampler->sampler_elements[r_index]->peer_id);
 513   sampler->sampler_elements[r_index]->last_request = GNUNET_TIME_absolute_get();
 514   LOG(GNUNET_ERROR_TYPE_DEBUG, "Sgrp: Returning PeerID %s\n", GNUNET_i2s(peer));
 515
 516
 517   return peer;
 518 }
 519
 520 /**
 521  * Get n random peers out of the sampled peers.
 522  *
 523  * We might want to reinitialise this sampler after giving the
 524  * corrsponding peer to the client.
 525  * Random with or without consumption?
 526  * Only used internally
 527  */
 528   const struct GNUNET_PeerIdentity *
 529 RPS_sampler_get_n_rand_peers_ (uint64_t n)
 530 {
 531   if ( 0 == sampler->sampler_size )
 532   {
 533     LOG (GNUNET_ERROR_TYPE_DEBUG,
 534         "Sgrp: List empty - Returning NULL\n");
 535     return NULL;
 536   }
 537   else
 538   {
 539     // TODO check if we have too much (distinct) sampled peers
 540     // If we are not ready yet maybe schedule for later
 541     struct GNUNET_PeerIdentity *peers;
 542     uint64_t i;
 543
 544     peers = GNUNET_malloc (n * sizeof(struct GNUNET_PeerIdentity));
 545
 546     for ( i = 0 ; i < n ; i++ ) {
 547       //peers[i] = RPS_sampler_get_rand_peer_(sampler->sampler_elements);
 548       memcpy (&peers[i], RPS_sampler_get_rand_peer_ (), sizeof (struct GNUNET_PeerIdentity));
 549     }
 550     return peers;
 551   }
 552 }
 553
 554
 555 /**
 556  * Get one random peer out of the sampled peers.
 557  *
 558  * We might want to reinitialise this sampler after giving the
 559  * corrsponding peer to the client.
 560  *
 561  * @return a random PeerID of the PeerIDs previously put into the sampler.
 562  */
 563   const struct GNUNET_PeerIdentity *
 564 RPS_sampler_get_rand_peer ()
 565 {
 566   struct GNUNET_PeerIdentity *peer;
 567
 568   if (64 > req_counter)
 569     req_counter++;
 570   if (1 < req_counter)
 571   {
 572     memcpy (&request_deltas[1],
 573         request_deltas,
 574         (req_counter - 1) * sizeof (struct GNUNET_TIME_Relative));
 575     request_deltas[0] = GNUNET_TIME_absolute_get_difference (last_request,
 576         GNUNET_TIME_absolute_get ());
 577     request_rate = T_relative_avg (request_deltas, req_counter);
 578   }
 579   last_request = GNUNET_TIME_absolute_get();
 580   // TODO resize the size of the extended_samplers
 581
 582   // use _get_rand_peer_ ?
 583   peer = GNUNET_new (struct GNUNET_PeerIdentity);
 584   *peer = sampler->sampler_elements[extended_samplers_index]->peer_id;
 585   RPS_sampler_elem_reinit (sampler->sampler_elements[extended_samplers_index]);
 586   if ( extended_samplers_index == sampler->sampler_size )
 587     extended_samplers_index = 0;
 588   else
 589     extended_samplers_index++;
 590   return peer;
 591 }
 592
 593
 594 /**
 595  * Get n random peers out of the sampled peers.
 596  *
 597  * We might want to reinitialise this sampler after giving the
 598  * corrsponding peer to the client.
 599  * Random with or without consumption?
 600  *
 601  * @return n random PeerIDs of the PeerIDs previously put into the sampler.
 602  */
 603   const struct GNUNET_PeerIdentity *
 604 RPS_sampler_get_n_rand_peers (uint64_t n)
 605 {
 606   // use _get_rand_peers_ ?
 607   if ( 0 == sampler->sampler_size )
 608   {
 609     LOG (GNUNET_ERROR_TYPE_DEBUG,
 610         "Sgrp: List empty - Returning NULL\n");
 611     return NULL;
 612   }
 613   else
 614   {
 615     // TODO check if we have too much (distinct) sampled peers
 616     // If we are not ready yet maybe schedule for later
 617     struct GNUNET_PeerIdentity *peers;
 618     const struct GNUNET_PeerIdentity *peer;
 619     uint64_t i;
 620
 621     peers = GNUNET_malloc (n * sizeof (struct GNUNET_PeerIdentity));
 622
 623     for ( i = 0 ; i < n ; i++ ) {
 624       //peers[i] = RPS_sampler_get_rand_peer_(sampler->sampler_elements);
 625       peer = RPS_sampler_get_rand_peer ();
 626       memcpy (&peers[i], peer, sizeof (struct GNUNET_PeerIdentity));
 627       //GNUNET_free (peer);
 628     }
 629     return peers;
 630   }
 631 }
 632
 633
 634 /**
 635  * Counts how many Samplers currently hold a given PeerID.
 636  *
 637  * @param id the PeerID to count.
 638  *
 639  * @return the number of occurrences of id.
 640  */
 641   uint64_t
 642 RPS_sampler_count_id (const struct GNUNET_PeerIdentity *id)
 643 {
 644   uint64_t count;
 645   uint64_t i;
 646
 647   count = 0;
 648   for ( i = 0 ; i < sampler->sampler_size ; i++ )
 649   {
 650     if ( 0 == GNUNET_CRYPTO_cmp_peer_identity (&sampler->sampler_elements[i]->peer_id, id)
 651         && EMPTY != sampler->sampler_elements[i]->is_empty)
 652       count++;
 653   }
 654   return count;
 655 }
 656
 657
 658 /**
 659  * Cleans the sampler.
 660  */
 661   void
 662 RPS_sampler_destroy ()
 663 {
 664   RPS_sampler_resize (0);
 665   GNUNET_free (request_deltas); // _array_grow()?
 666   GNUNET_array_grow (sampler->sampler_elements, sampler->sampler_size, 0);
 667 }
 668
 669 /* end of gnunet-service-rps.c */