examples/amok/saturate/saturate.c

   1 /* saturate - link saturation demo of AMOK features                         */
   2
   3 /* Copyright (c) 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /* This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the license (GNU LGPL) which comes with this package. */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <signal.h>
  12 #include <time.h>
  13
  14 #include "xbt/peer.h"
  15 #include "gras.h"
  16 #include "amok/bandwidth.h"
  17 #include "amok/peermanagement.h"
  18
  19 XBT_LOG_NEW_DEFAULT_CATEGORY(saturate,
  20                              "Messages specific to this example");
  21
  22 /* **********************************************************************
  23  * Sensor code
  24  * **********************************************************************/
  25
  26 /* Function prototypes */
  27 int sensor(int argc, char *argv[]);
  28
  29 int sensor(int argc, char *argv[])
  30 {
  31   gras_socket_t mysock;
  32   gras_socket_t master;
  33
  34   gras_init(&argc, argv);
  35   amok_bw_init();
  36   amok_pm_init();
  37
  38   mysock = gras_socket_server_range(3000, 9999, 0, 0);
  39   XBT_INFO("Sensor starting (on port %d)", gras_os_myport());
  40   gras_os_sleep(2);             /* let the master get ready */
  41   master = gras_socket_client_from_string(argv[1]);
  42
  43   amok_pm_group_join(master, "saturate");
  44   amok_pm_mainloop(600);
  45
  46   gras_socket_close(mysock);
  47   gras_socket_close(master);
  48   gras_exit();
  49   return 0;
  50 }
  51
  52 /* **********************************************************************
  53  * Maestro code
  54  * **********************************************************************/
  55
  56 /* Function prototypes */
  57 int maestro(int argc, char *argv[]);
  58
  59 /* XP setups */
  60 const int buf_size = 0;
  61 const int msg_size = 50 * 1024;
  62 const int msg_amount = 2;
  63 const int sat_size = 1024 * 1024 * 10;
  64 const double min_duration = 1;
  65
  66 static double XP(const char *bw1, const char *bw2,
  67                  const char *sat1, const char *sat2)
  68 {
  69
  70   double sec, bw, sec_sat, bw_sat;
  71
  72   gras_os_sleep(5.0);           /* wait for the sensors to show up */
  73   /* Test BW without saturation */
  74   amok_bw_request(bw1, 4000, bw2, 4000,
  75                   buf_size, msg_size, msg_amount, min_duration, &sec, &bw);
  76   XBT_INFO("BW(%s,%s) => %f sec, achieving %f Mb/s",
  77         bw1, bw2, sec, (bw / 1024.0 / 1024.0));
  78
  79
  80   /* Test BW with saturation */
  81   amok_bw_saturate_start(sat1, 4000, sat2, 4000, sat_size, 60);
  82   gras_os_sleep(1.0);           /* let it start */
  83
  84   amok_bw_request(bw1, 4000, bw2, 4000,
  85                   buf_size, msg_size, msg_amount, min_duration, &sec_sat,
  86                   &bw_sat);
  87   XBT_INFO("BW(%s,%s//%s,%s) => %f sec, achieving %f Mb/s", bw1, bw2, sat1,
  88         sat2, sec, bw / 1024.0 / 1024.0);
  89
  90   amok_bw_saturate_stop(sat1, 4000, NULL, NULL);
  91
  92   if (bw_sat / bw < 0.7) {
  93     XBT_INFO("THERE IS SOME INTERFERENCE !!!");
  94   }
  95   if (bw / bw_sat < 0.7) {
  96     XBT_INFO("THERE IS SOME INTERFERENCE (and I'm an idiot) !!!");
  97   }
  98   return bw_sat / bw;
  99 }
 100
 101 static void kill_buddy(char *name, int port)
 102 {
 103   gras_socket_t sock = gras_socket_client(name, port);
 104   gras_msg_send(sock, "kill", NULL);
 105   gras_socket_close(sock);
 106 }
 107
 108 static void kill_buddy_dynar(void *b)
 109 {
 110   xbt_peer_t buddy = *(xbt_peer_t *) b;
 111   kill_buddy(buddy->name, buddy->port);
 112 }
 113
 114 static void free_peer(void *d)
 115 {
 116   xbt_peer_t h = *(xbt_peer_t *) d;
 117   free(h->name);
 118   free(h);
 119 }
 120
 121 static void simple_saturation(int argc, char *argv[])
 122 {
 123   xbt_ex_t e;
 124
 125   /* where are the sensors */
 126   xbt_dynar_t peers;
 127   xbt_peer_t h1, h2;
 128   /* results */
 129   double duration, bw;
 130
 131   /* Init the group */
 132   peers = amok_pm_group_new("saturate");
 133   /* wait for dudes */
 134   gras_msg_handleall(5);
 135
 136   /* Stop all sensors but two of them */
 137   while (xbt_dynar_length(peers) > 2) {
 138     xbt_dynar_pop(peers, &h1);
 139     amok_pm_kill_hp(h1->name, h1->port);
 140     xbt_peer_free(h1);
 141   }
 142
 143   /* get 2 friends */
 144   xbt_dynar_get_cpy(peers, 0, &h1);
 145   xbt_dynar_get_cpy(peers, 1, &h2);
 146
 147   /* Start saturation */
 148   XBT_INFO("Start saturation between %s:%d and %s:%d",
 149         h1->name, h1->port, h2->name, h2->port);
 150
 151   amok_bw_saturate_start(h1->name, h1->port, h2->name, h2->port, 0,     /* Be a nice boy, compute msg_size yourself */
 152                          30 /* 5 sec timeout */ );
 153
 154   /* Stop it after a while */
 155   XBT_INFO("Have a rest");
 156   gras_os_sleep(1);
 157   TRY {
 158     XBT_INFO("Stop the saturation");
 159     amok_bw_saturate_stop(h1->name, h1->port, &duration, &bw);
 160   }
 161   CATCH(e) {
 162     XBT_INFO("Ooops, stoping the saturation raised an exception");
 163     xbt_ex_free(e);
 164   }
 165   XBT_INFO("Saturation took %.2fsec, achieving %fb/s", duration, bw);
 166
 167   /* Game is over, friends */
 168   amok_pm_group_shutdown("saturate");
 169 }
 170
 171 /********************************************************************************************/
 172 static void full_fledged_saturation(int argc, char *argv[])
 173 {
 174   double time1 = 5.0, bw1 = 5.0;        // 0.5 for test
 175   /* timers */
 176   double begin_simulated;
 177   int begin;
 178
 179   /* where are the sensors */
 180   xbt_dynar_t peers;
 181   int nb_peers;
 182
 183   /* results */
 184   double *bw;
 185   double *bw_sat;
 186
 187   /* iterators */
 188   unsigned int i, j, k, l;
 189   xbt_peer_t h1, h2, h3, h4;
 190
 191   /* Init the group */
 192   peers = amok_pm_group_new("saturate");
 193   /* wait 4 dudes */
 194   gras_msg_handle(60);
 195   gras_msg_handle(60);
 196   gras_msg_handle(60);
 197   gras_msg_handle(60);
 198   nb_peers = xbt_dynar_length(peers);
 199
 200   XBT_INFO("Let's go for the bw_matrix");
 201
 202   /* Do the test without saturation */
 203   begin = time(NULL);
 204   begin_simulated = gras_os_time();
 205
 206   bw = amok_bw_matrix(peers, buf_size, msg_size, msg_amount, min_duration);
 207
 208   XBT_INFO("Did all BW tests in %ld sec (%.2f simulated(?) sec)",
 209         (long int) (time(NULL) - begin), gras_os_time() - begin_simulated);
 210
 211   /* Do the test with saturation */
 212   bw_sat = xbt_new(double, nb_peers * nb_peers);
 213   xbt_dynar_foreach(peers, i, h1) {
 214     xbt_dynar_foreach(peers, j, h2) {
 215       if (i == j)
 216         continue;
 217
 218       TRY {
 219         amok_bw_saturate_start(h1->name, h1->port, h2->name, h2->port, 0,       /* Be nice, compute msg_size yourself */
 220                                0 /* no timeout */ );
 221       }
 222       CATCH_ANONYMOUS {
 223         RETHROWF("Cannot ask peers to saturate the link: %s");
 224       }
 225       gras_os_sleep(5);
 226
 227       begin = time(NULL);
 228       begin_simulated = gras_os_time();
 229       xbt_dynar_foreach(peers, k, h3) {
 230         if (i == k || j == k)
 231           continue;
 232
 233         xbt_dynar_foreach(peers, l, h4) {
 234           double ratio;
 235           if (i == l || j == l || k == l)
 236             continue;
 237
 238           XBT_VERB("TEST %s %s // %s %s",
 239                 h1->name, h2->name, h3->name, h4->name);
 240           amok_bw_request(h3->name, h3->port, h4->name, h4->port,
 241                           buf_size, msg_size, msg_amount, min_duration,
 242                           NULL, &(bw_sat[k * nb_peers + l]));
 243
 244           ratio = bw_sat[k * nb_peers + l] / bw[k * nb_peers + l];
 245           XBT_INFO("SATURATED BW XP(%s %s // %s %s) => %f (%f vs %f)%s",
 246                 h1->name, h2->name, h3->name, h4->name,
 247                 ratio,
 248                 bw[k * nb_peers + l], bw_sat[k * nb_peers + l],
 249                 ratio < 0.7 ? " THERE IS SOME INTERFERENCE !!!" : "");
 250         }
 251       }
 252       amok_bw_saturate_stop(h1->name, h1->port, &time1, &bw1);
 253
 254       XBT_INFO
 255           ("Did an iteration on saturation pair in %ld sec (%.2f simulated sec)",
 256            (long int) (time(NULL) - begin),
 257            gras_os_time() - begin_simulated);
 258       XBT_INFO
 259           ("the duration of the experiment >>>>> %.3f sec (%.3f bandwidth)",
 260            time1, bw1);
 261     }
 262   }
 263   free(bw_sat);
 264   free(bw);
 265   /* Game is over, friends */
 266   amok_pm_group_shutdown("saturate");
 267 }
 268
 269
 270 int maestro(int argc, char *argv[])
 271 {
 272
 273   gras_init(&argc, argv);
 274   amok_bw_init();
 275   amok_pm_init();
 276
 277   gras_socket_server(atoi(argv[1]));
 278
 279   simple_saturation(argc, argv);
 280   //full_fledged_saturation(argc, argv);
 281
 282   gras_exit();
 283   return 0;
 284
 285 }