examples/msg/cloud/simple_vm.c

   1 /* Copyright (c) 2007-2012. The SimGrid Team. All rights reserved. */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include <stdio.h>
   7 #include "msg/msg.h"
   8 #include "xbt/sysdep.h"         /* calloc, printf */
   9
  10 /* Create a log channel to have nice outputs. */
  11 #include "xbt/log.h"
  12 #include "xbt/asserts.h"
  13 XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test,
  14                              "Messages specific for this msg example");
  15
  16
  17 int computation_fun(int argc, char *argv[])
  18 {
  19   const char *pr_name = MSG_process_get_name(MSG_process_self());
  20   const char *host_name = MSG_host_get_name(MSG_host_self());
  21
  22   msg_task_t task = MSG_task_create("Task", 1000000, 1000000, NULL);
  23
  24   double clock_sta = MSG_get_clock();
  25   MSG_task_execute(task);
  26   double clock_end = MSG_get_clock();
  27
  28   XBT_INFO("%s:%s task executed %g", host_name, pr_name, clock_end - clock_sta);
  29
  30   MSG_task_destroy(task);
  31
  32   return 0;
  33 }
  34
  35 void launch_computation_worker(msg_host_t host)
  36 {
  37   const char *pr_name = "compute";
  38   char **argv = xbt_new(char *, 2);
  39   argv[0] = xbt_strdup(pr_name);
  40   argv[1] = NULL;
  41
  42   MSG_process_create_with_arguments(pr_name, computation_fun, NULL, host, 1, argv);
  43 }
  44
  45 struct task_priv {
  46   msg_host_t tx_host;
  47   msg_process_t tx_proc;
  48   double clock_sta;
  49 };
  50
  51 int communication_tx_fun(int argc, char *argv[])
  52 {
  53   xbt_assert(argc == 2);
  54   const char *mbox = argv[1];
  55
  56   msg_task_t task = MSG_task_create("Task", 1000000, 1000000, NULL);
  57
  58   struct task_priv *priv = xbt_new(struct task_priv, 1);
  59   priv->tx_proc = MSG_process_self();
  60   priv->tx_host = MSG_host_self();
  61   priv->clock_sta = MSG_get_clock();
  62
  63   MSG_task_set_data(task, priv);
  64
  65   MSG_task_send(task, mbox);
  66
  67   return 0;
  68 }
  69
  70 int communication_rx_fun(int argc, char *argv[])
  71 {
  72   const char *pr_name = MSG_process_get_name(MSG_process_self());
  73   const char *host_name = MSG_host_get_name(MSG_host_self());
  74   xbt_assert(argc == 2);
  75   const char *mbox = argv[1];
  76
  77   msg_task_t task = NULL;
  78   MSG_task_recv(&task, mbox);
  79
  80   struct task_priv *priv = MSG_task_get_data(task);
  81   double clock_end = MSG_get_clock();
  82
  83   XBT_INFO("%s:%s to %s:%s => %g sec",
  84       MSG_host_get_name(priv->tx_host),
  85       MSG_process_get_name(priv->tx_proc),
  86       host_name, pr_name, clock_end - priv->clock_sta);
  87
  88   MSG_task_destroy(task);
  89
  90   return 0;
  91 }
  92
  93 void launch_communication_worker(msg_host_t tx_host, msg_host_t rx_host)
  94 {
  95   char *mbox = bprintf("MBOX:%s-%s",
  96       MSG_host_get_name(tx_host),
  97       MSG_host_get_name(rx_host));
  98   char **argv = NULL;
  99   char *pr_name = NULL;
 100
 101   pr_name = "comm_tx";
 102   argv = xbt_new(char *, 3);
 103   argv[0] = xbt_strdup(pr_name);
 104   argv[1] = xbt_strdup(mbox);
 105   argv[2] = NULL;
 106
 107   MSG_process_create_with_arguments(pr_name, communication_tx_fun, NULL, tx_host, 2, argv);
 108
 109   pr_name = "comm_rx";
 110   argv = xbt_new(char *, 3);
 111   argv[0] = xbt_strdup(pr_name);
 112   argv[1] = xbt_strdup(mbox);
 113   argv[2] = NULL;
 114
 115   MSG_process_create_with_arguments(pr_name, communication_rx_fun, NULL, rx_host, 2, argv);
 116
 117   xbt_free(mbox);
 118 }
 119
 120
 121 int master_main(int argc, char *argv[])
 122 {
 123   xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
 124   msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t);
 125   msg_host_t pm1 = xbt_dynar_get_as(hosts_dynar, 1, msg_host_t);
 126   msg_host_t pm2 = xbt_dynar_get_as(hosts_dynar, 2, msg_host_t);
 127   msg_vm_t vm0, vm1;
 128
 129   XBT_INFO("### Put a task on a PM");
 130   launch_computation_worker(pm0);
 131   MSG_process_sleep(2);
 132
 133   XBT_INFO("### Put two tasks on a PM");
 134   launch_computation_worker(pm0);
 135   launch_computation_worker(pm0);
 136   MSG_process_sleep(2);
 137
 138   XBT_INFO("### Put a task on each PM");
 139   launch_computation_worker(pm0);
 140   launch_computation_worker(pm1);
 141   MSG_process_sleep(2);
 142
 143   XBT_INFO("### Put a VM on a PM, and put a task to the VM");
 144   vm0 = MSG_vm_create_core(pm0, "VM0");
 145   MSG_vm_start(vm0);
 146   launch_computation_worker(vm0);
 147   MSG_process_sleep(2);
 148   MSG_vm_destroy(vm0);
 149
 150   XBT_INFO("### Put a VM on a PM, and put a task to the PM (FIXME: broken)");
 151   vm0 = MSG_vm_create_core(pm0, "VM0");
 152   MSG_vm_start(vm0);
 153   launch_computation_worker(pm0);
 154   MSG_process_sleep(2);
 155   MSG_vm_destroy(vm0);
 156
 157   XBT_INFO("### Put two VMs on a PM, and put a task to each VM");
 158   vm0 = MSG_vm_create_core(pm0, "VM0");
 159   vm1 = MSG_vm_create_core(pm0, "VM1");
 160   MSG_vm_start(vm0);
 161   MSG_vm_start(vm1);
 162   launch_computation_worker(vm0);
 163   launch_computation_worker(vm1);
 164   MSG_process_sleep(2);
 165   MSG_vm_destroy(vm0);
 166   MSG_vm_destroy(vm1);
 167
 168   XBT_INFO("### Put a VM on each PM, and put a task to each VM");
 169   vm0 = MSG_vm_create_core(pm0, "VM0");
 170   vm1 = MSG_vm_create_core(pm1, "VM1");
 171   MSG_vm_start(vm0);
 172   MSG_vm_start(vm1);
 173   launch_computation_worker(vm0);
 174   launch_computation_worker(vm1);
 175   MSG_process_sleep(2);
 176   MSG_vm_destroy(vm0);
 177   MSG_vm_destroy(vm1);
 178
 179
 180   XBT_INFO("### Make a connection between PM0 and PM1");
 181   launch_communication_worker(pm0, pm1);
 182   MSG_process_sleep(5);
 183
 184   XBT_INFO("### Make two connection between PM0 and PM1");
 185   launch_communication_worker(pm0, pm1);
 186   launch_communication_worker(pm0, pm1);
 187   MSG_process_sleep(5);
 188
 189   XBT_INFO("### Make a connection between PM0 and VM0@PM0");
 190   vm0 = MSG_vm_create_core(pm0, "VM0");
 191   MSG_vm_start(vm0);
 192   launch_communication_worker(pm0, vm0);
 193   MSG_process_sleep(5);
 194   MSG_vm_destroy(vm0);
 195
 196   XBT_INFO("### Make a connection between PM0 and VM0@PM1");
 197   vm0 = MSG_vm_create_core(pm1, "VM0");
 198   MSG_vm_start(vm0);
 199   launch_communication_worker(pm0, vm0);
 200   MSG_process_sleep(5);
 201   MSG_vm_destroy(vm0);
 202
 203   XBT_INFO("### Make two connections between PM0 and VM0@PM1");
 204   vm0 = MSG_vm_create_core(pm1, "VM0");
 205   MSG_vm_start(vm0);
 206   launch_communication_worker(pm0, vm0);
 207   launch_communication_worker(pm0, vm0);
 208   MSG_process_sleep(5);
 209   MSG_vm_destroy(vm0);
 210
 211   XBT_INFO("### Make a connection between PM0 and VM0@PM1, and also make a connection between PM0 and PM1");
 212   vm0 = MSG_vm_create_core(pm1, "VM0");
 213   MSG_vm_start(vm0);
 214   launch_communication_worker(pm0, vm0);
 215   launch_communication_worker(pm0, pm1);
 216   MSG_process_sleep(5);
 217   MSG_vm_destroy(vm0);
 218
 219   XBT_INFO("### Make a connection between VM0@PM0 and PM1@PM1, and also make a connection between VM0@PM0 and VM1@PM1");
 220   vm0 = MSG_vm_create_core(pm0, "VM0");
 221   vm1 = MSG_vm_create_core(pm1, "VM1");
 222   MSG_vm_start(vm0);
 223   MSG_vm_start(vm1);
 224   launch_communication_worker(vm0, vm1);
 225   launch_communication_worker(vm0, vm1);
 226   MSG_process_sleep(5);
 227   MSG_vm_destroy(vm0);
 228   MSG_vm_destroy(vm1);
 229
 230
 231   XBT_INFO("### Relocate VM0 between PM0 and PM1");
 232   vm0 = MSG_vm_create_core(pm0, "VM0");
 233   MSG_vm_start(vm0);
 234   launch_communication_worker(vm0, pm2);
 235   MSG_process_sleep(0.01);
 236   MSG_vm_migrate(vm0, pm1);
 237   MSG_process_sleep(0.01);
 238   MSG_vm_migrate(vm0, pm0);
 239   MSG_process_sleep(5);
 240   MSG_vm_destroy(vm0);
 241
 242   return 0;
 243 }
 244
 245 void launch_master(msg_host_t host)
 246 {
 247   const char *pr_name = "master_";
 248   char **argv = xbt_new(char *, 2);
 249   argv[0] = xbt_strdup(pr_name);
 250   argv[1] = NULL;
 251
 252   msg_process_t pr = MSG_process_create_with_arguments(pr_name, master_main, NULL, host, 1, argv);
 253 }
 254
 255
 256 int main(int argc, char *argv[])
 257 {
 258   /* Get the arguments */
 259   MSG_init(&argc, argv);
 260
 261   /* load the platform file */
 262   MSG_create_environment(argv[1]);
 263
 264   xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
 265   msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t);
 266   launch_master(pm0);
 267
 268   int res = MSG_main();
 269   XBT_INFO("Simulation time %g", MSG_get_clock());
 270
 271   XBT_INFO("bye");
 272
 273   return 0;
 274 }