From ac2da2e897e8e361f5476beb2f0c28254a90005b Mon Sep 17 00:00:00 2001 From: =?utf8?q?Christophe=20Thi=C3=A9ry?= Date: Wed, 2 Nov 2011 14:46:15 +0100 Subject: [PATCH 1/1] Implement direct context switching also for raw contexts --- src/simix/smx_context_raw.c | 241 +++++++++++++++++++++++------------ src/simix/smx_context_sysv.c | 18 +-- src/surf/surf_config.c | 2 +- 3 files changed, 170 insertions(+), 91 deletions(-) diff --git a/src/simix/smx_context_raw.c b/src/simix/smx_context_raw.c index 66a92649e7..5cf7c0726e 100644 --- a/src/simix/smx_context_raw.c +++ b/src/simix/smx_context_raw.c @@ -1,4 +1,4 @@ -/* context_raw - context switching with ucontextes from System V */ +/* context_raw - fast context switching inspired from System V ucontextes */ /* Copyright (c) 2009, 2010. The SimGrid Team. * All rights reserved. */ @@ -9,7 +9,6 @@ #include "simix/private.h" #include "xbt/parmap.h" - #ifdef HAVE_VALGRIND_VALGRIND_H # include #endif /* HAVE_VALGRIND_VALGRIND_H */ @@ -18,19 +17,25 @@ typedef char * raw_stack_t; typedef void (*rawctx_entry_point_t)(void *); typedef struct s_smx_ctx_raw { - s_smx_ctx_base_t super; /* Fields of super implementation */ - char *malloced_stack; /* malloced area containing the stack */ - raw_stack_t stack_top; /* pointer to stack top (within previous area) */ - raw_stack_t old_stack_top; /* to whom I should return the control */ + s_smx_ctx_base_t super; /* Fields of super implementation */ + char *malloced_stack; /* malloced area containing the stack */ + raw_stack_t stack_top; /* pointer to stack top (within previous area) */ #ifdef HAVE_VALGRIND_VALGRIND_H - unsigned int valgrind_stack_id; /* the valgrind stack id */ + unsigned int valgrind_stack_id; /* the valgrind stack id */ #endif #ifdef TIME_BENCH - unsigned int thread; /* Just for measuring purposes */ + unsigned int thread; /* Just for measuring purposes */ #endif } s_smx_ctx_raw_t, *smx_ctx_raw_t; -smx_ctx_raw_t maestro_raw_context; +#ifdef CONTEXT_THREADS +static xbt_parmap_t raw_parmap; +static raw_stack_t* raw_local_maestro_stacks; /* space to save maestro's stack in each thread */ +#endif + +static unsigned long raw_process_index = 0; /* index of the next process to run in the + * list of runnable processes */ +smx_ctx_raw_t raw_maestro_context; extern raw_stack_t raw_makecontext(char* malloced_stack, int stack_size, rawctx_entry_point_t entry_point, void* arg); @@ -129,7 +134,7 @@ __asm__ ( ".text\n" ".globl raw_swapcontext\n" ".type raw_swapcontext,@function\n" - "raw_swapcontext:\n" /* Calling convention sets the arguments in rdi and rsi, respectively */ + "raw_swapcontext:\n" /* Calling convention sets the arguments in rdi and rsi, respectively */ #endif " pushq %rdi\n" " pushq %rsi\n" @@ -162,7 +167,7 @@ __asm__ ( #else /* If you implement raw contextes for other processors, don't forget to - update the definition of HAVE_RAWCTX in buildtools/Cmake/AddTests.cmake */ + update the definition of HAVE_RAWCTX in buildtools/Cmake/CompleteInFiles.cmake */ raw_stack_t raw_makecontext(char* malloced_stack, int stack_size, rawctx_entry_point_t entry_point, void* arg) { @@ -177,10 +182,6 @@ void raw_swapcontext(raw_stack_t* old, raw_stack_t new) { XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context); -#ifdef CONTEXT_THREADS -static xbt_parmap_t parmap; -#endif - #ifdef TIME_BENCH #include "xbt/xbt_os_time.h" #define NUM_THREADS 4 @@ -195,6 +196,58 @@ static char new_sr = 0; #endif static void smx_ctx_raw_wrapper(smx_ctx_raw_t context); +static int smx_ctx_raw_factory_finalize(smx_context_factory_t *factory); +static smx_context_t smx_ctx_raw_create_context(xbt_main_func_t code, int argc, + char **argv, void_pfn_smxprocess_t cleanup_func, void *data); +static void smx_ctx_raw_free(smx_context_t context); +static void smx_ctx_raw_wrapper(smx_ctx_raw_t context); +static void smx_ctx_raw_stop(smx_context_t context); +static void smx_ctx_raw_suspend_serial(smx_context_t context); +static void smx_ctx_raw_resume_serial(smx_process_t first_process); +static void smx_ctx_raw_runall_serial(void); +static void smx_ctx_raw_suspend_parallel(smx_context_t context); +static void smx_ctx_raw_resume_parallel(smx_process_t first_process); +static void smx_ctx_raw_runall_parallel(void); +static void smx_ctx_raw_runall(void); + +void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory) +{ + XBT_VERB("Using raw contexts. Because the glibc is just not good enough for us."); + smx_ctx_base_factory_init(factory); + + (*factory)->finalize = smx_ctx_raw_factory_finalize; + (*factory)->create_context = smx_ctx_raw_create_context; + /* Do not overload that method (*factory)->finalize */ + (*factory)->free = smx_ctx_raw_free; + (*factory)->stop = smx_ctx_raw_stop; + (*factory)->name = "smx_raw_context_factory"; + + if (SIMIX_context_is_parallel()) { +#ifdef CONTEXT_THREADS + int nthreads = SIMIX_context_get_nthreads(); + raw_parmap = xbt_parmap_new(nthreads); + raw_local_maestro_stacks = xbt_new(raw_stack_t, nthreads); +#endif + if (SIMIX_context_get_parallel_threshold() > 1) { + /* choose dynamically */ + (*factory)->runall = smx_ctx_raw_runall; + (*factory)->suspend = NULL; + } + else { + /* always parallel */ + (*factory)->runall = smx_ctx_raw_runall_parallel; + (*factory)->suspend = smx_ctx_raw_suspend_parallel; + } + } + else { + /* always serial */ + (*factory)->runall = smx_ctx_raw_runall_serial; + (*factory)->suspend = smx_ctx_raw_suspend_serial; + } +#ifdef TIME_BENCH + timer = xbt_os_timer_new(); +#endif +} static int smx_ctx_raw_factory_finalize(smx_context_factory_t *factory) { @@ -204,13 +257,13 @@ static int smx_ctx_raw_factory_finalize(smx_context_factory_t *factory) #endif #ifdef CONTEXT_THREADS - if(parmap) - xbt_parmap_destroy(parmap); + if (raw_parmap) + xbt_parmap_destroy(raw_parmap); + xbt_free(raw_local_maestro_stacks); #endif return smx_ctx_base_factory_finalize(factory); } - static smx_context_t smx_ctx_raw_create_context(xbt_main_func_t code, int argc, char **argv, void_pfn_smxprocess_t cleanup_func, @@ -226,8 +279,8 @@ smx_ctx_raw_create_context(xbt_main_func_t code, int argc, char **argv, cleanup_func, data); - /* If the user provided a function for the process then use it - otherwise is the context for maestro */ + /* if the user provided a function for the process then use it, + otherwise it is the context for maestro */ if (code) { context->malloced_stack = xbt_malloc0(smx_context_stack_size); context->stack_top = @@ -240,8 +293,8 @@ smx_ctx_raw_create_context(xbt_main_func_t code, int argc, char **argv, context->malloced_stack + smx_context_stack_size); #endif /* HAVE_VALGRIND_VALGRIND_H */ - }else{ - maestro_raw_context = context; + } else { + raw_maestro_context = context; } return (smx_context_t) context; @@ -262,33 +315,46 @@ static void smx_ctx_raw_free(smx_context_t context) smx_ctx_base_free(context); } -static void smx_ctx_raw_suspend(smx_context_t context) +static void smx_ctx_raw_wrapper(smx_ctx_raw_t context) { - SIMIX_context_set_current((smx_context_t) maestro_raw_context); - raw_swapcontext( - &((smx_ctx_raw_t) context)->stack_top, - ((smx_ctx_raw_t) context)->old_stack_top); + (context->super.code) (context->super.argc, context->super.argv); + + smx_ctx_raw_stop((smx_context_t) context); } static void smx_ctx_raw_stop(smx_context_t context) { smx_ctx_base_stop(context); - smx_ctx_raw_suspend(context); + simix_global->context_factory->suspend(context); } -static void smx_ctx_raw_wrapper(smx_ctx_raw_t context) -{ - (context->super.code) (context->super.argc, context->super.argv); - - smx_ctx_raw_stop((smx_context_t) context); +static void smx_ctx_raw_suspend_serial(smx_context_t context) +{ + /* determine the next context */ + smx_context_t next_context; + unsigned long int i = raw_process_index++; + + if (i < xbt_dynar_length(simix_global->process_to_run)) { + /* execute the next process */ + XBT_DEBUG("Run next process"); + next_context = xbt_dynar_get_as( + simix_global->process_to_run,i, smx_process_t)->context; + } + else { + /* all processes were run, return to maestro */ + XBT_DEBUG("No more process to run"); + next_context = (smx_context_t) raw_maestro_context; + } + SIMIX_context_set_current(next_context); + raw_swapcontext(&((smx_ctx_raw_t) context)->stack_top, + ((smx_ctx_raw_t) next_context)->stack_top); } -static void smx_ctx_raw_resume(smx_process_t process) +static void smx_ctx_raw_resume_serial(smx_process_t first_process) { - smx_ctx_raw_t context = (smx_ctx_raw_t)process->context; + smx_ctx_raw_t context = (smx_ctx_raw_t) first_process->context; SIMIX_context_set_current((smx_context_t) context); - raw_swapcontext( - &((smx_ctx_raw_t) context)->old_stack_top, + raw_swapcontext(&raw_maestro_context->stack_top, ((smx_ctx_raw_t) context)->stack_top); } @@ -360,69 +426,82 @@ void smx_ctx_raw_new_sr(void) XBT_VERB("New scheduling round"); } #else -static void smx_ctx_raw_runall_serial() +static void smx_ctx_raw_runall_serial(void) { - smx_process_t process; - unsigned int cursor; + if (xbt_dynar_length(simix_global->process_to_run) > 0) { + smx_process_t first_process = + xbt_dynar_get_as(simix_global->process_to_run, 0, smx_process_t); + raw_process_index = 1; - xbt_dynar_foreach(simix_global->process_to_run, cursor, process) { - XBT_DEBUG("Schedule item %u of %lu", cursor, xbt_dynar_length(simix_global->process_to_run)); - smx_ctx_raw_resume(process); + /* execute the first process */ + smx_ctx_raw_resume_serial(first_process); } } #endif -static void smx_ctx_raw_runall_parallel() +static void smx_ctx_raw_stop_parallel(smx_context_t context) +{ + smx_ctx_base_stop(context); + smx_ctx_raw_suspend_parallel(context); +} + +static void smx_ctx_raw_suspend_parallel(smx_context_t context) { #ifdef CONTEXT_THREADS - xbt_parmap_apply(parmap, (void_f_pvoid_t) smx_ctx_raw_resume, + /* determine the next context */ + smx_process_t next_work = xbt_parmap_next(raw_parmap); + smx_context_t next_context; + raw_stack_t next_stack; + + if (next_work != NULL) { + /* there is a next process to resume */ + XBT_DEBUG("Run next process"); + next_context = next_work->context; + next_stack = ((smx_ctx_raw_t) next_context)->stack_top; + } + else { + /* all processes were run, go to the barrier */ + XBT_DEBUG("No more processes to run"); + next_context = (smx_context_t) raw_maestro_context; + unsigned long worker_id = xbt_parmap_get_worker_id(raw_parmap); + next_stack = raw_local_maestro_stacks[worker_id]; + } + + SIMIX_context_set_current(next_context); + raw_swapcontext(&((smx_ctx_raw_t) context)->stack_top, next_stack); +#endif +} + +static void smx_ctx_raw_resume_parallel(smx_process_t first_process) +{ +#ifdef CONTEXT_THREADS + unsigned long worker_id = xbt_parmap_get_worker_id(raw_parmap); + raw_stack_t* local_maestro_stack = &raw_local_maestro_stacks[worker_id]; + + smx_context_t context = first_process->context; + SIMIX_context_set_current(context); + raw_swapcontext(local_maestro_stack, ((smx_ctx_raw_t) context)->stack_top); +#endif +} + +static void smx_ctx_raw_runall_parallel(void) +{ +#ifdef CONTEXT_THREADS + xbt_parmap_apply(raw_parmap, (void_f_pvoid_t) smx_ctx_raw_resume_parallel, simix_global->process_to_run); #endif } -static void smx_ctx_raw_runall() +static void smx_ctx_raw_runall(void) { unsigned long nb_processes = xbt_dynar_length(simix_global->process_to_run); if (nb_processes >= SIMIX_context_get_parallel_threshold()) { XBT_DEBUG("Runall // %lu", nb_processes); + simix_global->context_factory->suspend = smx_ctx_raw_suspend_parallel; smx_ctx_raw_runall_parallel(); } else { XBT_DEBUG("Runall serial %lu", nb_processes); + simix_global->context_factory->suspend = smx_ctx_raw_suspend_serial; smx_ctx_raw_runall_serial(); } } - -void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory) -{ - XBT_VERB("Using raw contexts. Because the glibc is just not good enough for us."); - smx_ctx_base_factory_init(factory); - - (*factory)->finalize = smx_ctx_raw_factory_finalize; - (*factory)->create_context = smx_ctx_raw_create_context; - /* Do not overload that method (*factory)->finalize */ - (*factory)->free = smx_ctx_raw_free; - (*factory)->stop = smx_ctx_raw_stop; - (*factory)->suspend = smx_ctx_raw_suspend; - (*factory)->name = "smx_raw_context_factory"; - - if (SIMIX_context_is_parallel()) { -#ifdef CONTEXT_THREADS - parmap = xbt_parmap_new(SIMIX_context_get_nthreads()); -#endif - if (SIMIX_context_get_parallel_threshold() > 1) { - /* choose dynamically */ - (*factory)->runall = smx_ctx_raw_runall; - } - else { - /* always parallel */ - (*factory)->runall = smx_ctx_raw_runall_parallel; - } - } - else { - /* always serial */ - (*factory)->runall = smx_ctx_raw_runall_serial; - } -#ifdef TIME_BENCH - timer = xbt_os_timer_new(); -#endif -} diff --git a/src/simix/smx_context_sysv.c b/src/simix/smx_context_sysv.c index 626c9ecfea..f57d5a942d 100644 --- a/src/simix/smx_context_sysv.c +++ b/src/simix/smx_context_sysv.c @@ -26,8 +26,8 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context); #ifdef CONTEXT_THREADS -static xbt_parmap_t parmap; -static ucontext_t* smx_ctx_sysv_local_maestro_uc; /* space to save maestro's stack in each thead */ +static xbt_parmap_t smx_ctx_sysv_parmap; +static ucontext_t* smx_ctx_sysv_local_maestro_uc; /* space to save maestro's stack in each thread */ #endif static unsigned long smx_ctx_sysv_process_index = 0; /* index of the next process to run in the * list of runnable processes */ @@ -80,7 +80,7 @@ void SIMIX_ctx_sysv_factory_init(smx_context_factory_t *factory) if (SIMIX_context_is_parallel()) { #ifdef CONTEXT_THREADS /* To use parallel ucontexts a thread pool is needed */ int nthreads = SIMIX_context_get_nthreads(); - parmap = xbt_parmap_new(nthreads); + smx_ctx_sysv_parmap = xbt_parmap_new(nthreads); smx_ctx_sysv_local_maestro_uc = xbt_new(ucontext_t, nthreads); (*factory)->stop = smx_ctx_sysv_stop_parallel; (*factory)->suspend = smx_ctx_sysv_suspend_parallel; @@ -99,8 +99,8 @@ void SIMIX_ctx_sysv_factory_init(smx_context_factory_t *factory) int smx_ctx_sysv_factory_finalize(smx_context_factory_t *factory) { #ifdef CONTEXT_THREADS - if (parmap) - xbt_parmap_destroy(parmap); + if (smx_ctx_sysv_parmap) + xbt_parmap_destroy(smx_ctx_sysv_parmap); xbt_free(smx_ctx_sysv_local_maestro_uc); #endif return smx_ctx_base_factory_finalize(factory); @@ -258,7 +258,7 @@ static void smx_ctx_sysv_suspend_parallel(smx_context_t context) { #ifdef CONTEXT_THREADS /* determine the next context */ - smx_process_t next_work = xbt_parmap_next(parmap); + smx_process_t next_work = xbt_parmap_next(smx_ctx_sysv_parmap); smx_context_t next_context; ucontext_t* next_uc; @@ -272,7 +272,7 @@ static void smx_ctx_sysv_suspend_parallel(smx_context_t context) /* all processes were run, go to the barrier */ XBT_DEBUG("No more processes to run"); next_context = (smx_context_t) smx_ctx_sysv_maestro_context; - unsigned long worker_id = (unsigned long) xbt_os_thread_get_extra_data(); + unsigned long worker_id = xbt_parmap_get_worker_id(smx_ctx_sysv_parmap); next_uc = &smx_ctx_sysv_local_maestro_uc[worker_id]; } @@ -284,7 +284,7 @@ static void smx_ctx_sysv_suspend_parallel(smx_context_t context) static void smx_ctx_sysv_resume_parallel(smx_process_t first_process) { #ifdef CONTEXT_THREADS - unsigned long worker_id = (unsigned long) xbt_os_thread_get_extra_data(); + unsigned long worker_id = xbt_parmap_get_worker_id(smx_ctx_sysv_parmap); ucontext_t* local_maestro_uc = &smx_ctx_sysv_local_maestro_uc[worker_id]; smx_context_t context = first_process->context; @@ -296,7 +296,7 @@ static void smx_ctx_sysv_resume_parallel(smx_process_t first_process) static void smx_ctx_sysv_runall_parallel(void) { #ifdef CONTEXT_THREADS - xbt_parmap_apply(parmap, (void_f_pvoid_t) smx_ctx_sysv_resume_parallel, + xbt_parmap_apply(smx_ctx_sysv_parmap, (void_f_pvoid_t) smx_ctx_sysv_resume_parallel, simix_global->process_to_run); #endif } diff --git a/src/surf/surf_config.c b/src/surf/surf_config.c index f269695277..8dc4779c57 100644 --- a/src/surf/surf_config.c +++ b/src/surf/surf_config.c @@ -411,7 +411,7 @@ void surf_config_init(int *argc, char **argv) /* minimal number of user contexts to be run in parallel */ default_value_int = 1; xbt_cfg_register(&_surf_cfg_set, "contexts/parallel_threshold", - "Minimal number of user contexts to be run in parallel", + "Minimal number of user contexts to be run in parallel (raw contexts only)", xbt_cfgelm_int, &default_value_int, 1, 1, _surf_cfg_cb_contexts_parallel_threshold, NULL); -- 2.20.1