Logo AND Algorithmique Numérique Distribuée

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