Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix initialization order.
[simgrid.git] / src / simix / smx_context.c
1 /* a fast and simple context switching library                              */
2
3 /* Copyright (c) 2009-2013. 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
17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_context, simix,
18                                 "Context switching mechanism");
19
20 char* smx_context_factory_name = NULL; /* factory name specified by --cfg=contexts/factory:value */
21 smx_ctx_factory_initializer_t smx_factory_initializer_to_use = NULL;
22 int smx_context_stack_size = 128 * 1024;
23 int smx_context_stack_size_was_set = 0;
24 #ifdef HAVE_THREAD_LOCAL_STORAGE
25 static __thread smx_context_t smx_current_context_parallel;
26 #else
27 static xbt_os_thread_key_t smx_current_context_key = 0;
28 #endif
29 static smx_context_t smx_current_context_serial;
30 static int smx_parallel_contexts = 1;
31 static int smx_parallel_threshold = 2;
32 static e_xbt_parmap_mode_t smx_parallel_synchronization_mode = XBT_PARMAP_DEFAULT;
33
34 /** 
35  * This function is called by SIMIX_global_init() to initialize the context module.
36  */
37 void SIMIX_context_mod_init(void)
38 {
39 #if defined(CONTEXT_THREADS) && !defined(HAVE_THREAD_LOCAL_STORAGE)
40   /* the __thread storage class is not available on this platform:
41    * use getspecific/setspecific instead to store the current context in each thread */
42   xbt_os_thread_key_create(&smx_current_context_key);
43 #endif
44   if (!simix_global->context_factory) {
45     /* select the context factory to use to create the contexts */
46     if (smx_factory_initializer_to_use) {
47       smx_factory_initializer_to_use(&simix_global->context_factory);
48     }
49     else { /* use the factory specified by --cfg=contexts/factory:value */
50
51
52       if (!strcmp(smx_context_factory_name, "thread")) {
53         /* use os threads (either pthreads or windows ones) */
54         SIMIX_ctx_thread_factory_init(&simix_global->context_factory);
55       }
56 #ifdef CONTEXT_UCONTEXT
57       else if (!strcmp(smx_context_factory_name, "ucontext")) {
58         /* use ucontext */
59         SIMIX_ctx_sysv_factory_init(&simix_global->context_factory);
60       }
61 #endif
62 #ifdef HAVE_RAWCTX
63       else if (!strcmp(smx_context_factory_name, "raw")) {
64         /* use raw contexts */
65         SIMIX_ctx_raw_factory_init(&simix_global->context_factory);
66       }
67 #endif
68       else {
69         XBT_ERROR("Invalid context factory specified. Valid factories on this machine:");
70 #ifdef HAVE_RAWCTX
71         XBT_ERROR("  raw: high performance context factory implemented specifically for SimGrid");
72 #else
73         XBT_ERROR("  (raw contexts are disabled at compilation time on this machine -- check configure logs for details)");
74 #endif
75 #ifdef CONTEXT_UCONTEXT
76         XBT_ERROR("  ucontext: classical system V contexts (implemented with makecontext, swapcontext and friends)");
77 #else
78         XBT_ERROR("  (ucontext is disabled at compilation time on this machine -- check configure logs for details)");
79 #endif
80         XBT_ERROR("  thread: slow portability layer using system threads (pthreads on UNIX, CreateThread() on windows)");
81         xbt_die("Please use a valid factory.");
82       }
83     }
84   }
85 }
86
87 /**
88  * This function is called by SIMIX_clean() to finalize the context module.
89  */
90 void SIMIX_context_mod_exit(void)
91 {
92   if (simix_global->context_factory) {
93     smx_pfn_context_factory_finalize_t finalize_factory;
94
95     /* finalize the context factory */
96     finalize_factory = simix_global->context_factory->finalize;
97     finalize_factory(&simix_global->context_factory);
98   }
99   xbt_dict_remove((xbt_dict_t) _sg_cfg_set,"contexts/factory");
100 }
101
102 /**
103  * \brief Returns whether some parallel threads are used
104  * for the user contexts.
105  * \return 1 if parallelism is used
106  */
107 XBT_INLINE int SIMIX_context_is_parallel(void) {
108   return smx_parallel_contexts > 1;
109 }
110
111 /**
112  * \brief Returns the number of parallel threads used
113  * for the user contexts.
114  * \return the number of threads (1 means no parallelism)
115  */
116 XBT_INLINE int SIMIX_context_get_nthreads(void) {
117   return smx_parallel_contexts;
118 }
119
120 /**
121  * \brief Sets the number of parallel threads to use
122  * for the user contexts.
123  *
124  * This function should be called before initializing SIMIX.
125  * A value of 1 means no parallelism (1 thread only).
126  * If the value is greater than 1, the thread support must be enabled.
127  *
128  * \param nb_threads the number of threads to use
129  */
130 void SIMIX_context_set_nthreads(int nb_threads) {
131   if (nb_threads<=0) {  
132      nb_threads = xbt_os_get_numcores();
133      XBT_INFO("Auto-setting contexts/nthreads to %d",nb_threads);
134   }   
135   
136   if (nb_threads > 1) {
137 #ifndef CONTEXT_THREADS
138     THROWF(arg_error, 0, "The thread factory cannot be run in parallel");
139 #endif
140   }
141   smx_parallel_contexts = nb_threads;
142 }
143
144 /**
145  * \brief Returns the threshold above which user processes are run in parallel.
146  *
147  * If the number of threads is set to 1, there is no parallelism and this
148  * threshold has no effect.
149  *
150  * \return when the number of user processes ready to run is above
151  * this threshold, they are run in parallel
152  */
153 XBT_INLINE int SIMIX_context_get_parallel_threshold(void) {
154   return smx_parallel_threshold;
155 }
156
157 /**
158  * \brief Sets the threshold above which user processes are run in parallel.
159  *
160  * If the number of threads is set to 1, there is no parallelism and this
161  * threshold has no effect.
162  *
163  * \param threshold when the number of user processes ready to run is above
164  * this threshold, they are run in parallel
165  */
166 XBT_INLINE void SIMIX_context_set_parallel_threshold(int threshold) {
167   smx_parallel_threshold = threshold;
168 }
169
170 /**
171  * \brief Returns the synchronization mode used when processes are run in
172  * parallel.
173  * \return how threads are synchronized if processes are run in parallel
174  */
175 XBT_INLINE e_xbt_parmap_mode_t SIMIX_context_get_parallel_mode(void) {
176   return smx_parallel_synchronization_mode;
177 }
178
179 /**
180  * \brief Sets the synchronization mode to use when processes are run in
181  * parallel.
182  * \param mode how to synchronize threads if processes are run in parallel
183  */
184 XBT_INLINE void SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode) {
185   smx_parallel_synchronization_mode = mode;
186 }
187
188 /**
189  * \brief Returns the current context of this thread.
190  * \return the current context of this thread
191  */
192 XBT_INLINE smx_context_t SIMIX_context_get_current(void)
193 {
194   if (SIMIX_context_is_parallel()) {
195 #ifdef HAVE_THREAD_LOCAL_STORAGE
196     return smx_current_context_parallel;
197 #else
198     return xbt_os_thread_get_specific(smx_current_context_key);
199 #endif
200   }
201   else {
202     return smx_current_context_serial;
203   }
204 }
205
206 /**
207  * \brief Sets the current context of this thread.
208  * \param context the context to set
209  */
210 XBT_INLINE void SIMIX_context_set_current(smx_context_t context)
211 {
212   if (SIMIX_context_is_parallel()) {
213 #ifdef HAVE_THREAD_LOCAL_STORAGE
214     smx_current_context_parallel = context;
215 #else
216     xbt_os_thread_set_specific(smx_current_context_key, context);
217 #endif
218   }
219   else {
220     smx_current_context_serial = context;
221   }
222 }