Restructure implementation of view (towards subsampling)

4 files changed, 244 insertions, 189 deletions

diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index 3d9f9234c..5abbc692f 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -386,6 +386,11 @@ struct SubSampler
   unsigned int view_size_est_min;
 
   /**
+   * @brief The view.
+   */
+  struct View *view;
+
+  /**
    * Identifier for the main task that runs periodically.
    */
   struct GNUNET_SCHEDULER_Task *do_round_task;
@@ -2092,8 +2097,8 @@ insert_in_view (const struct GNUNET_PeerIdentity *peer)
   }
   /* Open channel towards peer to keep connection open */
   indicate_sending_intention (peer);
-  ret = View_put (peer);
-  GNUNET_STATISTICS_set (stats, "view size", View_size(), GNUNET_NO);
+  ret = View_put (mss->view, peer);
+  GNUNET_STATISTICS_set (stats, "view size", View_size(mss->view), GNUNET_NO);
   return ret;
 }
 
@@ -2115,8 +2120,8 @@ send_view (const struct ClientContext *cli_ctx,
 
   if (NULL == view_array)
   {
-    view_size = View_size ();
-    view_array = View_get_as_array();
+    view_size = View_size (mss->view);
+    view_array = View_get_as_array(mss->view);
   }
 
   ev = GNUNET_MQ_msg_extra (out_msg,
@@ -2172,8 +2177,8 @@ clients_notify_view_update (void)
   uint64_t num_peers;
   const struct GNUNET_PeerIdentity *view_array;
 
-  num_peers = View_size ();
-  view_array = View_get_as_array();
+  num_peers = View_size (mss->view);
+  view_array = View_get_as_array(mss->view);
   /* check size of view is small enough */
   if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
   {
@@ -2485,7 +2490,7 @@ check_sending_channel_needed (const struct GNUNET_PeerIdentity *peer)
   if (GNUNET_YES == check_sending_channel_exists (peer))
   {
     if ( (0 < RPS_sampler_count_id (mss->sampler, peer)) ||
-         (GNUNET_YES == View_contains_peer (peer)) ||
+         (GNUNET_YES == View_contains_peer (mss->view, peer)) ||
          (GNUNET_YES == CustomPeerMap_contains_peer (mss->push_map, peer)) ||
          (GNUNET_YES == CustomPeerMap_contains_peer (mss->pull_map, peer)) ||
          (GNUNET_YES == check_peer_flag (peer, Peers_PULL_REPLY_PENDING)))
@@ -2506,7 +2511,7 @@ check_sending_channel_needed (const struct GNUNET_PeerIdentity *peer)
 static void
 remove_peer (const struct GNUNET_PeerIdentity *peer)
 {
-  (void) View_remove_peer (peer);
+  (void) View_remove_peer (mss->view, peer);
   CustomPeerMap_remove_peer (mss->pull_map, peer);
   CustomPeerMap_remove_peer (mss->push_map, peer);
   RPS_sampler_reinitialise_by_value (mss->sampler, peer);
@@ -2538,7 +2543,7 @@ clean_peer (const struct GNUNET_PeerIdentity *peer)
   }
 
   if ( (GNUNET_NO == check_peer_send_intention (peer)) &&
-       (GNUNET_NO == View_contains_peer (peer)) &&
+       (GNUNET_NO == View_contains_peer (mss->view, peer)) &&
        (GNUNET_NO == CustomPeerMap_contains_peer (mss->push_map, peer)) &&
        (GNUNET_NO == CustomPeerMap_contains_peer (mss->push_map, peer)) &&
        (0 == RPS_sampler_count_id (mss->sampler,   peer)) &&
@@ -2682,7 +2687,7 @@ new_subsampler (const char *shared_value,
   ss->push_map = CustomPeerMap_create (4);
   ss->pull_map = CustomPeerMap_create (4);
   ss->view_size_est_min = sampler_size;;
-  View_create (ss->view_size_est_min);
+  ss->view = View_create (ss->view_size_est_min);
   GNUNET_STATISTICS_set (stats,
                          "view size aim",
                          ss->view_size_est_min,
@@ -2748,7 +2753,7 @@ nse_callback (void *cls,
 
   /* If the NSE has changed adapt the lists accordingly */
   resize_wrapper (mss->sampler, mss->sampler_size_est_need);
-  View_change_len (mss->view_size_est_need);
+  View_change_len (mss->view, mss->view_size_est_need);
 }
 
 
@@ -3043,8 +3048,8 @@ handle_peer_pull_request (void *cls,
 
   GNUNET_break_op (check_peer_known (peer));
   GNUNET_CADET_receive_done (channel_ctx->channel);
-  view_array = View_get_as_array ();
-  send_pull_reply (peer, view_array, View_size ());
+  view_array = View_get_as_array (mss->view);
+  send_pull_reply (peer, view_array, View_size (mss->view));
 }
 
 
@@ -3579,8 +3584,8 @@ do_round (void *cls)
        "Printing view:\n");
   to_file (mss->file_name_view_log,
            "___ new round ___");
-  view_array = View_get_as_array ();
-  for (i = 0; i < View_size (); i++)
+  view_array = View_get_as_array (mss->view);
+  for (i = 0; i < View_size (mss->view); i++)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "\t%s\n", GNUNET_i2s (&view_array[i]));
@@ -3591,17 +3596,17 @@ do_round (void *cls)
 
 
   /* Send pushes and pull requests */
-  if (0 < View_size ())
+  if (0 < View_size (mss->view))
   {
     permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
-                                           View_size ());
+                                           View_size (mss->view));
 
     /* Send PUSHes */
-    a_peers = ceil (alpha * View_size ());
+    a_peers = ceil (alpha * View_size (mss->view));
 
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
-         a_peers, alpha, View_size ());
+         a_peers, alpha, View_size (mss->view));
     for (i = 0; i < a_peers; i++)
     {
       peer = view_array[permut[i]];
@@ -3610,17 +3615,17 @@ do_round (void *cls)
     }
 
     /* Send PULL requests */
-    b_peers = ceil (beta * View_size ());
+    b_peers = ceil (beta * View_size (mss->view));
     first_border = a_peers;
     second_border = a_peers + b_peers;
-    if (second_border > View_size ())
+    if (second_border > View_size (mss->view))
     {
-      first_border = View_size () - b_peers;
-      second_border = View_size ();
+      first_border = View_size (mss->view) - b_peers;
+      second_border = View_size (mss->view);
     }
     LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
-        b_peers, beta, View_size ());
+        b_peers, beta, View_size (mss->view));
     for (i = first_border; i < second_border; i++)
     {
       peer = view_array[permut[i]];
@@ -3651,13 +3656,15 @@ do_round (void *cls)
 
     peers_to_clean = NULL;
     peers_to_clean_size = 0;
-    GNUNET_array_grow (peers_to_clean, peers_to_clean_size, View_size ());
+    GNUNET_array_grow (peers_to_clean,
+                       peers_to_clean_size,
+                       View_size (mss->view));
     GNUNET_memcpy (peers_to_clean,
             view_array,
-            View_size () * sizeof (struct GNUNET_PeerIdentity));
+            View_size (mss->view) * sizeof (struct GNUNET_PeerIdentity));
 
     /* Seems like recreating is the easiest way of emptying the peermap */
