X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f3eb95bea2b4188d46fa0cb4d652dd1d200f1e12..60059959d6d517261ca7f4176b0267bc37caf04d:/src/simix/smx_private.h diff --git a/src/simix/smx_private.h b/src/simix/smx_private.h index 6e151d75db..e6f00601ba 100644 --- a/src/simix/smx_private.h +++ b/src/simix/smx_private.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team. +/* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -22,17 +22,18 @@ #include "smx_host_private.h" #include "smx_io_private.h" #include "smx_network_private.h" -#include "smx_smurf_private.h" +#include "popping_private.h" #include "smx_synchro_private.h" -/* ****************************************************************************************** */ -/* TUTORIAL: New API */ -/* ****************************************************************************************** */ -#include "smx_new_api_private.h" /* Define only for SimGrid benchmarking purposes */ -//#define TIME_BENCH_PER_SR /* this aims at measuring the time spent in each scheduling round per each thread. The code is thus run in sequential to bench separately each SSR */ -//#define TIME_BENCH_AMDAHL /* this aims at measuring the porting of time that could be parallelized at maximum (to get the optimal speedup by applying the amdahl law). */ +//#define TIME_BENCH_PER_SR /* this aims at measuring the time spent in each scheduling round per each thread. The code is thus run in sequential to bench separately each SSR */ +//#define TIME_BENCH_AMDAHL /* this aims at measuring the porting of time that could be parallelized at maximum (to get the optimal speedup by applying the amdahl law). */ +//#define ADAPTIVE_THRESHOLD /* this is to enable the adaptive threshold algorithm in raw contexts*/ +//#define TIME_BENCH_ENTIRE_SRS /* more general benchmark than TIME_BENCH_PER_SR. It aims to measure the total time spent in a whole scheduling round (including synchro costs)*/ +#ifdef TIME_BENCH_PER_SR +void smx_ctx_raw_new_sr(void); +#endif /********************************** Simix Global ******************************/ typedef struct s_smx_global { smx_context_factory_t context_factory; @@ -59,12 +60,20 @@ extern unsigned long simix_process_maxpid; extern xbt_dict_t watched_hosts_lib; -/******************************** Exceptions *********************************/ +#ifdef __cplusplus +extern "C" { +#endif +XBT_PUBLIC(void) SIMIX_clean(void); +#ifdef __cplusplus +} +#endif -#define SMX_EXCEPTION(issuer, c, v, m) \ +/******************************** Exceptions *********************************/ +/** @brief Ask to the provided simix process to raise the provided exception */ +#define SMX_EXCEPTION(issuer, cat, val, msg) \ if (1) { \ - smx_process_t _smx_throw_issuer = (issuer); \ - THROW_PREPARE(_smx_throw_issuer->running_ctx, (c), (v), xbt_strdup(m)); \ + smx_process_t _smx_throw_issuer = (issuer); /* evaluate only once */\ + THROW_PREPARE(_smx_throw_issuer->running_ctx, (cat), (val), xbt_strdup(msg)); \ _smx_throw_issuer->doexception = 1; \ } else ((void)0) @@ -73,12 +82,9 @@ extern xbt_dict_t watched_hosts_lib; /* ******************************** File ************************************ */ typedef struct s_smx_file { surf_file_t surf_file; + void* data; /**< @brief user data */ } s_smx_file_t; -typedef struct s_smx_stat { - s_file_stat_t surf_stat; -} s_smx_stat_t; - /*********************************** Time ************************************/ /** @brief Timer datatype */ @@ -94,13 +100,10 @@ typedef enum { SIMIX_ACTION_EXECUTE, SIMIX_ACTION_PARALLEL_EXECUTE, SIMIX_ACTION_COMMUNICATE, + SIMIX_ACTION_JOIN, SIMIX_ACTION_SLEEP, SIMIX_ACTION_SYNCHRO, SIMIX_ACTION_IO, - /* ****************************************************************************************** */ - /* TUTORIAL: New API */ - /* ****************************************************************************************** */ - SIMIX_ACTION_NEW_API } e_smx_action_type_t; typedef enum { @@ -136,6 +139,12 @@ typedef struct s_smx_action { struct { e_smx_comm_type_t type; /* Type of the communication (SIMIX_COMM_SEND or SIMIX_COMM_RECEIVE) */ smx_rdv_t rdv; /* Rendez-vous where the comm is queued */ + +#ifdef HAVE_MC + smx_rdv_t rdv_cpy; /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR + (comm.rdv set to NULL when the communication is removed from the mailbox + (used as garbage collector)) */ +#endif int refcount; /* Number of processes involved in the cond */ int detached; /* If detached or not */ @@ -143,6 +152,7 @@ typedef struct s_smx_action { int (*match_fun)(void*,void*,smx_action_t); /* Filter function used by the other side. It is used when looking if a given communication matches my needs. For that, myself must match the expectations of the other side, too. See */ + void (*copy_data_fun) (smx_action_t, void*, size_t); /* Surf action data */ surf_action_t surf_comm; /* The Surf communication action encapsulated */ @@ -162,7 +172,7 @@ typedef struct s_smx_action { void* src_data; /* User data associated to communication */ void* dst_data; - } comm; + } comm; struct { smx_host_t host; /* The host that is sleeping */ @@ -177,13 +187,6 @@ typedef struct s_smx_action { smx_host_t host; surf_action_t surf_io; } io; - - /* ****************************************************************************************** */ - /* TUTORIAL: New API */ - /* ****************************************************************************************** */ - struct { - surf_action_t surf_new_api; - } new_api; }; #ifdef HAVE_LATENCY_BOUND_TRACKING @@ -195,26 +198,26 @@ typedef struct s_smx_action { #endif } s_smx_action_t; -/* FIXME: check if we can delete this function */ -static XBT_INLINE e_smx_state_t SIMIX_action_map_state(e_surf_action_state_t state) -{ - switch (state) { - case SURF_ACTION_READY: - return SIMIX_READY; - case SURF_ACTION_RUNNING: - return SIMIX_RUNNING; - case SURF_ACTION_FAILED: - return SIMIX_FAILED; - case SURF_ACTION_DONE: - return SIMIX_DONE; - default: - xbt_die("Unexpected SURF action state"); - } -} - void SIMIX_context_mod_init(void); void SIMIX_context_mod_exit(void); +#ifndef WIN32 +XBT_PUBLIC_DATA(char sigsegv_stack[SIGSTKSZ]); +#endif + +/* We are using the bottom of the stack to save some information, like the + * valgrind_stack_id. Define smx_context_usable_stack_size to give the remaining + * size for the stack. */ +#ifdef HAVE_VALGRIND_VALGRIND_H +# define smx_context_usable_stack_size \ + (smx_context_stack_size - sizeof(unsigned int)) /* for valgrind_stack_id */ +#else +# define smx_context_usable_stack_size smx_context_stack_size +#endif + +void *SIMIX_context_stack_new(void); +void SIMIX_context_stack_delete(void *stack); + void SIMIX_context_set_current(smx_context_t context); smx_context_t SIMIX_context_get_current(void); @@ -231,12 +234,12 @@ void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory); /* Scenario for the end of a context: * * CASE 1: death after end of the main function - * the context_wrapper, called internally by the context module, calls - * SIMIX_context_stop after user code stops, smx_context_stop calls user + * the context_wrapper, called internally by the context module, calls + * SIMIX_context_stop after user code stops, smx_context_stop calls user * cleanup_func if any (in context settings), add current process to trashbin * and yields back to maestro. * From time to time, maestro calls SIMIX_context_empty_trash, which destroy - * all the process and context data structures, and frees the memory + * all the process and context data structures, and frees the memory * * CASE 2: brutal death * SIMIX_process_kill (from any process) set process->iwannadie = 1 and then @@ -258,7 +261,8 @@ static XBT_INLINE smx_context_t SIMIX_context_new(xbt_main_func_t code, void_pfn_smxprocess_t cleanup_func, smx_process_t simix_process) { - + if (!simix_global) + xbt_die("simix is not initialized, please call MSG_init first"); return simix_global->context_factory->create_context(code, argc, argv, cleanup_func, @@ -266,7 +270,7 @@ static XBT_INLINE smx_context_t SIMIX_context_new(xbt_main_func_t code, } /** - * \brief destroy a context + * \brief destroy a context * \param context the context to destroy * Argument must be stopped first -- runs in maestro context */ @@ -299,29 +303,30 @@ static XBT_INLINE void SIMIX_context_suspend(smx_context_t context) */ static XBT_INLINE void SIMIX_context_runall(void) { - simix_global->context_factory->runall(); + if (!xbt_dynar_is_empty(simix_global->process_to_run)) { + simix_global->context_factory->runall(); + } } /** - \brief returns the current running context + \brief returns the current running context */ static XBT_INLINE smx_context_t SIMIX_context_self(void) { if (simix_global && simix_global->context_factory) { return simix_global->context_factory->self(); } - return NULL; } /** - \brief returns the data associated to a context + \brief returns the SIMIX process associated to a context \param context The context - \return The data + \return The SIMIX process */ -static XBT_INLINE void* SIMIX_context_get_data(smx_context_t context) +static XBT_INLINE smx_process_t SIMIX_context_get_process(smx_context_t context) { - return simix_global->context_factory->get_data(context); + return simix_global->context_factory->get_process(context); } XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);