Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
doc cleanups
[simgrid.git] / src / simix / smx_host.cpp
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 "smx_private.h"
8 #include "xbt/sysdep.h"
9 #include "mc/mc.h"
10 #include "src/mc/mc_replay.h"
11 #include "src/surf/virtual_machine.hpp"
12 #include "src/surf/HostImpl.hpp"
13
14 #include "src/simix/SynchroExec.hpp"
15 #include "src/simix/SynchroComm.hpp"
16
17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_host, simix, "SIMIX hosts");
18
19 /** @brief Internal function to create a SIMIX host. */
20 void SIMIX_host_create(sg_host_t host) // FIXME: braindead prototype. Take sg_host as parameter
21 {
22   smx_host_priv_t smx_host = xbt_new0(s_smx_host_priv_t, 1);
23
24   /* Host structure */
25   simgrid::simix::Process proc;
26   smx_host->process_list = xbt_swag_new(xbt_swag_offset(proc, host_proc_hookup));
27
28   /* Update global variables */
29   sg_host_simix_set(host, smx_host);
30 }
31
32 /** @brief Start the host if it is off */
33 void SIMIX_host_on(sg_host_t h)
34 {
35   smx_host_priv_t host = sg_host_simix(h);
36
37   xbt_assert((host != NULL), "Invalid parameters");
38
39   if (h->isOff()) {
40     simgrid::surf::HostImpl* surf_host = h->extension<simgrid::surf::HostImpl>();
41     surf_host->turnOn();
42
43     unsigned int cpt;
44     smx_process_arg_t arg;
45     xbt_dynar_foreach(host->boot_processes,cpt,arg) {
46       XBT_DEBUG("Booting Process %s(%s) right now",
47         arg->name.c_str(), arg->hostname);
48       if (simix_global->create_process_function) {
49         simix_global->create_process_function(arg->name.c_str(),
50                                               arg->code,
51                                               NULL,
52                                               arg->hostname,
53                                               arg->kill_time,
54                                               arg->properties,
55                                               arg->auto_restart,
56                                               NULL);
57       } else {
58         simcall_process_create(arg->name.c_str(),
59                                arg->code,
60                                NULL,
61                                arg->hostname,
62                                arg->kill_time,
63                                arg->properties,
64                                arg->auto_restart);
65       }
66     }
67   }
68 }
69
70 /** @brief Stop the host if it is on */
71 void SIMIX_host_off(sg_host_t h, smx_process_t issuer)
72 {
73   smx_host_priv_t host = sg_host_simix(h);
74
75   xbt_assert((host != NULL), "Invalid parameters");
76
77   if (h->isOn()) {
78     simgrid::surf::HostImpl* surf_host = h->extension<simgrid::surf::HostImpl>();
79     surf_host->turnOff();
80
81     /* Clean Simulator data */
82     if (xbt_swag_size(host->process_list) != 0) {
83       smx_process_t process = NULL;
84       xbt_swag_foreach(process, host->process_list) {
85         SIMIX_process_kill(process, issuer);
86         XBT_DEBUG("Killing %s on %s by %s",
87           process->name.c_str(),  sg_host_get_name(process->host),
88           issuer->name.c_str());
89       }
90     }
91   } else {
92     XBT_INFO("Host %s is already off", h->name().c_str());
93   }
94 }
95
96 /**
97  * \brief Internal function to destroy a SIMIX host.
98  *
99  * \param h the host to destroy (a sg_host_t)
100  */
101 void SIMIX_host_destroy(void *h)
102 {
103   smx_host_priv_t host = (smx_host_priv_t) h;
104
105   xbt_assert((host != NULL), "Invalid parameters");
106
107   /* Clean Simulator data */
108   if (xbt_swag_size(host->process_list) != 0) {
109     char *msg = xbt_strdup("Shutting down host, but it's not empty:");
110     char *tmp;
111     smx_process_t process = NULL;
112
113     xbt_swag_foreach(process, host->process_list) {
114       tmp = bprintf("%s\n\t%s", msg, process->name.c_str());
115       free(msg);
116       msg = tmp;
117     }
118     SIMIX_display_process_status();
119     THROWF(arg_error, 0, "%s", msg);
120   }
121   xbt_dynar_free(&host->auto_restart_processes);
122   xbt_dynar_free(&host->boot_processes);
123   xbt_swag_free(host->process_list);
124
125   /* Clean host structure */
126   free(host);
127   return;
128 }
129
130 sg_host_t SIMIX_host_self(void)
131 {
132   smx_process_t process = SIMIX_process_self();
133   return (process == NULL) ? NULL : SIMIX_process_get_host(process);
134 }
135
136 /* needs to be public and without simcall for exceptions and logging events */
137 const char* SIMIX_host_self_get_name(void)
138 {
139   sg_host_t host = SIMIX_host_self();
140   if (host == NULL || SIMIX_process_self() == simix_global->maestro_process)
141     return "";
142
143   return sg_host_get_name(host);
144 }
145
146 void _SIMIX_host_free_process_arg(void *data)
147 {
148   smx_process_arg_t arg = *(smx_process_arg_t*)data;
149   delete arg;
150 }
151 /**
152  * \brief Add a process to the list of the processes that the host will restart when it comes back
153  * This function add a process to the list of the processes that will be restarted when the host comes
154  * back. It is expected that this function is called when the host is down.
155  * The processes will only be restarted once, meaning that you will have to register the process
156  * again to restart the process again.
157  */
158 void SIMIX_host_add_auto_restart_process(
159   sg_host_t host, const char *name, std::function<void()> code,
160   void* data, const char *hostname, double kill_time,
161   xbt_dict_t properties, int auto_restart)
162 {
163   if (!sg_host_simix(host)->auto_restart_processes) {
164     sg_host_simix(host)->auto_restart_processes = xbt_dynar_new(sizeof(smx_process_arg_t),_SIMIX_host_free_process_arg);
165   }
166   smx_process_arg_t arg = new simgrid::simix::ProcessArg();
167   arg->name = name;
168   arg->code = std::move(code);
169   arg->data = data;
170   arg->hostname = hostname;
171   arg->kill_time = kill_time;
172   arg->properties = properties;
173   arg->auto_restart = auto_restart;
174
175   if( host->isOff() && !xbt_dict_get_or_null(watched_hosts_lib,sg_host_get_name(host))){
176     xbt_dict_set(watched_hosts_lib,sg_host_get_name(host),host,NULL);
177     XBT_DEBUG("Push host %s to watched_hosts_lib because state == SURF_RESOURCE_OFF",sg_host_get_name(host));
178   }
179   xbt_dynar_push_as(sg_host_simix(host)->auto_restart_processes,smx_process_arg_t,arg);
180 }
181 /** @brief Restart the list of processes that have been registered to the host */
182 void SIMIX_host_autorestart(sg_host_t host)
183 {
184   unsigned int cpt;
185   smx_process_arg_t arg;
186   xbt_dynar_t process_list = sg_host_simix(host)->auto_restart_processes;
187   if (!process_list)
188     return;
189
190   xbt_dynar_foreach (process_list, cpt, arg) {
191
192     XBT_DEBUG("Restarting Process %s(%s) right now", arg->name.c_str(), arg->hostname);
193     if (simix_global->create_process_function) {
194       simix_global->create_process_function(arg->name.c_str(),
195                                             arg->code,
196                                             NULL,
197                                             arg->hostname,
198                                             arg->kill_time,
199                                             arg->properties,
200                                             arg->auto_restart,
201                                             NULL);
202     } else {
203       simcall_process_create(arg->name.c_str(),
204                              arg->code,
205                              NULL,
206                              arg->hostname,
207                              arg->kill_time,
208                              arg->properties,
209                              arg->auto_restart);
210     }
211   }
212   xbt_dynar_reset(process_list);
213 }
214
215 smx_synchro_t simcall_HANDLER_execution_start(smx_simcall_t simcall,
216     const char* name, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
217   return SIMIX_execution_start(simcall->issuer, name,flops_amount,priority,bound,affinity_mask);
218 }
219 smx_synchro_t SIMIX_execution_start(smx_process_t issuer, const char *name,
220      double flops_amount, double priority, double bound, unsigned long affinity_mask){
221
222   /* alloc structures and initialize */
223   simgrid::simix::Exec *exec = new simgrid::simix::Exec();
224   exec->name = xbt_strdup(name);
225   exec->state = SIMIX_RUNNING;
226   exec->host = issuer->host;
227
228   /* set surf's action */
229   if (!MC_is_active() && !MC_record_replay_is_active()) {
230
231     exec->surf_exec = issuer->host->pimpl_cpu->execution_start(flops_amount);
232     exec->surf_exec->setData(exec);
233     exec->surf_exec->setPriority(priority);
234
235     if (bound != 0)
236       static_cast<simgrid::surf::CpuAction*>(exec->surf_exec)->setBound(bound);
237
238     if (affinity_mask != 0) {
239       /* just a double check to confirm that this host is the host where this task is running. */
240       xbt_assert(exec->host == issuer->host);
241       static_cast<simgrid::surf::CpuAction*>(exec->surf_exec)
242         ->setAffinity(issuer->host->pimpl_cpu, affinity_mask);
243     }
244   }
245
246   XBT_DEBUG("Create execute synchro %p: %s", exec, exec->name);
247
248   return exec;
249 }
250
251 smx_synchro_t SIMIX_execution_parallel_start(const char *name,
252     int host_nb, sg_host_t *host_list,
253     double *flops_amount, double *bytes_amount,
254     double amount, double rate){
255
256   sg_host_t *host_list_cpy = NULL;
257   int i;
258
259   /* alloc structures and initialize */
260   simgrid::simix::Exec *exec = new simgrid::simix::Exec();
261   exec->name = xbt_strdup(name);
262   exec->state = SIMIX_RUNNING;
263   exec->host = nullptr; /* FIXME: do we need the list of hosts? */
264
265   /* set surf's synchro */
266   host_list_cpy = xbt_new0(sg_host_t, host_nb);
267   for (i = 0; i < host_nb; i++)
268     host_list_cpy[i] = host_list[i];
269
270   /* Check that we are not mixing VMs and PMs in the parallel task */
271   simgrid::surf::HostImpl *host = host_list[0]->extension<simgrid::surf::HostImpl>();
272   bool is_a_vm = (nullptr != dynamic_cast<simgrid::surf::VirtualMachine*>(host));
273   for (i = 1; i < host_nb; i++) {
274     bool tmp_is_a_vm = (nullptr != dynamic_cast<simgrid::surf::VirtualMachine*>(host_list[i]->extension<simgrid::surf::HostImpl>()));
275     xbt_assert(is_a_vm == tmp_is_a_vm, "parallel_execute: mixing VMs and PMs is not supported (yet).");
276   }
277
278   /* set surf's synchro */
279   if (!MC_is_active() && !MC_record_replay_is_active()) {
280     exec->surf_exec = surf_host_model->executeParallelTask(host_nb, host_list_cpy, flops_amount, bytes_amount, rate);
281     exec->surf_exec->setData(exec);
282   }
283   XBT_DEBUG("Create parallel execute synchro %p", exec);
284
285   return exec;
286 }
287
288 void SIMIX_execution_cancel(smx_synchro_t synchro)
289 {
290   XBT_DEBUG("Cancel synchro %p", synchro);
291   simgrid::simix::Exec *exec = static_cast<simgrid::simix::Exec *>(synchro);
292
293   if (exec->surf_exec)
294     exec->surf_exec->cancel();
295 }
296
297 void SIMIX_execution_set_priority(smx_synchro_t synchro, double priority)
298 {
299   simgrid::simix::Exec *exec = static_cast<simgrid::simix::Exec *>(synchro);
300   if(exec->surf_exec)
301     exec->surf_exec->setPriority(priority);
302 }
303
304 void SIMIX_execution_set_bound(smx_synchro_t synchro, double bound)
305 {
306   simgrid::simix::Exec *exec = static_cast<simgrid::simix::Exec *>(synchro);
307   if(exec->surf_exec)
308     static_cast<simgrid::surf::CpuAction*>(exec->surf_exec)->setBound(bound);
309 }
310
311 void SIMIX_execution_set_affinity(smx_synchro_t synchro, sg_host_t host, unsigned long mask)
312 {
313   simgrid::simix::Exec *exec = static_cast<simgrid::simix::Exec *>(synchro);
314   if(exec->surf_exec) {
315     /* just a double check to confirm that this host is the host where this task is running. */
316     xbt_assert(exec->host == host);
317     static_cast<simgrid::surf::CpuAction*>(exec->surf_exec)->setAffinity(host->pimpl_cpu, mask);
318   }
319 }
320
321 void simcall_HANDLER_execution_wait(smx_simcall_t simcall, smx_synchro_t synchro)
322 {
323   simgrid::simix::Exec *exec = static_cast<simgrid::simix::Exec *>(synchro);
324   XBT_DEBUG("Wait for execution of synchro %p, state %d", synchro, (int)synchro->state);
325
326   /* Associate this simcall to the synchro */
327   xbt_fifo_push(synchro->simcalls, simcall);
328   simcall->issuer->waiting_synchro = synchro;
329
330   /* set surf's synchro */
331   if (MC_is_active() || MC_record_replay_is_active()) {
332     synchro->state = SIMIX_DONE;
333     SIMIX_execution_finish(exec);
334     return;
335   }
336
337   /* If the synchro is already finished then perform the error handling */
338   if (synchro->state != SIMIX_RUNNING)
339     SIMIX_execution_finish(exec);
340 }
341
342 void SIMIX_execution_finish(simgrid::simix::Exec *exec)
343 {
344   xbt_fifo_item_t item;
345   smx_simcall_t simcall;
346
347   xbt_fifo_foreach(exec->simcalls, item, simcall, smx_simcall_t) {
348
349     switch (exec->state) {
350
351       case SIMIX_DONE:
352         /* do nothing, synchro done */
353         XBT_DEBUG("SIMIX_execution_finished: execution successful");
354         break;
355
356       case SIMIX_FAILED:
357         XBT_DEBUG("SIMIX_execution_finished: host '%s' failed", sg_host_get_name(simcall->issuer->host));
358         simcall->issuer->context->iwannadie = 1;
359         SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
360         break;
361
362       case SIMIX_CANCELED:
363         XBT_DEBUG("SIMIX_execution_finished: execution canceled");
364         SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Canceled");
365         break;
366
367       default:
368         xbt_die("Internal error in SIMIX_execution_finish: unexpected synchro state %d",
369             (int)exec->state);
370     }
371     /* Fail the process if the host is down */
372     if (simcall->issuer->host->isOff())
373       simcall->issuer->context->iwannadie = 1;
374
375     simcall->issuer->waiting_synchro = NULL;
376     simcall_execution_wait__set__result(simcall, exec->state);
377     SIMIX_simcall_answer(simcall);
378   }
379
380   /* We no longer need it */
381   exec->unref();
382 }
383
384 void SIMIX_set_category(smx_synchro_t synchro, const char *category)
385 {
386   if (synchro->state != SIMIX_RUNNING) return;
387
388   simgrid::simix::Exec *exec = dynamic_cast<simgrid::simix::Exec *>(synchro);
389   if (exec != nullptr) {
390     exec->surf_exec->setCategory(category);
391     return;
392   }
393
394   simgrid::simix::Comm *comm = dynamic_cast<simgrid::simix::Comm *>(synchro);
395   if (comm != nullptr) {
396     comm->surf_comm->setCategory(category);
397     return;
398   }
399 }