Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix initialization order.
[simgrid.git] / src / simix / smx_context_sysv.c
1 /* context_sysv - context switching with ucontexts from System V           */
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 <stdarg.h>
10
11 #include "xbt/parmap.h"
12 #include "smx_private.h"
13 #include "internal_config.h"
14 #include "context_sysv_config.h"        /* loads context system definitions */
15 #include "mc/mc.h"
16
17 #ifdef _XBT_WIN32
18 #  include <win32_ucontext.h>     /* context relative declarations */
19 #else
20 #  include <ucontext.h>           /* context relative declarations */
21 #endif
22
23 #ifdef HAVE_VALGRIND_VALGRIND_H
24 #  include <valgrind/valgrind.h>
25 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
26
27 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
28
29 typedef struct s_smx_ctx_sysv {
30   s_smx_ctx_base_t super;       /* Fields of super implementation */
31   ucontext_t uc;                /* the ucontext that executes the code */
32 #ifdef HAVE_VALGRIND_VALGRIND_H
33   unsigned int valgrind_stack_id;       /* the valgrind stack id */
34 #endif
35   char stack[0];                /* the thread stack (must remain the last element of the structure) */
36 } s_smx_ctx_sysv_t, *smx_ctx_sysv_t;
37
38 #ifdef CONTEXT_THREADS
39 static xbt_parmap_t sysv_parmap;
40 static smx_ctx_sysv_t* sysv_workers_context;   /* space to save the worker's context in each thread */
41 static unsigned long sysv_threads_working;     /* number of threads that have started their work */
42 static xbt_os_thread_key_t sysv_worker_id_key; /* thread-specific storage for the thread id */
43 #endif
44 static unsigned long sysv_process_index = 0;   /* index of the next process to run in the
45                                                 * list of runnable processes */
46 static smx_ctx_sysv_t sysv_maestro_context;
47
48 static int smx_ctx_sysv_factory_finalize(smx_context_factory_t *factory);
49 static smx_context_t
50 smx_ctx_sysv_create_context_sized(size_t structure_size,
51                                   xbt_main_func_t code, int argc,
52                                   char **argv,
53                                   void_pfn_smxprocess_t cleanup_func,
54                                   void *data);
55 static void smx_ctx_sysv_free(smx_context_t context);
56 static smx_context_t
57 smx_ctx_sysv_create_context(xbt_main_func_t code, int argc, char **argv,
58     void_pfn_smxprocess_t cleanup_func, void* data);
59
60 static void smx_ctx_sysv_wrapper(int count, ...);
61
62 static void smx_ctx_sysv_stop_serial(smx_context_t context);
63 static void smx_ctx_sysv_suspend_serial(smx_context_t context);
64 static void smx_ctx_sysv_resume_serial(smx_process_t first_process);
65 static void smx_ctx_sysv_runall_serial(void);
66
67 static void smx_ctx_sysv_stop_parallel(smx_context_t context);
68 static void smx_ctx_sysv_suspend_parallel(smx_context_t context);
69 static void smx_ctx_sysv_resume_parallel(smx_process_t first_process);
70 static void smx_ctx_sysv_runall_parallel(void);
71
72 /* This is a bit paranoid about sizeof(smx_ctx_sysv_t) not being a multiple of
73  * sizeof(int), but it doesn't harm. */
74 #define CTX_ADDR_LEN                            \
75   (sizeof(smx_ctx_sysv_t) / sizeof(int) +       \
76    !!(sizeof(smx_ctx_sysv_t) % sizeof(int)))
77
78 void SIMIX_ctx_sysv_factory_init(smx_context_factory_t *factory)
79 {
80   smx_ctx_base_factory_init(factory);
81   XBT_VERB("Activating SYSV context factory");
82
83   (*factory)->finalize = smx_ctx_sysv_factory_finalize;
84   (*factory)->create_context = smx_ctx_sysv_create_context;
85   /* Do not overload that method (*factory)->finalize */
86   (*factory)->free = smx_ctx_sysv_free;
87   (*factory)->name = "smx_sysv_context_factory";
88
89   if (SIMIX_context_is_parallel()) {
90 #ifdef CONTEXT_THREADS  /* To use parallel ucontexts a thread pool is needed */
91     int nthreads = SIMIX_context_get_nthreads();
92     sysv_parmap = xbt_parmap_new(nthreads, SIMIX_context_get_parallel_mode());
93     sysv_workers_context = xbt_new(smx_ctx_sysv_t, nthreads);
94     sysv_maestro_context = NULL;
95     xbt_os_thread_key_create(&sysv_worker_id_key);
96     (*factory)->stop = smx_ctx_sysv_stop_parallel;
97     (*factory)->suspend = smx_ctx_sysv_suspend_parallel;
98     (*factory)->runall = smx_ctx_sysv_runall_parallel;
99 #else
100     THROWF(arg_error, 0, "No thread support for parallel context execution");
101 #endif
102   } else {
103     (*factory)->stop = smx_ctx_sysv_stop_serial;
104     (*factory)->suspend = smx_ctx_sysv_suspend_serial;
105     (*factory)->runall = smx_ctx_sysv_runall_serial;
106   }    
107 }
108
109 static int smx_ctx_sysv_factory_finalize(smx_context_factory_t *factory)
110
111 #ifdef CONTEXT_THREADS
112   if (sysv_parmap)
113     xbt_parmap_destroy(sysv_parmap);
114   xbt_free(sysv_workers_context);
115 #endif
116   return smx_ctx_base_factory_finalize(factory);
117 }
118
119 static smx_context_t
120 smx_ctx_sysv_create_context_sized(size_t size, xbt_main_func_t code,
121                                   int argc, char **argv,
122                                   void_pfn_smxprocess_t cleanup_func,
123                                   void *data)
124 {
125   int ctx_addr[CTX_ADDR_LEN];
126   smx_ctx_sysv_t context =
127       (smx_ctx_sysv_t) smx_ctx_base_factory_create_context_sized(size,
128                                                                  code,
129                                                                  argc,
130                                                                  argv,
131                                                                  cleanup_func,
132                                                                  data);
133
134   /* if the user provided a function for the process then use it,
135      otherwise it is the context for maestro */
136   if (code) {
137
138     getcontext(&(context->uc));
139
140     context->uc.uc_link = NULL;
141
142     context->uc.uc_stack.ss_sp =
143         pth_skaddr_makecontext(context->stack, smx_context_stack_size);
144
145     context->uc.uc_stack.ss_size =
146         pth_sksize_makecontext(context->stack, smx_context_stack_size);
147
148 #ifdef HAVE_VALGRIND_VALGRIND_H
149     context->valgrind_stack_id =
150         VALGRIND_STACK_REGISTER(context->uc.uc_stack.ss_sp,
151                                 ((char *) context->uc.uc_stack.ss_sp) +
152                                 context->uc.uc_stack.ss_size);
153 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
154     memcpy(ctx_addr, &context, sizeof(smx_ctx_sysv_t));
155     switch (CTX_ADDR_LEN) {
156     case 1:
157       makecontext(&context->uc, (void (*)())smx_ctx_sysv_wrapper,
158                   1, ctx_addr[0]);
159       break;
160     case 2:
161       makecontext(&context->uc, (void (*)())smx_ctx_sysv_wrapper,
162                   2, ctx_addr[0], ctx_addr[1]);
163       break;
164     default:
165       xbt_die("Ucontexts are not supported on this arch yet (addr len = %zu/%zu = %zu)",
166               sizeof(smx_ctx_sysv_t), sizeof(int), CTX_ADDR_LEN);
167     }
168   } else {
169     if(data != NULL && sysv_maestro_context == NULL)
170       sysv_maestro_context = context;
171   }
172
173   if(MC_is_active() && code)
174     MC_new_stack_area(context, ((smx_process_t)((smx_context_t)context)->data)->name, &(context->uc), size);
175
176   return (smx_context_t) context;
177 }
178
179 static smx_context_t
180 smx_ctx_sysv_create_context(xbt_main_func_t code, int argc, char **argv,
181     void_pfn_smxprocess_t cleanup_func,
182     void *data)
183 {
184
185   return smx_ctx_sysv_create_context_sized(sizeof(s_smx_ctx_sysv_t) + smx_context_stack_size,
186                                            code, argc, argv, cleanup_func,
187                                            data);
188
189 }
190
191 static void smx_ctx_sysv_free(smx_context_t context)
192 {
193
194   if (context) {
195
196 #ifdef HAVE_VALGRIND_VALGRIND_H
197     VALGRIND_STACK_DEREGISTER(((smx_ctx_sysv_t)
198                                context)->valgrind_stack_id);
199 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
200
201   }
202   smx_ctx_base_free(context);
203 }
204
205 static void smx_ctx_sysv_wrapper(int first, ...)
206
207   int ctx_addr[CTX_ADDR_LEN];
208   smx_ctx_sysv_t context;
209
210   ctx_addr[0] = first;
211   if (CTX_ADDR_LEN > 1) {
212     va_list ap;
213     int i;
214     va_start(ap, first);
215     for (i = 1; i < CTX_ADDR_LEN; i++)
216       ctx_addr[i] = va_arg(ap, int);
217     va_end(ap);
218   }
219   memcpy(&context, ctx_addr, sizeof(smx_ctx_sysv_t));
220   (context->super.code) (context->super.argc, context->super.argv);
221
222   simix_global->context_factory->stop((smx_context_t) context);
223 }
224
225 static void smx_ctx_sysv_stop_serial(smx_context_t context)
226 {
227   smx_ctx_base_stop(context);
228   smx_ctx_sysv_suspend_serial(context);
229 }
230
231 static void smx_ctx_sysv_suspend_serial(smx_context_t context)
232 {
233   /* determine the next context */
234   smx_context_t next_context;
235   unsigned long int i = sysv_process_index++;
236
237   if (i < xbt_dynar_length(simix_global->process_to_run)) {
238     /* execute the next process */
239     XBT_DEBUG("Run next process");
240     next_context = xbt_dynar_get_as(
241         simix_global->process_to_run,i, smx_process_t)->context;
242   }
243   else {
244     /* all processes were run, return to maestro */
245     XBT_DEBUG("No more process to run");
246     next_context = (smx_context_t) sysv_maestro_context;
247   }
248   SIMIX_context_set_current(next_context);
249   swapcontext(&((smx_ctx_sysv_t) context)->uc,
250       &((smx_ctx_sysv_t) next_context)->uc);
251 }
252
253 static void smx_ctx_sysv_resume_serial(smx_process_t first_process)
254 {
255   smx_context_t context = first_process->context;
256   SIMIX_context_set_current(context);
257   swapcontext(&sysv_maestro_context->uc,
258       &((smx_ctx_sysv_t) context)->uc);
259 }
260
261 static void smx_ctx_sysv_runall_serial(void)
262 {
263   smx_process_t first_process =
264       xbt_dynar_get_as(simix_global->process_to_run, 0, smx_process_t);
265   sysv_process_index = 1;
266
267   /* execute the first process */
268   smx_ctx_sysv_resume_serial(first_process);
269 }
270
271 static void smx_ctx_sysv_stop_parallel(smx_context_t context)
272 {
273   smx_ctx_base_stop(context);
274   smx_ctx_sysv_suspend_parallel(context);
275 }
276
277 static void smx_ctx_sysv_suspend_parallel(smx_context_t context)
278 {
279 #ifdef CONTEXT_THREADS
280   /* determine the next context */
281   smx_process_t next_work = xbt_parmap_next(sysv_parmap);
282   smx_context_t next_context;
283   ucontext_t* next_stack;
284
285   if (next_work != NULL) {
286     /* there is a next process to resume */
287     XBT_DEBUG("Run next process");
288     next_context = next_work->context;
289     next_stack = &((smx_ctx_sysv_t) next_context)->uc;
290   }
291   else {
292     /* all processes were run, go to the barrier */
293     XBT_DEBUG("No more processes to run");
294     unsigned long worker_id =
295         (unsigned long) xbt_os_thread_get_specific(sysv_worker_id_key);
296     next_context = (smx_context_t)sysv_workers_context[worker_id];
297     next_stack = &((smx_ctx_sysv_t)next_context)->uc;
298   }
299
300   SIMIX_context_set_current(next_context);
301   swapcontext(&((smx_ctx_sysv_t) context)->uc, next_stack);
302 #endif
303 }
304
305 static void smx_ctx_sysv_resume_parallel(smx_process_t first_process)
306 {
307 #ifdef CONTEXT_THREADS
308   unsigned long worker_id = __sync_fetch_and_add(&sysv_threads_working, 1);
309   xbt_os_thread_set_specific(sysv_worker_id_key, (void*) worker_id);
310   smx_ctx_sysv_t worker_context = (smx_ctx_sysv_t)SIMIX_context_self();
311   sysv_workers_context[worker_id] = worker_context;
312   ucontext_t* worker_stack = &worker_context->uc;
313
314   smx_context_t context = first_process->context;
315   SIMIX_context_set_current(context);
316   swapcontext(worker_stack, &((smx_ctx_sysv_t) context)->uc);
317 #endif
318 }
319
320 static void smx_ctx_sysv_runall_parallel(void)
321 {
322 #ifdef CONTEXT_THREADS
323   sysv_threads_working = 0;
324   xbt_parmap_apply(sysv_parmap, (void_f_pvoid_t) smx_ctx_sysv_resume_parallel,
325       simix_global->process_to_run);
326 #endif
327 }