-/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2004-2015. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include "msg_private.h"
#include "xbt/sysdep.h"
#include "xbt/log.h"
+#include "simix/smx_process_private.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg,
"Logging specific to MSG (process)");
/** @addtogroup m_process_management
- * \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Processes" --> \endhtmlonly
+ * \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Processes" --> \endhtmlonly
*
- * We need to simulate many independent scheduling decisions, so
- * the concept of <em>process</em> is at the heart of the
- * simulator. A process may be defined as a <em>code</em>, with
- * some <em>private data</em>, executing in a <em>location</em>.
- * \see msg_process_t
+ * Processes (#msg_process_t) are independent agents that can do stuff on their own. They are in charge of executing your code interacting with the simulated world.
+ * A process may be defined as a <em>code</em> with some <em>private data</em>.
+ * Processes must be located on <em>hosts</em> (#msg_host_t), and they exchange data by sending tasks (#msg_task_t) that are similar to envelops containing data.
*/
/******************************** Process ************************************/
simcall_process_set_data(smx_proc, NULL);
}
-#ifdef HAVE_TRACING
TRACE_msg_process_end(smx_proc);
-#endif
-
// free the data if a function was provided
- if (msg_proc->data && msg_global->process_data_cleanup) {
+ if (msg_proc && msg_proc->data && msg_global->process_data_cleanup) {
msg_global->process_data_cleanup(msg_proc->data);
}
- // remove the process from its virtual machine
- if (msg_proc->vm) {
- int pos = xbt_dynar_search(msg_proc->vm->processes,&smx_proc);
- xbt_dynar_remove_at(msg_proc->vm->processes,pos, NULL);
- }
-
// free the MSG process
xbt_free(msg_proc);
+ SIMIX_process_cleanup(smx_proc);
}
/* This function creates a MSG process. It has the prototype enforced by SIMIX_function_register_process_create */
-void MSG_process_create_from_SIMIX(smx_process_t* process, const char *name,
- xbt_main_func_t code, void *data,
- const char *hostname, double kill_time, int argc, char **argv,
- xbt_dict_t properties, int auto_restart)
+smx_process_t MSG_process_create_from_SIMIX(const char *name,
+ xbt_main_func_t code, void *data,
+ const char *hostname, double kill_time,
+ int argc, char **argv,
+ xbt_dict_t properties, int auto_restart,
+ smx_process_t parent_process)
{
- m_host_t host = MSG_get_host_by_name(hostname);
+ msg_host_t host = MSG_host_by_name(hostname);
msg_process_t p = MSG_process_create_with_environment(name, code, data,
host, argc, argv,
properties);
MSG_process_set_kill_time(p,kill_time);
MSG_process_auto_restart_set(p,auto_restart);
}
- *((msg_process_t*) process) = p;
+ return p;
}
/** \ingroup m_process_management
*/
msg_process_t MSG_process_create(const char *name,
xbt_main_func_t code, void *data,
- m_host_t host)
+ msg_host_t host)
{
return MSG_process_create_with_environment(name, code, data, host, -1,
NULL, NULL);
m_process_management (to create a new #msg_process_t for example),
in \ref m_host_management (only the read-only functions i.e. whose
name contains the word get), in \ref m_task_management (to create
- or destroy some #m_task_t for example) and in \ref
+ or destroy some #msg_task_t for example) and in \ref
msg_task_usage (to handle file transfers and task processing).
* \param data a pointer to any data one may want to attach to the new
object. It is for user-level information and can be NULL. It can
msg_process_t MSG_process_create_with_arguments(const char *name,
xbt_main_func_t code,
- void *data, m_host_t host,
+ void *data, msg_host_t host,
int argc, char **argv)
{
return MSG_process_create_with_environment(name, code, data, host,
m_process_management (to create a new #msg_process_t for example),
in \ref m_host_management (only the read-only functions i.e. whose
name contains the word get), in \ref m_task_management (to create
- or destroy some #m_task_t for example) and in \ref
+ or destroy some #msg_task_t for example) and in \ref
msg_task_usage (to handle file transfers and task processing).
* \param data a pointer to any data one may want to attach to the new
object. It is for user-level information and can be NULL. It can
be retrieved with the function \ref MSG_process_get_data.
* \param host the location where the new process is executed.
* \param argc first argument passed to \a code
- * \param argv second argument passed to \a code
+ * \param argv second argument passed to \a code. WARNING, these strings are freed by the SimGrid kernel when the process exits, so they cannot be static nor shared between several processes.
* \param properties list a properties defined for this process
* \see msg_process_t
* \return The new corresponding object.
*/
msg_process_t MSG_process_create_with_environment(const char *name,
xbt_main_func_t code,
- void *data, m_host_t host,
+ void *data, msg_host_t host,
int argc, char **argv,
xbt_dict_t properties)
{
- xbt_assert(code != NULL && host != NULL, "Invalid parameters");
+ xbt_assert(code != NULL && host != NULL, "Invalid parameters: host and code params must not be NULL");
simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
msg_process_t process;
/* Simulator data for MSG */
- simdata->PID = msg_global->PID++;
simdata->waiting_action = NULL;
simdata->waiting_task = NULL;
simdata->m_host = host;
simdata->data = data;
simdata->last_errno = MSG_OK;
- if (SIMIX_process_self()) {
- simdata->PPID = MSG_process_get_PID(MSG_process_self());
- } else {
- simdata->PPID = -1;
- }
-
-#ifdef HAVE_TRACING
- TRACE_msg_process_create(name, simdata->PID, simdata->m_host);
- #endif
/* Let's create the process: SIMIX may decide to start it right now,
* even before returning the flow control to us */
- simcall_process_create(&process, name, code, simdata, SIMIX_host_get_name(host->smx_host), -1,
+ process = simcall_process_create(name, code, simdata, sg_host_name(host), -1,
argc, argv, properties,0);
+ TRACE_msg_process_create(name, SIMIX_process_get_PID(process), host);
+
if (!process) {
/* Undo everything we have just changed */
- msg_global->PID--;
xbt_free(simdata);
return NULL;
}
else {
- #ifdef HAVE_TRACING
- simcall_process_on_exit(process,(int_f_pvoid_t)TRACE_msg_process_kill,MSG_process_self());
- #endif
+ simcall_process_on_exit(process,(int_f_pvoid_pvoid_t)TRACE_msg_process_kill,process);
}
return process;
}
// if (p_simdata->waiting_task && p_simdata->waiting_task->simdata->comm) {
// simcall_comm_cancel(p_simdata->waiting_task->simdata->comm);
// }
-
+
simcall_process_kill(process);
return;
}
+/**
+* \brief Wait for the completion of a #msg_process_t.
+*
+* \param process the process to wait for
+* \param timeout wait until the process is over, or the timeout occurs
+*/
+msg_error_t MSG_process_join(msg_process_t process, double timeout){
+ simcall_process_join(process, timeout);
+ return MSG_OK;
+}
+
/** \ingroup m_process_management
* \brief Migrates a process to another location.
*
* This function checks whether \a process and \a host are valid pointers
- and change the value of the #m_host_t on which \a process is running.
+ and change the value of the #msg_host_t on which \a process is running.
*/
-MSG_error_t MSG_process_migrate(msg_process_t process, m_host_t host)
+msg_error_t MSG_process_migrate(msg_process_t process, msg_host_t host)
{
simdata_process_t simdata = simcall_process_get_data(process);
simdata->m_host = host;
-#ifdef HAVE_TRACING
- m_host_t now = simdata->m_host;
+ msg_host_t now = simdata->m_host;
TRACE_msg_process_change_host(process, now, host);
-#endif
- simcall_process_change_host(process, host->smx_host);
+ simcall_process_change_host(process, host);
return MSG_OK;
}
*/
void* MSG_process_get_data(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: first parameter must not be NULL!");
/* get from SIMIX the MSG process data, and then the user data */
simdata_process_t simdata = simcall_process_get_data(process);
- return simdata->data;
+ if (simdata)
+ return simdata->data;
+ else
+ return NULL;
}
/** \ingroup m_process_management
* This function checks whether \a process is a valid pointer or not
and sets the user data associated to this process.
*/
-MSG_error_t MSG_process_set_data(msg_process_t process, void *data)
+msg_error_t MSG_process_set_data(msg_process_t process, void *data)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: first parameter must not be NULL!");
simdata_process_t simdata = simcall_process_get_data(process);
simdata->data = data;
/** \ingroup m_process_management
* \brief Return the location on which a process is running.
* \param process a process (NULL means the current one)
- * \return the m_host_t corresponding to the location on which \a
+ * \return the msg_host_t corresponding to the location on which \a
* process is running.
*/
-m_host_t MSG_process_get_host(msg_process_t process)
+msg_host_t MSG_process_get_host(msg_process_t process)
{
simdata_process_t simdata;
if (process == NULL) {
else {
simdata = simcall_process_get_data(process);
}
- return simdata->m_host;
+ return simdata ? simdata->m_host : NULL;
}
/** \ingroup m_process_management
xbt_dynar_t MSG_processes_as_dynar(void) {
return SIMIX_processes_as_dynar();
}
+/** @brief Return the current number MSG processes.
+ */
+int MSG_process_get_number(void)
+{
+ return SIMIX_process_count();
+}
/** \ingroup m_process_management
* \brief Set the kill time of a process.
* \param process a process
* \param kill_time the time when the process is killed.
*/
-MSG_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time)
+msg_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time)
{
simcall_process_set_kill_time(process,kill_time);
return MSG_OK;
if (process == NULL) {
return 0;
}
-
- simdata_process_t simdata = simcall_process_get_data(process);
-
- return simdata != NULL ? simdata->PID : 0;
+ return simcall_process_get_PID(process);
}
/** \ingroup m_process_management
*/
int MSG_process_get_PPID(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
- simdata_process_t simdata = simcall_process_get_data(process);
-
- return simdata->PPID;
+ return simcall_process_get_PPID(process);
}
/** \ingroup m_process_management
*/
const char *MSG_process_get_name(msg_process_t process)
{
- xbt_assert(process, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
return simcall_process_get_name(process);
}
*/
xbt_dict_t MSG_process_get_properties(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
return simcall_process_get_properties(process);
* This function suspends the process by suspending the task on which
* it was waiting for the completion.
*/
-MSG_error_t MSG_process_suspend(msg_process_t process)
+msg_error_t MSG_process_suspend(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
-#ifdef HAVE_TRACING
TRACE_msg_process_suspend(process);
-#endif
-
simcall_process_suspend(process);
MSG_RETURN(MSG_OK);
}
* This function resumes a suspended process by resuming the task on
* which it was waiting for the completion.
*/
-MSG_error_t MSG_process_resume(msg_process_t process)
+msg_error_t MSG_process_resume(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
-#ifdef HAVE_TRACING
TRACE_msg_process_resume(process);
-#endif
-
simcall_process_resume(process);
MSG_RETURN(MSG_OK);
}
*/
int MSG_process_is_suspended(msg_process_t process)
{
- xbt_assert(process != NULL, "Invalid parameter");
+ xbt_assert(process != NULL, "Invalid parameter: First argument must not be NULL");
return simcall_process_is_suspended(process);
}
* The on_exit functions are the functions executed when your process is killed.
* You should use them to free the data used by your process.
*/
-void MSG_process_on_exit(int_f_pvoid_t fun, void *data) {
+void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data) {
simcall_process_on_exit(MSG_process_self(),fun,data);
}
/**
XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart) {
simcall_process_auto_restart_set(process,auto_restart);
}
+/*
+ * \ingroup m_process_management
+ * \brief Restarts a process from the beginning.
+ */
+XBT_PUBLIC(msg_process_t) MSG_process_restart(msg_process_t process) {
+ return simcall_process_restart(process);
+}
