src/simix/smx_context.c

   1 /* a fast and simple context switching library                              */
   2
   3 /* Copyright (c) 2009-2014. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /* This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the license (GNU LGPL) which comes with this package. */
   8
   9 #include "portable.h"
  10 #include "xbt/log.h"
  11 #include "xbt/swag.h"
  12 #include "xbt/xbt_os_thread.h"
  13 #include "smx_private.h"
  14 #include "simgrid/sg_config.h"
  15 #include "internal_config.h"
  16 #include "simgrid/modelchecker.h"
  17 #include <sys/mman.h>
  18
  19 #ifdef HAVE_VALGRIND_VALGRIND_H
  20 # include <valgrind/valgrind.h>
  21 #endif
  22
  23 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_context, simix,
  24                                 "Context switching mechanism");
  25
  26 char* smx_context_factory_name = NULL; /* factory name specified by --cfg=contexts/factory:value */
  27 smx_ctx_factory_initializer_t smx_factory_initializer_to_use = NULL;
  28 int smx_context_stack_size;
  29 int smx_context_stack_size_was_set = 0;
  30 int smx_context_guard_size;
  31 int smx_context_guard_size_was_set = 0;
  32 #ifdef HAVE_THREAD_LOCAL_STORAGE
  33 static __thread smx_context_t smx_current_context_parallel;
  34 #else
  35 static xbt_os_thread_key_t smx_current_context_key = 0;
  36 #endif
  37 static smx_context_t smx_current_context_serial;
  38 static int smx_parallel_contexts = 1;
  39 static int smx_parallel_threshold = 2;
  40 static e_xbt_parmap_mode_t smx_parallel_synchronization_mode = XBT_PARMAP_DEFAULT;
  41
  42 /**
  43  * This function is called by SIMIX_global_init() to initialize the context module.
  44  */
  45 void SIMIX_context_mod_init(void)
  46 {
  47 #if defined(CONTEXT_THREADS) && !defined(HAVE_THREAD_LOCAL_STORAGE)
  48   /* the __thread storage class is not available on this platform:
  49    * use getspecific/setspecific instead to store the current context in each thread */
  50   xbt_os_thread_key_create(&smx_current_context_key);
  51 #endif
  52   if (!simix_global->context_factory) {
  53     /* select the context factory to use to create the contexts */
  54     if (smx_factory_initializer_to_use) {
  55       smx_factory_initializer_to_use(&simix_global->context_factory);
  56     }
  57     else { /* use the factory specified by --cfg=contexts/factory:value */
  58
  59
  60       if (!strcmp(smx_context_factory_name, "thread")) {
  61         /* use os threads (either pthreads or windows ones) */
  62         SIMIX_ctx_thread_factory_init(&simix_global->context_factory);
  63       }
  64 #ifdef CONTEXT_UCONTEXT
  65       else if (!strcmp(smx_context_factory_name, "ucontext")) {
  66         /* use ucontext */
  67         SIMIX_ctx_sysv_factory_init(&simix_global->context_factory);
  68       }
  69 #endif
  70 #ifdef HAVE_RAWCTX
  71       else if (!strcmp(smx_context_factory_name, "raw")) {
  72         /* use raw contexts */
  73         SIMIX_ctx_raw_factory_init(&simix_global->context_factory);
  74       }
  75 #endif
  76       else {
  77         XBT_ERROR("Invalid context factory specified. Valid factories on this machine:");
  78 #ifdef HAVE_RAWCTX
  79         XBT_ERROR("  raw: high performance context factory implemented specifically for SimGrid");
  80 #else
  81         XBT_ERROR("  (raw contexts are disabled at compilation time on this machine -- check configure logs for details)");
  82 #endif
  83 #ifdef CONTEXT_UCONTEXT
  84         XBT_ERROR("  ucontext: classical system V contexts (implemented with makecontext, swapcontext and friends)");
  85 #else
  86         XBT_ERROR("  (ucontext is disabled at compilation time on this machine -- check configure logs for details)");
  87 #endif
  88         XBT_ERROR("  thread: slow portability layer using system threads (pthreads on UNIX, CreateThread() on windows)");
  89         xbt_die("Please use a valid factory.");
  90       }
  91     }
  92   }
  93 }
  94
  95 /**
  96  * This function is called by SIMIX_clean() to finalize the context module.
  97  */
  98 void SIMIX_context_mod_exit(void)
  99 {
 100   if (simix_global->context_factory) {
 101     smx_pfn_context_factory_finalize_t finalize_factory;
 102
 103     /* finalize the context factory */
 104     finalize_factory = simix_global->context_factory->finalize;
 105     finalize_factory(&simix_global->context_factory);
 106   }
 107   xbt_dict_remove((xbt_dict_t) _sg_cfg_set,"contexts/factory");
 108 }
 109
 110 void *SIMIX_context_stack_new(void)
 111 {
 112   void *stack;
 113
 114   if (smx_context_guard_size > 0 && !MC_is_active()) {
 115     size_t size = smx_context_stack_size + smx_context_guard_size;
 116 #ifdef HAVE_MC
 117     /* Cannot use posix_memalign when HAVE_MC. Align stack by hand, and save the
 118      * pointer returned by xbt_malloc0. */
 119     char *alloc = xbt_malloc0(size + xbt_pagesize);
 120     stack = alloc - ((uintptr_t)alloc & (xbt_pagesize - 1)) + xbt_pagesize;
 121     *((void **)stack - 1) = alloc;
 122 #else
 123     if (posix_memalign(&stack, xbt_pagesize, size) != 0)
 124       xbt_die("Failed to allocate stack.");
 125 #endif
 126     if (mprotect(stack, smx_context_guard_size, PROT_NONE) == -1) {
 127       XBT_WARN("Failed to protect stack: %s", strerror(errno));
 128       /* That's not fatal, pursue anyway. */
 129     }
 130     stack = (char *)stack + smx_context_guard_size;
 131   } else {
 132     stack = xbt_malloc0(smx_context_stack_size);
 133   }
 134
 135 #ifdef HAVE_VALGRIND_VALGRIND_H
 136   unsigned int valgrind_stack_id =
 137     VALGRIND_STACK_REGISTER(stack, (char *)stack + smx_context_stack_size);
 138   memcpy((char *)stack + smx_context_usable_stack_size, &valgrind_stack_id,
 139          sizeof valgrind_stack_id);
 140 #endif
 141
 142   return stack;
 143 }
 144
 145 void SIMIX_context_stack_delete(void *stack)
 146 {
 147   if (!stack)
 148     return;
 149
 150 #ifdef HAVE_VALGRIND_VALGRIND_H
 151   unsigned int valgrind_stack_id;
 152   memcpy(&valgrind_stack_id, (char *)stack + smx_context_usable_stack_size,
 153          sizeof valgrind_stack_id);
 154   VALGRIND_STACK_DEREGISTER(valgrind_stack_id);
 155 #endif
 156
 157   if (smx_context_guard_size > 0 && !MC_is_active()) {
 158     stack = (char *)stack - smx_context_guard_size;
 159     if (mprotect(stack, smx_context_guard_size,
 160                  PROT_READ | PROT_WRITE | PROT_EXEC) == -1) {
 161       XBT_WARN("Failed to remove page protection: %s", strerror(errno));
 162       /* try to pursue anyway */
 163     }
 164 #ifdef HAVE_MC
 165     /* Retrieve the saved pointer.  See SIMIX_context_stack_new above. */
 166     stack = *((void **)stack - 1);
 167 #endif
 168   }
 169   xbt_free(stack);
 170 }
 171
 172 /**
 173  * \brief Returns whether some parallel threads are used
 174  * for the user contexts.
 175  * \return 1 if parallelism is used
 176  */
 177 XBT_INLINE int SIMIX_context_is_parallel(void) {
 178   return smx_parallel_contexts > 1;
 179 }
 180
 181 /**
 182  * \brief Returns the number of parallel threads used
 183  * for the user contexts.
 184  * \return the number of threads (1 means no parallelism)
 185  */
 186 XBT_INLINE int SIMIX_context_get_nthreads(void) {
 187   return smx_parallel_contexts;
 188 }
 189
 190 /**
 191  * \brief Sets the number of parallel threads to use
 192  * for the user contexts.
 193  *
 194  * This function should be called before initializing SIMIX.
 195  * A value of 1 means no parallelism (1 thread only).
 196  * If the value is greater than 1, the thread support must be enabled.
 197  *
 198  * \param nb_threads the number of threads to use
 199  */
 200 void SIMIX_context_set_nthreads(int nb_threads) {
 201   if (nb_threads<=0) {
 202      nb_threads = xbt_os_get_numcores();
 203      XBT_INFO("Auto-setting contexts/nthreads to %d",nb_threads);
 204   }
 205
 206   if (nb_threads > 1) {
 207 #ifndef CONTEXT_THREADS
 208     THROWF(arg_error, 0, "The thread factory cannot be run in parallel");
 209 #endif
 210   }
 211   smx_parallel_contexts = nb_threads;
 212 }
 213
 214 /**
 215  * \brief Returns the threshold above which user processes are run in parallel.
 216  *
 217  * If the number of threads is set to 1, there is no parallelism and this
 218  * threshold has no effect.
 219  *
 220  * \return when the number of user processes ready to run is above
 221  * this threshold, they are run in parallel
 222  */
 223 XBT_INLINE int SIMIX_context_get_parallel_threshold(void) {
 224   return smx_parallel_threshold;
 225 }
 226
 227 /**
 228  * \brief Sets the threshold above which user processes are run in parallel.
 229  *
 230  * If the number of threads is set to 1, there is no parallelism and this
 231  * threshold has no effect.
 232  *
 233  * \param threshold when the number of user processes ready to run is above
 234  * this threshold, they are run in parallel
 235  */
 236 XBT_INLINE void SIMIX_context_set_parallel_threshold(int threshold) {
 237   smx_parallel_threshold = threshold;
 238 }
 239
 240 /**
 241  * \brief Returns the synchronization mode used when processes are run in
 242  * parallel.
 243  * \return how threads are synchronized if processes are run in parallel
 244  */
 245 XBT_INLINE e_xbt_parmap_mode_t SIMIX_context_get_parallel_mode(void) {
 246   return smx_parallel_synchronization_mode;
 247 }
 248
 249 /**
 250  * \brief Sets the synchronization mode to use when processes are run in
 251  * parallel.
 252  * \param mode how to synchronize threads if processes are run in parallel
 253  */
 254 XBT_INLINE void SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode) {
 255   smx_parallel_synchronization_mode = mode;
 256 }
 257
 258 /**
 259  * \brief Returns the current context of this thread.
 260  * \return the current context of this thread
 261  */
 262 XBT_INLINE smx_context_t SIMIX_context_get_current(void)
 263 {
 264   if (SIMIX_context_is_parallel()) {
 265 #ifdef HAVE_THREAD_LOCAL_STORAGE
 266     return smx_current_context_parallel;
 267 #else
 268     return xbt_os_thread_get_specific(smx_current_context_key);
 269 #endif
 270   }
 271   else {
 272     return smx_current_context_serial;
 273   }
 274 }
 275
 276 /**
 277  * \brief Sets the current context of this thread.
 278  * \param context the context to set
 279  */
 280 XBT_INLINE void SIMIX_context_set_current(smx_context_t context)
 281 {
 282   if (SIMIX_context_is_parallel()) {
 283 #ifdef HAVE_THREAD_LOCAL_STORAGE
 284     smx_current_context_parallel = context;
 285 #else
 286     xbt_os_thread_set_specific(smx_current_context_key, context);
 287 #endif
 288   }
 289   else {
 290     smx_current_context_serial = context;
 291   }
 292 }