src/set/gnunet-set-profiler.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2013 Christian Grothoff (and other contributing authors)
   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 2, 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 set/gnunet-set-profiler.c
  23  * @brief profiling tool for set
  24  * @author Florian Dold
  25  */
  26 #include "platform.h"
  27 #include "gnunet_common.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_set_service.h"
  30 #include "gnunet_testbed_service.h"
  31
  32
  33 static int ret;
  34
  35 static unsigned int num_a = 5;
  36 static unsigned int num_b = 5;
  37 static unsigned int num_c = 20;
  38
  39 static unsigned int salt = 42;
  40
  41 static char* op_str = "union";
  42
  43 const static struct GNUNET_CONFIGURATION_Handle *config;
  44
  45 struct GNUNET_CONTAINER_MultiHashMap *map_a;
  46 struct GNUNET_CONTAINER_MultiHashMap *map_b;
  47 struct GNUNET_CONTAINER_MultiHashMap *map_c;
  48
  49
  50 /**
  51  * Elements that set a received, should match map_c
  52  * in the end.
  53  */
  54 struct GNUNET_CONTAINER_MultiHashMap *map_a_received;
  55
  56 /**
  57  * Elements that set b received, should match map_c
  58  * in the end.
  59  */
  60 struct GNUNET_CONTAINER_MultiHashMap *map_b_received;
  61
  62 struct GNUNET_SET_Handle *set_a;
  63 struct GNUNET_SET_Handle *set_b;
  64
  65 struct GNUNET_HashCode app_id;
  66
  67 struct GNUNET_PeerIdentity local_peer;
  68
  69 struct GNUNET_SET_ListenHandle *set_listener;
  70
  71 struct GNUNET_SET_OperationHandle *set_oh1;
  72 struct GNUNET_SET_OperationHandle *set_oh2;
  73
  74
  75 int a_done;
  76 int b_done;
  77
  78
  79
  80 static int
  81 map_remove_iterator (void *cls,
  82                      const struct GNUNET_HashCode *key,
  83                      void *value)
  84 {
  85   struct GNUNET_CONTAINER_MultiHashMap *m = cls;
  86   int ret;
  87
  88   ret = GNUNET_CONTAINER_multihashmap_remove (m, key, NULL);
  89   GNUNET_assert (GNUNET_OK == ret);
  90   return GNUNET_YES;
  91
  92 }
  93
  94
  95 static void
  96 set_result_cb_1 (void *cls,
  97                  const struct GNUNET_SET_Element *element,
  98                  enum GNUNET_SET_Status status)
  99 {
 100   GNUNET_assert (GNUNET_NO == a_done);
 101   GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode));
 102   switch (status)
 103   {
 104     case GNUNET_SET_STATUS_DONE:
 105     case GNUNET_SET_STATUS_HALF_DONE:
 106       a_done = GNUNET_YES;
 107       GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_a_received);
 108       GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_a_received));
 109       return;
 110     case GNUNET_SET_STATUS_FAILURE:
 111       GNUNET_assert (0);
 112       return;
 113     case GNUNET_SET_STATUS_OK:
 114       break;
 115     default:
 116       GNUNET_assert (0);
 117   }
 118   GNUNET_CONTAINER_multihashmap_put (map_a_received,
 119                                      element->data, NULL,
 120                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 121 }
 122
 123
 124 static void
 125 set_result_cb_2 (void *cls,
 126                  const struct GNUNET_SET_Element *element,
 127                  enum GNUNET_SET_Status status)
 128 {
 129   GNUNET_assert (GNUNET_NO == b_done);
 130   GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode));
 131   switch (status)
 132   {
 133     case GNUNET_SET_STATUS_DONE:
 134     case GNUNET_SET_STATUS_HALF_DONE:
 135       b_done = GNUNET_YES;
 136       GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_b_received);
 137       GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_b_received));
 138       return;
 139     case GNUNET_SET_STATUS_FAILURE:
 140       GNUNET_assert (0);
 141       return;
 142     case GNUNET_SET_STATUS_OK:
 143       break;
 144     default:
 145       GNUNET_assert (0);
 146   }
 147   GNUNET_CONTAINER_multihashmap_put (map_b_received,
 148                                      element->data, NULL,
 149                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 150 }
 151
 152
 153 static void
 154 set_listen_cb (void *cls,
 155                const struct GNUNET_PeerIdentity *other_peer,
 156                const struct GNUNET_MessageHeader *context_msg,
 157                struct GNUNET_SET_Request *request)
 158 {
 159   GNUNET_assert (NULL == set_oh2);
 160   set_oh2 = GNUNET_SET_accept (request, GNUNET_SET_RESULT_ADDED,
 161                                set_result_cb_2, NULL);
 162   GNUNET_SET_commit (set_oh2, set_b);
 163 }
 164
 165
 166
 167 static int
 168 set_insert_iterator (void *cls,
 169                      const struct GNUNET_HashCode *key,
 170                      void *value)
 171 {
 172   struct GNUNET_SET_Handle *set = cls;
 173   struct GNUNET_SET_Element *el;
 174
 175   el = GNUNET_malloc (sizeof *el + sizeof *key);
 176   el->type = 0;
 177   memcpy (&el[1], key, sizeof *key);
 178   el->data = &el[1];
 179   el->size = sizeof *key;
 180   GNUNET_SET_add_element (set, el, NULL, NULL);
 181   GNUNET_free (el);
 182   return GNUNET_YES;
 183 }
 184
 185
 186 static void
 187 run (void *cls, char *const *args, const char *cfgfile,
 188      const struct GNUNET_CONFIGURATION_Handle *cfg)
 189 {
 190   unsigned int i;
 191   struct GNUNET_HashCode hash;
 192
 193   config = cfg;
 194
 195   if (GNUNET_OK != GNUNET_CRYPTO_get_host_identity (cfg, &local_peer))
 196   {
 197     GNUNET_assert (0);
 198     return;
 199   }
 200
 201   map_a = GNUNET_CONTAINER_multihashmap_create (num_a, GNUNET_NO);
 202   map_b = GNUNET_CONTAINER_multihashmap_create (num_b, GNUNET_NO);
 203   map_c = GNUNET_CONTAINER_multihashmap_create (num_c, GNUNET_NO);
 204
 205   for (i = 0; i < num_a; i++)
 206   {
 207     GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
 208     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
 209     {
 210       i--;
 211       continue;
 212     }
 213     GNUNET_CONTAINER_multihashmap_put (map_a, &hash, &hash,
 214                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 215   }
 216
 217   for (i = 0; i < num_b; i++)
 218   {
 219     GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
 220     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
 221     {
 222       i--;
 223       continue;
 224     }
 225     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash))
 226     {
 227       i--;
 228       continue;
 229     }
 230     GNUNET_CONTAINER_multihashmap_put (map_b, &hash, NULL,
 231                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 232   }
 233
 234   for (i = 0; i < num_c; i++)
 235   {
 236     GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
 237     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
 238     {
 239       i--;
 240       continue;
 241     }
 242     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash))
 243     {
 244       i--;
 245       continue;
 246     }
 247     if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_c, &hash))
 248     {
 249       i--;
 250       continue;
 251     }
 252     GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
 253     GNUNET_CONTAINER_multihashmap_put (map_c, &hash, NULL,
 254                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 255   }
 256
 257   /* use last hash for app id */
 258   app_id = hash;
 259
 260   /* FIXME: also implement intersection etc. */
 261   set_a = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
 262   set_b = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
 263
 264   GNUNET_CONTAINER_multihashmap_iterate (map_a, set_insert_iterator, set_a);
 265   GNUNET_CONTAINER_multihashmap_iterate (map_b, set_insert_iterator, set_b);
 266   GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_a);
 267   GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_b);
 268
 269   set_listener = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION,
 270                                     &app_id, set_listen_cb, NULL);
 271
 272   set_oh1 = GNUNET_SET_prepare (&local_peer, &app_id, NULL, salt, GNUNET_SET_RESULT_ADDED,
 273                        set_result_cb_1, NULL);
 274   GNUNET_SET_commit (set_oh1, set_a);
 275 }
 276
 277
 278 int
 279 main (int argc, char **argv)
 280 {
 281    static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 282       { 'A', "num-first", NULL,
 283         gettext_noop ("number of values"),
 284         GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_a },
 285       { 'B', "num-second", NULL,
 286         gettext_noop ("number of values"),
 287         GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_b },
 288       { 'C', "num-common", NULL,
 289         gettext_noop ("number of values"),
 290         GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_c },
 291       { 'x', "operation", NULL,
 292         gettext_noop ("oeration to execute"),
 293         GNUNET_YES, &GNUNET_GETOPT_set_string, &op_str },
 294       GNUNET_GETOPT_OPTION_END
 295   };
 296   GNUNET_PROGRAM_run (argc, argv, "gnunet-set-profiler",
 297                       "help",
 298                       options, &run, NULL);
 299   return ret;
 300 }
 301