Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix compilation bug when enabling pthreads.
[simgrid.git] / src / simix / xbt_context_sysv.c
1 /* $Id$ */
2
3 /* context_sysv - implementation of context switching with ucontextes from Sys V */
4
5 /* Copyright (c) 2004-2008 the SimGrid team. All right reserved */
6
7 /* This program is free software; you can redistribute it and/or modify it
8  * under the terms of the license (GNU LGPL) which comes with this package. */
9
10 #include "xbt/ex_interface.h"
11 #include "xbt_context_private.h"
12
13 #include "context_sysv_config.h"        /* loads context system definitions                             */
14 #include "portable.h"
15 #include <ucontext.h>           /* context relative declarations                                */
16 #define STACK_SIZE 128*1024     /* lower this if you want to reduce the memory consumption      */
17 #ifdef HAVE_VALGRIND_VALGRIND_H
18 #  include <valgrind/valgrind.h>
19 #endif /* HAVE_VALGRIND_VALGRIND_H */
20
21 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_context);
22
23 typedef struct s_xbt_ctx_sysv {
24   XBT_CTX_BASE_T;
25   ucontext_t uc;                /* the thread that execute the code                             */
26   char stack[STACK_SIZE];       /* the thread stack size                                        */
27   struct s_xbt_ctx_sysv *prev;  /* the previous thread                                          */
28 #ifdef HAVE_VALGRIND_VALGRIND_H
29   unsigned int valgrind_stack_id;       /* the valgrind stack id.       */
30 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
31 } s_xbt_ctx_sysv_t, *xbt_ctx_sysv_t;
32
33
34 /* callback: context fetching */
35 static ex_ctx_t *xbt_jcontext_ex_ctx(void);
36
37 /* callback: termination */
38 static void xbt_jcontext_ex_terminate(xbt_ex_t * e);
39
40 static xbt_context_t
41 xbt_ctx_sysv_factory_create_context(const char *name, xbt_main_func_t code,
42                                     void_f_pvoid_t startup_func,
43                                     void *startup_arg,
44                                     void_f_pvoid_t cleanup_func,
45                                     void *cleanup_arg, int argc, char **argv);
46
47 static int xbt_ctx_sysv_factory_finalize(xbt_context_factory_t * factory);
48
49 static int
50 xbt_ctx_sysv_factory_create_maestro_context(xbt_context_t * maestro);
51
52 static void xbt_ctx_sysv_free(xbt_context_t context);
53
54 static void xbt_ctx_sysv_kill(xbt_context_t context);
55
56 static void xbt_ctx_sysv_schedule(xbt_context_t context);
57
58 static void xbt_ctx_sysv_yield(void);
59
60 static void xbt_ctx_sysv_start(xbt_context_t context);
61
62 static void xbt_ctx_sysv_stop(int exit_code);
63
64 static void xbt_ctx_sysv_swap(xbt_context_t context);
65
66 static void xbt_ctx_sysv_schedule(xbt_context_t context);
67
68 static void xbt_ctx_sysv_yield(void);
69
70 static void xbt_ctx_sysv_suspend(xbt_context_t context);
71
72 static void xbt_ctx_sysv_resume(xbt_context_t context);
73
74 static void xbt_ctx_sysv_wrapper(void);
75
76 /* callback: context fetching */
77 static ex_ctx_t *xbt_ctx_sysv_ex_ctx(void)
78 {
79   return current_context->exception;
80 }
81
82 /* callback: termination */
83 static void xbt_ctx_sysv_ex_terminate(xbt_ex_t * e)
84 {
85   xbt_ex_display(e);
86   abort();
87 }
88
89
90 void xbt_ctx_sysv_factory_init(xbt_context_factory_t * factory)
91 {
92   *factory = xbt_new0(s_xbt_context_factory_t, 1);
93
94   (*factory)->create_context = xbt_ctx_sysv_factory_create_context;
95   (*factory)->finalize = xbt_ctx_sysv_factory_finalize;
96   (*factory)->create_maestro_context = xbt_ctx_sysv_factory_create_maestro_context;
97   (*factory)->free = xbt_ctx_sysv_free;
98   (*factory)->kill = xbt_ctx_sysv_kill;
99   (*factory)->schedule = xbt_ctx_sysv_schedule;
100   (*factory)->yield = xbt_ctx_sysv_yield;
101   (*factory)->start = xbt_ctx_sysv_start;
102   (*factory)->stop = xbt_ctx_sysv_stop;
103   (*factory)->name = "ctx_sysv_context_factory";
104
105   /* context exception handlers */
106   __xbt_ex_ctx = xbt_ctx_sysv_ex_ctx;
107   __xbt_ex_terminate = xbt_ctx_sysv_ex_terminate;
108 }
109
110 static int
111 xbt_ctx_sysv_factory_create_maestro_context(xbt_context_t * maestro)
112 {
113
114   xbt_ctx_sysv_t context = xbt_new0(s_xbt_ctx_sysv_t, 1);
115
116   context->name = (char *) "maestro";
117
118   context->exception = xbt_new(ex_ctx_t, 1);
119   XBT_CTX_INITIALIZE(context->exception);
120
121   *maestro = (xbt_context_t) context;
122
123   return 0;
124
125 }
126
127
128 static int xbt_ctx_sysv_factory_finalize(xbt_context_factory_t * factory)
129 {
130   free(maestro_context->exception);
131   free(*factory);
132   *factory = NULL;
133   return 0;
134 }
135
136 static xbt_context_t
137 xbt_ctx_sysv_factory_create_context(const char *name, xbt_main_func_t code,
138                                     void_f_pvoid_t startup_func,
139                                     void *startup_arg,
140                                     void_f_pvoid_t cleanup_func,
141                                     void *cleanup_arg, int argc, char **argv)
142 {
143   VERB1("Create context %s", name);
144   xbt_ctx_sysv_t context = xbt_new0(s_xbt_ctx_sysv_t, 1);
145
146   context->code = code;
147   context->name = xbt_strdup(name);
148
149   xbt_assert2(getcontext(&(context->uc)) == 0,
150               "Error in context saving: %d (%s)", errno, strerror(errno));
151   context->uc.uc_link = NULL;
152   context->uc.uc_stack.ss_sp =
153     pth_skaddr_makecontext(context->stack, STACK_SIZE);
154   context->uc.uc_stack.ss_size =
155     pth_sksize_makecontext(context->stack, STACK_SIZE);
156 #ifdef HAVE_VALGRIND_VALGRIND_H
157   context->valgrind_stack_id =
158     VALGRIND_STACK_REGISTER(context->uc.uc_stack.ss_sp,
159                             ((char *) context->uc.uc_stack.ss_sp) +
160                             context->uc.uc_stack.ss_size);
161 #endif /* HAVE_VALGRIND_VALGRIND_H */
162
163   context->exception = xbt_new(ex_ctx_t, 1);
164   XBT_CTX_INITIALIZE(context->exception);
165   context->iwannadie = 0;       /* useless but makes valgrind happy */
166   context->argc = argc;
167   context->argv = argv;
168   context->startup_func = startup_func;
169   context->startup_arg = startup_arg;
170   context->cleanup_func = cleanup_func;
171   context->cleanup_arg = cleanup_arg;
172
173   return (xbt_context_t) context;
174 }
175
176 static void xbt_ctx_sysv_free(xbt_context_t context)
177 {
178   if (context) {
179     free(context->name);
180
181     if (context->argv) {
182       int i;
183
184       for (i = 0; i < context->argc; i++)
185         if (context->argv[i])
186           free(context->argv[i]);
187
188       free(context->argv);
189     }
190
191     if (context->exception)
192       free(context->exception);
193
194 #ifdef HAVE_VALGRIND_VALGRIND_H
195     VALGRIND_STACK_DEREGISTER(((xbt_ctx_sysv_t) context)->valgrind_stack_id);
196 #endif /* HAVE_VALGRIND_VALGRIND_H */
197
198     /* finally destroy the context */
199     free(context);
200   }
201 }
202
203 static void xbt_ctx_sysv_kill(xbt_context_t context)
204 {
205   DEBUG2("Kill context '%s' (from '%s')", context->name,
206          current_context->name);
207   context->iwannadie = 1;
208   xbt_ctx_sysv_swap(context);
209 }
210
211 /** 
212  * \param context the winner
213  *
214  * Calling this function blocks the current context and schedule \a context.  
215  * When \a context will call xbt_context_yield, it will return
216  * to this function as if nothing had happened.
217  * 
218  * Only the maestro can call this function to run a given process.
219  */
220 static void xbt_ctx_sysv_schedule(xbt_context_t context)
221 {
222   DEBUG1("Schedule context '%s'", context->name);
223   xbt_assert0((current_context == maestro_context),
224               "You are not supposed to run this function here!");
225   xbt_ctx_sysv_swap(context);
226 }
227
228 /** 
229  * Calling this function makes the current context yield. The context
230  * that scheduled it returns from xbt_context_schedule as if nothing
231  * had happened.
232  * 
233  * Only the processes can call this function, giving back the control
234  * to the maestro
235  */
236 static void xbt_ctx_sysv_yield(void)
237 {
238   DEBUG1("Yielding context '%s'", current_context->name);
239   xbt_assert0((current_context != maestro_context),
240               "You are not supposed to run this function here!");
241   xbt_ctx_sysv_swap(current_context);
242 }
243
244 static void xbt_ctx_sysv_start(xbt_context_t context)
245 {
246   DEBUG1("Start context '%s'", context->name);
247   makecontext(&(((xbt_ctx_sysv_t) context)->uc), xbt_ctx_sysv_wrapper, 0);
248 }
249
250 static void xbt_ctx_sysv_stop(int exit_code)
251 {
252   /* please no debug here: our procdata was already free'd */
253   if (current_context->cleanup_func)
254     ((*current_context->cleanup_func)) (current_context->cleanup_arg);
255
256   xbt_swag_remove(current_context, context_living);
257   xbt_swag_insert(current_context, context_to_destroy);
258
259   xbt_ctx_sysv_swap(current_context);
260 }
261
262 static void xbt_ctx_sysv_swap(xbt_context_t context)
263 {
264   DEBUG2("Swap context: '%s' -> '%s'", current_context->name, context->name);
265   xbt_assert0(current_context, "You have to call context_init() first.");
266   xbt_assert0(context, "Invalid argument");
267
268   if (((xbt_ctx_sysv_t) context)->prev == NULL)
269     xbt_ctx_sysv_resume(context);
270   else
271     xbt_ctx_sysv_suspend(context);
272
273   if (current_context->iwannadie)
274     xbt_ctx_sysv_stop(1);
275 }
276
277 static void xbt_ctx_sysv_wrapper(void)
278 {
279   if (current_context->startup_func)
280     (*current_context->startup_func) (current_context->startup_arg);
281
282   xbt_ctx_sysv_stop((*(current_context->code))
283                     (current_context->argc, current_context->argv));
284 }
285
286 static void xbt_ctx_sysv_suspend(xbt_context_t context)
287 {
288   int rv;
289
290   DEBUG1("Suspend context: '%s'", current_context->name);
291   xbt_ctx_sysv_t prev_context = ((xbt_ctx_sysv_t) context)->prev;
292
293   current_context = (xbt_context_t) (((xbt_ctx_sysv_t) context)->prev);
294
295   ((xbt_ctx_sysv_t) context)->prev = NULL;
296
297   rv = swapcontext(&(((xbt_ctx_sysv_t) context)->uc), &(prev_context->uc));
298
299   xbt_assert0((rv == 0), "Context swapping failure");
300 }
301
302 static void xbt_ctx_sysv_resume(xbt_context_t context)
303 {
304   int rv;
305
306   DEBUG2("Resume context: '%s' (from '%s')", context->name,
307          current_context->name);
308   ((xbt_ctx_sysv_t) context)->prev = (xbt_ctx_sysv_t) current_context;
309
310   current_context = context;
311
312   rv = swapcontext(&(((xbt_ctx_sysv_t) context)->prev->uc),
313                    &(((xbt_ctx_sysv_t) context)->uc));
314
315   xbt_assert0((rv == 0), "Context swapping failure");
316 }