msg_process_t MSG_process_create_with_environment(
const char *name, std::function<void()> code, void *data,
msg_host_t host, xbt_dict_t properties)
{
xbt_assert(code != nullptr && host != nullptr, "Invalid parameters: host and code params must not be nullptr");
simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
msg_process_t process;
/* Simulator data for MSG */
simdata->waiting_action = nullptr;
simdata->waiting_task = nullptr;
simdata->m_host = host;
simdata->data = data;
simdata->last_errno = MSG_OK;
/* Let's create the process: SIMIX may decide to start it right now,
* even before returning the flow control to us */
process = simcall_process_create(
name, std::move(code), simdata, host, -1, properties, 0);
if (!process) {
/* Undo everything we have just changed */
xbt_free(simdata);
return nullptr;
}
else {
simcall_process_on_exit(process,(int_f_pvoid_pvoid_t)TRACE_msg_process_kill,process);
}
return process;
}
/* Become a process in the simulation
*
* Currently this can only be called by the main thread (once) and only work with some thread factories
* (currently ThreadContextFactory).
*
* In the future, it might be extended in order to attach other threads created by a third party library.
*/
msg_process_t MSG_process_attach(const char *name, void *data, msg_host_t host, xbt_dict_t properties)
{
xbt_assert(host != nullptr, "Invalid parameters: host and code params must not be nullptr");
simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
msg_process_t process;
/* Simulator data for MSG */
simdata->waiting_action = nullptr;
simdata->waiting_task = nullptr;
simdata->m_host = host;
simdata->data = data;
simdata->last_errno = MSG_OK;
/* Let's create the process: SIMIX may decide to start it right now, even before returning the flow control to us */
process = SIMIX_process_attach(name, simdata, host->cname(), properties, nullptr);
if (!process)
xbt_die("Could not attach");
simcall_process_on_exit(process,(int_f_pvoid_pvoid_t)TRACE_msg_process_kill,process);
return process;
}
/** \ingroup m_process_management
* \brief Creates and runs a new #msg_process_t.
* A constructor for #msg_process_t taking four arguments and returning the
* corresponding object. The structure (and the corresponding thread) is
* created, and put in the list of ready process.
* \param name a name for the object. It is for user-level information
and can be NULL.
* \param code is a function describing the behavior of the process. It
should then only use functions described in \ref
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 #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. 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, msg_host_t host,
int argc, char **argv,
xbt_dict_t properties)
{
xbt_assert(code != NULL && host != NULL, "Invalid parameters");
simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1);
msg_process_t process;
/* Simulator data for MSG */
simdata->waiting_action = NULL;
simdata->waiting_task = NULL;
simdata->m_host = host;
simdata->argc = argc;
simdata->argv = argv;
simdata->data = data;
simdata->last_errno = MSG_OK;
/* 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, 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
if (!process) {
/* Undo everything we have just changed */
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
}
return process;
}
/**
* \ingroup m_process_management
* \brief Add a function to the list of "on_exit" functions for the current 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_pvoid_t fun, void *data) {
simcall_process_on_exit(MSG_process_self(),fun,data);
}
