Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
fix warning and build
[simgrid.git] / src / simix / smx_context.cpp
1 /* a fast and simple context switching library                              */
2
3 /* Copyright (c) 2009-2015. 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 <utility>
10 #include <string>
11
12 #include <xbt/config.hpp>
13 #include <xbt/range.hpp>
14
15 #include "src/internal_config.h"
16 #include "xbt/log.h"
17 #include "xbt/swag.h"
18 #include "xbt/xbt_os_thread.h"
19 #include "smx_private.h"
20 #include "smx_private.hpp"
21 #include "simgrid/sg_config.h"
22 #include "src/internal_config.h"
23 #include "simgrid/modelchecker.h"
24
25
26 #ifdef _WIN32
27 #include <windows.h>
28 #include <malloc.h>
29 #else
30 #include <sys/mman.h>
31 #endif
32
33 #ifdef __MINGW32__ 
34 #define _aligned_malloc __mingw_aligned_malloc 
35 #define _aligned_free  __mingw_aligned_free 
36 #endif //MINGW
37
38 #if HAVE_VALGRIND_H
39 # include <valgrind/valgrind.h>
40 #endif
41
42 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_context, simix, "Context switching mechanism");
43
44 static std::pair<const char*, simgrid::simix::ContextFactoryInitializer> context_factories[] = {
45 #if HAVE_RAW_CONTEXTS
46   { "raw", simgrid::simix::raw_factory },
47 #endif
48 #if HAVE_UCONTEXT_CONTEXTS
49   { "ucontext", simgrid::simix::sysv_factory },
50 #endif
51 #if HAVE_BOOST_CONTEXTS
52   { "boost", simgrid::simix::boost_factory },
53 #endif
54 #if HAVE_THREAD_CONTEXTS
55   { "thread", simgrid::simix::thread_factory },
56 #endif
57 };
58
59 static_assert(sizeof(context_factories) != 0,
60   "No context factories are enabled for this build");
61
62 // Create the list of possible contexts:
63 static inline
64 std::string contexts_list()
65 {
66   std::string res;
67   const std::size_t n = sizeof(context_factories) / sizeof(context_factories[0]);
68   for (std::size_t i = 1; i != n; ++i) {
69     res += ", ";
70     res += context_factories[i].first;
71   }
72   return res;
73 }
74
75 static simgrid::config::Flag<std::string> context_factory_name(
76   "contexts/factory",
77   (std::string("Possible values: ")+contexts_list()).c_str(),
78   context_factories[0].first);
79
80 int smx_context_stack_size;
81 int smx_context_stack_size_was_set = 0;
82 int smx_context_guard_size;
83 int smx_context_guard_size_was_set = 0;
84 #if HAVE_THREAD_LOCAL_STORAGE
85 static XBT_THREAD_LOCAL smx_context_t smx_current_context_parallel;
86 #else
87 static xbt_os_thread_key_t smx_current_context_key = 0;
88 #endif
89 static smx_context_t smx_current_context_serial;
90 static int smx_parallel_contexts = 1;
91 static int smx_parallel_threshold = 2;
92 static e_xbt_parmap_mode_t smx_parallel_synchronization_mode = XBT_PARMAP_DEFAULT;
93
94 static inline
95 void invalid_context_factory()
96 {
97   XBT_ERROR("Invalid context factory specified. Valid factories on this machine:");
98 #if HAVE_RAW_CONTEXTS
99   XBT_ERROR("  raw: high performance context factory implemented specifically for SimGrid");
100 #else
101   XBT_ERROR("  (raw contexts were disabled at compilation time on this machine -- check configure logs for details)");
102 #endif
103 #if HAVE_UCONTEXT_CONTEXTS
104   XBT_ERROR("  ucontext: classical system V contexts (implemented with makecontext, swapcontext and friends)");
105 #else
106   XBT_ERROR("  (ucontext was disabled at compilation time on this machine -- check configure logs for details)");
107 #endif
108 #if HAVE_BOOST_CONTEXTS
109   XBT_ERROR("  boost: this uses the boost libraries context implementation");
110 #else
111   XBT_ERROR("  (boost was disabled at compilation time on this machine -- check configure logs for details. Did you install the libboost-context-dev package?)");
112 #endif
113   XBT_ERROR("  thread: slow portability layer using pthreads as provided by gcc");
114   xbt_die("Please use a valid factory.");
115 }
116
117 /**
118  * This function is called by SIMIX_global_init() to initialize the context module.
119  */
120 void SIMIX_context_mod_init(void)
121 {
122 #if HAVE_THREAD_CONTEXTS && !HAVE_THREAD_LOCAL_STORAGE
123   /* the __thread storage class is not available on this platform:
124    * use getspecific/setspecific instead to store the current context in each thread */
125   xbt_os_thread_key_create(&smx_current_context_key);
126 #endif
127   if (simix_global->context_factory)
128     return;
129   /* select the context factory to use to create the contexts */
130   if (simgrid::simix::factory_initializer) {
131     simix_global->context_factory = simgrid::simix::factory_initializer();
132     return;
133   }
134   /* use the factory specified by --cfg=contexts/factory:value */
135   for (auto const& factory : context_factories)
136     if (context_factory_name == factory.first) {
137       simix_global->context_factory = factory.second();
138       break;
139     }
140   if (simix_global->context_factory == nullptr)
141     invalid_context_factory();
142 }
143
144 /**
145  * This function is called by SIMIX_clean() to finalize the context module.
146  */
147 void SIMIX_context_mod_exit(void)
148 {
149   delete simix_global->context_factory;
150   simix_global->context_factory = nullptr;
151 }
152
153 void *SIMIX_context_stack_new(void)
154 {
155   void *stack;
156
157   /* FIXME: current code for stack overflow protection assumes that stacks are
158    * growing downward (PTH_STACKGROWTH == -1).  Protected pages need to be put
159    * after the stack when PTH_STACKGROWTH == 1. */
160
161   if (smx_context_guard_size > 0 && !MC_is_active()) {
162
163 #if !defined(PTH_STACKGROWTH) || (PTH_STACKGROWTH != -1)
164     static int warned_once = 0;
165     if (!warned_once) {
166       XBT_WARN("Stack overflow protection is known to be broken on your system.  Either stack grows upwards, or it was not even tested properly.");
167       warned_once = 1;
168     }
169 #endif
170
171     size_t size = smx_context_stack_size + smx_context_guard_size;
172 #if HAVE_MC
173     /* Cannot use posix_memalign when HAVE_MC. Align stack by hand, and save the
174      * pointer returned by xbt_malloc0. */
175     char *alloc = (char*)xbt_malloc0(size + xbt_pagesize);
176     stack = alloc - ((uintptr_t)alloc & (xbt_pagesize - 1)) + xbt_pagesize;
177     *((void **)stack - 1) = alloc;
178 #elif !defined(_WIN32)
179     if (posix_memalign(&stack, xbt_pagesize, size) != 0)
180       xbt_die("Failed to allocate stack.");
181 #else
182     stack = _aligned_malloc(size, xbt_pagesize);
183 #endif
184
185 #ifndef _WIN32
186     if (mprotect(stack, smx_context_guard_size, PROT_NONE) == -1) {
187       xbt_die("Failed to protect stack: %s", strerror(errno));
188       /* This is fatal. We are going to fail at some point when
189          we tryi reusing this. */
190     }
191 #endif
192     stack = (char *)stack + smx_context_guard_size;
193   } else {
194     stack = xbt_malloc0(smx_context_stack_size);
195   }
196
197 #if HAVE_VALGRIND_H
198   unsigned int valgrind_stack_id = VALGRIND_STACK_REGISTER(stack, (char *)stack + smx_context_stack_size);
199   memcpy((char *)stack + smx_context_usable_stack_size, &valgrind_stack_id, sizeof valgrind_stack_id);
200 #endif
201
202   return stack;
203 }
204
205 void SIMIX_context_stack_delete(void *stack)
206 {
207   if (!stack)
208     return;
209
210 #if HAVE_VALGRIND_H
211   unsigned int valgrind_stack_id;
212   memcpy(&valgrind_stack_id, (char *)stack + smx_context_usable_stack_size, sizeof valgrind_stack_id);
213   VALGRIND_STACK_DEREGISTER(valgrind_stack_id);
214 #endif
215
216 #ifndef _WIN32
217   if (smx_context_guard_size > 0 && !MC_is_active()) {
218     stack = (char *)stack - smx_context_guard_size;
219     if (mprotect(stack, smx_context_guard_size, PROT_READ | PROT_WRITE) == -1) {
220       XBT_WARN("Failed to remove page protection: %s", strerror(errno));
221       /* try to pursue anyway */
222     }
223 #if HAVE_MC
224     /* Retrieve the saved pointer.  See SIMIX_context_stack_new above. */
225     stack = *((void **)stack - 1);
226 #endif
227   }
228 #endif /* not windows */
229
230   xbt_free(stack);
231 }
232
233 /** @brief Returns whether some parallel threads are used for the user contexts. */
234 int SIMIX_context_is_parallel(void) {
235   return smx_parallel_contexts > 1;
236 }
237
238 /**
239  * \brief Returns the number of parallel threads used
240  * for the user contexts.
241  * \return the number of threads (1 means no parallelism)
242  */
243 int SIMIX_context_get_nthreads(void) {
244   return smx_parallel_contexts;
245 }
246
247 /**
248  * \brief Sets the number of parallel threads to use
249  * for the user contexts.
250  *
251  * This function should be called before initializing SIMIX.
252  * A value of 1 means no parallelism (1 thread only).
253  * If the value is greater than 1, the thread support must be enabled.
254  *
255  * \param nb_threads the number of threads to use
256  */
257 void SIMIX_context_set_nthreads(int nb_threads) {
258   if (nb_threads<=0) {  
259      nb_threads = xbt_os_get_numcores();
260      XBT_INFO("Auto-setting contexts/nthreads to %d",nb_threads);
261   }   
262 #if !HAVE_THREAD_CONTEXTS
263   xbt_assert(nb_threads == 1, "Parallel runs are impossible when the pthreads are missing.");
264 #endif
265   smx_parallel_contexts = nb_threads;
266 }
267
268 /**
269  * \brief Returns the threshold above which user processes are run in parallel.
270  *
271  * If the number of threads is set to 1, there is no parallelism and this
272  * threshold has no effect.
273  *
274  * \return when the number of user processes ready to run is above
275  * this threshold, they are run in parallel
276  */
277 int SIMIX_context_get_parallel_threshold(void) {
278   return smx_parallel_threshold;
279 }
280
281 /**
282  * \brief Sets the threshold above which user processes are run in parallel.
283  *
284  * If the number of threads is set to 1, there is no parallelism and this
285  * threshold has no effect.
286  *
287  * \param threshold when the number of user processes ready to run is above
288  * this threshold, they are run in parallel
289  */
290 void SIMIX_context_set_parallel_threshold(int threshold) {
291   smx_parallel_threshold = threshold;
292 }
293
294 /**
295  * \brief Returns the synchronization mode used when processes are run in
296  * parallel.
297  * \return how threads are synchronized if processes are run in parallel
298  */
299 e_xbt_parmap_mode_t SIMIX_context_get_parallel_mode(void) {
300   return smx_parallel_synchronization_mode;
301 }
302
303 /**
304  * \brief Sets the synchronization mode to use when processes are run in
305  * parallel.
306  * \param mode how to synchronize threads if processes are run in parallel
307  */
308 void SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode) {
309   smx_parallel_synchronization_mode = mode;
310 }
311
312 /**
313  * \brief Returns the current context of this thread.
314  * \return the current context of this thread
315  */
316 smx_context_t SIMIX_context_get_current(void)
317 {
318   if (SIMIX_context_is_parallel()) {
319 #if HAVE_THREAD_LOCAL_STORAGE
320     return smx_current_context_parallel;
321 #else
322     return xbt_os_thread_get_specific(smx_current_context_key);
323 #endif
324   }
325   else {
326     return smx_current_context_serial;
327   }
328 }
329
330 /**
331  * \brief Sets the current context of this thread.
332  * \param context the context to set
333  */
334 void SIMIX_context_set_current(smx_context_t context)
335 {
336   if (SIMIX_context_is_parallel()) {
337 #if HAVE_THREAD_LOCAL_STORAGE
338     smx_current_context_parallel = context;
339 #else
340     xbt_os_thread_set_specific(smx_current_context_key, context);
341 #endif
342   }
343   else {
344     smx_current_context_serial = context;
345   }
346 }