Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[simix] Create a (fake) simcall for creating a process directly from a simgrid::simix...
[simgrid.git] / src / msg / msg_process.cpp
1 /* Copyright (c) 2004-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 "msg_private.h"
8 #include "xbt/sysdep.h"
9 #include "xbt/log.h"
10 #include "src/simix/smx_process_private.h"
11 #include "src/simix/smx_private.h"
12
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg, "Logging specific to MSG (process)");
14
15 /** @addtogroup m_process_management
16  *
17  *  Processes (#msg_process_t) are independent agents that can do stuff on their own. They are in charge of executing
18  *  your code interacting with the simulated world.
19  *  A process may be defined as a <em>code</em> with some <em>private data</em>.
20  *  Processes must be located on <em>hosts</em> (#msg_host_t), and they exchange data by sending tasks (#msg_task_t)
21  *  that are similar to envelops containing data.
22  */
23
24 /******************************** Process ************************************/
25 /**
26  * \brief Cleans the MSG data of a process.
27  * \param smx_proc a SIMIX process
28  */
29 void MSG_process_cleanup_from_SIMIX(smx_process_t smx_proc)
30 {
31   simdata_process_t msg_proc;
32
33   // get the MSG process from the SIMIX process
34   if (smx_proc == SIMIX_process_self()) {
35     /* avoid a SIMIX request if this function is called by the process itself */
36     msg_proc = (simdata_process_t) SIMIX_process_self_get_data();
37     SIMIX_process_self_set_data(NULL);
38   } else {
39     msg_proc = (simdata_process_t) simcall_process_get_data(smx_proc);
40     simcall_process_set_data(smx_proc, NULL);
41   }
42
43   TRACE_msg_process_destroy(smx_proc->name.c_str(), smx_proc->pid);
44   // free the data if a function was provided
45   if (msg_proc && msg_proc->data && msg_global->process_data_cleanup) {
46     msg_global->process_data_cleanup(msg_proc->data);
47   }
48
49   // free the MSG process
50   xbt_free(msg_proc);
51   SIMIX_process_cleanup(smx_proc);
52 }
53
54 /* This function creates a MSG process. It has the prototype enforced by SIMIX_function_register_process_create */
55 smx_process_t MSG_process_create_from_SIMIX(const char *name, xbt_main_func_t code, void *data, const char *hostname,
56                                             double kill_time, simgrid::simix::args args, xbt_dict_t properties,
57                                             int auto_restart, smx_process_t parent_process)
58 {
59   msg_host_t host = MSG_host_by_name(hostname);
60   msg_process_t p = MSG_process_create_with_environment(
61     name, code, data, host, args.argc(), args.to_argv(), properties);
62   if (p) {
63     MSG_process_set_kill_time(p,kill_time);
64     MSG_process_auto_restart_set(p,auto_restart);
65   }
66   return p;
67 }
68
69 /** \ingroup m_process_management
70  * \brief Creates and runs a new #msg_process_t.
71  *
72  * Does exactly the same as #MSG_process_create_with_arguments but without providing standard arguments
73  * (\a argc, \a argv, \a start_time, \a kill_time).
74  * \sa MSG_process_create_with_arguments
75  */
76 msg_process_t MSG_process_create(const char *name, xbt_main_func_t code, void *data, msg_host_t host)
77 {
78   return MSG_process_create_with_environment(name, code, data, host, 0, NULL, NULL);
79 }
80
81 /** \ingroup m_process_management
82  * \brief Creates and runs a new #msg_process_t.
83
84  * A constructor for #msg_process_t taking four arguments and returning the corresponding object. The structure (and
85  * the corresponding thread) is created, and put in the list of ready process.
86  * \param name a name for the object. It is for user-level information and can be NULL.
87  * \param code is a function describing the behavior of the process. It should then only use functions described
88  * in \ref m_process_management (to create a new #msg_process_t for example),
89    in \ref m_host_management (only the read-only functions i.e. whose name contains the word get),
90    in \ref m_task_management (to create or destroy some #msg_task_t for example) and
91    in \ref msg_task_usage (to handle file transfers and task processing).
92  * \param data a pointer to any data one may want to attach to the new object.  It is for user-level information and
93  *        can be NULL. It can be retrieved with the function \ref MSG_process_get_data.
94  * \param host the location where the new process is executed.
95  * \param argc first argument passed to \a code
96  * \param argv second argument passed to \a code
97  * \see msg_process_t
98  * \return The new corresponding object.
99  */
100
101 msg_process_t MSG_process_create_with_arguments(const char *name, xbt_main_func_t code, void *data, msg_host_t host,
102                                               int argc, char **argv)
103 {
104   return MSG_process_create_with_environment(name, code, data, host, argc, argv, NULL);
105 }
106
107 /** \ingroup m_process_management
108  * \brief Creates and runs a new #msg_process_t.
109
110  * A constructor for #msg_process_t taking four arguments and returning the corresponding object. The structure (and
111  * the corresponding thread) is created, and put in the list of ready process.
112  * \param name a name for the object. It is for user-level information and can be NULL.
113  * \param code is a function describing the behavior of the process. It should then only use functions described
114  * in \ref m_process_management (to create a new #msg_process_t for example),
115    in \ref m_host_management (only the read-only functions i.e. whose name contains the word get),
116    in \ref m_task_management (to create or destroy some #msg_task_t for example) and
117    in \ref msg_task_usage (to handle file transfers and task processing).
118  * \param data a pointer to any data one may want to attach to the new object.  It is for user-level information and
119  *        can be NULL. It can be retrieved with the function \ref MSG_process_get_data.
120  * \param host the location where the new process is executed.
121  * \param argc first argument passed to \a code
122  * \param argv second argument passed to \a code. WARNING, these strings are freed by the SimGrid kernel when the
123  *             process exits, so they cannot be static nor shared between several processes.
124  * \param properties list a properties defined for this process
125  * \see msg_process_t
126  * \return The new corresponding object.
127  */
128 msg_process_t MSG_process_create_with_environment(const char *name, xbt_main_func_t code, void *data, msg_host_t host,
129                                                   int argc, char **argv, xbt_dict_t properties)
130 {
131   msg_process_t res = MSG_process_create_with_environment(name, code, data, host,
132     simgrid::simix::args(argc, argv), properties);
133   for (int i = 0; i != argc; ++i)
134     xbt_free(argv[i]);
135   xbt_free(argv);
136   return res;
137 }
138
139 msg_process_t MSG_process_create_with_environment(
140   const char *name, xbt_main_func_t code, void *data,
141   msg_host_t host, simgrid::simix::args args,
142   xbt_dict_t properties)
143 {
144   xbt_assert(code != NULL && host != NULL, "Invalid parameters: host and code params must not be NULL");
145   simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
146   msg_process_t process;
147
148   /* Simulator data for MSG */
149   simdata->waiting_action = NULL;
150   simdata->waiting_task = NULL;
151   simdata->m_host = host;
152   simdata->data = data;
153   simdata->last_errno = MSG_OK;
154
155   /* Let's create the process: SIMIX may decide to start it right now,
156    * even before returning the flow control to us */
157   process = simcall_process_create(
158     name, code, simdata, sg_host_get_name(host), -1, std::move(args), properties, 0);
159
160   if (!process) {
161     /* Undo everything we have just changed */
162     xbt_free(simdata);
163     return NULL;
164   }
165   else {
166     simcall_process_on_exit(process,(int_f_pvoid_pvoid_t)TRACE_msg_process_kill,process);
167   }
168   return process;
169 }
170
171 static int MSG_maestro(int argc, char** argv)
172 {
173   int res = MSG_main();
174   return res;
175 }
176
177 /* Become a process in the simulation
178  *
179  * Currently this can only be called by the main thread (once) and only work with some thread factories
180  * (currently ThreadContextFactory).
181  *
182  * In the future, it might be extended in order to attach other threads created by a third party library.
183  */
184 msg_process_t MSG_process_attach(const char *name, void *data, msg_host_t host, xbt_dict_t properties)
185 {
186   xbt_assert(host != NULL, "Invalid parameters: host and code params must not be NULL");
187   simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
188   msg_process_t process;
189
190   /* Simulator data for MSG */
191   simdata->waiting_action = NULL;
192   simdata->waiting_task = NULL;
193   simdata->m_host = host;
194   simdata->data = data;
195   simdata->last_errno = MSG_OK;
196
197   /* Let's create the process: SIMIX may decide to start it right now, even before returning the flow control to us */
198   process = SIMIX_process_attach(name, simdata, sg_host_get_name(host), properties, NULL);
199   if (!process)
200     xbt_die("Could not attach");
201   simcall_process_on_exit(process,(int_f_pvoid_pvoid_t)TRACE_msg_process_kill,process);
202   return process;
203 }
204
205 /** Detach a process attached with `MSG_process_attach()`
206  *
207  *  This is called when the current process has finished its job.
208  *  Used in the main thread, it waits for the simulation to finish before  returning. When it returns, the other
209  *  simulated processes and the maestro are destroyed.
210  */
211 void MSG_process_detach(void)
212 {
213   SIMIX_process_detach();
214 }
215
216 /** \ingroup m_process_management
217  * \param process poor victim
218  *
219  * This function simply kills a \a process... scary isn't it ? :)
220  */
221 void MSG_process_kill(msg_process_t process)
222 {
223 //  /* FIXME: why do we only cancel communication actions? is this useful? */
224 //  simdata_process_t p_simdata = simcall_process_get_data(process);
225 //  if (p_simdata->waiting_task && p_simdata->waiting_task->simdata->comm) {
226 //    simcall_comm_cancel(p_simdata->waiting_task->simdata->comm);
227 //  }
228   simcall_process_kill(process);
229 }
230
231 /**
232 * \brief Wait for the completion of a #msg_process_t.
233 *
234 * \param process the process to wait for
235 * \param timeout wait until the process is over, or the timeout occurs
236 */
237 msg_error_t MSG_process_join(msg_process_t process, double timeout){
238   simcall_process_join(process, timeout);
239   return MSG_OK;
240 }
241
242 /** \ingroup m_process_management
243  * \brief Migrates a process to another location.
244  *
245  * This function checks whether \a process and \a host are valid pointers and change the value of the #msg_host_t on
246  * which \a process is running.
247  */
248 msg_error_t MSG_process_migrate(msg_process_t process, msg_host_t host)
249 {
250   simdata_process_t simdata = (simdata_process_t) simcall_process_get_data(process);
251   simdata->m_host = host;
252   msg_host_t now = simdata->m_host;
253   TRACE_msg_process_change_host(process, now, host);
254   simcall_process_set_host(process, host);
255   return MSG_OK;
256 }
257
258 /** \ingroup m_process_management
259  * \brief Returns the user data of a process.
260  *
261  * This function checks whether \a process is a valid pointer and returns the user data associated to this process.
262  */
263 void* MSG_process_get_data(msg_process_t process)
264 {
265   xbt_assert(process != NULL, "Invalid parameter: first parameter must not be NULL!");
266
267   /* get from SIMIX the MSG process data, and then the user data */
268   simdata_process_t simdata = (simdata_process_t) simcall_process_get_data(process);
269   if (simdata)
270     return simdata->data;
271   else
272     return NULL;
273 }
274
275 /** \ingroup m_process_management
276  * \brief Sets the user data of a process.
277  *
278  * This function checks whether \a process is a valid pointer and sets the user data associated to this process.
279  */
280 msg_error_t MSG_process_set_data(msg_process_t process, void *data)
281 {
282   xbt_assert(process != NULL, "Invalid parameter: first parameter must not be NULL!");
283
284   simdata_process_t simdata = (simdata_process_t) simcall_process_get_data(process);
285   simdata->data = data;
286
287   return MSG_OK;
288 }
289
290 /** \ingroup m_process_management
291  * \brief Sets a cleanup function to be called to free the userdata of a process when a process is destroyed.
292  * \param data_cleanup a cleanup function for the userdata of a process, or NULL to call no function
293  */
294 XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup) {
295   msg_global->process_data_cleanup = data_cleanup;
296 }
297
298 /** \ingroup m_process_management
299  * \brief Return the location on which a process is running.
300  * \param process a process (NULL means the current one)
301  * \return the msg_host_t corresponding to the location on which \a process is running.
302  */
303 msg_host_t MSG_process_get_host(msg_process_t process)
304 {
305   simdata_process_t simdata;
306   if (process == NULL) {
307     simdata = (simdata_process_t) SIMIX_process_self_get_data();
308   }
309   else {
310     simdata = (simdata_process_t) simcall_process_get_data(process);
311   }
312   return simdata ? simdata->m_host : NULL;
313 }
314
315 /** \ingroup m_process_management
316  *
317  * \brief Return a #msg_process_t given its PID.
318  *
319  * This function search in the list of all the created msg_process_t for a msg_process_t  whose PID is equal to \a PID.
320  * If no host is found, \c NULL is returned.
321    Note that the PID are uniq in the whole simulation, not only on a given host.
322  */
323 msg_process_t MSG_process_from_PID(int PID)
324 {
325   return SIMIX_process_from_PID(PID);
326 }
327
328 /** @brief returns a list of all currently existing processes */
329 xbt_dynar_t MSG_processes_as_dynar(void) {
330   return SIMIX_processes_as_dynar();
331 }
332
333 /** @brief Return the current number MSG processes. */
334 int MSG_process_get_number(void)
335 {
336   return SIMIX_process_count();
337 }
338
339 /** \ingroup m_process_management
340  * \brief Set the kill time of a process.
341  *
342  * \param process a process
343  * \param kill_time the time when the process is killed.
344  */
345 msg_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time)
346 {
347   simcall_process_set_kill_time(process,kill_time);
348   return MSG_OK;
349 }
350
351 /** \ingroup m_process_management
352  * \brief Returns the process ID of \a process.
353  *
354  * This function checks whether \a process is a valid pointer and return its PID (or 0 in case of problem).
355  */
356 int MSG_process_get_PID(msg_process_t process)
357 {
358   /* Do not raise an exception here: this function is called by the logs
359    * and the exceptions, so it would be called back again and again */
360   if (process == NULL) {
361     return 0;
362   }
363   return simcall_process_get_PID(process);
364 }
365
366 /** \ingroup m_process_management
367  * \brief Returns the process ID of the parent of \a process.
368  *
369  * This function checks whether \a process is a valid pointer and return its PID.
370  * Returns -1 if the process has not been created by any other process.
371  */
372 int MSG_process_get_PPID(msg_process_t process)
373 {
374   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
375   return simcall_process_get_PPID(process);
376 }
377
378 /** \ingroup m_process_management
379  * \brief Return the name of a process.
380  *
381  * This function checks whether \a process is a valid pointer and return its name.
382  */
383 const char *MSG_process_get_name(msg_process_t process)
384 {
385   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
386   return simcall_process_get_name(process);
387 }
388
389 /** \ingroup m_process_management
390  * \brief Returns the value of a given process property
391  *
392  * \param process a process
393  * \param name a property name
394  * \return value of a property (or NULL if the property is not set)
395  */
396 const char *MSG_process_get_property_value(msg_process_t process, const char *name)
397 {
398   return (char*) xbt_dict_get_or_null(MSG_process_get_properties(process), name);
399 }
400
401 /** \ingroup m_process_management
402  * \brief Return the list of properties
403  *
404  * This function returns all the parameters associated with a process
405  */
406 xbt_dict_t MSG_process_get_properties(msg_process_t process)
407 {
408   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
409   return simcall_process_get_properties(process);
410 }
411
412 /** \ingroup m_process_management
413  * \brief Return the PID of the current process.
414  *
415  * This function returns the PID of the currently running #msg_process_t.
416  */
417 int MSG_process_self_PID(void)
418 {
419   return MSG_process_get_PID(MSG_process_self());
420 }
421
422 /** \ingroup m_process_management
423  * \brief Return the PPID of the current process.
424  *
425  * This function returns the PID of the parent of the currently running #msg_process_t.
426  */
427 int MSG_process_self_PPID(void)
428 {
429   return MSG_process_get_PPID(MSG_process_self());
430 }
431
432 /** \ingroup m_process_management
433  * \brief Return the current process.
434  *
435  * This function returns the currently running #msg_process_t.
436  */
437 msg_process_t MSG_process_self(void)
438 {
439   return SIMIX_process_self();
440 }
441
442 /** \ingroup m_process_management
443  * \brief Suspend the process.
444  *
445  * This function suspends the process by suspending the task on which it was waiting for the completion.
446  */
447 msg_error_t MSG_process_suspend(msg_process_t process)
448 {
449   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
450
451   TRACE_msg_process_suspend(process);
452   simcall_process_suspend(process);
453   MSG_RETURN(MSG_OK);
454 }
455
456 /** \ingroup m_process_management
457  * \brief Resume a suspended process.
458  *
459  * This function resumes a suspended process by resuming the task on which it was waiting for the completion.
460  */
461 msg_error_t MSG_process_resume(msg_process_t process)
462 {
463   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
464
465   TRACE_msg_process_resume(process);
466   simcall_process_resume(process);
467   MSG_RETURN(MSG_OK);
468 }
469
470 /** \ingroup m_process_management
471  * \brief Returns true if the process is suspended .
472  *
473  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
474  */
475 int MSG_process_is_suspended(msg_process_t process)
476 {
477   xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
478   return simcall_process_is_suspended(process);
479 }
480
481 smx_context_t MSG_process_get_smx_ctx(msg_process_t process) {
482   return SIMIX_process_get_context(process);
483 }
484 /**
485  * \ingroup m_process_management
486  * \brief Add a function to the list of "on_exit" functions for the current process.
487  * The on_exit functions are the functions executed when your process is killed.
488  * You should use them to free the data used by your process.
489  */
490 void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data) {
491   simcall_process_on_exit(MSG_process_self(),fun,data);
492 }
493 /**
494  * \ingroup m_process_management
495  * \brief Sets the "auto-restart" flag of the process.
496  * If the flag is set to 1, the process will be automatically restarted when its host comes back up.
497  */
498 XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart) {
499   simcall_process_auto_restart_set(process,auto_restart);
500 }
501 /*
502  * \ingroup m_process_management
503  * \brief Restarts a process from the beginning.
504  */
505 XBT_PUBLIC(msg_process_t) MSG_process_restart(msg_process_t process) {
506   return simcall_process_restart(process);
507 }