-    View_clear ();
+    View_clear (mss->view);
     to_file (mss->file_name_view_log,
              "--- emptied ---");
 
@@ -3724,7 +3731,7 @@ do_round (void *cls)
                                   NULL);
     // TODO change the peer_flags accordingly
 
-    for (i = 0; i < View_size (); i++)
+    for (i = 0; i < View_size (mss->view); i++)
       rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
 
     /* Clean peers that were removed from the view */
@@ -3741,10 +3748,10 @@ do_round (void *cls)
   } else {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
     GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
-    if (CustomPeerMap_size (mss->push_map) > alpha * View_size () &&
+    if (CustomPeerMap_size (mss->push_map) > alpha * View_size (mss->view) &&
         !(0 >= CustomPeerMap_size (mss->pull_map)))
       GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO);
-    if (CustomPeerMap_size (mss->push_map) > alpha * View_size () &&
+    if (CustomPeerMap_size (mss->push_map) > alpha * View_size (mss->view) &&
         (0 >= CustomPeerMap_size (mss->pull_map)))
       GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO);
     if (0 >= CustomPeerMap_size (mss->push_map) &&
@@ -3754,7 +3761,7 @@ do_round (void *cls)
         (0 >= CustomPeerMap_size (mss->pull_map)))
       GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO);
     if (0 >= CustomPeerMap_size (mss->pull_map) &&
-        CustomPeerMap_size (mss->push_map) > alpha * View_size () &&
+        CustomPeerMap_size (mss->push_map) > alpha * View_size (mss->view) &&
         0 >= CustomPeerMap_size (mss->push_map))
       GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO);
   }
