X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/30a95d9c54b09486dad30be824b354fb570078b1..504b4d20dd2db9ea1eaa9c4b390b2a412d7c9779:/src/msg/m_process.c diff --git a/src/msg/m_process.c b/src/msg/m_process.c index d49a58ac30..6bd53d04ff 100644 --- a/src/msg/m_process.c +++ b/src/msg/m_process.c @@ -1,21 +1,24 @@ -/* $Id$ */ +/* $Id$ */ -/* Copyright (c) 2002,2003,2004 Arnaud Legrand. All rights reserved. */ +/* Copyright (c) 2002-2007 Arnaud Legrand. */ +/* Copyright (c) 2007 Bruno Donassolo. */ +/* 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. */ -#include "private.h" +#include "msg/private.h" #include "xbt/sysdep.h" #include "xbt/log.h" + XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg, "Logging specific to MSG (process)"); /** \defgroup m_process_management Management Functions of Agents * \brief This section describes the agent structure of MSG - */ -/** \addtogroup m_process_management * (#m_process_t) and the functions for managing it. + */ +/** @addtogroup m_process_management * \htmlonly \endhtmlonly * * We need to simulate many independent scheduling decisions, so @@ -34,31 +37,49 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg, * \sa MSG_process_create_with_arguments */ m_process_t MSG_process_create(const char *name, - m_process_code_t code, void *data, + xbt_main_func_t code, void *data, m_host_t host) { - return MSG_process_create_with_arguments(name, code, data, host, -1, NULL); + return MSG_process_create_with_arguments(name, code, data, host, -1, + NULL); } -static void MSG_process_cleanup(void *arg) +void __MSG_process_cleanup(void *arg) { + /* arg is a pointer to a simix process, we can get the msg process with the field data */ + m_process_t proc = ((smx_process_t) arg)->data; + xbt_fifo_remove(msg_global->process_list, proc); + SIMIX_process_cleanup(arg); + free(proc->name); + proc->name = NULL; + free(proc->simdata); + proc->simdata = NULL; + free(proc); + + return; +} - while(((m_process_t)arg)->simdata->paje_state) { - PAJE_PROCESS_POP_STATE((m_process_t)arg); - } - - PAJE_PROCESS_FREE(arg); +/* This function creates a MSG process. It has the prototype by SIMIX_function_register_process_create */ +void *_MSG_process_create_from_SIMIX(const char *name, + xbt_main_func_t code, void *data, + char *hostname, int argc, char **argv) +{ + m_host_t host = MSG_get_host_by_name(hostname); + return (void *) MSG_process_create_with_arguments(name, code, data, host, + argc, argv); +} - xbt_fifo_remove(msg_global->process_list, arg); - xbt_fifo_remove(msg_global->process_to_run, arg); - xbt_fifo_remove(((m_process_t) arg)->simdata->host->simdata->process_list, arg); - free(((m_process_t) arg)->name); - ((m_process_t) arg)->name = NULL; - free(((m_process_t) arg)->simdata); - ((m_process_t) arg)->simdata = NULL; - free(arg); +/* This function creates a MSG process with properties. It has the prototype by SIMIX_function_register_process_create */ +void *_MSG_process_create_with_env_from_SIMIX(const char *name, + xbt_main_func_t code, void *data, + char *hostname, int argc, char **argv, xbt_dict_t properties) +{ + m_host_t host = MSG_get_host_by_name(hostname); + return (void *) MSG_process_create_with_environment(name, code, data, host, + argc, argv,properties); } + /** \ingroup m_process_management * \brief Creates and runs a new #m_process_t. @@ -83,54 +104,110 @@ static void MSG_process_cleanup(void *arg) * \see m_process_t * \return The new corresponding object. */ + m_process_t MSG_process_create_with_arguments(const char *name, - m_process_code_t code, void *data, - m_host_t host, int argc, char **argv) + xbt_main_func_t code, + void *data, m_host_t host, + int argc, char **argv) { - simdata_process_t simdata = xbt_new0(s_simdata_process_t,1); - m_process_t process = xbt_new0(s_m_process_t,1); - m_process_t self = NULL; - + simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1); + m_process_t process = xbt_new0(s_m_process_t, 1); xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters"); - /* Simulator Data */ + /* Simulator Data */ simdata->PID = msg_global->PID++; - simdata->host = host; simdata->waiting_task = NULL; + simdata->m_host = host; simdata->argc = argc; simdata->argv = argv; - simdata->context = xbt_context_new(code, NULL, NULL, - MSG_process_cleanup, process, - simdata->argc, simdata->argv); + simdata->s_process = SIMIX_process_create(name, code, + (void *) process, host->name, + argc, argv, NULL); - if((self=msg_global->current_process)) { - simdata->PPID = MSG_process_get_PID(self); + if (SIMIX_process_self()) { + simdata->PPID = MSG_process_get_PID(SIMIX_process_self()->data); } else { simdata->PPID = -1; } - simdata->last_errno=MSG_OK; + simdata->last_errno = MSG_OK; /* Process structure */ process->name = xbt_strdup(name); process->simdata = simdata; - process->data = data; + process->data = data ; - xbt_fifo_unshift(host->simdata->process_list, process); + xbt_fifo_unshift(msg_global->process_list, process); - /* *************** FIX du current_process !!! *************** */ - self = msg_global->current_process; - xbt_context_start(process->simdata->context); - msg_global->current_process = self; + return process; +} - xbt_fifo_unshift(msg_global->process_list, process); - DEBUG2("Inserting %s(%s) in the to_run list",process->name, - host->name); - xbt_fifo_unshift(msg_global->process_to_run, process); +/** \ingroup m_process_management + * \brief Creates and runs a new #m_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 code is a function describing the behavior of the agent. It + should then only use functions described in \ref + m_process_management (to create a new #m_process_t for example), + in \ref m_host_management (only the read-only functions i.e. whose + name contains the word get), in \ref m_task_management (to create + or destroy some #m_task_t for example) and in \ref + msg_gos_functions (to handle file transfers and task processing). + * \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 properties list a properties defined for this process + * \see m_process_t + * \return The new corresponding object. + */ +m_process_t MSG_process_create_with_environment(const char *name, + xbt_main_func_t code, + void *data, m_host_t host, + int argc, char **argv, xbt_dict_t properties) +{ + simdata_process_t simdata = xbt_new0(s_simdata_process_t, 1); + m_process_t process = xbt_new0(s_m_process_t, 1); + xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters"); - PAJE_PROCESS_NEW(process); + /* Simulator Data */ + simdata->PID = msg_global->PID++; + simdata->waiting_task = NULL; + simdata->m_host = host; + simdata->argc = argc; + simdata->argv = argv; + simdata->s_process = SIMIX_process_create(name, code, + (void *) process, host->name, + argc, argv, properties); + + if (SIMIX_process_self()) { + simdata->PPID = MSG_process_get_PID(SIMIX_process_self()->data); + } else { + simdata->PPID = -1; + } + simdata->last_errno = MSG_OK; + + + /* Process structure */ + process->name = xbt_strdup(name); + process->simdata = simdata; + process->data = data ; + + xbt_fifo_unshift(msg_global->process_list, process); return process; + +} + +void _MSG_process_kill_from_SIMIX(void *p) +{ + MSG_process_kill((m_process_t) p); } /** \ingroup m_process_management @@ -140,53 +217,24 @@ m_process_t MSG_process_create_with_arguments(const char *name, */ void MSG_process_kill(m_process_t process) { - int i; simdata_process_t p_simdata = process->simdata; - simdata_host_t h_simdata= p_simdata->host->simdata; - int _cursor; - m_process_t proc = NULL; - - DEBUG3("Killing %s(%d) on %s",process->name, p_simdata->PID, - p_simdata->host->name); - - for (i=0; imax_channel; i++) { - if (h_simdata->sleeping[i] == process) { - h_simdata->sleeping[i] = NULL; - break; - } - } - - if(p_simdata->waiting_task) { - xbt_dynar_foreach(p_simdata->waiting_task->simdata->sleeping,_cursor,proc) { - if(proc==process) - xbt_dynar_remove_at(p_simdata->waiting_task->simdata->sleeping,_cursor,&proc); - } - if(p_simdata->waiting_task->simdata->compute) - surf_workstation_resource->common_public-> - action_free(p_simdata->waiting_task->simdata->compute); - else if (p_simdata->waiting_task->simdata->comm) { - surf_workstation_resource->common_public-> - action_change_state(p_simdata->waiting_task->simdata->comm,SURF_ACTION_FAILED); - surf_workstation_resource->common_public-> - action_free(p_simdata->waiting_task->simdata->comm); - } else { - xbt_die("UNKNOWN STATUS. Please report this bug."); - } - } - if ((i==msg_global->max_channel) && (process!=MSG_process_self()) && - (!p_simdata->waiting_task)) { - xbt_die("UNKNOWN STATUS. Please report this bug."); + DEBUG3("Killing %s(%d) on %s", + process->name, p_simdata->PID, p_simdata->m_host->name); + + if (p_simdata->waiting_task) { + DEBUG1("Canceling waiting task %s", p_simdata->waiting_task->name); + if (p_simdata->waiting_task->simdata->compute) { + SIMIX_action_cancel(p_simdata->waiting_task->simdata->compute); + } else if (p_simdata->waiting_task->simdata->comm) { + SIMIX_action_cancel(p_simdata->waiting_task->simdata->comm); + } } - xbt_fifo_remove(msg_global->process_to_run,process); - xbt_fifo_remove(msg_global->process_list,process); - xbt_context_kill(process->simdata->context); + xbt_fifo_remove(msg_global->process_list, process); + SIMIX_process_kill(process->simdata->s_process); - if(process==MSG_process_self()) { - /* I just killed myself */ - xbt_context_yield(); - } + return; } /** \ingroup m_process_management @@ -197,18 +245,8 @@ void MSG_process_kill(m_process_t process) */ MSG_error_t MSG_process_change_host(m_process_t process, m_host_t host) { - simdata_process_t simdata = NULL; - - /* Sanity check */ - - xbt_assert0(((process) && (process->simdata) - && (host)), "Invalid parameters"); - simdata = process->simdata; - - xbt_fifo_remove(simdata->host->simdata->process_list,process); - simdata->host = host; - xbt_fifo_unshift(host->simdata->process_list,process); - + xbt_die + ("MSG_process_change_host - not implemented yet - maybe useless function"); return MSG_OK; } @@ -231,13 +269,13 @@ void *MSG_process_get_data(m_process_t process) * 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. */ -MSG_error_t MSG_process_set_data(m_process_t process,void *data) +MSG_error_t MSG_process_set_data(m_process_t process, void *data) { xbt_assert0((process != NULL), "Invalid parameters"); xbt_assert0((process->data == NULL), "Data already set"); - + process->data = data; - + return MSG_OK; } @@ -250,9 +288,10 @@ MSG_error_t MSG_process_set_data(m_process_t process,void *data) */ m_host_t MSG_process_get_host(m_process_t process) { - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); - return (((simdata_process_t) process->simdata)->host); + return (((simdata_process_t) process->simdata)->m_host); } /** \ingroup m_process_management @@ -268,8 +307,9 @@ m_process_t MSG_process_from_PID(int PID) xbt_fifo_item_t i = NULL; m_process_t process = NULL; - xbt_fifo_foreach(msg_global->process_list,i,process,m_process_t) { - if(MSG_process_get_PID(process) == PID) return process; + xbt_fifo_foreach(msg_global->process_list, i, process, m_process_t) { + if (MSG_process_get_PID(process) == PID) + return process; } return NULL; } @@ -278,11 +318,14 @@ m_process_t MSG_process_from_PID(int PID) * \brief Returns the process ID of \a process. * * This functions checks whether \a process is a valid pointer or not - and return its PID. + and return its PID (or 0 in case of problem). */ int MSG_process_get_PID(m_process_t process) { - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); + /* Do not raise an exception here: this function is used in the logs, + and it will be called back by the exception handling stuff */ + if (process == NULL || process->simdata == NULL) + return 0; return (((simdata_process_t) process->simdata)->PID); } @@ -296,7 +339,8 @@ int MSG_process_get_PID(m_process_t process) */ int MSG_process_get_PPID(m_process_t process) { - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); return (((simdata_process_t) process->simdata)->PPID); } @@ -309,11 +353,37 @@ int MSG_process_get_PPID(m_process_t process) */ const char *MSG_process_get_name(m_process_t process) { - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); return (process->name); } +/** \ingroup m_process_management + * \brief Returns the value of a certain process property + * + * \param process a process + * \param name a property name + * \return value of a property + */ +const char* MSG_process_get_property_value(m_process_t process, char* name) +{ + return xbt_dict_get_or_null(MSG_process_get_properties(process), name); +} + +/** \ingroup m_process_management + * \brief Return the list of properties + * + * This functions returns all the parameters associated with a process + */ +xbt_dict_t MSG_process_get_properties(m_process_t process) +{ + xbt_assert0((process != NULL), "Invalid parameters"); + + return (SIMIX_process_get_properties(((simdata_process_t)process->simdata)->s_process)); + +} + /** \ingroup m_process_management * \brief Return the PID of the current agent. * @@ -342,7 +412,13 @@ int MSG_process_self_PPID(void) */ m_process_t MSG_process_self(void) { - return msg_global ? msg_global->current_process : NULL; + smx_process_t proc = SIMIX_process_self(); + if (proc != NULL) { + return (m_process_t) proc->data; + } else { + return NULL; + } + } /** \ingroup m_process_management @@ -353,51 +429,12 @@ m_process_t MSG_process_self(void) */ MSG_error_t MSG_process_suspend(m_process_t process) { - simdata_process_t simdata = NULL; - simdata_task_t simdata_task = NULL; - - XBT_IN2("(%p(%s))", process, process->name); - - xbt_assert0(((process) && (process->simdata)), "Invalid parameters"); - - PAJE_PROCESS_PUSH_STATE(process,"S",NULL); - - if(process!=MSG_process_self()) { - simdata = process->simdata; - - xbt_assert0(simdata->waiting_task,"Process not waiting for anything else. Weird !"); - - simdata_task = simdata->waiting_task->simdata; - - simdata->suspended = 1; - if(simdata->blocked) { - XBT_OUT; - return MSG_OK; - } - - xbt_assert0(((simdata_task->compute)||(simdata_task->comm))&& - !((simdata_task->compute)&&(simdata_task->comm)), - "Got a problem in deciding which action to choose !"); - simdata->suspended = 1; - if(simdata_task->compute) - surf_workstation_resource->common_public->suspend(simdata_task->compute); - else - surf_workstation_resource->common_public->suspend(simdata_task->comm); - } else { - m_task_t dummy = MSG_TASK_UNINITIALIZED; - dummy = MSG_task_create("suspended", 0.0, 0, NULL); - - simdata = process->simdata; - simdata->suspended = 1; - __MSG_task_execute(process,dummy); - surf_workstation_resource->common_public->suspend(dummy->simdata->compute); - __MSG_wait_for_computation(process,dummy); - simdata->suspended = 0; + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); + CHECK_HOST(); - MSG_task_destroy(dummy); - } - XBT_OUT; - return MSG_OK; + SIMIX_process_suspend(process->simdata->s_process); + MSG_RETURN(MSG_OK); } /** \ingroup m_process_management @@ -408,47 +445,12 @@ MSG_error_t MSG_process_suspend(m_process_t process) */ MSG_error_t MSG_process_resume(m_process_t process) { - simdata_process_t simdata = NULL; - simdata_task_t simdata_task = NULL; - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); CHECK_HOST(); - XBT_IN2("(%p(%s))", process, process->name); - - if(process == MSG_process_self()) { - XBT_OUT; - MSG_RETURN(MSG_OK); - } - - simdata = process->simdata; - - if(simdata->blocked) { - PAJE_PROCESS_POP_STATE(process); - - simdata->suspended = 0; /* He'll wake up by itself */ - XBT_OUT; - MSG_RETURN(MSG_OK); - } - - if(!(simdata->waiting_task)) { - xbt_assert0(0,"Process not waiting for anything else. Weird !"); - XBT_OUT; - return MSG_WARNING; - } - simdata_task = simdata->waiting_task->simdata; - - - if(simdata_task->compute) { - surf_workstation_resource->common_public->resume(simdata_task->compute); - PAJE_PROCESS_POP_STATE(process); - } - else { - PAJE_PROCESS_POP_STATE(process); - surf_workstation_resource->common_public->resume(simdata_task->comm); - } - - XBT_OUT; + SIMIX_process_resume(process->simdata->s_process); MSG_RETURN(MSG_OK); } @@ -460,77 +462,7 @@ MSG_error_t MSG_process_resume(m_process_t process) */ int MSG_process_is_suspended(m_process_t process) { - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); - - return (process->simdata->suspended); -} - -int __MSG_process_block(double max_duration, const char *info) -{ - m_process_t process = MSG_process_self(); - m_task_t dummy = MSG_TASK_UNINITIALIZED; - char blocked_name[512]; - snprintf(blocked_name,512,"blocked [%s] (%s:%s)", - info, process->name, process->simdata->host->name); - - XBT_IN1(": max_duration=%g",max_duration); - - dummy = MSG_task_create(blocked_name, 0.0, 0, NULL); - - PAJE_PROCESS_PUSH_STATE(process,"B",NULL); - - process->simdata->blocked=1; - __MSG_task_execute(process,dummy); - surf_workstation_resource->common_public->suspend(dummy->simdata->compute); - if(max_duration>=0) - surf_workstation_resource->common_public->set_max_duration(dummy->simdata->compute, - max_duration); - __MSG_wait_for_computation(process,dummy); - MSG_task_destroy(dummy); - process->simdata->blocked=0; - - if(process->simdata->suspended) { - DEBUG0("I've been suspended in the meantime"); - MSG_process_suspend(process); - DEBUG0("I've been resumed, let's keep going"); - } - - PAJE_PROCESS_POP_STATE(process); - - XBT_OUT; - return 1; -} - -MSG_error_t __MSG_process_unblock(m_process_t process) -{ - simdata_process_t simdata = NULL; - simdata_task_t simdata_task = NULL; - - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); - CHECK_HOST(); - - XBT_IN2(": %s unblocking %s", MSG_process_self()->name,process->name); - - simdata = process->simdata; - if(!(simdata->waiting_task)) { - xbt_assert0(0,"Process not waiting for anything else. Weird !"); - XBT_OUT; - return MSG_WARNING; - } - simdata_task = simdata->waiting_task->simdata; - - xbt_assert0(simdata->blocked,"Process not blocked"); - - surf_workstation_resource->common_public->resume(simdata_task->compute); - - XBT_OUT; - - MSG_RETURN(MSG_OK); -} - -int __MSG_process_isBlocked(m_process_t process) -{ - xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters"); - - return (process->simdata->blocked); + xbt_assert0(((process != NULL) + && (process->simdata)), "Invalid parameters"); + return SIMIX_process_is_suspended(process->simdata->s_process); }