src/simix/smx_context.cpp

   1 /* a fast and simple context switching library                              */
   2
   3 /* Copyright (c) 2009-2019. The SimGrid Team. All rights reserved.          */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "src/simix/smx_private.hpp"
   9 #include "xbt/config.hpp"
  10
  11 #include <thread>
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_context, simix, "Context switching mechanism");
  14
  15 static std::pair<const char*, simgrid::kernel::context::ContextFactoryInitializer> context_factories[] = {
  16 #if HAVE_RAW_CONTEXTS
  17   { "raw", &simgrid::kernel::context::raw_factory },
  18 #endif
  19 #if HAVE_UCONTEXT_CONTEXTS
  20   { "ucontext", &simgrid::kernel::context::sysv_factory },
  21 #endif
  22 #if HAVE_BOOST_CONTEXTS
  23   { "boost", &simgrid::kernel::context::boost_factory },
  24 #endif
  25   { "thread", &simgrid::kernel::context::thread_factory },
  26 };
  27
  28 static_assert(sizeof(context_factories) != 0, "No context factories are enabled for this build");
  29
  30 // Create the list of possible contexts:
  31 static inline
  32 std::string contexts_list()
  33 {
  34   std::string res;
  35   const std::size_t n = sizeof(context_factories) / sizeof(context_factories[0]);
  36   for (std::size_t i = 1; i != n; ++i) {
  37     res += ", ";
  38     res += context_factories[i].first;
  39   }
  40   return res;
  41 }
  42
  43 static simgrid::config::Flag<std::string> context_factory_name(
  44   "contexts/factory",
  45   (std::string("Possible values: ")+contexts_list()).c_str(),
  46   context_factories[0].first);
  47
  48 unsigned smx_context_stack_size;
  49 int smx_context_stack_size_was_set = 0;
  50 unsigned smx_context_guard_size;
  51 int smx_context_guard_size_was_set = 0;
  52 static int smx_parallel_contexts = 1;
  53 static int smx_parallel_threshold = 2;
  54 static e_xbt_parmap_mode_t smx_parallel_synchronization_mode = XBT_PARMAP_DEFAULT;
  55
  56 /**
  57  * This function is called by SIMIX_global_init() to initialize the context module.
  58  */
  59 void SIMIX_context_mod_init()
  60 {
  61   xbt_assert(simix_global->context_factory == nullptr);
  62
  63   smx_context_stack_size_was_set = not simgrid::config::is_default("contexts/stack-size");
  64   smx_context_guard_size_was_set = not simgrid::config::is_default("contexts/guard-size");
  65
  66 #if HAVE_SMPI && (defined(__APPLE__) || defined(__NetBSD__))
  67   std::string priv = simgrid::config::get_value<std::string>("smpi/privatization");
  68   if (context_factory_name == "thread" && (priv == "dlopen" || priv == "yes" || priv == "default" || priv == "1")) {
  69     XBT_WARN("dlopen+thread broken on Apple and BSD. Switching to raw contexts.");
  70     context_factory_name = "raw";
  71   }
  72 #endif
  73
  74 #if HAVE_SMPI && defined(__FreeBSD__)
  75   if (context_factory_name == "thread" && simgrid::config::get_value<std::string>("smpi/privatization") != "no") {
  76     XBT_WARN("mmap broken on FreeBSD, but dlopen+thread broken too. Switching to dlopen+raw contexts.");
  77     context_factory_name = "raw";
  78   }
  79 #endif
  80
  81   /* select the context factory to use to create the contexts */
  82   if (simgrid::kernel::context::factory_initializer != nullptr) { // Give Java a chance to hijack the factory mechanism
  83     simix_global->context_factory = simgrid::kernel::context::factory_initializer();
  84     return;
  85   }
  86   /* use the factory specified by --cfg=contexts/factory:value */
  87   for (auto const& factory : context_factories)
  88     if (context_factory_name == factory.first) {
  89       simix_global->context_factory = factory.second();
  90       break;
  91     }
  92
  93   if (simix_global->context_factory == nullptr) {
  94     XBT_ERROR("Invalid context factory specified. Valid factories on this machine:");
  95 #if HAVE_RAW_CONTEXTS
  96     XBT_ERROR("  raw: high performance context factory implemented specifically for SimGrid");
  97 #else
  98     XBT_ERROR("  (raw contexts were disabled at compilation time on this machine -- check configure logs for details)");
  99 #endif
 100 #if HAVE_UCONTEXT_CONTEXTS
 101     XBT_ERROR("  ucontext: classical system V contexts (implemented with makecontext, swapcontext and friends)");
 102 #else
 103     XBT_ERROR("  (ucontext was disabled at compilation time on this machine -- check configure logs for details)");
 104 #endif
 105 #if HAVE_BOOST_CONTEXTS
 106     XBT_ERROR("  boost: this uses the boost libraries context implementation");
 107 #else
 108     XBT_ERROR("  (boost was disabled at compilation time on this machine -- check configure logs for details. Did you install the libboost-context-dev package?)");
 109 #endif
 110     XBT_ERROR("  thread: slow portability layer using pthreads as provided by gcc");
 111     xbt_die("Please use a valid factory.");
 112   }
 113 }
 114
 115 /**
 116  * This function is called by SIMIX_clean() to finalize the context module.
 117  */
 118 void SIMIX_context_mod_exit()
 119 {
 120   delete simix_global->context_factory;
 121   simix_global->context_factory = nullptr;
 122 }
 123
 124 /** @brief Returns whether some parallel threads are used for the user contexts. */
 125 int SIMIX_context_is_parallel() {
 126   return smx_parallel_contexts > 1;
 127 }
 128
 129 /**
 130  * @brief Returns the number of parallel threads used for the user contexts.
 131  * @return the number of threads (1 means no parallelism)
 132  */
 133 int SIMIX_context_get_nthreads() {
 134   return smx_parallel_contexts;
 135 }
 136
 137 /**
 138  * @brief Sets the number of parallel threads to use
 139  * for the user contexts.
 140  *
 141  * This function should be called before initializing SIMIX.
 142  * A value of 1 means no parallelism (1 thread only).
 143  * If the value is greater than 1, the thread support must be enabled.
 144  *
 145  * @param nb_threads the number of threads to use
 146  */
 147 void SIMIX_context_set_nthreads(int nb_threads) {
 148   if (nb_threads<=0) {
 149     nb_threads = std::thread::hardware_concurrency();
 150     XBT_INFO("Auto-setting contexts/nthreads to %d", nb_threads);
 151   }
 152   smx_parallel_contexts = nb_threads;
 153 }
 154
 155 /**
 156  * @brief Returns the threshold above which user processes are run in parallel.
 157  *
 158  * If the number of threads is set to 1, there is no parallelism and this
 159  * threshold has no effect.
 160  *
 161  * @return when the number of user processes ready to run is above
 162  * this threshold, they are run in parallel
 163  */
 164 int SIMIX_context_get_parallel_threshold() {
 165   return smx_parallel_threshold;
 166 }
 167
 168 /**
 169  * @brief Sets the threshold above which user processes are run in parallel.
 170  *
 171  * If the number of threads is set to 1, there is no parallelism and this
 172  * threshold has no effect.
 173  *
 174  * @param threshold when the number of user processes ready to run is above
 175  * this threshold, they are run in parallel
 176  */
 177 void SIMIX_context_set_parallel_threshold(int threshold) {
 178   smx_parallel_threshold = threshold;
 179 }
 180
 181 /**
 182  * @brief Returns the synchronization mode used when processes are run in
 183  * parallel.
 184  * @return how threads are synchronized if processes are run in parallel
 185  */
 186 e_xbt_parmap_mode_t SIMIX_context_get_parallel_mode() {
 187   return smx_parallel_synchronization_mode;
 188 }
 189
 190 /**
 191  * @brief Sets the synchronization mode to use when processes are run in
 192  * parallel.
 193  * @param mode how to synchronize threads if processes are run in parallel
 194  */
 195 void SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode) {
 196   smx_parallel_synchronization_mode = mode;
 197 }