X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fc727903530d55d5d3f903a8213c7cb8a3273c7a..9f66e12669c65c600c935aed2188e92160616c62:/src/simix/smx_process.c diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c index eee6efdd03..a318d30bb2 100644 --- a/src/simix/smx_process.c +++ b/src/simix/smx_process.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team. +/* Copyright (c) 2007-2012. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -38,6 +38,9 @@ int SIMIX_process_has_pending_comms(smx_process_t process) { return xbt_fifo_size(process->comms) > 0; } +void SIMIX_pre_process_cleanup(smx_simcall_t simcall, smx_process_t process) { + SIMIX_process_cleanup(process); +} /** * \brief Moves a process to the list of processes to destroy. */ @@ -94,7 +97,7 @@ void SIMIX_process_cleanup(smx_process_t process) /*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_remove(process, SIMIX_host_priv(process->smx_host)->process_list); xbt_swag_insert(process, simix_global->process_to_destroy); process->context->iwannadie = 0; } @@ -118,6 +121,8 @@ void SIMIX_process_empty_trash(void) xbt_fifo_free(process->comms); + xbt_dynar_free(&process->on_exit); + free(process->name); free(process); } @@ -139,12 +144,43 @@ void SIMIX_create_maestro_process() maestro->context = SIMIX_context_new(NULL, 0, NULL, NULL, maestro); maestro->simcall.issuer = maestro; + if (SIMIX_process_self()) { + maestro->ppid = SIMIX_process_get_PID(SIMIX_process_self()); + } else { + maestro->ppid = -1; + } + simix_global->maestro_process = maestro; return; } +/** + * \brief Stops a process. + * + * Stops the process, execute all the registered on_exit functions, + * register it to the list of the process to restart if needed + * and stops its context. + */ +void SIMIX_process_stop(smx_process_t arg) { + /* execute the on_exit functions */ + SIMIX_process_on_exit_runall(arg); + /* Add the process to the list of process to restart, only if + * the host is down + */ + if (arg->auto_restart && !SIMIX_host_get_state(arg->smx_host)) { + SIMIX_host_add_auto_restart_process(arg->smx_host,arg->name,arg->code, arg->data, + sg_host_name(arg->smx_host), + arg->kill_time, + arg->argc,arg->argv,arg->properties, + arg->auto_restart); + } + XBT_DEBUG("Process %s (%s) is dead",arg->name,sg_host_name(arg->smx_host)); + /* stop the context */ + SIMIX_context_stop(arg->context); +} /** * \brief Same as SIMIX_process_create() but with only one argument (used by timers). + * This function frees the argument. * \return the process created */ smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args) { @@ -159,17 +195,32 @@ smx_process_t SIMIX_process_create_from_wrapper(smx_process_arg_t args) { args->kill_time, args->argc, args->argv, - args->properties); - + args->properties, + args->auto_restart); + xbt_free(args); return process; } + +void SIMIX_pre_process_create(smx_simcall_t simcall, + smx_process_t *process, + const char *name, + xbt_main_func_t code, + void *data, + const char *hostname, + double kill_time, + int argc, char **argv, + xbt_dict_t properties, + int auto_restart){ + return SIMIX_process_create(process, name, code, data, hostname, + kill_time, argc, argv, properties, auto_restart); +} /** * \brief Internal function to create a process. * * This function actually creates the process. * It may be called when a SIMCALL_PROCESS_CREATE simcall occurs, - * or directly for SIMIX internal purposes. + * or directly for SIMIX internal purposes. The sure thing is that it's called from maestro context. * * \return the process created */ @@ -180,12 +231,13 @@ void SIMIX_process_create(smx_process_t *process, const char *hostname, double kill_time, int argc, char **argv, - xbt_dict_t properties) { + xbt_dict_t properties, + int auto_restart) { *process = NULL; smx_host_t host = SIMIX_host_get_by_name(hostname); - XBT_DEBUG("Start process %s on host %s", name, hostname); + XBT_DEBUG("Start process %s on host '%s'", name, hostname); if (!SIMIX_host_get_state(host)) { XBT_WARN("Cannot launch process '%s' on failed host '%s'", name, @@ -195,7 +247,6 @@ void SIMIX_process_create(smx_process_t *process, *process = xbt_new0(s_smx_process_t, 1); xbt_assert(((code != NULL) && (host != NULL)), "Invalid parameters"); - /* Process data */ (*process)->pid = simix_process_maxpid++; (*process)->name = xbt_strdup(name); @@ -203,10 +254,24 @@ void SIMIX_process_create(smx_process_t *process, (*process)->data = data; (*process)->comms = xbt_fifo_new(); (*process)->simcall.issuer = *process; + + if (SIMIX_process_self()) { + (*process)->ppid = SIMIX_process_get_PID(SIMIX_process_self()); + } else { + (*process)->ppid = -1; + } + + /* Process data for auto-restart */ + (*process)->auto_restart = auto_restart; + (*process)->code = code; + (*process)->argc = argc; + (*process)->argv = argv; + (*process)->kill_time = kill_time; + 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); @@ -215,20 +280,20 @@ void SIMIX_process_create(smx_process_t *process, (*process)->properties = properties; /* Add the process to it's host process list */ - xbt_swag_insert(*process, host->process_list); + xbt_swag_insert(*process, SIMIX_host_priv(host)->process_list); XBT_DEBUG("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); - XBT_DEBUG("Inserting %s(%s) in the to_run list", (*process)->name, host->name); + XBT_DEBUG("Inserting %s(%s) in the to_run list", (*process)->name, sg_host_name(host)); 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); + sg_host_name((*process)->smx_host), kill_time); SIMIX_timer_set(kill_time, simix_global->kill_process_function, *process); } } @@ -253,6 +318,9 @@ void SIMIX_process_runall(void) xbt_dynar_reset(simix_global->process_to_run); } +void SIMIX_pre_process_kill(smx_simcall_t simcall, smx_process_t process) { + SIMIX_process_kill(process, simcall->issuer); +} /** * \brief Internal function to kill a SIMIX process. * @@ -260,10 +328,11 @@ void SIMIX_process_runall(void) * or directly for SIMIX internal purposes. * * \param process poor victim + * \param issuer the process which has sent the PROCESS_KILL. Important to not schedule twice the same process. */ -void SIMIX_process_kill(smx_process_t process) { +void SIMIX_process_kill(smx_process_t process, smx_process_t issuer) { - XBT_DEBUG("Killing process %s on %s", process->name, process->smx_host->name); + XBT_DEBUG("Killing process %s on %s", process->name, sg_host_name(process->smx_host)); process->context->iwannadie = 1; process->blocked = 0; @@ -275,70 +344,87 @@ void SIMIX_process_kill(smx_process_t process) { switch (process->waiting_action->type) { - case SIMIX_ACTION_EXECUTE: - case SIMIX_ACTION_PARALLEL_EXECUTE: - SIMIX_host_execution_destroy(process->waiting_action); - break; - - case SIMIX_ACTION_COMMUNICATE: - xbt_fifo_remove(process->comms, process->waiting_action); - SIMIX_comm_destroy(process->waiting_action); - break; + case SIMIX_ACTION_EXECUTE: + case SIMIX_ACTION_PARALLEL_EXECUTE: + SIMIX_host_execution_destroy(process->waiting_action); + break; + + case SIMIX_ACTION_COMMUNICATE: + xbt_fifo_remove(process->comms, process->waiting_action); + SIMIX_comm_cancel(process->waiting_action); + SIMIX_comm_destroy(process->waiting_action); + break; + + case SIMIX_ACTION_SLEEP: + SIMIX_process_sleep_destroy(process->waiting_action); + break; + + case SIMIX_ACTION_SYNCHRO: + SIMIX_synchro_stop_waiting(process, &process->simcall); + SIMIX_synchro_destroy(process->waiting_action); + break; + + case SIMIX_ACTION_IO: + SIMIX_io_destroy(process->waiting_action); + break; + + /* **************************************/ + /* TUTORIAL: New API */ + case SIMIX_ACTION_NEW_API: + SIMIX_new_api_destroy(process->waiting_action); + break; + /* **************************************/ - case SIMIX_ACTION_SLEEP: - SIMIX_process_sleep_destroy(process->waiting_action); - break; - - case SIMIX_ACTION_SYNCHRO: - SIMIX_synchro_stop_waiting(process, &process->simcall); - SIMIX_synchro_destroy(process->waiting_action); - break; - - case SIMIX_ACTION_IO: - SIMIX_io_destroy(process->waiting_action); - break; } } - if(!xbt_dynar_member(simix_global->process_to_run, &(process))) + if(!xbt_dynar_member(simix_global->process_to_run, &(process)) && process != issuer) { xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, process); + } + } +void SIMIX_pre_process_killall(smx_simcall_t simcall, int reset_pid) { + SIMIX_process_killall(simcall->issuer, reset_pid); +} /** * \brief Kills all running processes. * \param issuer this one will not be killed */ -void SIMIX_process_killall(smx_process_t issuer) +void SIMIX_process_killall(smx_process_t issuer, int reset_pid) { smx_process_t p = NULL; while ((p = xbt_swag_extract(simix_global->process_list))) { if (p != issuer) { - SIMIX_process_kill(p); + SIMIX_process_kill(p,issuer); } } + if (reset_pid > 0) + simix_process_maxpid = reset_pid; + SIMIX_context_runall(); SIMIX_process_empty_trash(); } +void SIMIX_pre_process_change_host(smx_simcall_t simcall, smx_process_t process, + smx_host_t dest) +{ + process->new_host = dest; +} 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); + xbt_swag_remove(process, SIMIX_host_priv(process->smx_host)->process_list); process->smx_host = dest; - xbt_swag_insert(process, dest->process_list); + xbt_swag_insert(process, SIMIX_host_priv(dest)->process_list); } -void SIMIX_pre_process_change_host(smx_process_t process, smx_host_t dest) -{ - process->new_host = dest; -} -void SIMIX_pre_process_suspend(smx_simcall_t simcall) +void SIMIX_pre_process_suspend(smx_simcall_t simcall, smx_process_t process) { - smx_process_t process = simcall->process_suspend.process; smx_action_t action_suspend = SIMIX_process_suspend(process, simcall->issuer); @@ -384,13 +470,17 @@ smx_action_t 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: xbt_die("Internal error in SIMIX_process_suspend: unexpected action type %d", (int)process->waiting_action->type); } return NULL; } else { - DIE_IMPOSSIBLE; + /* Suspension is delayed to when the process is rescheduled. */ return NULL; } } else { @@ -398,13 +488,22 @@ smx_action_t SIMIX_process_suspend(smx_process_t process, smx_process_t issuer) } } +void SIMIX_pre_process_resume(smx_simcall_t simcall, smx_process_t process){ + SIMIX_process_resume(process, simcall->issuer); +} + void SIMIX_process_resume(smx_process_t process, smx_process_t issuer) { xbt_assert((process != NULL), "Invalid parameters"); - if(process->context->iwannadie) + 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 @@ -428,28 +527,59 @@ 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: xbt_die("Internal error in SIMIX_process_resume: unexpected action type %d", (int)process->waiting_action->type); } } - else { - DIE_IMPOSSIBLE; -// if(!xbt_dynar_member(simix_global->process_to_run, &(process))) -// 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) { return simix_process_maxpid; } +int SIMIX_pre_process_count(smx_simcall_t simcall){ + return SIMIX_process_count(); +} int SIMIX_process_count(void) { return xbt_swag_size(simix_global->process_list); } +int SIMIX_pre_process_get_PID(smx_simcall_t simcall, smx_process_t self){ + return SIMIX_process_get_PID(self); +} + +int SIMIX_process_get_PID(smx_process_t self){ + if (self == NULL) + return 0; + else + return self->pid; +} + +int SIMIX_pre_process_get_PPID(smx_simcall_t simcall, smx_process_t self){ + return SIMIX_process_get_PPID(self); +} + +int SIMIX_process_get_PPID(smx_process_t self){ + if (self == NULL) + return 0; + else + return self->ppid; +} + +void* SIMIX_pre_process_self_get_data(smx_simcall_t simcall, smx_process_t self){ + return SIMIX_process_self_get_data(self); +} + void* SIMIX_process_self_get_data(smx_process_t self) { xbt_assert(self == SIMIX_process_self(), "This is not the current process"); @@ -460,6 +590,10 @@ void* SIMIX_process_self_get_data(smx_process_t self) return SIMIX_process_get_data(self); } +void SIMIX_pre_process_set_data(smx_simcall_t simcall, smx_process_t process, + void *data){ + SIMIX_process_set_data(process, data); +} void SIMIX_process_self_set_data(smx_process_t self, void *data) { xbt_assert(self == SIMIX_process_self(), "This is not the current process"); @@ -467,6 +601,9 @@ void SIMIX_process_self_set_data(smx_process_t self, void *data) SIMIX_process_set_data(self, data); } +void* SIMIX_pre_process_get_data(smx_simcall_t simcall, smx_process_t process){ + return SIMIX_process_get_data(process); +} void* SIMIX_process_get_data(smx_process_t process) { return process->data; @@ -477,6 +614,9 @@ void SIMIX_process_set_data(smx_process_t process, void *data) process->data = data; } +smx_host_t SIMIX_pre_process_get_host(smx_simcall_t simcall, smx_process_t process){ + return SIMIX_process_get_host(process); +} smx_host_t SIMIX_process_get_host(smx_process_t process) { return process->smx_host; @@ -493,6 +633,9 @@ const char* SIMIX_process_self_get_name(void) { return SIMIX_process_get_name(process); } +const char* SIMIX_pre_process_get_name(smx_simcall_t simcall, smx_process_t process) { + return SIMIX_process_get_name(process); +} const char* SIMIX_process_get_name(smx_process_t process) { return process->name; @@ -510,25 +653,31 @@ smx_process_t SIMIX_process_get_by_name(const char* name) return NULL; } +int SIMIX_pre_process_is_suspended(smx_simcall_t simcall, smx_process_t process){ + return SIMIX_process_is_suspended(process); +} int SIMIX_process_is_suspended(smx_process_t process) { return process->suspended; } +xbt_dict_t SIMIX_pre_process_get_properties(smx_simcall_t simcall, smx_process_t process){ + return SIMIX_process_get_properties(process); +} xbt_dict_t SIMIX_process_get_properties(smx_process_t process) { return process->properties; } -void SIMIX_pre_process_sleep(smx_simcall_t simcall) +void SIMIX_pre_process_sleep(smx_simcall_t simcall, double duration) { - if (MC_IS_ENABLED) { - MC_process_clock_add(simcall->issuer, simcall->process_sleep.duration); - simcall->process_sleep.result = SIMIX_DONE; + if (MC_is_active()) { + MC_process_clock_add(simcall->issuer, duration); + simcall_process_sleep__set__result(simcall, SIMIX_DONE); SIMIX_simcall_answer(simcall); return; } - smx_action_t action = SIMIX_process_sleep(simcall->issuer, simcall->process_sleep.duration); + smx_action_t action = SIMIX_process_sleep(simcall->issuer, duration); xbt_fifo_push(action->simcalls, simcall); simcall->issuer->waiting_action = action; } @@ -540,9 +689,9 @@ smx_action_t SIMIX_process_sleep(smx_process_t process, double duration) /* check if the host is active */ if (surf_workstation_model->extension. - workstation.get_state(host->host) != SURF_RESOURCE_ON) { + workstation.get_state(host) != SURF_RESOURCE_ON) { THROWF(host_error, 0, "Host %s failed, you cannot call this function", - host->name); + sg_host_name(host)); } action = xbt_mallocator_get(simix_global->action_mallocator); @@ -554,7 +703,7 @@ smx_action_t SIMIX_process_sleep(smx_process_t process, double duration) action->sleep.host = host; action->sleep.surf_sleep = - surf_workstation_model->extension.workstation.sleep(host->host, duration); + surf_workstation_model->extension.workstation.sleep(host, duration); surf_workstation_model->action_data_set(action->sleep.surf_sleep, action); XBT_DEBUG("Create sleep action %p", action); @@ -571,7 +720,8 @@ void SIMIX_post_process_sleep(smx_action_t action) switch(surf_workstation_model->action_state_get(action->sleep.surf_sleep)){ case SURF_ACTION_FAILED: - state = SIMIX_SRC_HOST_FAILURE; + simcall->issuer->context->iwannadie = 1; + //SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed"); break; case SURF_ACTION_DONE: @@ -582,9 +732,14 @@ void SIMIX_post_process_sleep(smx_action_t action) THROW_IMPOSSIBLE; break; } - simcall->process_sleep.result = state; + if (surf_workstation_model->extension. + workstation.get_state(simcall->issuer->smx_host) != SURF_RESOURCE_ON) { + simcall->issuer->context->iwannadie = 1; + } + simcall_process_sleep__set__result(simcall, state); simcall->issuer->waiting_action = NULL; SIMIX_simcall_answer(simcall); + } SIMIX_process_sleep_destroy(action); } @@ -625,9 +780,20 @@ void SIMIX_process_yield(smx_process_t self) /* Ok, maestro returned control to us */ 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); + SIMIX_process_stop(self); + } + + 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) { @@ -635,11 +801,7 @@ void SIMIX_process_yield(smx_process_t self) self->doexception = 0; SMX_THROW(); } - - if (self->new_host) { - SIMIX_process_change_host(self, self->new_host); - self->new_host = NULL; - } + } /* callback: context fetching */ @@ -652,7 +814,7 @@ xbt_running_ctx_t *SIMIX_process_get_running_context(void) void SIMIX_process_exception_terminate(xbt_ex_t * e) { xbt_ex_display(e); - abort(); + xbt_abort(); } smx_context_t SIMIX_process_get_context(smx_process_t p) { @@ -676,13 +838,13 @@ xbt_dynar_t SIMIX_process_get_runnable(void) */ 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; + 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 */ @@ -694,3 +856,100 @@ xbt_dynar_t SIMIX_processes_as_dynar(void) { } 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_pre_process_on_exit(smx_simcall_t simcall, smx_process_t process, + int_f_pvoid_t fun, void *data) { + SIMIX_process_on_exit(process, fun, data); +} + +void SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_t fun, void *data) { + 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); +} + +void SIMIX_pre_process_auto_restart_set(smx_simcall_t simcall, smx_process_t process, + int auto_restart) { + SIMIX_process_auto_restart_set(process, auto_restart); +} +/** + * \brief Sets the auto-restart status of the process. + * If set to 1, the process will be automatically restarted when its host + * comes back. + */ +void SIMIX_process_auto_restart_set(smx_process_t process, int auto_restart) { + process->auto_restart = auto_restart; +} + +smx_process_t SIMIX_pre_process_restart(smx_simcall_t simcall, smx_process_t process) { + return SIMIX_process_restart(process, simcall->issuer); +} +/** + * \brief Restart a process. + * Restart a process, starting it again from the beginning. + */ +smx_process_t SIMIX_process_restart(smx_process_t process, smx_process_t issuer) { + XBT_DEBUG("Restarting process %s on %s", process->name, sg_host_name(process->smx_host)); + //retrieve the arguments of the old process + //FIXME: Factorise this with SIMIX_host_add_auto_restart_process ? + s_smx_process_arg_t arg; + arg.code = process->code; + arg.hostname = sg_host_name(process->smx_host); + arg.kill_time = process->kill_time; + arg.argc = process->argc; + arg.data = process->data; + int i; + arg.argv = xbt_new(char*,process->argc + 1); + for (i = 0; i < arg.argc; i++) { + arg.argv[i] = xbt_strdup(process->argv[i]); + } + arg.argv[process->argc] = NULL; + arg.properties = NULL; + arg.auto_restart = process->auto_restart; + //kill the old process + SIMIX_process_kill(process,issuer); + //start the new process + smx_process_t new_process; + if (simix_global->create_process_function) { + simix_global->create_process_function(&new_process, + arg.argv[0], + arg.code, + arg.data, + arg.hostname, + arg.kill_time, + arg.argc, + arg.argv, + arg.properties, + arg.auto_restart); + } + else { + simcall_process_create(&new_process, + arg.argv[0], + arg.code, + arg.data, + arg.hostname, + arg.kill_time, + arg.argc, + arg.argv, + arg.properties, + arg.auto_restart); + + } + return new_process; +}