Logo AND Algorithmique Numérique Distribuée

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