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
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg, "Logging specific to MSG (process)");
  15
  16 /** \defgroup m_process_management Management Functions of Agents
  17  *  \brief This section describes the agent structure of MSG
  18  *  (#m_process_t) and the functions for managing it.
  19  */
  20 /** @addtogroup m_process_management
  21  *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Agents" --> \endhtmlonly
  22  *
  23  *  We need to simulate many independent scheduling decisions, so
  24  *  the concept of <em>process</em> is at the heart of the
  25  *  simulator. A process may be defined as a <em>code</em>, with
  26  *  some <em>private data</em>, executing in a <em>location</em>.
  27  *  \see m_process_t
  28  */
  29
  30 /******************************** Process ************************************/
  31 /** \ingroup m_process_management
  32  * \brief Creates and runs a new #m_process_t.
  33  *
  34  * Does exactly the same as #MSG_process_create_with_arguments but without
  35    providing standard arguments (\a argc, \a argv, \a start_time, \a kill_time).
  36  * \sa MSG_process_create_with_arguments
  37  */
  38 m_process_t MSG_process_create(const char *name,
  39                                xbt_main_func_t code, void *data,
  40                                m_host_t host)
  41 {
  42   return MSG_process_create_with_arguments(name, code, data, host, -1, NULL);
  43 }
  44
  45 void __MSG_process_cleanup(void *arg)
  46 {
  47         /* arg is a pointer to a simix process, we can get the msg process with the field data */
  48    m_process_t proc = ((smx_process_t)arg)->data;
  49    xbt_fifo_remove(msg_global->process_list, proc);
  50    SIMIX_process_cleanup(arg);
  51    free(proc->name);
  52    proc->name = NULL;
  53    free(proc->simdata);
  54    proc->simdata = NULL;
  55    free(proc);
  56
  57    return;
  58 }
  59
  60 /* This function creates a MSG process. It has the prototype by SIMIX_function_register_process_create */
  61 void *_MSG_process_create_from_SIMIX(const char *name,
  62                                      xbt_main_func_t code, void *data,
  63                                      char * hostname, int argc, char **argv)
  64 {
  65         m_host_t host = MSG_get_host_by_name(hostname);
  66         return (void*)MSG_process_create_with_arguments(name,code,data,host,argc,argv);
  67 }
  68
  69
  70 /** \ingroup m_process_management
  71  * \brief Creates and runs a new #m_process_t.
  72
  73  * A constructor for #m_process_t taking four arguments and returning the
  74  * corresponding object. The structure (and the corresponding thread) is
  75  * created, and put in the list of ready process.
  76  * \param name a name for the object. It is for user-level information
  77    and can be NULL.
  78  * \param code is a function describing the behavior of the agent. It
  79    should then only use functions described in \ref
  80    m_process_management (to create a new #m_process_t for example),
  81    in \ref m_host_management (only the read-only functions i.e. whose
  82    name contains the word get), in \ref m_task_management (to create
  83    or destroy some #m_task_t for example) and in \ref
  84    msg_gos_functions (to handle file transfers and task processing).
  85  * \param data a pointer to any data one may want to attach to the new
  86    object.  It is for user-level information and can be NULL. It can
  87    be retrieved with the function \ref MSG_process_get_data.
  88  * \param host the location where the new agent is executed.
  89  * \param argc first argument passed to \a code
  90  * \param argv second argument passed to \a code
  91  * \see m_process_t
  92  * \return The new corresponding object.
  93  */
  94
  95 m_process_t MSG_process_create_with_arguments(const char *name,
  96                                               xbt_main_func_t code, void *data,
  97                                               m_host_t host, int argc, char **argv)
  98 {
  99   simdata_process_t simdata = xbt_new0(s_simdata_process_t,1);
 100   m_process_t process = xbt_new0(s_m_process_t,1);
 101   xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters");
 102
 103   /* Simulator Data */
 104   simdata->PID = msg_global->PID++;
 105         simdata->waiting_task = NULL;
 106   simdata->m_host = host;
 107   simdata->argc = argc;
 108   simdata->argv = argv;
 109   simdata->s_process = SIMIX_process_create(name, code,
 110                                             (void*)process, host->name, argc, argv);
 111
 112   if (SIMIX_process_self()) {
 113     simdata->PPID = MSG_process_get_PID(SIMIX_process_self()->data);
 114   } else {
 115     simdata->PPID = -1;
 116   }
 117   simdata->last_errno=MSG_OK;
 118
 119
 120   /* Process structure */
 121   process->name = xbt_strdup(name);
 122   process->simdata = simdata;
 123   process->data = data;
 124
 125   xbt_fifo_unshift(msg_global->process_list, process);
 126
 127   return process;
 128 }
 129
 130
 131 void _MSG_process_kill_from_SIMIX(void *p) {
 132    MSG_process_kill((m_process_t)p);
 133 }
 134
 135 /** \ingroup m_process_management
 136  * \param process poor victim
 137  *
 138  * This function simply kills a \a process... scarry isn't it ? :)
 139  */
 140 void MSG_process_kill(m_process_t process)
 141 {
 142   simdata_process_t p_simdata = process->simdata;
 143
 144   DEBUG3("Killing %s(%d) on %s",
 145          process->name, p_simdata->PID, p_simdata->m_host->name);
 146
 147   if(p_simdata->waiting_task) {
 148     DEBUG1("Canceling waiting task %s",p_simdata->waiting_task->name);
 149     if(p_simdata->waiting_task->simdata->compute) {
 150       SIMIX_action_cancel(p_simdata->waiting_task->simdata->compute);
 151     } else if (p_simdata->waiting_task->simdata->comm) {
 152       SIMIX_action_cancel(p_simdata->waiting_task->simdata->comm);
 153     }
 154   }
 155
 156   xbt_fifo_remove(msg_global->process_list,process);
 157   SIMIX_process_kill(process->simdata->s_process);
 158
 159   return;
 160 }
 161
 162 /** \ingroup m_process_management
 163  * \brief Migrates an agent to another location.
 164  *
 165  * This functions checks whether \a process and \a host are valid pointers
 166    and change the value of the #m_host_t on which \a process is running.
 167  */
 168 MSG_error_t MSG_process_change_host(m_process_t process, m_host_t host)
 169 {
 170         xbt_die("MSG_process_change_host - not implemented yet - maybe useless function");
 171   return MSG_OK;
 172 }
 173
 174 /** \ingroup m_process_management
 175  * \brief Return the user data of a #m_process_t.
 176  *
 177  * This functions checks whether \a process is a valid pointer or not
 178    and return the user data associated to \a process if it is possible.
 179  */
 180 void *MSG_process_get_data(m_process_t process)
 181 {
 182   xbt_assert0((process != NULL), "Invalid parameters");
 183
 184   return (process->data);
 185 }
 186
 187 /** \ingroup m_process_management
 188  * \brief Set the user data of a #m_process_t.
 189  *
 190  * This functions checks whether \a process is a valid pointer or not
 191    and set the user data associated to \a process if it is possible.
 192  */
 193 MSG_error_t MSG_process_set_data(m_process_t process,void *data)
 194 {
 195   xbt_assert0((process != NULL), "Invalid parameters");
 196   xbt_assert0((process->data == NULL), "Data already set");
 197
 198   process->data = data;
 199
 200   return MSG_OK;
 201 }
 202
 203 /** \ingroup m_process_management
 204  * \brief Return the location on which an agent is running.
 205  *
 206  * This functions checks whether \a process is a valid pointer or not
 207    and return the m_host_t corresponding to the location on which \a
 208    process is running.
 209  */
 210 m_host_t MSG_process_get_host(m_process_t process)
 211 {
 212   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 213
 214   return (((simdata_process_t) process->simdata)->m_host);
 215 }
 216
 217 /** \ingroup m_process_management
 218  *
 219  * \brief Return a #m_process_t given its PID.
 220  *
 221  * This functions search in the list of all the created m_process_t for a m_process_t
 222    whose PID is equal to \a PID. If no host is found, \c NULL is returned.
 223    Note that the PID are uniq in the whole simulation, not only on a given host.
 224  */
 225 m_process_t MSG_process_from_PID(int PID)
 226 {
 227   xbt_fifo_item_t i = NULL;
 228   m_process_t process = NULL;
 229
 230   xbt_fifo_foreach(msg_global->process_list,i,process,m_process_t) {
 231     if(MSG_process_get_PID(process) == PID) return process;
 232   }
 233   return NULL;
 234 }
 235
 236 /** \ingroup m_process_management
 237  * \brief Returns the process ID of \a process.
 238  *
 239  * This functions checks whether \a process is a valid pointer or not
 240    and return its PID (or 0 in case of problem).
 241  */
 242 int MSG_process_get_PID(m_process_t process)
 243 {
 244   /* Do not raise an exception here: this function is used in the logs,
 245      and it will be called back by the exception handling stuff */
 246   if (process == NULL || process->simdata == NULL)
 247      return 0;
 248
 249   return (((simdata_process_t) process->simdata)->PID);
 250 }
 251
 252 /** \ingroup m_process_management
 253  * \brief Returns the process ID of the parent of \a process.
 254  *
 255  * This functions checks whether \a process is a valid pointer or not
 256    and return its PID. Returns -1 if the agent has not been created by
 257    another agent.
 258  */
 259 int MSG_process_get_PPID(m_process_t process)
 260 {
 261   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 262
 263   return (((simdata_process_t) process->simdata)->PPID);
 264 }
 265
 266 /** \ingroup m_process_management
 267  * \brief Return the name of an agent.
 268  *
 269  * This functions checks whether \a process is a valid pointer or not
 270    and return its name.
 271  */
 272 const char *MSG_process_get_name(m_process_t process)
 273 {
 274   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 275
 276   return (process->name);
 277 }
 278
 279 /** \ingroup m_process_management
 280  * \brief Return the PID of the current agent.
 281  *
 282  * This functions returns the PID of the currently running #m_process_t.
 283  */
 284 int MSG_process_self_PID(void)
 285 {
 286   return (MSG_process_get_PID(MSG_process_self()));
 287 }
 288
 289 /** \ingroup m_process_management
 290  * \brief Return the PPID of the current agent.
 291  *
 292  * This functions returns the PID of the parent of the currently
 293  * running #m_process_t.
 294  */
 295 int MSG_process_self_PPID(void)
 296 {
 297   return (MSG_process_get_PPID(MSG_process_self()));
 298 }
 299
 300 /** \ingroup m_process_management
 301  * \brief Return the current agent.
 302  *
 303  * This functions returns the currently running #m_process_t.
 304  */
 305 m_process_t MSG_process_self(void)
 306 {
 307         smx_process_t proc = SIMIX_process_self();
 308         if (proc != NULL) {
 309                 return (m_process_t)proc->data;
 310         }
 311         else {
 312                 return NULL;
 313         }
 314
 315 }
 316
 317 /** \ingroup m_process_management
 318  * \brief Suspend the process.
 319  *
 320  * This functions suspend the process by suspending the task on which
 321  * it was waiting for the completion.
 322  */
 323 MSG_error_t MSG_process_suspend(m_process_t process)
 324 {
 325   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 326   CHECK_HOST();
 327
 328         SIMIX_process_suspend(process->simdata->s_process);
 329   MSG_RETURN(MSG_OK);
 330 }
 331
 332 /** \ingroup m_process_management
 333  * \brief Resume a suspended process.
 334  *
 335  * This functions resume a suspended process by resuming the task on
 336  * which it was waiting for the completion.
 337  */
 338 MSG_error_t MSG_process_resume(m_process_t process)
 339 {
 340
 341   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 342   CHECK_HOST();
 343
 344         SIMIX_process_resume(process->simdata->s_process);
 345   MSG_RETURN(MSG_OK);
 346 }
 347
 348 /** \ingroup m_process_management
 349  * \brief Returns true if the process is suspended .
 350  *
 351  * This checks whether a process is suspended or not by inspecting the
 352  * task on which it was waiting for the completion.
 353  */
 354 int MSG_process_is_suspended(m_process_t process)
 355 {
 356   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
 357         return SIMIX_process_is_suspended(process->simdata->s_process);
 358 }
 359