X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6b89334bd957e8d02b2fd66f3fd6650957e99387..e379b4008b304af4688fe6cb29fbfdaf9e9e6873:/src/simix/private.h diff --git a/src/simix/private.h b/src/simix/private.h index 2b344a057a..6cf1c9a1c9 100644 --- a/src/simix/private.h +++ b/src/simix/private.h @@ -1,7 +1,5 @@ -/* $Id$ */ - -/* Copyright (c) 2007 Arnaud Legrand, Bruno Donnassolo. - 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. */ @@ -9,7 +7,6 @@ #ifndef SIMIX_PRIVATE_H #define SIMIX_PRIVATE_H -#include #include "simix/simix.h" #include "surf/surf.h" #include "xbt/fifo.h" @@ -18,6 +15,7 @@ #include "xbt/config.h" #include "xbt/function_types.h" #include "xbt/ex_interface.h" +#include "instr/private.h" /******************************** Datatypes ***********************************/ @@ -59,7 +57,7 @@ extern SIMIX_Global_t simix_global; @ingroup m_datatypes_management_details @{ */ typedef struct s_smx_process { s_xbt_swag_hookup_t process_hookup; - s_xbt_swag_hookup_t synchro_hookup; + s_xbt_swag_hookup_t synchro_hookup; /* process_to_run or mutex->sleeping and co */ s_xbt_swag_hookup_t host_proc_hookup; s_xbt_swag_hookup_t destroy_hookup; @@ -72,6 +70,7 @@ extern SIMIX_Global_t simix_global; int iwannadie : 1; smx_mutex_t mutex; /* mutex on which the process is blocked */ smx_cond_t cond; /* cond on which the process is blocked */ + smx_sem_t sem; /* semaphore on which the process is blocked */ smx_action_t waiting_action; xbt_dict_t properties; void *data; /* kept for compatibility, it should be replaced with moddata */ @@ -93,11 +92,9 @@ typedef struct s_smx_process_arg { void SIMIX_create_maestro_process(void); void SIMIX_process_empty_trash(void); void SIMIX_process_schedule(smx_process_t process); -void SIMIX_process_yield(void); ex_ctx_t *SIMIX_process_get_exception(void); void SIMIX_process_exception_terminate(xbt_ex_t * e); - /*************************** Mutex and Conditional ****************************/ typedef struct s_smx_mutex { @@ -119,17 +116,78 @@ typedef struct s_smx_cond { } s_smx_cond_t; +typedef struct s_smx_sem { + /* KEEP IT IN SYNC WITH src/xbt_sg_thread.c::struct s_xbt_sem */ + xbt_swag_t sleeping; /* list of sleeping process */ + int capacity; + xbt_fifo_t actions; /* list of actions */ + /* KEEP IT IN SYNC WITH src/xbt_sg_thread.c::struct s_xbt_sem */ + +} s_smx_sem_t; + +/******************************* Networking ***********************************/ + +/** @brief Rendez-vous point datatype */ +typedef struct s_smx_rvpoint { + char *name; + smx_mutex_t read; + smx_mutex_t write; + xbt_fifo_t comm_fifo; + void *data; +} s_smx_rvpoint_t; + +typedef struct s_smx_comm { + + + smx_comm_type_t type; /* Type of the communication (comm_send,comm_recv) */ + smx_rdv_t rdv; /* Rendez-vous where the comm is queued */ + smx_sem_t sem; /* Semaphore associated to the surf simulation */ + int refcount; /* Number of processes involved in the cond */ + + /* Surf action data */ + smx_process_t src_proc; + smx_process_t dst_proc; + smx_action_t src_timeout; + smx_action_t dst_timeout; + smx_action_t act; + double rate; + double task_size; + + /* Data to be transfered */ + void *src_buff; + void *dst_buff; + size_t src_buff_size; + size_t *dst_buff_size; + char copied; + + void *data; /* User data associated to communication */ +} s_smx_comm_t; + +void SIMIX_network_copy_data(smx_comm_t comm); +smx_comm_t SIMIX_communication_new(smx_comm_type_t type); +static XBT_INLINE void SIMIX_communication_use(smx_comm_t comm); +static XBT_INLINE void SIMIX_communication_wait_for_completion(smx_comm_t comm, double timeout); +static XBT_INLINE void SIMIX_rdv_push(smx_rdv_t rdv, smx_comm_t comm); +static XBT_INLINE void SIMIX_rdv_remove(smx_rdv_t rdv, smx_comm_t comm); + /********************************* Action *************************************/ +typedef enum {ready, ongoing, done, failed} smx_action_state_t; + /** @brief Action datatype @ingroup m_datatypes_management_details */ typedef struct s_smx_action { char *name; /**< @brief action name if any */ xbt_fifo_t cond_list; /*< conditional variables that must be signaled when the action finish. */ + xbt_fifo_t sem_list; /*< semaphores that must be signaled when the action finish. */ void *data; /**< @brief user data */ int refcount; /**< @brief reference counter */ surf_action_t surf_action; /* SURF modeling of computation */ smx_host_t source; +#ifdef HAVE_TRACING + long long int counter; /* simix action unique identifier for instrumentation */ + char *category; /* simix action category for instrumentation */ +#endif } s_smx_action_t; /************************** Configuration support *****************************/ @@ -150,82 +208,34 @@ void __SIMIX_action_display_conditions(smx_action_t action); /******************************** Context *************************************/ -void SIMIX_context_mod_init(void); - -void SIMIX_context_mod_exit(void); - -/* *********************** */ -/* Context type definition */ -/* *********************** */ -/* the following function pointers types describe the interface that all context - concepts must implement */ - -/* each context type must contain this macro at its begining -- OOP in C :/ */ -#define SMX_CTX_BASE_T \ - s_xbt_swag_hookup_t hookup; \ - xbt_main_func_t code; \ - int argc; \ - char **argv; \ - void_f_pvoid_t cleanup_func; \ - void *cleanup_arg; \ - -/* all other context types derive from this structure */ -typedef struct s_smx_context { - SMX_CTX_BASE_T; -} s_smx_context_t; - -/* *********************** */ -/* factory type definition */ -/* *********************** */ - -/* Each context implementation define its own context factory - * A context factory is responsable of the creation and manipulation of the - * execution context of all the simulated processes (and maestro) using the - * selected implementation. - * - * For example, the context switch based on java thread use the - * java implementation of the context and the java factory to build and control - * the contexts depending on this implementation. - - * The following function pointer types describe the interface that any context - * factory should implement. - */ +/* The following function pointer types describe the interface that any context + factory should implement */ -/* function used to create a new context */ -typedef smx_context_t (*smx_pfn_context_factory_create_context_t) +typedef smx_context_t (*smx_pfn_context_factory_create_context_t) (xbt_main_func_t, int, char**, void_f_pvoid_t, void*); - -/* this function finalize the specified context factory */ typedef int (*smx_pfn_context_factory_finalize_t) (smx_context_factory_t*); - -/* function used to destroy the specified context */ typedef void (*smx_pfn_context_free_t) (smx_context_t); - -/* function used to start the specified context */ typedef void (*smx_pfn_context_start_t) (smx_context_t); - -/* function used to stop the current context */ typedef void (*smx_pfn_context_stop_t) (smx_context_t); - -/* function used to suspend the current context */ typedef void (*smx_pfn_context_suspend_t) (smx_context_t context); - -/* function used to resume the current context */ -typedef void (*smx_pfn_context_resume_t) (smx_context_t old_context, - smx_context_t new_context); +typedef void (*smx_pfn_context_resume_t) (smx_context_t new_context); /* interface of the context factories */ typedef struct s_smx_context_factory { smx_pfn_context_factory_create_context_t create_context; smx_pfn_context_factory_finalize_t finalize; smx_pfn_context_free_t free; - smx_pfn_context_start_t start; smx_pfn_context_stop_t stop; smx_pfn_context_suspend_t suspend; smx_pfn_context_resume_t resume; const char *name; } s_smx_context_factory_t; + +void SIMIX_context_mod_init(void); + +void SIMIX_context_mod_exit(void); + /* Selects a context factory associated with the name specified by the parameter name. * If successful the function returns 0. Otherwise the function returns the error code. */ @@ -240,6 +250,8 @@ void SIMIX_context_init_factory_by_name(smx_context_factory_t * factory, const c void SIMIX_ctx_thread_factory_init(smx_context_factory_t * factory); void SIMIX_ctx_sysv_factory_init(smx_context_factory_t * factory); +void SIMIX_ctx_lua_factory_init(smx_context_factory_t * factory); + void SIMIX_ctx_java_factory_init(smx_context_factory_t * factory); @@ -272,11 +284,11 @@ void SIMIX_ctx_java_factory_init(smx_context_factory_t * factory); * \param cleanup_func the function to call when the context stops * \param cleanup_arg the argument of the cleanup_func function */ -static inline smx_context_t SIMIX_context_new(xbt_main_func_t code, int argc, +static XBT_INLINE smx_context_t SIMIX_context_new(xbt_main_func_t code, int argc, char** argv, void_f_pvoid_t cleanup_func, - void* cleanup_arg) -{ + void* cleanup_arg) { + return (*(simix_global->context_factory->create_context)) (code, argc, argv, cleanup_func, cleanup_arg); } @@ -286,27 +298,15 @@ static inline smx_context_t SIMIX_context_new(xbt_main_func_t code, int argc, * \param context the context to destroy * Argument must be stopped first -- runs in maestro context */ -static inline void SIMIX_context_free(smx_context_t context) -{ +static XBT_INLINE void SIMIX_context_free(smx_context_t context) { (*(simix_global->context_factory->free)) (context); } -/** - * \brief prepares aa context to be run - * \param context the context to start - * It will however run effectively only when calling #SIMIX_process_schedule - */ -static inline void SIMIX_context_start(smx_context_t context) -{ - (*(simix_global->context_factory->start)) (context); -} - /** * \brief stops the execution of a context * \param context to stop */ -static inline void SIMIX_context_stop(smx_context_t context) -{ +static XBT_INLINE void SIMIX_context_stop(smx_context_t context) { (*(simix_global->context_factory->stop)) (context); } @@ -315,10 +315,9 @@ static inline void SIMIX_context_stop(smx_context_t context) \param old_context the actual context from which is resuming \param new_context the context to resume */ -static inline void SIMIX_context_resume(smx_context_t old_context, - smx_context_t new_context) +static XBT_INLINE void SIMIX_context_resume(smx_context_t new_context) { - (*(simix_global->context_factory->resume)) (old_context, new_context); + (*(simix_global->context_factory->resume)) (new_context); } /** @@ -326,7 +325,7 @@ static inline void SIMIX_context_resume(smx_context_t old_context, scheduled it \param context the context to be suspended (it must be the running one) */ -static inline void SIMIX_context_suspend(smx_context_t context) +static XBT_INLINE void SIMIX_context_suspend(smx_context_t context) { (*(simix_global->context_factory->suspend)) (context); }