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 static int numeric;
  80
  81 static int N_peers_start;
  82 static int N_peers_end;
  83 static int N_address;
  84
  85 /**
  86  * Statistics handle
  87  */
  88 struct GNUNET_STATISTICS_Handle * stats;
  89
  90 /**
  91  * MLP solver handle
  92  */
  93 struct GAS_MLP_Handle *mlp;
  94
  95 /**
  96  * Hashmap containing addresses
  97  */
  98 struct GNUNET_CONTAINER_MultiHashMap * addresses;
  99
 100 struct PerfPeer *peers;
 101
 102 static void
 103 end_now (int res)
 104 {
 105   if (NULL != stats)
 106   {
 107           GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
 108           stats = NULL;
 109   }
 110   /*
 111   if (NULL != addresses)
 112   {
 113                 GNUNET_CONTAINER_multihashmap_iterate (addresses, &addr_it, NULL);
 114                 GNUNET_CONTAINER_multihashmap_destroy (addresses);
 115                 addresses = NULL ;
 116   }*/
 117   if (NULL != peers)
 118         {
 119                 GNUNET_free (peers);
 120         }
 121   if (NULL != mlp)
 122   {
 123                 GAS_mlp_done (mlp);
 124                 mlp = NULL;
 125   }
 126
 127         ret = res;
 128 }
 129
 130
 131 static void
 132 bandwidth_changed_cb (void *cls, struct ATS_Address *address)
 133 {
 134
 135 }
 136
 137 static void
 138 perf_create_peer (int cp)
 139 {
 140         GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &peers[cp].id.hashPubKey);
 141         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating peer #%u: %s \n", cp, GNUNET_i2s (&peers[cp].id));
 142 }
 143
 144 static struct ATS_Address *
 145 perf_create_address (int cp, int ca)
 146 {
 147         struct ATS_Address *a;
 148         a = create_address (&peers[cp].id, "Test 1", "test 1", strlen ("test 1") + 1, 0);
 149         GNUNET_CONTAINER_DLL_insert (peers[cp].head, peers[cp].tail, a);
 150         GNUNET_CONTAINER_multihashmap_put (addresses, &peers[cp].id.hashPubKey, a, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 151         return a;
 152 }
 153
 154
 155
 156
 157
 158 static void
 159 check (void *cls, char *const *args, const char *cfgfile,
 160        const struct GNUNET_CONFIGURATION_Handle *cfg)
 161 {
 162   int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
 163   unsigned long long  quotas_in[GNUNET_ATS_NetworkTypeCount];
 164   unsigned long long  quotas_out[GNUNET_ATS_NetworkTypeCount];
 165         int cp;
 166         int ca;
 167         struct ATS_Address * cur_addr;
 168
 169   stats = GNUNET_STATISTICS_create("ats", cfg);
 170   if (NULL == stats)
 171   {
 172         GNUNET_break (0);
 173     end_now (1);
 174     return;
 175   }
 176
 177   /* Load quotas */
 178   if (GNUNET_ATS_NetworkTypeCount != load_quotas (cfg, quotas_out, quotas_in,
 179                         GNUNET_ATS_NetworkTypeCount))
 180   {
 181         GNUNET_break (0);
 182       end_now (1);
 183       return;
 184   }
 185
 186   GNUNET_assert (N_peers_end >= N_peers_start);
 187   GNUNET_assert (N_address >= 0);
 188
 189   if ((0 == N_peers_start) && (0 == N_peers_end))
 190   {
 191                 N_peers_start = PEERS_START;
 192                 N_peers_end = PEERS_END;
 193   }
 194   if (0 == N_address)
 195                 N_address = ADDRESSES;
 196
 197   fprintf (stderr, "Solving problem for %u..%u peers with %u addresses\n",
 198                 N_peers_start, N_peers_end, N_address);
 199
 200   count_p = N_peers_end;
 201   count_a = N_address;
 202   peers = GNUNET_malloc ((count_p) * sizeof (struct PerfPeer));
 203   /* Setup address hashmap */
 204   addresses = GNUNET_CONTAINER_multihashmap_create (N_address, GNUNET_NO);
 205
 206   /* Init MLP solver */
 207   mlp  = GAS_mlp_init (cfg, stats, quotas, quotas_out, quotas_in,
 208                 GNUNET_ATS_NetworkTypeCount, &bandwidth_changed_cb, NULL);
 209   if (NULL == mlp)
 210   {
 211         GNUNET_break (0);
 212       end_now (1);
 213       return;
 214   }
 215   mlp->mlp_auto_solve = GNUNET_NO;
 216
 217         for (cp = 0; cp < count_p; cp++)
 218                         perf_create_peer (cp);
 219
 220         if (GNUNET_YES == numeric)
 221                 fprintf (stderr, "#peers;#addresses per peer;LP/MIP state;presolv;exec build in ms;exec LP in ms; exec MIP in ms;#cols;#rows;#nonzero elements\n");
 222
 223         for (cp = 0; cp < count_p; cp++)
 224         {
 225                         for (ca = 0; ca < count_a; ca++)
 226                         {
 227                                         cur_addr = perf_create_address(cp, ca);
 228                                         /* add address */
 229                                         GAS_mlp_address_add (mlp, addresses, cur_addr);
 230                                         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding address for peer %u address %u: \n", cp, ca);
 231                         }
 232                         GAS_mlp_get_preferred_address( mlp, addresses, &peers[cp].id);
 233                         /* solve */
 234                         if (cp + 1 >= N_peers_start)
 235                         {
 236
 237                                 GAS_mlp_solve_problem (mlp, addresses);
 238                                 if (GNUNET_NO == numeric)
 239                                         fprintf (stderr, "%u peers each %u addresses;  LP/MIP state [%s/%s] presolv [%s/%s], (build/LP/MIP in ms): %04llu %04llu %04llu; size (cols x rows, nonzero elements): [%u x %u] = %u\n",
 240                                                         cp + 1, ca,
 241                                                         (GNUNET_OK == mlp->ps.lp_res) ? "OK" : "FAIL",
 242                                                         (GNUNET_OK == mlp->ps.mip_res) ? "OK" : "FAIL",
 243                                                         (GLP_YES == mlp->ps.lp_presolv) ? "YES" : "NO",
 244                                                         (GNUNET_OK == mlp->ps.mip_presolv) ? "YES" : "NO",
 245                                                         (unsigned long long) mlp->ps.build_dur.rel_value,
 246                                                         (unsigned long long) mlp->ps.lp_dur.rel_value,
 247                                                         (unsigned long long) mlp->ps.mip_dur.rel_value,
 248                                                         mlp->ps.p_cols, mlp->ps.p_rows, mlp->ps.p_elements);
 249                                 else
 250                                         fprintf (stderr, "%u;%u;%s;%s;%s;%s;%04llu;%04llu;%04llu;%u;%u;%u\n",
 251                                                         cp + 1, ca,
 252                                                         (GNUNET_OK == mlp->ps.lp_res) ? "OK" : "FAIL",
 253                                                         (GNUNET_OK == mlp->ps.mip_res) ? "OK" : "FAIL",
 254                                                         (GLP_YES == mlp->ps.lp_presolv) ? "YES" : "NO",
 255                                                         (GNUNET_OK == mlp->ps.mip_presolv) ? "YES" : "NO",
 256                                                         (unsigned long long) mlp->ps.build_dur.rel_value,
 257                                                         (unsigned long long) mlp->ps.lp_dur.rel_value,
 258                                                         (unsigned long long) mlp->ps.mip_dur.rel_value,
 259                                                         mlp->ps.p_cols, mlp->ps.p_rows, mlp->ps.p_elements);
 260                         }
 261
 262         }
 263
 264
 265         struct ATS_Address *cur;
 266         struct ATS_Address *next;
 267         for (cp = 0; cp < count_p; cp++)
 268         {
 269                         for (cur = peers[cp].head; cur != NULL; cur = next)
 270                         {
 271                                         GAS_mlp_address_delete (mlp, addresses, cur, GNUNET_NO);
 272                                         next = cur->next;
 273                                         GNUNET_CONTAINER_DLL_remove (peers[cp].head, peers[cp].tail, cur);
 274                                         GNUNET_free (cur);
 275                         }
 276
 277         }
 278         GNUNET_free (peers);
 279
 280 }
 281
 282
 283 int
 284 main (int argc, char *argv[])
 285 {
 286
 287   static char *const argv2[] = { "perf_ats_mlp",
 288     "-c",
 289     "test_ats_mlp.conf",
 290     "-L", "WARNING",
 291     NULL
 292   };
 293
 294   N_peers_start = 0;
 295   N_peers_end = 0;
 296   N_address = 0;
 297   int c;
 298   for (c = 0; c < argc; c++)
 299   {
 300                 if ((0 == strcmp (argv[c], "-q")) && (c < argc))
 301                 {
 302                                 if (0 != atoi(argv[c+1]))
 303                                 {
 304                                                 N_peers_start = atoi(argv[c+1]);
 305                                 }
 306                 }
 307                 if ((0 == strcmp (argv[c], "-w")) && (c < argc))
 308                 {
 309                                 if (0 != atoi(argv[c+1]))
 310                                 {
 311                                                 N_peers_end = atoi(argv[c+1]);
 312                                 }
 313                 }
 314                 if ((0 == strcmp (argv[c], "-a")) && (c < argc))
 315                 {
 316                                 if (0 != atoi(argv[c+1]))
 317                                 {
 318                                                 N_address = atoi(argv[c+1]);
 319                                 }
 320                 }
 321                 if ((0 == strcmp (argv[c], "-n")))
 322                 {
 323                                 numeric = GNUNET_YES;
 324                 }
 325   }
 326
 327   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 328     GNUNET_GETOPT_OPTION_END
 329   };
 330
 331
 332   GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
 333                       "perf_ats_mlp", "nohelp", options,
 334                       &check, NULL);
 335
 336
 337   return ret;
 338 }
 339
 340 /* end of file perf_ats_mlp.c */