Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
sed -i -e 's/\t/ /g' [sources] Please people, stop using tabs
[simgrid.git] / examples / msg / cloud / multicore.c
1 /* Copyright (c) 2007-2015. 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 "simgrid/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, "Messages specific for this msg example");
15
16
17
18
19
20 static int worker_main(int argc, char *argv[])
21 {
22   msg_task_t task = MSG_process_get_data(MSG_process_self());
23   MSG_task_execute(task);
24
25   XBT_INFO("task %p bye", task);
26
27   return 0;
28 }
29
30
31 struct task_data {
32   msg_task_t task;
33   double prev_computation_amount;
34   double prev_clock;
35 };
36
37
38 static void task_data_init_clock(struct task_data *t)
39 {
40   t->prev_computation_amount = MSG_task_get_flops_amount(t->task);
41   t->prev_clock = MSG_get_clock();
42 }
43
44
45 static void task_data_get_clock(struct task_data *t)
46 {
47   double now_computation_amount = MSG_task_get_flops_amount(t->task);
48   double now_clock = MSG_get_clock();
49
50   double done = t->prev_computation_amount - now_computation_amount;
51   double duration = now_clock - t->prev_clock;
52
53   XBT_INFO("%s: %f fops/s", MSG_task_get_name(t->task), done / duration);
54
55   t->prev_computation_amount = now_computation_amount;
56   t->prev_clock = now_clock;
57 }
58
59
60 static void test_pm_pin(void)
61 {
62   xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
63   msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t);
64   msg_host_t pm1 = xbt_dynar_get_as(hosts_dynar, 1, msg_host_t);
65   msg_host_t pm2 = xbt_dynar_get_as(hosts_dynar, 2, msg_host_t);
66
67
68   struct task_data t1;
69   struct task_data t2;
70   struct task_data t3;
71   struct task_data t4;
72
73   t1.task = MSG_task_create("Task1", 1e16, 0, NULL);
74   t2.task = MSG_task_create("Task2", 1e16, 0, NULL);
75   t3.task = MSG_task_create("Task3", 1e16, 0, NULL);
76   t4.task = MSG_task_create("Task4", 1e16, 0, NULL);
77
78   MSG_process_create("worker1", worker_main, t1.task, pm1);
79   MSG_process_create("worker2", worker_main, t2.task, pm1);
80   MSG_process_create("worker3", worker_main, t3.task, pm1);
81   MSG_process_create("worker4", worker_main, t4.task, pm1);
82
83
84   XBT_INFO("## 1. start 4 tasks on PM1 (2 cores)");
85   task_data_init_clock(&t1);
86   task_data_init_clock(&t2);
87   task_data_init_clock(&t3);
88   task_data_init_clock(&t4);
89
90   MSG_process_sleep(10);
91   task_data_get_clock(&t1);
92   task_data_get_clock(&t2);
93   task_data_get_clock(&t3);
94   task_data_get_clock(&t4);
95
96
97   XBT_INFO("## 2. pin all tasks to CPU0");
98   MSG_task_set_affinity(t1.task, pm1, 0x01);
99   MSG_task_set_affinity(t2.task, pm1, 0x01);
100   MSG_task_set_affinity(t3.task, pm1, 0x01);
101   MSG_task_set_affinity(t4.task, pm1, 0x01);
102
103   MSG_process_sleep(10);
104   task_data_get_clock(&t1);
105   task_data_get_clock(&t2);
106   task_data_get_clock(&t3);
107   task_data_get_clock(&t4);
108
109
110   XBT_INFO("## 3. clear the affinity of task4");
111   MSG_task_set_affinity(t4.task, pm1, 0);
112
113   MSG_process_sleep(10);
114   task_data_get_clock(&t1);
115   task_data_get_clock(&t2);
116   task_data_get_clock(&t3);
117   task_data_get_clock(&t4);
118
119
120   XBT_INFO("## 4. clear the affinity of task3");
121   MSG_task_set_affinity(t3.task, pm1, 0);
122
123   MSG_process_sleep(10);
124   task_data_get_clock(&t1);
125   task_data_get_clock(&t2);
126   task_data_get_clock(&t3);
127   task_data_get_clock(&t4);
128
129
130   XBT_INFO("## 5. clear the affinity of task2");
131   MSG_task_set_affinity(t2.task, pm1, 0);
132
133   MSG_process_sleep(10);
134   task_data_get_clock(&t1);
135   task_data_get_clock(&t2);
136   task_data_get_clock(&t3);
137   task_data_get_clock(&t4);
138
139
140   XBT_INFO("## 6. pin all tasks to CPU0 of another PM (no effect now)");
141   MSG_task_set_affinity(t1.task, pm0, 0);
142   MSG_task_set_affinity(t2.task, pm0, 0);
143   MSG_task_set_affinity(t3.task, pm2, 0);
144   MSG_task_set_affinity(t4.task, pm2, 0);
145
146   MSG_process_sleep(10);
147   task_data_get_clock(&t1);
148   task_data_get_clock(&t2);
149   task_data_get_clock(&t3);
150   task_data_get_clock(&t4);
151
152
153
154   MSG_task_cancel(t1.task);
155   MSG_task_cancel(t2.task);
156   MSG_task_cancel(t3.task);
157   MSG_task_cancel(t4.task);
158   MSG_process_sleep(10);
159   MSG_task_destroy(t1.task);
160   MSG_task_destroy(t2.task);
161   MSG_task_destroy(t3.task);
162   MSG_task_destroy(t4.task);
163 }
164
165
166 static void test_vm_pin(void)
167 {
168   xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
169   msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t); // 1 cores
170   msg_host_t pm1 = xbt_dynar_get_as(hosts_dynar, 1, msg_host_t); // 2 cores
171   msg_host_t pm2 = xbt_dynar_get_as(hosts_dynar, 2, msg_host_t); // 4 cores
172
173
174   /* set up VMs on PM2 (4 cores) */
175   msg_vm_t vm0 = MSG_vm_create_core(pm2, "VM0");
176   msg_vm_t vm1 = MSG_vm_create_core(pm2, "VM1");
177   msg_vm_t vm2 = MSG_vm_create_core(pm2, "VM2");
178   msg_vm_t vm3 = MSG_vm_create_core(pm2, "VM3");
179
180   s_vm_params_t params;
181   memset(&params, 0, sizeof(params));
182   params.ramsize = 1L * 1024 * 1024;
183   params.skip_stage1 = 1;
184   params.skip_stage2 = 1;
185   //params.mig_speed = 1L * 1024 * 1024;
186   MSG_host_set_params(vm0, &params);
187   MSG_host_set_params(vm1, &params);
188   MSG_host_set_params(vm2, &params);
189   MSG_host_set_params(vm3, &params);
190
191   MSG_vm_start(vm0);
192   MSG_vm_start(vm1);
193   MSG_vm_start(vm2);
194   MSG_vm_start(vm3);
195
196
197   /* set up tasks and processes */
198   struct task_data t0;
199   struct task_data t1;
200   struct task_data t2;
201   struct task_data t3;
202
203   t0.task = MSG_task_create("Task0", 1e16, 0, NULL);
204   t1.task = MSG_task_create("Task1", 1e16, 0, NULL);
205   t2.task = MSG_task_create("Task2", 1e16, 0, NULL);
206   t3.task = MSG_task_create("Task3", 1e16, 0, NULL);
207
208   MSG_process_create("worker0", worker_main, t0.task, vm0);
209   MSG_process_create("worker1", worker_main, t1.task, vm1);
210   MSG_process_create("worker2", worker_main, t2.task, vm2);
211   MSG_process_create("worker3", worker_main, t3.task, vm3);
212
213
214   /* start experiments */
215   XBT_INFO("## 1. start 4 VMs on PM2 (4 cores)");
216   task_data_init_clock(&t0);
217   task_data_init_clock(&t1);
218   task_data_init_clock(&t2);
219   task_data_init_clock(&t3);
220
221   MSG_process_sleep(10);
222   task_data_get_clock(&t0);
223   task_data_get_clock(&t1);
224   task_data_get_clock(&t2);
225   task_data_get_clock(&t3);
226
227
228   XBT_INFO("## 2. pin all VMs to CPU0 of PM2");
229   MSG_vm_set_affinity(vm0, pm2, 0x01);
230   MSG_vm_set_affinity(vm1, pm2, 0x01);
231   MSG_vm_set_affinity(vm2, pm2, 0x01);
232   MSG_vm_set_affinity(vm3, pm2, 0x01);
233
234   MSG_process_sleep(10);
235   task_data_get_clock(&t0);
236   task_data_get_clock(&t1);
237   task_data_get_clock(&t2);
238   task_data_get_clock(&t3);
239
240
241   XBT_INFO("## 3. pin all VMs to CPU0 of PM1 (no effect at now)");
242   /* Because VMs are on PM2, the below operations do not effect computation now. */
243   MSG_vm_set_affinity(vm0, pm1, 0x01);
244   MSG_vm_set_affinity(vm1, pm1, 0x01);
245   MSG_vm_set_affinity(vm2, pm1, 0x01);
246   MSG_vm_set_affinity(vm3, pm1, 0x01);
247
248   MSG_process_sleep(10);
249   task_data_get_clock(&t0);
250   task_data_get_clock(&t1);
251   task_data_get_clock(&t2);
252   task_data_get_clock(&t3);
253
254
255   XBT_INFO("## 4. unpin VM0, and pin VM2 and VM3 to CPU1 of PM2");
256   MSG_vm_set_affinity(vm0, pm2, 0x00);
257   MSG_vm_set_affinity(vm2, pm2, 0x02);
258   MSG_vm_set_affinity(vm3, pm2, 0x02);
259
260   MSG_process_sleep(10);
261   task_data_get_clock(&t0);
262   task_data_get_clock(&t1);
263   task_data_get_clock(&t2);
264   task_data_get_clock(&t3);
265
266
267   XBT_INFO("## 5. migrate all VMs to PM0 (only 1 CPU core)");
268   MSG_vm_migrate(vm0, pm0);
269   MSG_vm_migrate(vm1, pm0);
270   MSG_vm_migrate(vm2, pm0);
271   MSG_vm_migrate(vm3, pm0);
272
273   MSG_process_sleep(10);
274   task_data_get_clock(&t0);
275   task_data_get_clock(&t1);
276   task_data_get_clock(&t2);
277   task_data_get_clock(&t3);
278
279   MSG_process_sleep(10);
280   task_data_get_clock(&t0);
281   task_data_get_clock(&t1);
282   task_data_get_clock(&t2);
283   task_data_get_clock(&t3);
284
285
286   XBT_INFO("## 6. migrate all VMs to PM1 (2 CPU cores, with affinity settings)");
287   MSG_vm_migrate(vm0, pm1);
288   MSG_vm_migrate(vm1, pm1);
289   MSG_vm_migrate(vm2, pm1);
290   MSG_vm_migrate(vm3, pm1);
291
292   MSG_process_sleep(10);
293   task_data_get_clock(&t0);
294   task_data_get_clock(&t1);
295   task_data_get_clock(&t2);
296   task_data_get_clock(&t3);
297
298   MSG_process_sleep(10);
299   task_data_get_clock(&t0);
300   task_data_get_clock(&t1);
301   task_data_get_clock(&t2);
302   task_data_get_clock(&t3);
303
304
305   XBT_INFO("## 7. clear affinity settings on PM1");
306   MSG_vm_set_affinity(vm0, pm1, 0);
307   MSG_vm_set_affinity(vm1, pm1, 0);
308   MSG_vm_set_affinity(vm2, pm1, 0);
309   MSG_vm_set_affinity(vm3, pm1, 0);
310
311   MSG_process_sleep(10);
312   task_data_get_clock(&t0);
313   task_data_get_clock(&t1);
314   task_data_get_clock(&t2);
315   task_data_get_clock(&t3);
316
317   MSG_process_sleep(10);
318   task_data_get_clock(&t0);
319   task_data_get_clock(&t1);
320   task_data_get_clock(&t2);
321   task_data_get_clock(&t3);
322
323
324   /* clean up everything */
325   MSG_task_cancel(t0.task);
326   MSG_task_cancel(t1.task);
327   MSG_task_cancel(t2.task);
328   MSG_task_cancel(t3.task);
329   MSG_process_sleep(10);
330   MSG_task_destroy(t0.task);
331   MSG_task_destroy(t1.task);
332   MSG_task_destroy(t2.task);
333   MSG_task_destroy(t3.task);
334
335   MSG_vm_destroy(vm0);
336   MSG_vm_destroy(vm1);
337   MSG_vm_destroy(vm2);
338   MSG_vm_destroy(vm3);
339 }
340
341
342 static int master_main(int argc, char *argv[])
343 {
344   XBT_INFO("=== Test PM (set affinity) ===");
345   test_pm_pin();
346
347   XBT_INFO("=== Test VM (set affinity) ===");
348   test_vm_pin();
349
350   return 0;
351 }
352
353
354 int main(int argc, char *argv[])
355 {
356   /* Get the arguments */
357   MSG_init(&argc, argv);
358
359   /* load the platform file */
360   if (argc != 2) {
361     printf("Usage: %s examples/msg/cloud/multicore_plat.xml\n", argv[0]);
362     return 1;
363   }
364
365   MSG_create_environment(argv[1]);
366
367   xbt_dynar_t hosts_dynar = MSG_hosts_as_dynar();
368   msg_host_t pm0 = xbt_dynar_get_as(hosts_dynar, 0, msg_host_t);
369   msg_host_t pm1 = xbt_dynar_get_as(hosts_dynar, 1, msg_host_t);
370   msg_host_t pm2 = xbt_dynar_get_as(hosts_dynar, 2, msg_host_t);
371
372
373   XBT_INFO("%s: %d core(s), %f flops/s per each", MSG_host_get_name(pm0), MSG_host_get_core_number(pm0), MSG_get_host_speed(pm0));
374   XBT_INFO("%s: %d core(s), %f flops/s per each", MSG_host_get_name(pm1), MSG_host_get_core_number(pm1), MSG_get_host_speed(pm1));
375   XBT_INFO("%s: %d core(s), %f flops/s per each", MSG_host_get_name(pm2), MSG_host_get_core_number(pm2), MSG_get_host_speed(pm2));
376
377
378
379   MSG_process_create("master", master_main, NULL, pm0);
380
381
382
383
384   int res = MSG_main();
385   XBT_INFO("Bye (simulation time %g)", MSG_get_clock());
386
387
388   return !(res == MSG_OK);
389 }