-/* $Id$ */
+//* $Id$ */
/* Copyright (c) 2002,2003,2004 Arnaud Legrand. All rights reserved. */
#include "private.h"
#include "xbt/sysdep.h"
#include "xbt/log.h"
+#include "xbt/dict.h"
+#include "msg/mailbox.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix,
- "Logging specific to SIMIX (process)");
+ "Logging specific to SIMIX (process)");
-/******************************** Process ************************************/
/**
- * \brief Creates and runs a new #smx_process_t.
+ * \brief Move a process to the list of process to destroy. *
+ */
+void SIMIX_process_cleanup(void *arg)
+{
+ xbt_swag_remove(arg, simix_global->process_to_run);
+ xbt_swag_remove(arg, simix_global->process_list);
+ xbt_swag_remove(arg, ((smx_process_t) arg)->smx_host->process_list);
+ xbt_swag_insert(arg, simix_global->process_to_destroy);
+}
+
+/**
+ * Garbage collection
*
- * Does exactly the same as #SIMIX_process_create_with_arguments but without
- providing standard arguments (\a argc, \a argv).
- * \see SIMIX_process_create_with_arguments
+ * Should be called some time to time to free the memory allocated for processes
+ * that have finished (or killed).
*/
+void SIMIX_process_empty_trash(void)
+{
+ smx_process_t process = NULL;
+ while ((process = xbt_swag_extract(simix_global->process_to_destroy))) {
+ SIMIX_context_free(process->context);
-void SIMIX_process_cleanup(void *arg)
+ /* Free the exception allocated at creation time */
+ if (process->exception)
+ free(process->exception);
+
+ free(process->name);
+ process->name = NULL;
+ free(process);
+ }
+}
+
+/**
+ * \brief Creates and runs the maestro process
+ */
+void SIMIX_create_maestro_process()
{
- xbt_swag_remove(arg, simix_global->process_list);
- xbt_swag_remove(arg, simix_global->process_to_run);
- xbt_swag_remove(arg, ((smx_process_t) arg)->simdata->s_host->simdata->process_list);
- free(((smx_process_t) arg)->name);
- ((smx_process_t) arg)->name = NULL;
+ smx_process_t process = NULL;
+ process = xbt_new0(s_smx_process_t, 1);
+
+ /* Process data */
+ process->name = (char *) "";
+
+ process->exception = xbt_new(ex_ctx_t, 1);
+ XBT_CTX_INITIALIZE(process->exception);
- free(((smx_process_t) arg)->simdata);
- ((smx_process_t) arg)->simdata = NULL;
- free(arg);
+ /* Create a dummy context for maestro */
+ process->context = SIMIX_context_new(NULL, 0, NULL, NULL, NULL);
+
+ /* Set it as the maestro process */
+ simix_global->maestro_process = process;
+ simix_global->current_process = process;
+
+ return;
}
-/**
+/**
* \brief Creates and runs a new #smx_process_t.
*
* A constructor for #m_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 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 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 agent is executed.
* \param argc first argument passed to \a code
* \param argv second argument passed to \a code
- * \param clean_process_function The cleanup function of user process. It will be called when the process finish. This function have to call the SIMIX_process_cleanup.
+ * \param clean_process_function The cleanup function of user process. It will be called when the process finish. This function have to call the SIMIX_process_cleanup.
* \see smx_process_t
* \return The new corresponding object.
*/
smx_process_t SIMIX_process_create(const char *name,
- smx_process_code_t code, void *data,
- const char * hostname, int argc, char **argv,
- void * clean_process_function)
+ xbt_main_func_t code, void *data,
+ const char *hostname, int argc,
+ char **argv, xbt_dict_t properties)
{
- smx_simdata_process_t simdata = xbt_new0(s_smx_simdata_process_t,1);
- smx_process_t process = xbt_new0(s_smx_process_t,1);
- smx_process_t self = NULL;
+ smx_process_t process = NULL;
smx_host_t host = SIMIX_host_get_by_name(hostname);
+ DEBUG2("Start process %s on host %s", name, hostname);
+
+ if (!SIMIX_host_get_state(host)) {
+ WARN2("Cannot launch process '%s' on failed host '%s'", name, hostname);
+ return NULL;
+ }
+ process = xbt_new0(s_smx_process_t, 1);
+
xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters");
- /* Simulator Data */
-
- simdata->s_host = host;
- simdata->mutex = NULL;
- simdata->cond = NULL;
- simdata->argc = argc;
- simdata->argv = argv;
- if (clean_process_function) {
- simdata->context = xbt_context_new(code, NULL, NULL,
- clean_process_function, process,
- simdata->argc, simdata->argv);
- }
- else {
- simdata->context = xbt_context_new(code, NULL, NULL,
- SIMIX_process_cleanup, process,
- simdata->argc, simdata->argv);
- }
-
- /* Process structure */
+
+ /* Process data */
process->name = xbt_strdup(name);
- process->simdata = simdata;
+ process->smx_host = host;
+ process->mutex = NULL;
+ process->cond = NULL;
+ process->iwannadie = 0;
process->data = data;
- xbt_swag_insert(process, host->simdata->process_list);
-
- /* *************** FIX du current_process !!! *************** */
- self = simix_global->current_process;
- xbt_context_start(process->simdata->context);
- simix_global->current_process = self;
+ VERB1("Create context %s", process->name);
+ process->context = SIMIX_context_new(code, argc, argv,
+ simix_global->cleanup_process_function,
+ process);
- xbt_swag_insert(process,simix_global->process_list);
- DEBUG2("Inserting %s(%s) in the to_run list",process->name,
- host->name);
- xbt_swag_insert(process,simix_global->process_to_run);
+ process->exception = xbt_new(ex_ctx_t, 1);
+ XBT_CTX_INITIALIZE(process->exception);
- return process;
-}
-
-/**
- * \brief Creates and runs a new #smx_process_t hosting a JAVA thread
- *
- * Warning: this should only be used in libsimgrid4java, since it create
- * a context with no code, which leads to segfaults in plain libsimgrid
- */
-smx_process_t SIMIX_jprocess_create(const char *name, smx_host_t host,
- void *data,
- void *jprocess, void *jenv)
-{
- smx_simdata_process_t simdata = xbt_new0(s_smx_simdata_process_t,1);
- smx_process_t process = xbt_new0(s_smx_process_t,1);
- smx_process_t self = NULL;
-
- DEBUG5("jprocess_create(name=%s,host=%p,data=%p,jproc=%p,jenv=%p)",
- name,host,data,jprocess,jenv);
- xbt_assert0(host, "Invalid parameters");
- /* Simulator Data */
- simdata->s_host = host;
- simdata->mutex = NULL;
- simdata->cond = NULL;
- simdata->argc = 0;
- simdata->argv = NULL;
-
- simdata->context = xbt_context_new(NULL, NULL, NULL,
- SIMIX_process_cleanup, process,
- /* argc/argv*/0,NULL);
- /* Process structure */
- process->name = xbt_strdup(name);
- process->simdata = simdata;
- process->data = data;
- SIMIX_process_set_jprocess(process,jprocess);
- SIMIX_process_set_jenv(process,jenv);
+ /* Add properties */
+ process->properties = properties;
- xbt_swag_insert(process, host->simdata->process_list);
+ /* Add the process to it's host process list */
+ xbt_swag_insert(process, host->process_list);
- /* *************** FIX du current_process !!! *************** */
- self = simix_global->current_process;
- xbt_context_start(process->simdata->context);
- simix_global->current_process = self;
+ DEBUG1("Start context '%s'", process->name);
+ SIMIX_context_start(process->context);
- xbt_swag_insert(process,simix_global->process_list);
- DEBUG2("Inserting %s(%s) in the to_run list",process->name,
- host->name);
- xbt_swag_insert(process,simix_global->process_to_run);
+ /* Now insert it in the global process list and in the process to run list */
+ xbt_swag_insert(process, simix_global->process_list);
+ DEBUG2("Inserting %s(%s) in the to_run list", process->name, host->name);
+ xbt_swag_insert(process, simix_global->process_to_run);
return process;
}
-
/** \brief Kill a SIMIX process
*
- * This function simply kills a \a process... scarry isn't it ? :). Removes it from the mutex or condition that it can be blocked.
+ * This function simply kills a \a process... scarry isn't it ? :).
* \param process poor victim
*
*/
void SIMIX_process_kill(smx_process_t process)
-{
- smx_simdata_process_t p_simdata = process->simdata;
-
- DEBUG2("Killing %s on %s",process->name, p_simdata->s_host->name);
-
- if (p_simdata->mutex) {
- xbt_swag_remove(process,p_simdata->mutex->sleeping);
- }
- if (p_simdata->cond) {
- xbt_swag_remove(process,p_simdata->cond->sleeping);
- }
- xbt_swag_remove(process,simix_global->process_to_run);
- xbt_swag_remove(process,simix_global->process_list);
- xbt_context_kill(process->simdata->context);
-
- if(process==SIMIX_process_self()) {
- /* I just killed myself */
- xbt_context_yield();
+{
+ DEBUG2("Killing process %s on %s", process->name, process->smx_host->name);
+
+ process->iwannadie = 1;
+
+ /* If I'm killing myself then stop otherwise schedule the process to kill
+ * Two different behaviors, if I'm killing my self, remove from mutex and condition and stop. Otherwise, first we must schedule the process, wait its ending and after remove it from mutex and condition */
+ if (process == SIMIX_process_self()) {
+ /* Cleanup if we were waiting for something */
+ if (process->mutex)
+ xbt_swag_remove(process, process->mutex->sleeping);
+
+ if (process->cond)
+ xbt_swag_remove(process, process->cond->sleeping);
+ if (process->waiting_action) {
+ SIMIX_unregister_action_to_condition(process->waiting_action, process->cond);
+ SIMIX_action_destroy(process->waiting_action);
+ }
+ SIMIX_context_stop(process->context);
+ } else {
+ DEBUG2("%p here! killing %p", simix_global->current_process, process);
+ SIMIX_process_schedule(process);
+ /* Cleanup if we were waiting for something */
+ if (process->mutex)
+ xbt_swag_remove(process, process->mutex->sleeping);
+
+ if (process->cond)
+ xbt_swag_remove(process, process->cond->sleeping);
+
+ if (process->waiting_action) {
+ SIMIX_unregister_action_to_condition(process->waiting_action, process->cond);
+ SIMIX_action_destroy(process->waiting_action);
+ }
}
}
void *SIMIX_process_get_data(smx_process_t process)
{
xbt_assert0((process != NULL), "Invalid parameters");
-
return (process->data);
}
* \param process SIMIX process
* \param data User data
*/
-void SIMIX_process_set_data(smx_process_t process,void *data)
+void SIMIX_process_set_data(smx_process_t process, void *data)
{
xbt_assert0((process != NULL), "Invalid parameters");
- xbt_assert0((process->data == NULL), "Data already set");
-
+
process->data = data;
-
- return ;
+ return;
}
/**
*/
smx_host_t SIMIX_process_get_host(smx_process_t process)
{
- xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
-
- return (process->simdata->s_host);
+ xbt_assert0((process != NULL), "Invalid parameters");
+ return (process->smx_host);
}
/**
*/
const char *SIMIX_process_get_name(smx_process_t process)
{
- xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
-
+ xbt_assert0((process != NULL), "Invalid parameters");
return (process->name);
}
+/**
+ * \brief Changes the name of an agent.
+ *
+ * This functions checks whether \a process is a valid pointer or not and return its name.
+ * \param process SIMIX process
+ * \param name The new process name
+ */
+void SIMIX_process_set_name(smx_process_t process, char *name)
+{
+ xbt_assert0((process != NULL), "Invalid parameters");
+ process->name = name;
+}
+
+/** \ingroup m_process_management
+ * \brief Return the properties
+ *
+ * This functions returns the properties associated with this process
+ */
+xbt_dict_t SIMIX_process_get_properties(smx_process_t process)
+{
+ return process->properties;
+}
+
/**
* \brief Return the current agent.
*
/**
* \brief Suspend the process.
*
- * This functions suspend the process by suspending the action on which it was waiting for the completion.
- * \param process SIMIX process
+ * This functions suspend the process by suspending the action on
+ * which it was waiting for the completion.
+ *
+ * \param process SIMIX process
*/
void SIMIX_process_suspend(smx_process_t process)
{
- smx_simdata_process_t simdata = NULL;
-
- xbt_assert0(((process) && (process->simdata)), "Invalid parameters");
-
- if(process!=SIMIX_process_self()) {
- simdata = process->simdata;
-
- if (simdata->mutex) {
- /* process blocked on a mutex, only set suspend=1 */
- simdata->suspended = 1;
- }
- else if (simdata->cond){
- /* process blocked cond, suspend all actions */
-
- /* temporaries variables */
- smx_cond_t c;
- xbt_fifo_item_t i;
- smx_action_t act;
-
- simdata->suspended = 1;
- c = simdata->cond;
- xbt_fifo_foreach(c->actions,i,act, smx_action_t) {
- surf_workstation_resource->common_public->suspend(act->simdata->surf_action);
- }
- }
- else {
- simdata->suspended = 1;
- }
+ xbt_assert0(process, "Invalid parameters");
+
+ if (process != SIMIX_process_self()) {
+
+ if (process->mutex) {
+ /* process blocked on a mutex, only set suspend=1 */
+ process->suspended = 1;
+ } else if (process->cond) {
+ /* process blocked cond, suspend all actions */
+
+ /* temporaries variables */
+ smx_cond_t c;
+ xbt_fifo_item_t i;
+ smx_action_t act;
+
+ process->suspended = 1;
+ c = process->cond;
+ xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
+ surf_workstation_model->suspend(act->surf_action);
+ }
+ } else {
+ process->suspended = 1;
+ }
+ } else {
+ /* process executing, I can create an action and suspend it */
+ smx_action_t dummy;
+ smx_cond_t cond;
+ char name[] = "dummy";
+ process->suspended = 1;
+
+ cond = SIMIX_cond_init();
+ dummy = SIMIX_action_execute(SIMIX_process_get_host(process), name, 0);
+ SIMIX_process_self()->waiting_action = dummy;
+ surf_workstation_model->suspend(dummy->surf_action);
+ SIMIX_register_action_to_condition(dummy, cond);
+ __SIMIX_cond_wait(cond);
+ SIMIX_process_self()->waiting_action = NULL;
+ SIMIX_unregister_action_to_condition(dummy, cond);
+ SIMIX_action_destroy(dummy);
+ SIMIX_cond_destroy(cond);
}
- else {
- /* process executing, I can create an action and suspend it */
- process->simdata->suspended = 1;
- smx_action_t dummy;
- smx_cond_t cond;
- char name[] = "dummy";
-
- cond = SIMIX_cond_init();
- dummy = SIMIX_action_execute(SIMIX_process_get_host(process), name, 0);
- surf_workstation_resource->common_public->set_priority(dummy->simdata->surf_action,0.0);
- SIMIX_register_condition_to_action(dummy,cond);
- SIMIX_register_action_to_condition(dummy,cond);
- __SIMIX_cond_wait(cond);
- //SIMIX_action_destroy(dummy);
- //SIMIX_cond_destroy(cond);
- }
- return ;
+ return;
}
/**
*/
void SIMIX_process_resume(smx_process_t process)
{
- smx_simdata_process_t simdata = NULL;
-
- xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
+ xbt_assert0((process != NULL), "Invalid parameters");
SIMIX_CHECK_HOST();
- if(process == SIMIX_process_self()) {
- return;
- }
-
- simdata = process->simdata;
- if(simdata->mutex) {
- DEBUG0("Resume process blocked on a mutex");
- simdata->suspended = 0; /* He'll wake up by itself */
- return;
+ if (process == SIMIX_process_self())
+ return;
+
+ if (process->mutex) {
+ DEBUG0("Resume process blocked on a mutex");
+ process->suspended = 0; /* It'll wake up by itself when mutex releases */
+ return;
+ } else if (process->cond) {
+ /* temporaries variables */
+ smx_cond_t c;
+ xbt_fifo_item_t i;
+ smx_action_t act;
+ DEBUG0("Resume process blocked on a conditional");
+ process->suspended = 0;
+ c = process->cond;
+ xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
+ surf_workstation_model->resume(act->surf_action);
+ }
+ SIMIX_cond_signal(c);
+ return;
+ } else {
+ process->suspended = 0;
+ xbt_swag_insert(process, simix_global->process_to_run);
}
- else if (simdata->cond) {
- DEBUG0("Resume process blocked on a conditional");
- /* temporaries variables */
- smx_cond_t c;
- xbt_fifo_item_t i;
- smx_action_t act;
- simdata->suspended = 0;
- c = simdata->cond;
- xbt_fifo_foreach(c->actions,i,act, smx_action_t) {
- surf_workstation_resource->common_public->resume(act->simdata->surf_action);
- }
- return;
- }
- else {
- simdata->suspended = 0;
- xbt_swag_insert(process,simix_global->process_to_run);
- }
+}
+/**
+ * \brief Migrates an agent to another location.
+ *
+ * This function changes the value of the host on which \a process is running.
+ */
+void SIMIX_process_change_host(smx_process_t process, char *source,
+ char *dest)
+{
+ xbt_assert0((process != NULL), "Invalid parameters");
+ smx_host_t h1 = SIMIX_host_get_by_name(source);
+ smx_host_t h2 = SIMIX_host_get_by_name(dest);
+ process->smx_host = h2;
+ xbt_swag_remove(process, h1->process_list);
+ xbt_swag_insert(process, h2->process_list);
}
/**
*/
int SIMIX_process_is_suspended(smx_process_t process)
{
- xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
+ xbt_assert0((process != NULL), "Invalid parameters");
- return (process->simdata->suspended);
+ return (process->suspended);
}
-
-/* Helper functions for jMSG: manipulate the context data without breaking the module separation */
-#include "xbt/context.h" /* to pass java objects from MSG to the context */
-void SIMIX_process_set_jprocess(smx_process_t process, void *jp) {
- xbt_context_set_jprocess(process->simdata->context,jp);
-}
-void* SIMIX_process_get_jprocess(smx_process_t process) {
- return xbt_context_get_jprocess(process->simdata->context);
+/**
+ * \brief Returns the amount of SIMIX processes in the system
+ *
+ * Maestro internal process is not counted, only user code processes are
+ */
+int SIMIX_process_count()
+{
+ return xbt_swag_size(simix_global->process_list);
}
-void SIMIX_process_set_jmutex(smx_process_t process, void *jm) {
- xbt_context_set_jmutex(process->simdata->context,jm);
-}
-void* SIMIX_process_get_jmutex(smx_process_t process) {
- return xbt_context_get_jmutex(process->simdata->context);
-}
+/**
+ * Calling this function makes the process process to yield. The process
+ * that scheduled it returns from __SIMIX_process_schedule as if nothing
+ * had happened.
+ *
+ * Only the processes can call this function, giving back the control
+ * to the maestro
+ */
+void SIMIX_process_yield(void)
+{
+ DEBUG1("Yield process '%s'", simix_global->current_process->name);
+ xbt_assert0((simix_global->current_process !=
+ simix_global->maestro_process),
+ "You are not supposed to run this function in maestro context!");
-void SIMIX_process_set_jcond(smx_process_t process, void *jc) {
- xbt_context_set_jcond(process->simdata->context,jc);
-}
-void* SIMIX_process_get_jcond(smx_process_t process) {
- return xbt_context_get_jcond(process->simdata->context);
+ SIMIX_context_suspend(simix_global->current_process->context);
+
+ if (simix_global->current_process->iwannadie)
+ SIMIX_context_stop(simix_global->current_process->context);
}
-void SIMIX_process_set_jenv(smx_process_t process, void *je) {
- xbt_context_set_jenv(process->simdata->context,je);
+void SIMIX_process_schedule(smx_process_t new_process)
+{
+ DEBUG1("Scheduling context: '%s'", new_process->name);
+
+ /* save the current process */
+ smx_process_t old_process = simix_global->current_process;
+
+ /* update the current process */
+ simix_global->current_process = new_process;
+
+ /* schedule the context */
+ SIMIX_context_resume(old_process->context, new_process->context);
+
+ /* restore the current process to the previously saved process */
+ simix_global->current_process = old_process;
}
-void* SIMIX_process_get_jenv(smx_process_t process) {
- return xbt_context_get_jenv(process->simdata->context);
+
+/* callback: context fetching */
+ex_ctx_t *SIMIX_process_get_exception(void)
+{
+ return simix_global->current_process->exception;
}
+/* callback: termination */
+void SIMIX_process_exception_terminate(xbt_ex_t * e)
+{
+ xbt_ex_display(e);
+ abort();
+}
