X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4e651064c117835e8a9340bc416a6dc1781cc56d..75b61335a13287f7a038935382966855d3a7098e:/src/simix/smx_process.c diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c index ac73df56c1..0020a7ac6d 100644 --- a/src/simix/smx_process.c +++ b/src/simix/smx_process.c @@ -4,11 +4,10 @@ /* 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. */ -#include "private.h" +#include "smx_private.h" #include "xbt/sysdep.h" #include "xbt/log.h" #include "xbt/dict.h" -#include "msg/mailbox.h" #include "mc/mc.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix, @@ -31,7 +30,16 @@ XBT_INLINE smx_process_t SIMIX_process_self(void) } /** - * \brief Move a process to the list of processes to destroy. + * \brief Returns whether a process has pending asynchronous communications. + * \return true if there are asynchronous communications in this process + */ +int SIMIX_process_has_pending_comms(smx_process_t process) { + + return xbt_fifo_size(process->comms) > 0; +} + +/** + * \brief Moves a process to the list of processes to destroy. */ void SIMIX_process_cleanup(smx_process_t process) { @@ -42,38 +50,53 @@ void SIMIX_process_cleanup(smx_process_t process) smx_action_t action; while ((action = xbt_fifo_pop(process->comms))) { - /* make sure no one will finish the comm after this process is destroyed */ + /* make sure no one will finish the comm after this process is destroyed, + * because src_proc or dst_proc would be an invalid pointer */ SIMIX_comm_cancel(action); if (action->comm.src_proc == process) { - XBT_DEBUG("Found an unfinished send comm %p (detached = %d), state %d", - action, action->comm.detached, action->state); + XBT_DEBUG("Found an unfinished send comm %p (detached = %d), state %d, src = %p, dst = %p", + action, action->comm.detached, (int)action->state, action->comm.src_proc, action->comm.dst_proc); action->comm.src_proc = NULL; if (action->comm.detached) { - /* the receiver was supposed to destroy the comm after completion, - * but the comm will actually never finish */ - action->comm.refcount++; + if (action->comm.refcount == 0) { + XBT_DEBUG("Increase the refcount before destroying it since it's detached"); + /* I'm not supposed to destroy a detached comm from the sender side, + * unless there is no receiver matching the rdv */ + action->comm.refcount++; + SIMIX_comm_destroy(action); + } + else { + XBT_DEBUG("Don't destroy it since its refcount is %d", action->comm.refcount); + } + } else { + SIMIX_comm_destroy(action); } } else if (action->comm.dst_proc == process){ - XBT_DEBUG("Found an unfinished recv comm %p, state %d", action, action->state); + XBT_DEBUG("Found an unfinished recv comm %p, state %d, src = %p, dst = %p", + action, (int)action->state, action->comm.src_proc, action->comm.dst_proc); action->comm.dst_proc = NULL; + + if (action->comm.detached && action->comm.refcount == 1 + && action->comm.src_proc != NULL) { + /* the comm will be freed right now, remove it from the sender */ + xbt_fifo_remove(action->comm.src_proc->comms, action); + } + SIMIX_comm_destroy(action); } else { - XBT_DEBUG("Strange, I'm not in comm %p, state = %d, src = %p, dst = %p", action, - action->state, action->comm.src_proc, action->comm.dst_proc); - THROW_IMPOSSIBLE; + xbt_die("Communication action %p is in my list but I'm not the sender " + "or the receiver", action); } - - /* FIXME uncommenting this instruction crashes complex simulations - SIMIX_comm_destroy(action); */ } /*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); + process->context->iwannadie = 0; } /** @@ -90,15 +113,14 @@ void SIMIX_process_empty_trash(void) 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->running_ctx); + xbt_dict_free(&process->properties); xbt_fifo_free(process->comms); + xbt_dynar_free(&process->on_exit); + free(process->name); - process->name = NULL; free(process); } } @@ -117,7 +139,7 @@ void SIMIX_create_maestro_process() 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); - maestro->request.issuer = maestro; + maestro->simcall.issuer = maestro; simix_global->maestro_process = maestro; return; @@ -136,6 +158,7 @@ smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args) { args->code, args->data, args->hostname, + args->kill_time, args->argc, args->argv, args->properties); @@ -147,8 +170,8 @@ smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args) { * \brief Internal function to create a process. * * This function actually creates the process. - * It may be called when a REQ_PROCESS_CREATE request occurs, - * or directly for SIMIX internal purposes. + * It may be called when a SIMCALL_PROCESS_CREATE simcall occurs, + * or directly for SIMIX internal purposes. The sure thing is that it's called from maestro context. * * \return the process created */ @@ -157,6 +180,7 @@ void SIMIX_process_create(smx_process_t *process, xbt_main_func_t code, void *data, const char *hostname, + double kill_time, int argc, char **argv, xbt_dict_t properties) { @@ -180,10 +204,11 @@ void SIMIX_process_create(smx_process_t *process, (*process)->smx_host = host; (*process)->data = data; (*process)->comms = xbt_fifo_new(); + (*process)->simcall.issuer = *process; XBT_VERB("Create context %s", (*process)->name); (*process)->context = SIMIX_context_new(code, argc, argv, - simix_global->cleanup_process_function, *process); + simix_global->cleanup_process_function, *process); (*process)->running_ctx = xbt_new(xbt_running_ctx_t, 1); XBT_RUNNING_CTX_INITIALIZE((*process)->running_ctx); @@ -201,6 +226,14 @@ void SIMIX_process_create(smx_process_t *process, XBT_DEBUG("Inserting %s(%s) in the to_run list", (*process)->name, host->name); xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, *process); } + + if (kill_time > SIMIX_get_clock()) { + if (simix_global->kill_process_function) { + XBT_DEBUG("Process %s(%s) will be kill at time %f", (*process)->name, + (*process)->smx_host->name, kill_time); + SIMIX_timer_set(kill_time, simix_global->kill_process_function, *process); + } + } } /** @@ -214,7 +247,8 @@ void SIMIX_process_create(smx_process_t *process, */ void SIMIX_process_runall(void) { - SIMIX_context_runall(simix_global->process_to_run); + SIMIX_context_runall(); + xbt_dynar_t tmp = simix_global->process_that_ran; simix_global->process_that_ran = simix_global->process_to_run; simix_global->process_to_run = tmp; @@ -224,7 +258,7 @@ void SIMIX_process_runall(void) /** * \brief Internal function to kill a SIMIX process. * - * This function may be called when a REQ_PROCESS_KILL request occurs, + * This function may be called when a SIMCALL_PROCESS_KILL simcall occurs, * or directly for SIMIX internal purposes. * * \param process poor victim @@ -249,25 +283,26 @@ void SIMIX_process_kill(smx_process_t process) { break; case SIMIX_ACTION_COMMUNICATE: + xbt_fifo_remove(process->comms, process->waiting_action); SIMIX_comm_destroy(process->waiting_action); break; case SIMIX_ACTION_SLEEP: - SIMIX_process_sleep_destroy(process->waiting_action); - break; + SIMIX_process_sleep_destroy(process->waiting_action); + break; case SIMIX_ACTION_SYNCHRO: - SIMIX_synchro_stop_waiting(process, &process->request); - SIMIX_synchro_destroy(process->waiting_action); - break; + SIMIX_synchro_stop_waiting(process, &process->simcall); + SIMIX_synchro_destroy(process->waiting_action); + break; case SIMIX_ACTION_IO: - THROW_UNIMPLEMENTED; - break; + SIMIX_io_destroy(process->waiting_action); + break; } } - - xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process); + if(!xbt_dynar_member(simix_global->process_to_run, &(process))) + xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process); } /** @@ -284,13 +319,13 @@ void SIMIX_process_killall(smx_process_t issuer) } } - SIMIX_context_runall(simix_global->process_to_run); + SIMIX_context_runall(); SIMIX_process_empty_trash(); } void SIMIX_process_change_host(smx_process_t process, - smx_host_t dest) + smx_host_t dest) { xbt_assert((process != NULL), "Invalid parameters"); xbt_swag_remove(process, process->smx_host->process_list); @@ -303,30 +338,35 @@ void SIMIX_pre_process_change_host(smx_process_t process, smx_host_t dest) process->new_host = dest; } -void SIMIX_pre_process_suspend(smx_req_t req) +void SIMIX_pre_process_suspend(smx_simcall_t simcall) { - smx_process_t process = req->process_suspend.process; - SIMIX_process_suspend(process, req->issuer); - - if (process != req->issuer) { - SIMIX_request_answer(req); + smx_process_t process = simcall->process_suspend.process; + smx_action_t action_suspend = + SIMIX_process_suspend(process, simcall->issuer); + + if (process != simcall->issuer) { + SIMIX_simcall_answer(simcall); + } else { + xbt_fifo_push(action_suspend->simcalls, simcall); + process->waiting_action = action_suspend; + SIMIX_host_execution_suspend(process->waiting_action); } - /* If we are suspending ourselves, then just do not replay the request. */ + /* If we are suspending ourselves, then just do not finish the simcall now */ } -void SIMIX_process_suspend(smx_process_t process, smx_process_t issuer) +smx_action_t SIMIX_process_suspend(smx_process_t process, smx_process_t issuer) { xbt_assert((process != NULL), "Invalid parameters"); if (process->suspended) { XBT_DEBUG("Process '%s' is already suspended", process->name); - return; + return NULL; } process->suspended = 1; /* If we are suspending another process, and it is waiting on an action, - suspend it's action. */ + suspend its action. */ if (process != issuer) { if (process->waiting_action) { @@ -346,10 +386,21 @@ void SIMIX_process_suspend(smx_process_t process, smx_process_t issuer) SIMIX_process_sleep_suspend(process->waiting_action); break; + case SIMIX_ACTION_SYNCHRO: + /* Suspension is delayed to when the process is rescheduled. */ + break; + default: - THROW_IMPOSSIBLE; + xbt_die("Internal error in SIMIX_process_suspend: unexpected action type %d", + (int)process->waiting_action->type); } + return NULL; + } else { + /* Suspension is delayed to when the process is rescheduled. */ + return NULL; } + } else { + return SIMIX_host_execute("suspend", process->smx_host, 0.0, 1.0); } } @@ -357,11 +408,14 @@ void SIMIX_process_resume(smx_process_t process, smx_process_t issuer) { xbt_assert((process != NULL), "Invalid parameters"); - if (!process->suspended) { - XBT_DEBUG("Process '%s' is not suspended", process->name); + XBT_IN("process = %p, issuer = %p", process, issuer); + + if(process->context->iwannadie) { + XBT_VERB("Ignoring request to suspend a process that is currently dying."); return; } + if(!process->suspended) return; process->suspended = 0; /* If we are resuming another process, resume the action it was waiting for @@ -385,14 +439,19 @@ void SIMIX_process_resume(smx_process_t process, smx_process_t issuer) SIMIX_process_sleep_resume(process->waiting_action); break; + case SIMIX_ACTION_SYNCHRO: + /* I cannot resume it now. This is delayed to when the process is rescheduled at + * the end of the synchro. */ + break; + default: - THROW_IMPOSSIBLE; + xbt_die("Internal error in SIMIX_process_resume: unexpected action type %d", + (int)process->waiting_action->type); } } - else { - xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process); - } - } + } else XBT_WARN("Strange. Process %p is trying to resume himself.", issuer); + + XBT_OUT(); } int SIMIX_process_get_maxpid(void) { @@ -404,18 +463,21 @@ int SIMIX_process_count(void) return xbt_swag_size(simix_global->process_list); } -void* SIMIX_process_self_get_data(void) +void* SIMIX_process_self_get_data(smx_process_t self) { - smx_process_t me = SIMIX_process_self(); - if (!me) { + xbt_assert(self == SIMIX_process_self(), "This is not the current process"); + + if (!self) { return NULL; } - return SIMIX_process_get_data(me); + return SIMIX_process_get_data(self); } -void SIMIX_process_self_set_data(void *data) +void SIMIX_process_self_set_data(smx_process_t self, void *data) { - SIMIX_process_set_data(SIMIX_process_self(), data); + xbt_assert(self == SIMIX_process_self(), "This is not the current process"); + + SIMIX_process_set_data(self, data); } void* SIMIX_process_get_data(smx_process_t process) @@ -433,7 +495,7 @@ smx_host_t SIMIX_process_get_host(smx_process_t process) return process->smx_host; } -/* needs to be public and without request because it is called +/* needs to be public and without simcall because it is called by exceptions and logging events */ const char* SIMIX_process_self_get_name(void) { @@ -471,17 +533,17 @@ xbt_dict_t SIMIX_process_get_properties(smx_process_t process) return process->properties; } -void SIMIX_pre_process_sleep(smx_req_t req) +void SIMIX_pre_process_sleep(smx_simcall_t simcall) { if (MC_IS_ENABLED) { - MC_process_clock_add(req->issuer, req->process_sleep.duration); - req->process_sleep.result = SIMIX_DONE; - SIMIX_request_answer(req); + MC_process_clock_add(simcall->issuer, simcall->process_sleep.duration); + simcall->process_sleep.result = SIMIX_DONE; + SIMIX_simcall_answer(simcall); return; } - 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; + smx_action_t action = SIMIX_process_sleep(simcall->issuer, simcall->process_sleep.duration); + xbt_fifo_push(action->simcalls, simcall); + simcall->issuer->waiting_action = action; } smx_action_t SIMIX_process_sleep(smx_process_t process, double duration) @@ -515,14 +577,14 @@ smx_action_t SIMIX_process_sleep(smx_process_t process, double duration) void SIMIX_post_process_sleep(smx_action_t action) { - smx_req_t req; + smx_simcall_t simcall; e_smx_state_t state; - while ((req = xbt_fifo_shift(action->request_list))) { + while ((simcall = xbt_fifo_shift(action->simcalls))) { switch(surf_workstation_model->action_state_get(action->sleep.surf_sleep)){ case SURF_ACTION_FAILED: - state = SIMIX_SRC_HOST_FAILURE; + SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed"); break; case SURF_ACTION_DONE: @@ -533,9 +595,9 @@ void SIMIX_post_process_sleep(smx_action_t action) THROW_IMPOSSIBLE; break; } - req->process_sleep.result = state; - req->issuer->waiting_action = NULL; - SIMIX_request_answer(req); + simcall->process_sleep.result = state; + simcall->issuer->waiting_action = NULL; + SIMIX_simcall_answer(simcall); } SIMIX_process_sleep_destroy(action); } @@ -559,35 +621,43 @@ void SIMIX_process_sleep_resume(smx_action_t action) } /** - * Calling this function makes the process to yield. - * Only the processes can call this function, giving back the control to maestro + * \brief Calling this function makes the process to yield. + * + * Only the current process can call this function, giving back the control to + * maestro. + * + * \param self the current process */ -void SIMIX_process_yield(void) +void SIMIX_process_yield(smx_process_t self) { - smx_process_t self = SIMIX_process_self(); - XBT_DEBUG("Yield process '%s'", self->name); /* Go into sleep and return control to maestro */ SIMIX_context_suspend(self->context); /* Ok, maestro returned control to us */ - XBT_DEBUG("Maestro returned control to me: '%s'", self->name); + XBT_DEBUG("Control returned to me: '%s'", self->name); + + if (self->new_host) { + SIMIX_process_change_host(self, self->new_host); + self->new_host = NULL; + } if (self->context->iwannadie){ XBT_DEBUG("I wanna die!"); SIMIX_context_stop(self->context); } + if(self->suspended) { + xbt_assert(!self->doexception, "Gloups! This exception may be lost by subsequent calls."); + self->suspended = 0; + SIMIX_process_suspend(self,self); + } + if (self->doexception) { XBT_DEBUG("Wait, maestro left me an exception"); self->doexception = 0; - RETHROW; - } - - if (self->new_host) { - SIMIX_process_change_host(self, self->new_host); - self->new_host = NULL; + SMX_THROW(); } } @@ -611,3 +681,55 @@ smx_context_t SIMIX_process_get_context(smx_process_t p) { void SIMIX_process_set_context(smx_process_t p,smx_context_t c) { p->context = c; } + +/** + * \brief Returns the list of processes to run. + */ +xbt_dynar_t SIMIX_process_get_runnable(void) +{ + return simix_global->process_to_run; +} + +/** + * \brief Returns the process from PID. + */ +smx_process_t SIMIX_process_from_PID(int PID) +{ + smx_process_t proc; + xbt_swag_foreach(proc, simix_global->process_list) + { + if(proc->pid == PID) + return proc; + } + return NULL; +} + +/** @brief returns a dynar containg all currently existing processes */ +xbt_dynar_t SIMIX_processes_as_dynar(void) { + smx_process_t proc; + xbt_dynar_t res = xbt_dynar_new(sizeof(smx_process_t),NULL); + xbt_swag_foreach(proc, simix_global->process_list) { + xbt_dynar_push(res,&proc); + } + return res; +} +void SIMIX_process_on_exit_runall(smx_process_t process) { + s_smx_process_exit_fun_t exit_fun; + + while (!xbt_dynar_is_empty(process->on_exit)) { + exit_fun = xbt_dynar_pop_as(process->on_exit,s_smx_process_exit_fun_t); + (exit_fun.fun)(exit_fun.arg); + } +} +void SIMIX_process_on_exit(int_f_pvoid_t fun, void *data) { + smx_process_t process = SIMIX_process_self(); + xbt_assert(process, "current process not found: are you in maestro context ?"); + + if (!process->on_exit) { + process->on_exit = xbt_dynar_new(sizeof(s_smx_process_exit_fun_t), NULL); + } + + s_smx_process_exit_fun_t exit_fun = {fun, data}; + + xbt_dynar_push_as(process->on_exit,s_smx_process_exit_fun_t,exit_fun); +}