@@ -3769,16 +3776,16 @@ do_round (void *cls)
       GNUNET_NO);
   GNUNET_STATISTICS_set (stats,
       "# peers in view at end of round",
-      View_size (),
+      View_size (mss->view),
       GNUNET_NO);
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (%u) = %.2f)\n",
+       "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (mss->view%u) = %.2f)\n",
        CustomPeerMap_size (mss->push_map),
        CustomPeerMap_size (mss->pull_map),
        alpha,
-       View_size (),
-       alpha * View_size ());
+       View_size (mss->view),
+       alpha * View_size (mss->view));
 
   /* Update samplers */
   for (i = 0; i < CustomPeerMap_size (mss->push_map); i++)
@@ -3808,7 +3815,7 @@ do_round (void *cls)
 
   GNUNET_STATISTICS_set (stats,
                          "view size",
-                         View_size(),
+                         View_size(mss->view),
                          GNUNET_NO);
 
   struct GNUNET_TIME_Relative time_next_round;
@@ -3943,7 +3950,7 @@ shutdown_task (void *cls)
   GNUNET_CADET_close_port (mss->cadet_port);
   GNUNET_CADET_disconnect (mss->cadet_handle);
   mss->cadet_handle = NULL;
-  View_destroy ();
+  View_destroy (mss->view);
   CustomPeerMap_destroy (mss->push_map);
   CustomPeerMap_destroy (mss->pull_map);
   if (NULL != stats)
diff --git a/src/rps/gnunet-service-rps_view.c b/src/rps/gnunet-service-rps_view.c
index 26a0b22bc..3af858e60 100644
--- a/src/rps/gnunet-service-rps_view.c
+++ b/src/rps/gnunet-service-rps_view.c
@@ -26,192 +26,221 @@
 #include "gnunet-service-rps_view.h"
 #include <inttypes.h>
 
+struct View
+{
+  /**
+   * Array containing the peers
+   */
+  struct GNUNET_PeerIdentity *array;
 
-/**
- * Array containing the peers
- */
-static struct GNUNET_PeerIdentity *array;
-
-/**
- * (Maximum) length of the view
- */
-static uint32_t length;
+  /**
+   * (Maximum) length of the view
+   */
+  uint32_t length;
 
-/**
- * Multipeermap containing the peers
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *mpm;
+  /**
+   * Multipeermap containing the peers
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *mpm;
+};
 
 
 /**
  * Create an empty view.
  *
  * @param len the maximum length for the view
+ * @return The newly created view
  */
-void
+struct View *
 View_create (uint32_t len)
 {
-  length = len;
-  array = GNUNET_new_array (len, struct GNUNET_PeerIdentity);
-  mpm = GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO); /* might even be
-                                                                * set to _YES */
+  struct View *view;
+
+  view = GNUNET_new (struct View);
+  view->length = len;
+  view->array = GNUNET_new_array (len, struct GNUNET_PeerIdentity);
+  view->mpm =
+    GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO); /* might even be
+                                                            * set to _YES */
+  return view;
 }
 
