-/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2004-2014. 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);
}
// 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)
+ 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)
{
msg_host_t host = MSG_get_host_by_name(hostname);
msg_process_t p = MSG_process_create_with_environment(name, code, data,
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;
simcall_process_create(&process, name, code, simdata, sg_host_name(host), -1,
argc, argv, properties,0);
- #ifdef HAVE_TRACING
- TRACE_msg_process_create(name, simcall_process_get_PID(process), simdata->m_host);
- #endif
+ TRACE_msg_process_create(name, SIMIX_process_get_PID(process), host);
if (!process) {
/* Undo everything we have just changed */
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.
*
{
simdata_process_t simdata = simcall_process_get_data(process);
simdata->m_host = host;
-#ifdef HAVE_TRACING
msg_host_t now = simdata->m_host;
TRACE_msg_process_change_host(process, now, host);
-#endif
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
*/
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;
else {
simdata = simcall_process_get_data(process);
}
- return simdata->m_host;
+ return simdata ? simdata->m_host : NULL;
}
/** \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");
return simcall_process_get_PPID(process);
}
*/
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);
*/
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);
}
*/
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);
}
/**
