Logo AND Algorithmique Numérique Distribuée

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