+
 /**
  * Change length of view
  *
  * If size is decreased, peers with higher indices are removed.
  *
+ * @param view The view that is changed
  * @param len the (maximum) length for the view
  */
 void
-View_change_len (uint32_t len)
+View_change_len (struct View *view,
+                 uint32_t len)
 {
   uint32_t i;
   uint32_t *index;
 
-  if (GNUNET_CONTAINER_multipeermap_size (mpm) < len)
+  if (GNUNET_CONTAINER_multipeermap_size (view->mpm) < len)
   { /* Simply shrink */
     /* We might simply clear and free the left over space */
-    GNUNET_array_grow (array, length, len);
+    GNUNET_array_grow (view->array, view->length, len);
   }
   else /* We have to remove elements */
   {
     /* TODO find a way to preserve indices */
     for (i = 0; i < len; i++)
     {
-      index = GNUNET_CONTAINER_multipeermap_get (mpm, &array[i]);
+      index = GNUNET_CONTAINER_multipeermap_get (view->mpm, &view->array[i]);
       GNUNET_assert (NULL != index);
       GNUNET_free (index);
     }
-    GNUNET_array_grow (array, length, len);
-    GNUNET_CONTAINER_multipeermap_destroy (mpm);
-    mpm = GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO);
+    GNUNET_array_grow (view->array, view->length, len);
+    GNUNET_CONTAINER_multipeermap_destroy (view->mpm);
+    view->mpm = GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO);
     for (i = 0; i < len; i++)
     {
       index = GNUNET_new (uint32_t);
       *index = i;
-      GNUNET_CONTAINER_multipeermap_put (mpm, &array[i], index,
+      GNUNET_CONTAINER_multipeermap_put (view->mpm, &view->array[i], index,
           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
     }
   }
-  GNUNET_assert (length == len);
+  GNUNET_assert (view->length == len);
 }
 
+
 /**
  * Get the view as an array
  *
+ * @param view The view of which the array representation is of interest
  * @return the view in array representation
  */
 const struct GNUNET_PeerIdentity *
-View_get_as_array ()
+View_get_as_array (const struct View *view)
 {
-  return array;
+  return view->array;
 }
 
+
 /**
  * Get the size of the view
  *
+ * @param view The view of which the size should be returned
  * @return current number of actually contained peers
  */
 unsigned int
-View_size ()
+View_size (const struct View *view)
 {
-  return GNUNET_CONTAINER_multipeermap_size (mpm);
+  return GNUNET_CONTAINER_multipeermap_size (view->mpm);
 }
 
+
 /**
  * Insert peer into the view
  *
+ * @param view The view to put the peer into
  * @param peer the peer to insert
  *
  * @return GNUNET_OK if peer was actually inserted
  *         GNUNET_NO if peer was not inserted
  */
 int
