-//* $Id$ */
-
-/* Copyright (c) 2002,2003,2004 Arnaud Legrand. All rights reserved. */
+/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+ * All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
/* Free the exception allocated at creation time */
if (process->exception)
free(process->exception);
+ if (process->properties)
+ xbt_dict_free(&process->properties);
free(process->name);
process->name = NULL;
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);
+ WARN2("Cannot launch process '%s' on failed host '%s'", name,
+ hostname);
return NULL;
}
process = xbt_new0(s_smx_process_t, 1);
xbt_swag_insert(process, host->process_list);
DEBUG1("Start context '%s'", process->name);
- SIMIX_context_start(process->context);
/* Now insert it in the global process list and in the process to run list */
xbt_swag_insert(process, simix_global->process_list);
*/
void SIMIX_process_kill(smx_process_t process)
{
- DEBUG2("Killing process %s on %s", process->name, process->smx_host->name);
+ DEBUG2("Killing process %s on %s", process->name,
+ process->smx_host->name);
process->iwannadie = 1;
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_unregister_action_to_condition(process->waiting_action,
+ process->cond);
SIMIX_action_destroy(process->waiting_action);
}
+
+ if (process->sem) {
+ xbt_fifo_remove(process->sem->sleeping, process);
+
+ if (process->waiting_action) {
+ SIMIX_unregister_action_to_semaphore(process->waiting_action,
+ process->sem);
+ 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)
+ DEBUG4("%s(%p) here! killing %s(%p)",
+ simix_global->current_process->name,
+ simix_global->current_process, process->name, process);
+
+ /* Cleanup if it were waiting for something */
+ if (process->mutex) {
xbt_swag_remove(process, process->mutex->sleeping);
+ process->mutex = NULL;
+ }
- if (process->cond)
+ 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);
+ if (process->waiting_action) {
+ SIMIX_unregister_action_to_condition(process->waiting_action,
+ process->cond);
+ SIMIX_action_destroy(process->waiting_action);
+ }
+ process->cond = NULL;
+ }
+
+ if (process->sem) {
+ xbt_fifo_remove(process->sem->sleeping, process);
+
+ if (process->waiting_action) {
+ SIMIX_unregister_action_to_semaphore(process->waiting_action,
+ process->sem);
+ SIMIX_action_destroy(process->waiting_action);
+ }
+ process->sem = NULL;
}
+
+ /* make sure that the process gets awake soon enough, now that we've set its iwannadie to 1 */
+ process->blocked = 0;
+ process->suspended = 0;
+ xbt_swag_insert(process, simix_global->process_to_run);
}
}
* \param process SIMIX process
* \return A void pointer to the user data
*/
-void *SIMIX_process_get_data(smx_process_t process)
+XBT_INLINE 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)
+XBT_INLINE void SIMIX_process_set_data(smx_process_t process, void *data)
{
xbt_assert0((process != NULL), "Invalid parameters");
* \param process SIMIX process
* \return SIMIX host
*/
-smx_host_t SIMIX_process_get_host(smx_process_t process)
+XBT_INLINE smx_host_t SIMIX_process_get_host(smx_process_t process)
{
xbt_assert0((process != NULL), "Invalid parameters");
return (process->smx_host);
* \param process SIMIX process
* \return The process name
*/
-const char *SIMIX_process_get_name(smx_process_t process)
+XBT_INLINE const char *SIMIX_process_get_name(smx_process_t process)
{
xbt_assert0((process != NULL), "Invalid parameters");
return (process->name);
* \param process SIMIX process
* \param name The new process name
*/
-void SIMIX_process_set_name(smx_process_t process, char *name)
+XBT_INLINE void SIMIX_process_set_name(smx_process_t process, char *name)
{
xbt_assert0((process != NULL), "Invalid parameters");
process->name = name;
*
* This functions returns the properties associated with this process
*/
-xbt_dict_t SIMIX_process_get_properties(smx_process_t process)
+XBT_INLINE xbt_dict_t SIMIX_process_get_properties(smx_process_t process)
{
return process->properties;
}
* This functions returns the currently running #smx_process_t.
* \return The SIMIX process
*/
-smx_process_t SIMIX_process_self(void)
+XBT_INLINE smx_process_t SIMIX_process_self(void)
{
- return simix_global ? simix_global->current_process : NULL;
+ if (simix_global)
+ return simix_global->current_process;
+ return NULL;
}
/**
if (process != SIMIX_process_self()) {
if (process->mutex) {
- /* process blocked on a mutex, only set suspend=1 */
+ /* process blocked on a mutex or sem, only set suspend=1 */
process->suspended = 1;
} else if (process->cond) {
/* process blocked cond, suspend all actions */
process->suspended = 1;
c = process->cond;
xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
- surf_workstation_model->suspend(act->surf_action);
+ SIMIX_action_suspend(act);
+ }
+ } else if (process->sem) {
+ smx_sem_t s;
+ xbt_fifo_item_t i;
+ smx_action_t act;
+
+ process->suspended = 1;
+ s = process->sem;
+ xbt_fifo_foreach(s->actions, i, act, smx_action_t) {
+ SIMIX_action_suspend(act);
}
} else {
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_action_suspend(dummy);
SIMIX_register_action_to_condition(dummy, cond);
__SIMIX_cond_wait(cond);
SIMIX_process_self()->waiting_action = NULL;
return;
if (process->mutex) {
- DEBUG0("Resume process blocked on a mutex");
+ DEBUG0("Resume process blocked on a mutex or semaphore");
process->suspended = 0; /* It'll wake up by itself when mutex releases */
return;
} else if (process->cond) {
process->suspended = 0;
c = process->cond;
xbt_fifo_foreach(c->actions, i, act, smx_action_t) {
- surf_workstation_model->resume(act->surf_action);
+ SIMIX_action_resume(act);
}
SIMIX_cond_signal(c);
return;
+ } else if (process->sem) {
+ /* temporaries variables */
+ smx_sem_t s;
+ xbt_fifo_item_t i;
+ smx_action_t act;
+ DEBUG0("Resume process blocked on a semaphore");
+ process->suspended = 0;
+ s = process->sem;
+ xbt_fifo_foreach(s->actions, i, act, smx_action_t) {
+ SIMIX_action_resume(act);
+ }
+ return;
} else {
process->suspended = 0;
xbt_swag_insert(process, simix_global->process_to_run);
void SIMIX_process_change_host(smx_process_t process, char *source,
char *dest)
{
+ smx_host_t h1 = NULL;
+ smx_host_t h2 = NULL;
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);
+ h1 = SIMIX_host_get_by_name(source);
+ 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);
* \param process SIMIX process
* \return 1, if the process is suspended, else 0.
*/
-int SIMIX_process_is_suspended(smx_process_t process)
+XBT_INLINE int SIMIX_process_is_suspended(smx_process_t process)
{
xbt_assert0((process != NULL), "Invalid parameters");
*
* Maestro internal process is not counted, only user code processes are
*/
-int SIMIX_process_count()
+XBT_INLINE int SIMIX_process_count()
{
return xbt_swag_size(simix_global->process_list);
}
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 here!");
+ "You are not supposed to run this function in maestro context!");
+
+ /* Go into sleep and return control to maestro */
SIMIX_context_suspend(simix_global->current_process->context);
+ /* Ok, maestro returned control to us */
if (simix_global->current_process->iwannadie)
SIMIX_context_stop(simix_global->current_process->context);
void SIMIX_process_schedule(smx_process_t new_process)
{
+ xbt_assert0(simix_global->current_process ==
+ simix_global->maestro_process,
+ "This function can only be called from maestro context");
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);
+ SIMIX_context_resume(new_process->context);
+ DEBUG1("Resumed from scheduling context: '%s'", new_process->name);
/* restore the current process to the previously saved process */
- simix_global->current_process = old_process;
+ simix_global->current_process = simix_global->maestro_process;
}
/* callback: context fetching */
