Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
trace process creation before request for simix, assuming it won't fail
[simgrid.git] / src / msg / m_process.c
1 /* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. 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
11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg,
12                                 "Logging specific to MSG (process)");
13
14 /** \defgroup m_process_management Management Functions of Agents
15  *  \brief This section describes the agent structure of MSG
16  *  (#m_process_t) and the functions for managing it.
17  */
18 /** @addtogroup m_process_management
19  *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Agents" --> \endhtmlonly
20  *
21  *  We need to simulate many independent scheduling decisions, so
22  *  the concept of <em>process</em> is at the heart of the
23  *  simulator. A process may be defined as a <em>code</em>, with
24  *  some <em>private data</em>, executing in a <em>location</em>.
25  *  \see m_process_t
26  */
27
28 /******************************** Process ************************************/
29 void MSG_process_cleanup_from_SIMIX(smx_process_t smx_proc)
30 {
31   simdata_process_t msg_proc;
32
33   if (smx_proc == SIMIX_process_self()) {
34     /* avoid a SIMIX request if this function is called by the process itself */
35     msg_proc = SIMIX_process_self_get_data();
36   }
37   else {
38     msg_proc = SIMIX_req_process_get_data(smx_proc);
39   }
40
41 #ifdef HAVE_TRACING
42   TRACE_msg_process_end(smx_proc);
43 #endif
44
45   xbt_free(msg_proc);
46 }
47
48 /* This function creates a MSG process. It has the prototype enforced by SIMIX_function_register_process_create */
49 void MSG_process_create_from_SIMIX(smx_process_t* process, const char *name,
50                                     xbt_main_func_t code, void *data,
51                                     const char *hostname, int argc, char **argv,
52                                     xbt_dict_t properties)
53 {
54   m_host_t host = MSG_get_host_by_name(hostname);
55   m_process_t p = MSG_process_create_with_environment(name, code, data,
56                                                       host, argc, argv,
57                                                       properties);
58   *((m_process_t*) process) = p;
59 }
60
61 /** \ingroup m_process_management
62  * \brief Creates and runs a new #m_process_t.
63  *
64  * Does exactly the same as #MSG_process_create_with_arguments but without
65    providing standard arguments (\a argc, \a argv, \a start_time, \a kill_time).
66  * \sa MSG_process_create_with_arguments
67  */
68 m_process_t MSG_process_create(const char *name,
69                                xbt_main_func_t code, void *data,
70                                m_host_t host)
71 {
72   return MSG_process_create_with_environment(name, code, data, host, -1,
73                                              NULL, NULL);
74 }
75
76 /** \ingroup m_process_management
77  * \brief Creates and runs a new #m_process_t.
78
79  * A constructor for #m_process_t taking four arguments and returning the
80  * corresponding object. The structure (and the corresponding thread) is
81  * created, and put in the list of ready process.
82  * \param name a name for the object. It is for user-level information
83    and can be NULL.
84  * \param code is a function describing the behavior of the agent. It
85    should then only use functions described in \ref
86    m_process_management (to create a new #m_process_t for example),
87    in \ref m_host_management (only the read-only functions i.e. whose
88    name contains the word get), in \ref m_task_management (to create
89    or destroy some #m_task_t for example) and in \ref
90    msg_gos_functions (to handle file transfers and task processing).
91  * \param data a pointer to any data one may want to attach to the new
92    object.  It is for user-level information and can be NULL. It can
93    be retrieved with the function \ref MSG_process_get_data.
94  * \param host the location where the new agent is executed.
95  * \param argc first argument passed to \a code
96  * \param argv second argument passed to \a code
97  * \see m_process_t
98  * \return The new corresponding object.
99  */
100
101 m_process_t MSG_process_create_with_arguments(const char *name,
102                                               xbt_main_func_t code,
103                                               void *data, m_host_t host,
104                                               int argc, char **argv)
105 {
106   return MSG_process_create_with_environment(name, code, data, host,
107                                              argc, argv, NULL);
108 }
109
110 /** \ingroup m_process_management
111  * \brief Creates and runs a new #m_process_t.
112
113  * A constructor for #m_process_t taking four arguments and returning the
114  * corresponding object. The structure (and the corresponding thread) is
115  * created, and put in the list of ready process.
116  * \param name a name for the object. It is for user-level information
117    and can be NULL.
118  * \param code is a function describing the behavior of the agent. It
119    should then only use functions described in \ref
120    m_process_management (to create a new #m_process_t for example),
121    in \ref m_host_management (only the read-only functions i.e. whose
122    name contains the word get), in \ref m_task_management (to create
123    or destroy some #m_task_t for example) and in \ref
124    msg_gos_functions (to handle file transfers and task processing).
125  * \param data a pointer to any data one may want to attach to the new
126    object.  It is for user-level information and can be NULL. It can
127    be retrieved with the function \ref MSG_process_get_data.
128  * \param host the location where the new agent is executed.
129  * \param argc first argument passed to \a code
130  * \param argv second argument passed to \a code
131  * \param properties list a properties defined for this process
132  * \see m_process_t
133  * \return The new corresponding object.
134  */
135 m_process_t MSG_process_create_with_environment(const char *name,
136                                                 xbt_main_func_t code,
137                                                 void *data, m_host_t host,
138                                                 int argc, char **argv,
139                                                 xbt_dict_t properties)
140 {
141   xbt_assert(code != NULL && host != NULL, "Invalid parameters");
142   simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
143   m_process_t process;
144
145   /* Simulator data for MSG */
146   simdata->PID = msg_global->PID++;
147   simdata->waiting_action = NULL;
148   simdata->waiting_task = NULL;
149   simdata->m_host = host;
150   simdata->argc = argc;
151   simdata->argv = argv;
152   simdata->data = data;
153   simdata->last_errno = MSG_OK;
154
155   if (SIMIX_process_self()) {
156     simdata->PPID = MSG_process_get_PID(MSG_process_self());
157   } else {
158     simdata->PPID = -1;
159   }
160
161 #ifdef HAVE_TRACING
162   TRACE_msg_process_create(name, simdata->PID, simdata->m_host);
163 #endif
164
165   /* Let's create the process: SIMIX may decide to start it right now,
166    * even before returning the flow control to us */
167   SIMIX_req_process_create(&process, name, code, simdata, host->name,
168                            argc, argv, properties);
169
170   if (!process) {
171     /* Undo everything we have just changed */
172     msg_global->PID--;
173     xbt_free(simdata);
174     return NULL;
175   }
176
177   return process;
178 }
179
180 void MSG_process_kill_from_SIMIX(smx_process_t p)
181 {
182 #ifdef HAVE_TRACING
183   TRACE_msg_process_kill(p);
184 #endif
185   MSG_process_kill(p);
186 }
187
188 /** \ingroup m_process_management
189  * \param process poor victim
190  *
191  * This function simply kills a \a process... scary isn't it ? :)
192  */
193 void MSG_process_kill(m_process_t process)
194 {
195 #ifdef HAVE_TRACING
196   TRACE_msg_process_kill(process);
197 #endif
198
199   /* FIXME: why do we only cancel communication actions? is this useful? */
200   simdata_process_t p_simdata = SIMIX_req_process_get_data(process);
201   if (p_simdata->waiting_task && p_simdata->waiting_task->simdata->comm) {
202     SIMIX_req_comm_cancel(p_simdata->waiting_task->simdata->comm);
203   }
204  
205   SIMIX_req_process_kill(process);
206
207   return;
208 }
209
210 /** \ingroup m_process_management
211  * \brief Migrates an agent to another location.
212  *
213  * This function checks whether \a process and \a host are valid pointers
214    and change the value of the #m_host_t on which \a process is running.
215  */
216 MSG_error_t MSG_process_migrate(m_process_t process, m_host_t host)
217 {
218   simdata_process_t simdata = SIMIX_req_process_get_data(process);
219   simdata->m_host = host;
220 #ifdef HAVE_TRACING
221   m_host_t now = simdata->m_host;
222   TRACE_msg_process_change_host(process, now, host);
223 #endif
224   SIMIX_req_process_change_host(process, host->simdata->smx_host);
225   return MSG_OK;
226 }
227
228 /** \ingroup m_process_management
229  * \brief Returns the user data of a process.
230  *
231  * This function checks whether \a process is a valid pointer or not
232    and returns the user data associated to this process.
233  */
234 void* MSG_process_get_data(m_process_t process)
235 {
236   xbt_assert(process != NULL, "Invalid parameter");
237
238   /* get from SIMIX the MSG process data, and then the user data */
239   simdata_process_t simdata = SIMIX_req_process_get_data(process);
240   return simdata->data;
241 }
242
243 /** \ingroup m_process_management
244  * \brief Sets the user data of a process.
245  *
246  * This function checks whether \a process is a valid pointer or not
247    and sets the user data associated to this process.
248  */
249 MSG_error_t MSG_process_set_data(m_process_t process, void *data)
250 {
251   xbt_assert(process != NULL, "Invalid parameter");
252
253   simdata_process_t simdata = SIMIX_req_process_get_data(process);
254   simdata->data = data;
255
256   return MSG_OK;
257 }
258
259 /** \ingroup m_process_management
260  * \brief Return the location on which an agent is running.
261  *
262  * This function checks whether \a process is a valid pointer or not
263    and return the m_host_t corresponding to the location on which \a
264    process is running.
265  */
266 m_host_t MSG_process_get_host(m_process_t process)
267 {
268   xbt_assert(process != NULL, "Invalid parameter");
269
270   simdata_process_t simdata = SIMIX_req_process_get_data(process);
271   return simdata->m_host;
272 }
273
274 /** \ingroup m_process_management
275  *
276  * \brief Return a #m_process_t given its PID.
277  *
278  * This function search in the list of all the created m_process_t for a m_process_t
279    whose PID is equal to \a PID. If no host is found, \c NULL is returned.
280    Note that the PID are uniq in the whole simulation, not only on a given host.
281  */
282 m_process_t MSG_process_from_PID(int PID)
283 {
284   /* FIXME: reimplement this function using SIMIX when we have a good PID.
285    * In the meantime, I guess nobody uses it so it should not break anything. */
286   THROW_UNIMPLEMENTED;
287 }
288
289 /** \ingroup m_process_management
290  * \brief Returns the process ID of \a process.
291  *
292  * This function checks whether \a process is a valid pointer or not
293    and return its PID (or 0 in case of problem).
294  */
295 int MSG_process_get_PID(m_process_t process)
296 {
297   /* Do not raise an exception here: this function is called by the logs
298    * and the exceptions, so it would be called back again and again */
299   if (process == NULL) {
300     return 0;
301   }
302
303   simdata_process_t simdata = SIMIX_req_process_get_data(process);
304
305   return simdata != NULL ? simdata->PID : 0;
306 }
307
308 /** \ingroup m_process_management
309  * \brief Returns the process ID of the parent of \a process.
310  *
311  * This function checks whether \a process is a valid pointer or not
312    and return its PID. Returns -1 if the agent has not been created by
313    another agent.
314  */
315 int MSG_process_get_PPID(m_process_t process)
316 {
317   xbt_assert(process != NULL, "Invalid parameter");
318
319   simdata_process_t simdata = SIMIX_req_process_get_data(process);
320
321   return simdata->PPID;
322 }
323
324 /** \ingroup m_process_management
325  * \brief Return the name of an agent.
326  *
327  * This function checks whether \a process is a valid pointer or not
328    and return its name.
329  */
330 const char *MSG_process_get_name(m_process_t process)
331 {
332   xbt_assert(process, "Invalid parameter");
333
334   return SIMIX_req_process_get_name(process);
335 }
336
337 /** \ingroup m_process_management
338  * \brief Returns the value of a given process property
339  *
340  * \param process a process
341  * \param name a property name
342  * \return value of a property (or NULL if the property is not set)
343  */
344 const char *MSG_process_get_property_value(m_process_t process,
345                                            const char *name)
346 {
347   return xbt_dict_get_or_null(MSG_process_get_properties(process), name);
348 }
349
350 /** \ingroup m_process_management
351  * \brief Return the list of properties
352  *
353  * This function returns all the parameters associated with a process
354  */
355 xbt_dict_t MSG_process_get_properties(m_process_t process)
356 {
357   xbt_assert(process != NULL, "Invalid parameter");
358
359   return SIMIX_req_process_get_properties(process);
360
361 }
362
363 /** \ingroup m_process_management
364  * \brief Return the PID of the current agent.
365  *
366  * This function returns the PID of the currently running #m_process_t.
367  */
368 int MSG_process_self_PID(void)
369 {
370   return MSG_process_get_PID(MSG_process_self());
371 }
372
373 /** \ingroup m_process_management
374  * \brief Return the PPID of the current agent.
375  *
376  * This function returns the PID of the parent of the currently
377  * running #m_process_t.
378  */
379 int MSG_process_self_PPID(void)
380 {
381   return MSG_process_get_PPID(MSG_process_self());
382 }
383
384 /** \ingroup m_process_management
385  * \brief Return the current process.
386  *
387  * This function returns the currently running #m_process_t.
388  */
389 m_process_t MSG_process_self(void)
390 {
391   return SIMIX_process_self();
392 }
393
394 /** \ingroup m_process_management
395  * \brief Suspend the process.
396  *
397  * This function suspends the process by suspending the task on which
398  * it was waiting for the completion.
399  */
400 MSG_error_t MSG_process_suspend(m_process_t process)
401 {
402   xbt_assert(process != NULL, "Invalid parameter");
403   CHECK_HOST();
404
405 #ifdef HAVE_TRACING
406   TRACE_msg_process_suspend(process);
407 #endif
408
409   SIMIX_req_process_suspend(process);
410   MSG_RETURN(MSG_OK);
411 }
412
413 /** \ingroup m_process_management
414  * \brief Resume a suspended process.
415  *
416  * This function resumes a suspended process by resuming the task on
417  * which it was waiting for the completion.
418  */
419 MSG_error_t MSG_process_resume(m_process_t process)
420 {
421   xbt_assert(process != NULL, "Invalid parameter");
422   CHECK_HOST();
423
424 #ifdef HAVE_TRACING
425   TRACE_msg_process_resume(process);
426 #endif
427
428   SIMIX_req_process_resume(process);
429   MSG_RETURN(MSG_OK);
430 }
431
432 /** \ingroup m_process_management
433  * \brief Returns true if the process is suspended .
434  *
435  * This checks whether a process is suspended or not by inspecting the
436  * task on which it was waiting for the completion.
437  */
438 int MSG_process_is_suspended(m_process_t process)
439 {
440   xbt_assert(process != NULL, "Invalid parameter");
441   return SIMIX_req_process_is_suspended(process);
442 }
443
444 smx_context_t MSG_process_get_smx_ctx(m_process_t process) {
445   return SIMIX_process_get_context(process);
446 }