-View_put (const struct GNUNET_PeerIdentity *peer)
+View_put (struct View *view,
+          const struct GNUNET_PeerIdentity *peer)
 {
   uint32_t *index;
 
-  if ((length <= View_size ()) || /* If array is 'full' */
-      (GNUNET_YES == View_contains_peer (peer)))
+  if ((view->length <= View_size (view)) || /* If array is 'full' */
+      (GNUNET_YES == View_contains_peer (view, peer)))
   {
     return GNUNET_NO;
   }
   else
   {
     index = GNUNET_new (uint32_t);
-    *index = (uint32_t) View_size ();
-    array[*index] = *peer;
-    GNUNET_CONTAINER_multipeermap_put (mpm, peer, index,
+    *index = (uint32_t) View_size (view);
+    view->array[*index] = *peer;
+    GNUNET_CONTAINER_multipeermap_put (view->mpm, peer, index,
         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
     return GNUNET_OK;
   }
 }
 
+
 /**
  * Check whether view contains a peer
  *
+ * @param view The which is checked for a peer
  * @param peer the peer to check for
  *
  * @return GNUNET_OK if view contains peer
  *         GNUNET_NO otherwise
  */
 int
-View_contains_peer (const struct GNUNET_PeerIdentity *peer)
+View_contains_peer (const struct View *view,
+                    const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multipeermap_contains (mpm, peer);
+  return GNUNET_CONTAINER_multipeermap_contains (view->mpm, peer);
 }
 
+
 /**
  * Remove peer from view
  *
+ * @param view The view of which to remove the peer
  * @param peer the peer to remove
  *
  * @return GNUNET_OK if view contained peer and removed it successfully
  *         GNUNET_NO if view does not contain peer
  */
 int
-View_remove_peer (const struct GNUNET_PeerIdentity *peer)
+View_remove_peer (struct View *view,
+                  const struct GNUNET_PeerIdentity *peer)
 {
   uint32_t *index;
   uint32_t *swap_index;
   uint32_t last_index;
 
-  if (GNUNET_NO == View_contains_peer (peer))
+  if (GNUNET_NO == View_contains_peer (view, peer))
   {
     return GNUNET_NO;
   }
-  index = GNUNET_CONTAINER_multipeermap_get (mpm, peer);
+  index = GNUNET_CONTAINER_multipeermap_get (view->mpm, peer);
   GNUNET_assert (NULL != index);
-  last_index = View_size () - 1;
+  last_index = View_size (view) - 1;
   if (*index < last_index)
   { /* Fill the 'gap' in the array with the last peer */
-    array[*index] = array[last_index];
-    GNUNET_assert (GNUNET_YES == View_contains_peer (&array[last_index]));
-    swap_index = GNUNET_CONTAINER_multipeermap_get (mpm, &array[last_index]);
+    view->array[*index] = view->array[last_index];
+    GNUNET_assert (GNUNET_YES == View_contains_peer (view,
+                                                     &view->array[last_index]));
+    swap_index = GNUNET_CONTAINER_multipeermap_get (view->mpm,
+                                                    &view->array[last_index]);
     GNUNET_assert (NULL != swap_index);
     *swap_index = *index;
     GNUNET_free (index);
   }
-  GNUNET_CONTAINER_multipeermap_remove_all (mpm, peer);
+  GNUNET_CONTAINER_multipeermap_remove_all (view->mpm, peer);
   return GNUNET_OK;
 }
 
+
 /**
  * Get a peer by index
  *
+ * @param view the view of which to get the peer
  * @param index the index of the peer to get
  *
  * @return peer to the corresponding index.
  *         NULL if this index is not known
  */
 const struct GNUNET_PeerIdentity *
-View_get_peer_by_index (uint32_t index)
+View_get_peer_by_index (const struct View *view,
+                        uint32_t index)
 {
-  if (index < GNUNET_CONTAINER_multipeermap_size (mpm))
+  if (index < GNUNET_CONTAINER_multipeermap_size (view->mpm))
   {
-    return &array[index];
+    return &view->array[index];
   }
   else
   {
@@ -219,42 +248,41 @@ View_get_peer_by_index (uint32_t index)
   }
 }
 
+
 /**
- * Clear the custom peer map
- *
- * @param c_peer_map the custom peer map to look in
+ * Clear the view
  *
- * @return size of the map
+ * @param view The view to clear
  */
 void
-View_clear ()
+View_clear (struct View *view)
 {
-  for (uint32_t i = 0; 0 < View_size (); i++)
+  for (uint32_t i = 0; 0 < View_size (view); i++)
   { /* Need to free indices stored at peers */
     uint32_t *index;
 
     GNUNET_assert (GNUNET_YES ==
-        GNUNET_CONTAINER_multipeermap_contains (mpm, &array[i]));
-    index = GNUNET_CONTAINER_multipeermap_get (mpm, &array[i]);
+        GNUNET_CONTAINER_multipeermap_contains (view->mpm, &view->array[i]));
+    index = GNUNET_CONTAINER_multipeermap_get (view->mpm, &view->array[i]);
     GNUNET_assert (NULL != index);
     GNUNET_free (index);
-    GNUNET_CONTAINER_multipeermap_remove_all (mpm, &array[i]);
+    GNUNET_CONTAINER_multipeermap_remove_all (view->mpm, &view->array[i]);
   }
-  GNUNET_assert (0 == View_size ());
+  GNUNET_assert (0 == View_size (view));
 }
 
 
 /**
- * Destroy peermap.
+ * Destroy view.
  *
- * @param c_peer_map the map to destroy
+ * @param view the view to destroy
  */
 void
-View_destroy ()
+View_destroy (struct View *view)
 {
-  View_clear ();
-  GNUNET_free (array);
-  GNUNET_CONTAINER_multipeermap_destroy (mpm);
+  View_clear (view);
+  GNUNET_free (view->array);
+  GNUNET_CONTAINER_multipeermap_destroy (view->mpm);
 }
 
 /* end of gnunet-service-rps_view.c */
diff --git a/src/rps/gnunet-service-rps_view.h b/src/rps/gnunet-service-rps_view.h
index 127b49faf..a9017bab8 100644
--- a/src/rps/gnunet-service-rps_view.h
+++ b/src/rps/gnunet-service-rps_view.h
@@ -24,24 +24,29 @@
 #include "gnunet_util_lib.h"
 #include <inttypes.h>
 
+struct View;
 
 /**
  * Create an empty view.
  *
  * @param len the maximum length for the view
+ * @return The newly created view
  */
-void
+struct View *
 View_create (unsigned int len);
 
+
 /**
  * Change length of view
  *
  * If size is decreased, peers with higher indices are removed.
  *
+ * @param view The view that is changed
  * @param len the (maximum) length for the view
  */
 void
-View_change_len (unsigned int len);
+View_change_len (struct View *view,
+                 unsigned int len);
 
 /**
  * Get the view as an array
@@ -49,76 +54,90 @@ View_change_len (unsigned int len);
  * @return the view in array representation
  */
 const struct GNUNET_PeerIdentity *
-View_get_as_array ();
+View_get_as_array (const struct View *view);
+
 
 /**
  * Get the size of the view
  *
+ * @param view The view of which the size should be returned
  * @return current number of actually contained peers
  */
 unsigned int
-View_size ();
+View_size (const struct View *view);
+
 
 /**
  * Insert peer into the view
  *
+ * @param view The view to put the peer into
  * @param peer the peer to insert
  *
  * @return GNUNET_OK if peer was actually inserted
  *         GNUNET_NO if peer was not inserted
  */
 int
-View_put (const struct GNUNET_PeerIdentity *peer);
+View_put (struct View *view,
+          const struct GNUNET_PeerIdentity *peer);
+
 
 /**
  * Check whether view contains a peer
  *
+ * @param view The which is checked for a peer
  * @param peer the peer to check for
  *
  * @return GNUNET_OK if view contains peer
  *         GNUNET_NO otherwise
  */
 int
-View_contains_peer (const struct GNUNET_PeerIdentity *peer);
+View_contains_peer (const struct View *view,
+                    const struct GNUNET_PeerIdentity *peer);
+
 
 /**
  * Remove peer from view
  *
+ * @param view The view of which to remove the peer
  * @param peer the peer to remove
  *
  * @return GNUNET_OK if view contained peer and removed it successfully
  *         GNUNET_NO if view does not contain peer
  */
 int
-View_remove_peer (const struct GNUNET_PeerIdentity *peer);
+View_remove_peer (struct View *view,
+                  const struct GNUNET_PeerIdentity *peer);
+
 
 /**
  * Get a peer by index
  *
+ * @param view the view of which to get the peer
  * @param index the index of the peer to get
  *
  * @return peer to the corresponding index.
  *         NULL if this index is not known
  */
 const struct GNUNET_PeerIdentity *
-View_get_peer_by_index (uint32_t index);
+View_get_peer_by_index (const struct View *view,
+                        uint32_t index);
+
 
 /**
- * Clear the custom peer map
+ * Clear the view
  *
- * @param c_peer_map the custom peer map to look in
- *
- * @return size of the map
+ * @param view The view to clear
  */
 void
-View_clear ();
+View_clear (struct View *view);
+
 
 /**
- * Destroy peermap.
+ * Destroy view.
  *
- * @param c_peer_map the map to destroy
+ * @param view the view to destroy
  */
 void
-View_destroy ();
+View_destroy (struct View *view);
 
 /* end of gnunet-service-rps_view.h */
diff --git a/src/rps/test_service_rps_view.c b/src/rps/test_service_rps_view.c
index 16cf4b832..7418a16fc 100644
--- a/src/rps/test_service_rps_view.c
+++ b/src/rps/test_service_rps_view.c
@@ -22,114 +22,115 @@
 #include <platform.h>
 #include "gnunet-service-rps_view.h"
 
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); View_destroy(); return 1; }
+#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); View_destroy(view); return 1; }
 #define CHECK(c) { if (! (c)) ABORT(); }
 
 
 static int
 check ()
 {
+  struct View *view;
   struct GNUNET_PeerIdentity k1;
   struct GNUNET_PeerIdentity k2;
   const struct GNUNET_PeerIdentity *array;
-  int j;
+  unsigned int j;
 
-  View_create (3);
+  view = View_create (3);
   memset (&k1, 0, sizeof (k1));
   memset (&k2, 1, sizeof (k2));
-  CHECK (GNUNET_NO == View_contains_peer (&k1));
-  CHECK (GNUNET_NO == View_contains_peer (&k2));
-  CHECK (GNUNET_NO == View_remove_peer (&k1));
-  CHECK (GNUNET_NO == View_remove_peer (&k2));
-  CHECK (NULL == View_get_peer_by_index (0));
-  CHECK (NULL == View_get_peer_by_index (1));
-  View_clear (); /* See if assertions trigger */
-  CHECK (0 == View_size ());
-
-  CHECK (GNUNET_OK == View_put (&k1));
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_NO == View_put (&k1));
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_YES == View_contains_peer (&k1));
-  CHECK (GNUNET_OK == View_remove_peer (&k1));
-  CHECK (0 == View_size ());
-  CHECK (GNUNET_NO == View_contains_peer (&k1));
-  CHECK (GNUNET_NO == View_contains_peer (&k2));
-
-  CHECK (GNUNET_OK == View_put (&k1));
-  CHECK (1 == View_size ());
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k2));
+  CHECK (GNUNET_NO == View_remove_peer (view, &k1));
+  CHECK (GNUNET_NO == View_remove_peer (view, &k2));
+  CHECK (NULL == View_get_peer_by_index (view, 0));
+  CHECK (NULL == View_get_peer_by_index (view, 1));
+  View_clear (view); /* See if assertions trigger */
+  CHECK (0 == View_size (view));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_NO == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_OK == View_remove_peer (view, &k1));
+  CHECK (0 == View_size (view));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k2));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
   for (j = 0; j < 16; j++)
   {
-    CHECK (GNUNET_NO == View_put (&k1));
+    CHECK (GNUNET_NO == View_put (view, &k1));
   }
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_OK == View_put (&k2));
-  CHECK (2 == View_size ());
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
   for (j = 0; j < 16; j++)
   {
-    CHECK (GNUNET_NO == View_put (&k2));
+    CHECK (GNUNET_NO == View_put (view, &k2));
   }
