X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/509e8eaf9d87061013538f79a0fba44865c58c0a..986fb5fef4507d37b47b9ff8ee5ba5c26e8a5cee:/src/simix/smx_process.c diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c index a970cdf166..ee203f4dd3 100644 --- a/src/simix/smx_process.c +++ b/src/simix/smx_process.c @@ -1,6 +1,5 @@ -//* $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. */ @@ -10,441 +9,529 @@ #include "xbt/log.h" #include "xbt/dict.h" #include "msg/mailbox.h" +#include "mc/mc.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix, "Logging specific to SIMIX (process)"); -/******************************** Process ************************************/ +static unsigned long simix_process_count = 0; + /** - * \brief Creates and runs a new #smx_process_t. + * \brief Returns the current agent. + * + * This functions returns the currently running SIMIX process. * - * 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 + * \return The SIMIX process */ +XBT_INLINE smx_process_t SIMIX_process_self(void) +{ + if (simix_global) + return SIMIX_context_get_data(SIMIX_context_self()); + return NULL; +} -void SIMIX_process_cleanup(void *arg) +/** + * \brief Move a process to the list of processes to destroy. + */ +void SIMIX_process_cleanup(smx_process_t 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->smx_host-> - simdata->process_list); - free(((smx_process_t) arg)->name); - ((smx_process_t) arg)->name = NULL; + DEBUG1("Cleanup process %s", process->name); + xbt_swag_remove(process, simix_global->process_to_run); + xbt_swag_remove(process, simix_global->process_list); + xbt_swag_remove(process, process->smx_host->process_list); + xbt_swag_insert(process, simix_global->process_to_destroy); +} - free(((smx_process_t) arg)->simdata); - ((smx_process_t) arg)->simdata = NULL; - free(arg); +/** + * Garbage collection + * + * 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); + + /* Free the exception allocated at creation time */ + if (process->running_ctx) + free(process->running_ctx); + if (process->properties) + xbt_dict_free(&process->properties); + + free(process->name); + process->name = NULL; + free(process); + } } /** - * \brief Creates and runs a new #smx_process_t. + * \brief Creates and runs the maestro process + */ +void SIMIX_create_maestro_process() +{ + smx_process_t maestro = NULL; + + /* Create maestro process and intilialize it */ + maestro = xbt_new0(s_smx_process_t, 1); + maestro->pid = simix_process_count++; + maestro->name = (char *) ""; + maestro->running_ctx = xbt_new(xbt_running_ctx_t, 1); + XBT_RUNNING_CTX_INITIALIZE(maestro->running_ctx); + maestro->context = SIMIX_context_new(NULL, 0, NULL, NULL, maestro); + + simix_global->maestro_process = maestro; + return; +} + +/** + * \brief Same as SIMIX_process_create() but with only one argument (used by timers). + * \return the process created + */ +smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args) { + + smx_process_t process; + + if (simix_global->create_process_function) { + process = simix_global->create_process_function(args->name, + args->code, + args->data, + args->hostname, + args->argc, + args->argv, + args->properties); + } + else { + process = SIMIX_process_create(args->name, + args->code, + args->data, + args->hostname, + args->argc, + args->argv, + args->properties); + } + // FIXME: to simplify this, simix_global->create_process_function could just + // be SIMIX_process_create() by default (and the same thing in smx_deployment.c) + + return process; +} + +/** + * \brief Internal function to create a process. * - * 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. + * This function actually creates the process. + * It may be called when a REQ_PROCESS_CREATE request occurs, + * or directly for SIMIX internal purposes. * - * \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 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. - * \see smx_process_t - * \return The new corresponding object. + * \return the process created */ smx_process_t SIMIX_process_create(const char *name, - xbt_main_func_t code, void *data, - const char *hostname, int argc, - char **argv, xbt_dict_t properties) -{ - smx_simdata_process_t simdata = NULL; + xbt_main_func_t code, + void *data, + const char *hostname, + int argc, char **argv, + xbt_dict_t properties) { + smx_process_t process = NULL; - smx_process_t self = NULL; smx_host_t host = SIMIX_host_get_by_name(hostname); - DEBUG2("Start process %s on host %s",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; + WARN2("Cannot launch process '%s' on failed host '%s'", name, + hostname); } - simdata = xbt_new0(s_smx_simdata_process_t, 1); - process = xbt_new0(s_smx_process_t, 1); - /*char alias[MAX_ALIAS_NAME + 1] = {0}; - msg_mailbox_t mailbox; */ - - xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters"); - /* Simulator Data */ - - simdata->smx_host = host; - simdata->mutex = NULL; - simdata->cond = NULL; - simdata->argc = argc; - simdata->argv = argv; - simdata->context = xbt_context_new(name, code, NULL, NULL, - simix_global->cleanup_process_function, - process, simdata->argc, simdata->argv); - - /* Process structure */ - process->name = xbt_strdup(name); - process->simdata = simdata; - process->data = data; + else { + process = xbt_new0(s_smx_process_t, 1); + + xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters"); - /* Add properties */ - simdata->properties = properties; + /* Process data */ + process->pid = simix_process_count++; + process->name = xbt_strdup(name); + process->smx_host = host; + process->data = data; - xbt_swag_insert(process, host->simdata->process_list); + VERB1("Create context %s", process->name); + process->context = SIMIX_context_new(code, argc, argv, + simix_global->cleanup_process_function, process); - /* fix current_process, about which xbt_context_start mocks around */ - self = simix_global->current_process; - xbt_context_start(process->simdata->context); - simix_global->current_process = self; + process->running_ctx = xbt_new(xbt_running_ctx_t, 1); + XBT_RUNNING_CTX_INITIALIZE(process->running_ctx); - 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); + /* Add properties */ + process->properties = properties; - /*sprintf(alias,"%s:%s",hostname,process->name); + /* Add the process to it's host process list */ + xbt_swag_insert(process, host->process_list); - mailbox = MSG_mailbox_new(alias); - MSG_mailbox_set_hostname(mailbox, hostname); */ + DEBUG1("Start context '%s'", process->name); + + /* 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 Creates and runs a new #smx_process_t hosting a JAVA thread + * \brief Internal function to kill a SIMIX process. * - * Warning: this should only be used in libsimgrid4java, since it create - * a context with no code, which leads to segfaults in plain libsimgrid + * This function may be called when a REQ_PROCESS_KILL request occurs, + * or directly for SIMIX internal purposes. + * + * \param process poor victim */ -void SIMIX_jprocess_create(const char *name, smx_host_t host, - void *data, - void *jprocess, void *jenv, smx_process_t * res) -{ - 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; - - /* HACK: We need this trick because when we xbt_context_new() do - syncronization stuff, the s_process field in the m_process needs - to have a valid value, and we call xbt_context_new() before - returning, of course, ie, before providing a right value to the - caller (Java_simgrid_msg_Msg_processCreate) have time to store it - in place. This way, we initialize the m_process->simdata->s_process - field ourself ASAP. - - All this would be much simpler if the synchronization stuff would be done - in the JAVA world, I think. - */ - *res = process; - - - - 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->smx_host = host; - simdata->mutex = NULL; - simdata->cond = NULL; - simdata->argc = 0; - simdata->argv = NULL; - - - simdata->context = xbt_context_new(name, NULL, NULL, jprocess, - simix_global->cleanup_process_function, - process, - /* argc/argv */ 0, NULL); - - /* Process structure */ - process->name = xbt_strdup(name); - process->simdata = simdata; - process->data = data; +void SIMIX_process_kill(smx_process_t process, smx_process_t killer) { - xbt_swag_insert(process, host->simdata->process_list); + DEBUG2("Killing process %s on %s", process->name, process->smx_host->name); - /* fix current_process, about which xbt_context_start mocks around */ - self = simix_global->current_process; + process->context->iwannadie = 1; + process->blocked = 0; + process->suspended = 0; + /* FIXME: set doexception to 0 also? */ - xbt_context_start(process->simdata->context); + if (process->waiting_action) { - simix_global->current_process = self; + switch (process->waiting_action->type) { - 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); + case SIMIX_ACTION_EXECUTE: + case SIMIX_ACTION_PARALLEL_EXECUTE: + SIMIX_host_execution_destroy(process->waiting_action); + break; -} + case SIMIX_ACTION_COMMUNICATE: + SIMIX_comm_destroy(process->waiting_action); + break; + case SIMIX_ACTION_SLEEP: + SIMIX_process_sleep_destroy(process->waiting_action); + break; -/** \brief Kill a SIMIX process - * - * This function simply kills a \a process... scarry isn't it ? :). - * \param process poor victim + case SIMIX_ACTION_SYNCHRO: + SIMIX_synchro_stop_waiting(process, process->request); + SIMIX_synchro_destroy(process->waiting_action); + break; + + case SIMIX_ACTION_IO: + THROW_UNIMPLEMENTED; + break; + } + } + + /* If I'm killing myself then stop, otherwise schedule the process to kill. */ + if (process == killer) { + SIMIX_context_stop(process->context); + } + else { + xbt_swag_insert(process, simix_global->process_to_run); + } +} + +/** + * \brief Kills all running processes. * + * Only maestro can kill everyone. */ -void SIMIX_process_kill(smx_process_t process) +void SIMIX_process_killall(void) { - smx_simdata_process_t p_simdata = process->simdata; + smx_process_t p = NULL; - DEBUG2("Killing process %s on %s", process->name, - p_simdata->smx_host->name); + while ((p = xbt_swag_extract(simix_global->process_list))) + SIMIX_process_kill(p, SIMIX_process_self()); - /* Cleanup if we were waiting for something */ - if (p_simdata->mutex) - xbt_swag_remove(process, p_simdata->mutex->sleeping); + SIMIX_process_empty_trash(); +} - if (p_simdata->cond) - xbt_swag_remove(process, p_simdata->cond->sleeping); +void SIMIX_process_change_host(smx_process_t process, + const char *source, const char *dest) +{ + smx_host_t h1 = NULL; + smx_host_t h2 = NULL; + xbt_assert0((process != NULL), "Invalid parameters"); + 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); +} - xbt_swag_remove(process, simix_global->process_to_run); - xbt_swag_remove(process, simix_global->process_list); - DEBUG2("%p here! killing %p", simix_global->current_process, process); - xbt_context_kill(process->simdata->context); +void SIMIX_pre_process_suspend(smx_req_t req) +{ + smx_process_t process = req->process_suspend.process; + SIMIX_process_suspend(process, req->issuer); - if (process == SIMIX_process_self()) { - /* I just killed myself */ - xbt_context_yield(); + if (process != req->issuer) { + SIMIX_request_answer(req); } + /* If we are suspending ourselves, then just do not replay the request. */ } -/** - * \brief Return the user data of a #smx_process_t. - * - * This functions checks whether \a process is a valid pointer or not and return the user data associated to \a process if it is possible. - * \param process SIMIX process - * \return A void pointer to the user data - */ -void *SIMIX_process_get_data(smx_process_t process) +void SIMIX_process_suspend(smx_process_t process, smx_process_t issuer) { - xbt_assert0((process != NULL), "Invalid parameters"); + xbt_assert0(process, "Invalid parameters"); + + process->suspended = 1; + + /* If we are suspending another process, and it is waiting on an action, + suspend it's action. */ + if (process != issuer) { + + if (process->waiting_action) { - return (process->data); + switch (process->waiting_action->type) { + + case SIMIX_ACTION_EXECUTE: + case SIMIX_ACTION_PARALLEL_EXECUTE: + SIMIX_host_execution_suspend(process->waiting_action); + break; + + case SIMIX_ACTION_COMMUNICATE: + SIMIX_comm_suspend(process->waiting_action); + break; + + case SIMIX_ACTION_SLEEP: + SIMIX_process_sleep_suspend(process->waiting_action); + break; + + default: + THROW_IMPOSSIBLE; + } + } + } } -/** - * \brief Set the user data of a #m_process_t. - * - * This functions checks whether \a process is a valid pointer or not and set the user data associated to \a process if it is possible. - * \param process SIMIX process - * \param data User data - */ -void SIMIX_process_set_data(smx_process_t process, void *data) +void SIMIX_process_resume(smx_process_t process, smx_process_t issuer) { xbt_assert0((process != NULL), "Invalid parameters"); - //xbt_assert0((process->data == NULL), "Data already set"); - process->data = data; + process->suspended = 0; - return; + /* If we are resuming another process, resume the action it was waiting for + if any. Otherwise add it to the list of process to run in the next round. */ + if (process != issuer) { + + if (process->waiting_action) { + + switch (process->waiting_action->type) { + + case SIMIX_ACTION_EXECUTE: + case SIMIX_ACTION_PARALLEL_EXECUTE: + SIMIX_host_execution_resume(process->waiting_action); + break; + + case SIMIX_ACTION_COMMUNICATE: + SIMIX_comm_resume(process->waiting_action); + break; + + case SIMIX_ACTION_SLEEP: + SIMIX_process_sleep_resume(process->waiting_action); + break; + + default: + THROW_IMPOSSIBLE; + } + } + else { + xbt_swag_insert(process, simix_global->process_to_run); + } + } +} + +int SIMIX_process_count(void) +{ + return xbt_swag_size(simix_global->process_list); +} + +void* SIMIX_process_self_get_data(void) +{ + smx_process_t me = SIMIX_process_self(); + if (!me) { + return NULL; + } + return SIMIX_process_get_data(me); +} + +void SIMIX_process_self_set_data(void *data) +{ + SIMIX_process_set_data(SIMIX_process_self(), data); +} + +void* SIMIX_process_get_data(smx_process_t process) +{ + return process->data; +} + +void SIMIX_process_set_data(smx_process_t process, void *data) +{ + process->data = data; } -/** - * \brief Return the location on which an agent is running. - * - * This functions checks whether \a process is a valid pointer or not and return the m_host_t corresponding to the location on which \a process is running. - * \param process SIMIX process - * \return SIMIX host - */ smx_host_t SIMIX_process_get_host(smx_process_t process) { - xbt_assert0(((process != NULL) - && (process->simdata)), "Invalid parameters"); + return process->smx_host; +} + +/* needs to be public and without request because it is called + by exceptions and logging events */ +const char* SIMIX_process_self_get_name(void) { + + smx_process_t process = SIMIX_process_self(); + if (process == NULL || process == simix_global->maestro_process) + return ""; - return (process->simdata->smx_host); + return SIMIX_process_get_name(process); } -/** - * \brief Return 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 - * \return The process name - */ -const char *SIMIX_process_get_name(smx_process_t process) +const char* SIMIX_process_get_name(smx_process_t process) { - xbt_assert0(((process != NULL) - && (process->simdata)), "Invalid parameters"); + return process->name; +} - return (process->name); +int SIMIX_process_is_suspended(smx_process_t process) +{ + return process->suspended; } -/** - * \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) +int SIMIX_process_is_enabled(smx_process_t process) { - xbt_assert0(((process != NULL) - && (process->simdata)), "Invalid parameters"); + if (process->request && SIMIX_request_is_enabled(process->request)) + return TRUE; - process->name = name; + return FALSE; } -/** \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->simdata->properties; + return process->properties; } -/** - * \brief Return the current agent. - * - * This functions returns the currently running #smx_process_t. - * \return The SIMIX process - */ -smx_process_t SIMIX_process_self(void) +void SIMIX_pre_process_sleep(smx_req_t req) { - return simix_global ? simix_global->current_process : NULL; + if (MC_IS_ENABLED) { + req->process_sleep.result = SIMIX_DONE; + SIMIX_request_answer(req); + } + smx_action_t action = SIMIX_process_sleep(req->issuer, req->process_sleep.duration); + xbt_fifo_push(action->request_list, req); + req->issuer->waiting_action = action; } -/** - * \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 - */ -void SIMIX_process_suspend(smx_process_t process) +smx_action_t SIMIX_process_sleep(smx_process_t process, double duration) { - smx_simdata_process_t simdata = NULL; - - xbt_assert0(((process) && (process->simdata)), "Invalid parameters"); + smx_action_t action; + smx_host_t host = process->smx_host; + + /* check if the host is active */ + if (surf_workstation_model->extension. + workstation.get_state(host->host) != SURF_RESOURCE_ON) { + THROW1(host_error, 0, "Host %s failed, you cannot call this function", + host->name); + } - if (process != SIMIX_process_self()) { - simdata = process->simdata; + action = xbt_new0(s_smx_action_t, 1); + action->type = SIMIX_ACTION_SLEEP; + action->request_list = xbt_fifo_new(); + action->name = xbt_strdup("sleep"); +#ifdef HAVE_TRACING + action->category = NULL; +#endif - 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 */ + action->sleep.host = host; + action->sleep.surf_sleep = + surf_workstation_model->extension.workstation.sleep(host->host, duration); - /* temporaries variables */ - smx_cond_t c; - xbt_fifo_item_t i; - smx_action_t act; + surf_workstation_model->action_data_set(action->sleep.surf_sleep, action); + DEBUG1("Create sleep action %p", action); - simdata->suspended = 1; - c = simdata->cond; - xbt_fifo_foreach(c->actions, i, act, smx_action_t) { - surf_workstation_model->common_public.suspend(act-> - simdata->surf_action); - } - } else { - simdata->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->simdata->suspended = 1; - - cond = SIMIX_cond_init(); - dummy = SIMIX_action_execute(SIMIX_process_get_host(process), name, 0); - surf_workstation_model->common_public.suspend(dummy->simdata-> - surf_action); - SIMIX_register_action_to_condition(dummy, cond); - __SIMIX_cond_wait(cond); - SIMIX_unregister_action_to_condition(dummy, cond); - SIMIX_action_destroy(dummy); - SIMIX_cond_destroy(cond); - } - return; + return action; } -/** - * \brief Resume a suspended process. - * - * This functions resume a suspended process by resuming the task on which it was waiting for the completion. - * \param process SIMIX process - */ -void SIMIX_process_resume(smx_process_t process) +void SIMIX_post_process_sleep(smx_action_t action) { - smx_simdata_process_t simdata = NULL; - - xbt_assert0(((process != NULL) - && (process->simdata)), "Invalid parameters"); - SIMIX_CHECK_HOST(); + e_smx_state_t state = SIMIX_action_map_state(surf_workstation_model->action_state_get(action->sleep.surf_sleep)); + smx_req_t req; - if (process == SIMIX_process_self()) { - return; + while ((req = xbt_fifo_shift(action->request_list))) { + req->process_sleep.result = state; + req->issuer->waiting_action = NULL; + SIMIX_request_answer(req); } - simdata = process->simdata; - if (simdata->mutex) { - DEBUG0("Resume process blocked on a mutex"); - simdata->suspended = 0; /* It'll wake up by itself when mutex releases */ - return; - } else if (simdata->cond) { - /* temporaries variables */ - smx_cond_t c; - xbt_fifo_item_t i; - smx_action_t act; - DEBUG0("Resume process blocked on a conditional"); - simdata->suspended = 0; - c = simdata->cond; - xbt_fifo_foreach(c->actions, i, act, smx_action_t) { - surf_workstation_model->common_public.resume(act->simdata-> - surf_action); - } - SIMIX_cond_signal(c); - return; - } else { - simdata->suspended = 0; - xbt_swag_insert(process, simix_global->process_to_run); - } + SIMIX_process_sleep_destroy(action); +} +void SIMIX_process_sleep_destroy(smx_action_t action) +{ + DEBUG1("Destroy action %p", action); + if (action->name) + xbt_free(action->name); + if (action->sleep.surf_sleep) + action->sleep.surf_sleep->model_type->action_unref(action->sleep.surf_sleep); +#ifdef HAVE_TRACING + TRACE_smx_action_destroy(action); +#endif + xbt_fifo_free(action->request_list); + xbt_free(action); } -/** - * \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) +void SIMIX_process_sleep_suspend(smx_action_t action) { - smx_simdata_process_t p_simdata = process->simdata; - smx_host_t h1 = SIMIX_host_get_by_name(source); - smx_host_t h2 = SIMIX_host_get_by_name(dest); - p_simdata->smx_host = h2; - xbt_swag_remove(process, h1->simdata->process_list); - xbt_swag_insert(process, h2->simdata->process_list); + surf_workstation_model->suspend(action->sleep.surf_sleep); } -/** - * \brief Returns true if the process is suspended . - * - * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion. - * \param process SIMIX process - * \return 1, if the process is suspended, else 0. +void SIMIX_process_sleep_resume(smx_action_t action) +{ + surf_workstation_model->resume(action->sleep.surf_sleep); +} + +/** + * Calling this function makes the process to yield. + * Only the processes can call this function, giving back the control to maestro */ -int SIMIX_process_is_suspended(smx_process_t process) +void SIMIX_process_yield(void) { - xbt_assert0(((process != NULL) - && (process->simdata)), "Invalid parameters"); + smx_process_t self = SIMIX_process_self(); + + DEBUG1("Yield process '%s'", self->name); + + /* Go into sleep and return control to maestro */ + SIMIX_context_suspend(self->context); + + /* Ok, maestro returned control to us */ + DEBUG1("Maestro returned control to me: '%s'", self->name); - return (process->simdata->suspended); + if (self->context->iwannadie) + SIMIX_context_stop(self->context); + + if (self->doexception) { + DEBUG0("Wait, maestro left me an exception"); + self->doexception = 0; + RETHROW; + } } -/** - * \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); +/* callback: context fetching */ +xbt_running_ctx_t *SIMIX_process_get_running_context(void) +{ + return SIMIX_process_self()->running_ctx; } +/* callback: termination */ +void SIMIX_process_exception_terminate(xbt_ex_t * e) +{ + xbt_ex_display(e); + abort(); +} + +smx_context_t SIMIX_process_get_context(smx_process_t p) { + return p->context; +} +void SIMIX_process_set_context(smx_process_t p,smx_context_t c) { + p->context = c; +}