src/ats/perf_ats_mlp.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,2011 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 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  * @file ats/perf_ats_mlp
  22  * @brief performance test for the MLP solver
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25
  26  */
  27
  28 /*
  29      This file is part of GNUnet.
  30      (C) 2010,2011 Christian Grothoff (and other contributing authors)
  31
  32      GNUnet is free software; you can redistribute it and/or modify
  33      it under the terms of the GNU General Public License as published
  34      by the Free Software Foundation; either version 3, or (at your
  35      option) any later version.
  36
  37      GNUnet is distributed in the hope that it will be useful, but
  38      WITHOUT ANY WARRANTY; without even the implied warranty of
  39      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  40      General Public License for more details.
  41
  42      You should have received a copy of the GNU General Public License
  43      along with GNUnet; see the file COPYING.  If not, write to the
  44      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  45      Boston, MA 02111-1307, USA.
  46 */
  47 /**
  48  * @file ats/test_ats_mlp.c
  49  * @brief basic test for the MLP solver
  50  * @author Christian Grothoff
  51  * @author Matthias Wachs
  52
  53  */
  54 #include "platform.h"
  55 #include "gnunet_util_lib.h"
  56 #include "gnunet_statistics_service.h"
  57 #include "gnunet_ats_service.h"
  58 #include "gnunet-service-ats_addresses_mlp.h"
  59 #include "test_ats_api_common.h"
  60
  61 #define PEERS_START 100
  62 #define PEERS_END       100
  63
  64 #define ADDRESSES 10
  65
  66 int count_p;
  67 int count_a;
  68
  69
  70 struct PerfPeer
  71 {
  72         struct GNUNET_PeerIdentity id;
  73
  74         struct ATS_Address *head;
  75         struct ATS_Address *tail;
  76 };
  77
  78 static int ret;
  79
  80 static int N_peers_start;
  81 static int N_peers_end;
  82 static int N_address;
  83
  84 /**
  85  * Statistics handle
  86  */
  87 struct GNUNET_STATISTICS_Handle * stats;
  88
  89 /**
  90  * MLP solver handle
  91  */
  92 struct GAS_MLP_Handle *mlp;
  93
  94 /**
  95  * Hashmap containing addresses
  96  */
  97 struct GNUNET_CONTAINER_MultiHashMap * addresses;
  98
  99 struct PerfPeer *peers;
 100
 101 static void
 102 end_now (int res)
 103 {
 104   if (NULL != stats)
 105   {
 106           GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
 107           stats = NULL;
 108   }
 109   /*
 110   if (NULL != addresses)
 111   {
 112                 GNUNET_CONTAINER_multihashmap_iterate (addresses, &addr_it, NULL);
 113                 GNUNET_CONTAINER_multihashmap_destroy (addresses);
 114                 addresses = NULL ;
 115   }*/
 116   if (NULL != peers)
 117         {
 118                 GNUNET_free (peers);
 119         }
 120   if (NULL != mlp)
 121   {
 122                 GAS_mlp_done (mlp);
 123                 mlp = NULL;
 124   }
 125
 126         ret = res;
 127 }
 128
 129 static void
 130 end_correctly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 131 {
 132
 133 }
 134
 135
 136 static void
 137 bandwidth_changed_cb (void *cls, struct ATS_Address *address)
 138 {
 139
 140 }
 141
 142 static void
 143 perf_create_peer (int cp)
 144 {
 145         GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &peers[cp].id.hashPubKey);
 146         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating peer #%u: %s \n", cp, GNUNET_i2s (&peers[cp].id));
 147 }
 148
 149 static struct ATS_Address *
 150 perf_create_address (int cp, int ca)
 151 {
 152         struct ATS_Address *a;
 153         a = create_address (&peers[cp].id, "Test 1", "test 1", strlen ("test 1") + 1, 0);
 154         GNUNET_CONTAINER_DLL_insert (peers[cp].head, peers[cp].tail, a);
 155         GNUNET_CONTAINER_multihashmap_put (addresses, &peers[cp].id.hashPubKey, a, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 156         return a;
 157 }
 158
 159
 160
 161
 162
 163 static void
 164 check (void *cls, char *const *args, const char *cfgfile,
 165        const struct GNUNET_CONFIGURATION_Handle *cfg)
 166 {
 167   int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
 168   unsigned long long  quotas_in[GNUNET_ATS_NetworkTypeCount];
 169   unsigned long long  quotas_out[GNUNET_ATS_NetworkTypeCount];
 170         int cp;
 171         int ca;
 172         struct ATS_Address * cur_addr;
 173
 174   stats = GNUNET_STATISTICS_create("ats", cfg);
 175   if (NULL == stats)
 176   {
 177         GNUNET_break (0);
 178     end_now (1);
 179     return;
 180   }
 181
 182   /* Load quotas */
 183   if (GNUNET_ATS_NetworkTypeCount != load_quotas (cfg, quotas_out, quotas_in,
 184                         GNUNET_ATS_NetworkTypeCount))
 185   {
 186         GNUNET_break (0);
 187       end_now (1);
 188       return;
 189   }
 190
 191   GNUNET_assert (N_peers_end >= N_peers_start);
 192   GNUNET_assert (N_address >= 0);
 193
 194   if ((0 == N_peers_start) && (0 == N_peers_end))
 195   {
 196                 N_peers_start = PEERS_START;
 197                 N_peers_end = PEERS_END;
 198   }
 199   if (0 == N_address)
 200                 N_address = ADDRESSES;
 201
 202   fprintf (stderr, "Solving problem for %u..%u peers with %u addresses\n",
 203                 N_peers_start, N_peers_end, N_address);
 204
 205   count_p = N_peers_end;
 206   count_a = N_address;
 207   peers = GNUNET_malloc ((count_p) * sizeof (struct PerfPeer));
 208   /* Setup address hashmap */
 209   addresses = GNUNET_CONTAINER_multihashmap_create (N_address, GNUNET_NO);
 210
 211   /* Init MLP solver */
 212   mlp  = GAS_mlp_init (cfg, stats, quotas, quotas_out, quotas_in,
 213                 GNUNET_ATS_NetworkTypeCount, &bandwidth_changed_cb, NULL);
 214   if (NULL == mlp)
 215   {
 216         GNUNET_break (0);
 217       end_now (1);
 218       return;
 219   }
 220   mlp->mlp_auto_solve = GNUNET_NO;
 221
 222         for (cp = 0; cp < count_p; cp++)
 223                         perf_create_peer (cp);
 224
 225         for (cp = 0; cp < count_p; cp++)
 226         {
 227                         for (ca = 0; ca < count_a; ca++)
 228                         {
 229                                         cur_addr = perf_create_address(cp, ca);
 230                                         /* add address */
 231                                         GAS_mlp_address_add (mlp, addresses, cur_addr);
 232                                         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding address for peer %u address %u: \n", cp, ca);
 233                         }
 234                         GAS_mlp_get_preferred_address( mlp, addresses, &peers[cp].id);
 235                         /* solve */
 236                         if (cp + 1 >= N_peers_start)
 237                         {
 238
 239                                 GAS_mlp_solve_problem (mlp, addresses);
 240                                 fprintf (stderr, "Solving problem for %u peers with each %u addresses (build/LP/MIP in ms): %llu %llu %llu\n",
 241                                                         cp + 1, ca,
 242                                                         (unsigned long long) mlp->ps.build_dur.rel_value,
 243                                                         (unsigned long long) mlp->ps.lp_dur.rel_value,
 244                                                         (unsigned long long) mlp->ps.mip_dur.rel_value);
 245                         }
 246
 247         }
 248
 249
 250         struct ATS_Address *cur;
 251         struct ATS_Address *next;
 252         for (cp = 0; cp < count_p; cp++)
 253         {
 254                         for (cur = peers[cp].head; cur != NULL; cur = next)
 255                         {
 256                                         GAS_mlp_address_delete (mlp, addresses, cur, GNUNET_NO);
 257                                         next = cur->next;
 258                                         GNUNET_CONTAINER_DLL_remove (peers[cp].head, peers[cp].tail, cur);
 259                                         GNUNET_free (cur);
 260                         }
 261
 262         }
 263         GNUNET_free (peers);
 264
 265 }
 266
 267
 268 int
 269 main (int argc, char *argv[])
 270 {
 271
 272   static char *const argv2[] = { "perf_ats_mlp",
 273     "-c",
 274     "test_ats_mlp.conf",
 275     "-L", "WARNING",
 276     NULL
 277   };
 278
 279   N_peers_start = 0;
 280   N_peers_end = 0;
 281   N_address = 0;
 282   int c;
 283   for (c = 0; c < argc; c++)
 284   {
 285                 if ((0 == strcmp (argv[c], "-q")) && (c < argc))
 286                 {
 287                                 if (0 != atoi(argv[c+1]))
 288                                 {
 289                                                 N_peers_start = atoi(argv[c+1]);
 290                                                 fprintf (stderr, "peers_start: %u\n",N_peers_start );
 291                                 }
 292                 }
 293                 if ((0 == strcmp (argv[c], "-w")) && (c < argc))
 294                 {
 295                                 if (0 != atoi(argv[c+1]))
 296                                 {
 297                                                 N_peers_end = atoi(argv[c+1]);
 298                                                 fprintf (stderr, "peers_end: %u\n",N_peers_end );
 299                                 }
 300                 }
 301                 if ((0 == strcmp (argv[c], "-a")) && (c < argc))
 302                 {
 303                                 if (0 != atoi(argv[c+1]))
 304                                 {
 305                                                 N_address = atoi(argv[c+1]);
 306                                                 fprintf (stderr, "address: %u\n",N_address );
 307                                 }
 308                 }
 309   }
 310
 311   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 312     GNUNET_GETOPT_OPTION_END
 313   };
 314
 315
 316   GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
 317                       "perf_ats_mlp", "nohelp", options,
 318                       &check, NULL);
 319
 320
 321   return ret;
 322 }
 323
 324 /* end of file perf_ats_mlp.c */