-  CHECK (2 == View_size ());
+  CHECK (2 == View_size (view));
 
   /* iterate */
-  for (j = 0; j < View_size (); j++)
+  for (j = 0; j < View_size (view); j++)
   {
-    CHECK (NULL != View_get_peer_by_index (j));
+    CHECK (NULL != View_get_peer_by_index (view, j));
   }
-  CHECK ((0 == memcmp (View_get_peer_by_index (0),
+  CHECK ((0 == memcmp (View_get_peer_by_index (view, 0),
                        &k1, sizeof (k1))));
-  CHECK ((0 == memcmp (View_get_peer_by_index (1),
+  CHECK ((0 == memcmp (View_get_peer_by_index (view, 1),
                        &k2, sizeof (k2))));
-  CHECK (GNUNET_OK == View_remove_peer (&k1));
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_NO == View_contains_peer (&k1));
-  CHECK (GNUNET_YES == View_contains_peer (&k2));
-  CHECK (NULL != View_get_peer_by_index (0));
-  CHECK (NULL == View_get_peer_by_index (1));
-
-  View_clear ();
-  CHECK (0 == View_size ());
-
-  CHECK (GNUNET_OK == View_put (&k1));
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_YES == View_contains_peer (&k1));
-  CHECK (GNUNET_OK == View_put (&k2));
-  CHECK (2 == View_size ());
-  CHECK (GNUNET_YES == View_contains_peer (&k2));
-  array = View_get_as_array ();
+  CHECK (GNUNET_OK == View_remove_peer (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_NO == View_contains_peer (view, &k1));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  CHECK (NULL != View_get_peer_by_index (view, 0));
+  CHECK (NULL == View_get_peer_by_index (view, 1));
+
+  View_clear (view);
+  CHECK (0 == View_size (view));
+
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
   CHECK (0 == memcmp (&array[0], &k1, sizeof (k1)));
   CHECK (0 == memcmp (&array[1], &k2, sizeof (k2)));
-  View_clear ();
-  CHECK (0 == View_size ());
+  View_clear (view);
+  CHECK (0 == View_size (view));
 
   /*View_change_len () */
-  CHECK (GNUNET_OK == View_put (&k1));
-  CHECK (GNUNET_OK == View_put (&k2));
-  CHECK (2 == View_size ());
-  View_change_len (4);
-  CHECK (2 == View_size ());
-  CHECK (GNUNET_YES == View_contains_peer (&k1));
-  CHECK (GNUNET_YES == View_contains_peer (&k2));
-  array = View_get_as_array ();
+  CHECK (GNUNET_OK == View_put (view, &k1));
+  CHECK (GNUNET_OK == View_put (view, &k2));
+  CHECK (2 == View_size (view));
+  View_change_len (view, 4);
+  CHECK (2 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
   CHECK (0 == memcmp (&array[0], &k1, sizeof (k1)));
   CHECK (0 == memcmp (&array[1], &k2, sizeof (k2)));
-  View_change_len (1);
-  CHECK (1 == View_size ());
-  CHECK (GNUNET_YES == View_contains_peer (&k1));
-  CHECK (GNUNET_NO  == View_contains_peer (&k2));
-  array = View_get_as_array ();
+  View_change_len (view, 1);
+  CHECK (1 == View_size (view));
+  CHECK (GNUNET_YES == View_contains_peer (view, &k1));
+  CHECK (GNUNET_NO  == View_contains_peer (view, &k2));
+  array = View_get_as_array (view);
   CHECK (0 == memcmp (&array[0], &k1, sizeof (k1)));
-  View_clear ();
-  CHECK (0 == View_size ());
+  View_clear (view);
+  CHECK (0 == View_size (view));
 
-  View_destroy ();
+  View_destroy (view);
 
   return 0;
 }
 
 
 int
-main (int argc, char *argv[])
+main ()
 {
   GNUNET_log_setup ("test_service_rps_peers", 
                     "WARNING",