Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Lots of renamings from xbt_ to smx_
[simgrid.git] / src / simix / smx_context_thread.c
1 /* $Id$ */
2
3 /* context_thread - implementation of context switching with native threads */
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/function_types.h"
11 #include "xbt_context_private.h"
12
13 #include "portable.h"           /* loads context system definitions */
14 #include "xbt/swag.h"
15 #include "xbt/xbt_os_thread.h"
16
17 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_context);
18
19 typedef struct s_xbt_ctx_thread {
20   XBT_CTX_BASE_T;
21   xbt_os_thread_t thread;       /* a plain dumb thread (portable to posix or windows) */
22   xbt_os_sem_t begin;           /* this semaphore is used to schedule/yield the process  */
23   xbt_os_sem_t end;             /* this semaphore is used to schedule/unschedule the process   */
24 } s_xbt_ctx_thread_t, *xbt_ctx_thread_t;
25
26 static xbt_context_t
27 xbt_ctx_thread_factory_create_context(const char *name, xbt_main_func_t code,
28                                       void_f_pvoid_t startup_func,
29                                       void *startup_arg,
30                                       void_f_pvoid_t cleanup_func,
31                                       void *cleanup_arg, int argc,
32                                       char **argv);
33
34
35 static int
36 xbt_ctx_thread_factory_create_master_context(xbt_context_t * maestro);
37
38 static int xbt_ctx_thread_factory_finalize(xbt_context_factory_t * factory);
39
40 static void xbt_ctx_thread_free(xbt_context_t context);
41
42 static void xbt_ctx_thread_kill(xbt_context_t context);
43
44 static void xbt_ctx_thread_schedule(xbt_context_t context);
45
46 static void xbt_ctx_thread_yield(void);
47
48 static void xbt_ctx_thread_start(xbt_context_t context);
49
50 static void xbt_ctx_thread_stop(int exit_code);
51
52 static void xbt_ctx_thread_swap(xbt_context_t context);
53
54 static void xbt_ctx_thread_schedule(xbt_context_t context);
55
56 static void xbt_ctx_thread_yield(void);
57
58 static void xbt_ctx_thread_suspend(xbt_context_t context);
59
60 static void xbt_ctx_thread_resume(xbt_context_t context);
61
62 static void *xbt_ctx_thread_wrapper(void *param);
63
64 void xbt_ctx_thread_factory_init(xbt_context_factory_t * factory)
65 {
66   *factory = xbt_new0(s_xbt_context_factory_t, 1);
67
68   (*factory)->create_context = xbt_ctx_thread_factory_create_context;
69   (*factory)->finalize = xbt_ctx_thread_factory_finalize;
70   (*factory)->create_maestro_context = xbt_ctx_thread_factory_create_master_context;
71   (*factory)->free = xbt_ctx_thread_free;
72   (*factory)->kill = xbt_ctx_thread_kill;
73   (*factory)->schedule = xbt_ctx_thread_schedule;
74   (*factory)->yield = xbt_ctx_thread_yield;
75   (*factory)->start = xbt_ctx_thread_start;
76   (*factory)->stop = xbt_ctx_thread_stop;
77   (*factory)->name = "ctx_thread_factory";
78 }
79
80 static int
81 xbt_ctx_thread_factory_create_master_context(xbt_context_t * maestro)
82 {
83   *maestro = (xbt_context_t) xbt_new0(s_xbt_ctx_thread_t, 1);
84   (*maestro)->name = (char *) "maestro";
85   return 0;
86 }
87
88 static int xbt_ctx_thread_factory_finalize(xbt_context_factory_t * factory)
89 {
90   free(*factory);
91   *factory = NULL;
92   return 0;
93 }
94
95 static xbt_context_t
96 xbt_ctx_thread_factory_create_context(const char *name, xbt_main_func_t code,
97                                       void_f_pvoid_t startup_func,
98                                       void *startup_arg,
99                                       void_f_pvoid_t cleanup_func,
100                                       void *cleanup_arg, int argc,
101                                       char **argv)
102 {
103   xbt_ctx_thread_t context = xbt_new0(s_xbt_ctx_thread_t, 1);
104
105   VERB1("Create context %s", name);
106   context->code = code;
107   context->name = xbt_strdup(name);
108   context->begin = xbt_os_sem_init(0);
109   context->end = xbt_os_sem_init(0);
110   context->iwannadie = 0;       /* useless but makes valgrind happy */
111   context->argc = argc;
112   context->argv = argv;
113   context->startup_func = startup_func;
114   context->startup_arg = startup_arg;
115   context->cleanup_func = cleanup_func;
116   context->cleanup_arg = cleanup_arg;
117
118   return (xbt_context_t) context;
119 }
120
121 static void xbt_ctx_thread_free(xbt_context_t context)
122 {
123   if (context) {
124     xbt_ctx_thread_t ctx_thread = (xbt_ctx_thread_t) context;
125
126     free(ctx_thread->name);
127
128     if (ctx_thread->argv) {
129       int i;
130
131       for (i = 0; i < ctx_thread->argc; i++)
132         if (ctx_thread->argv[i])
133           free(ctx_thread->argv[i]);
134
135       free(ctx_thread->argv);
136     }
137
138     /* wait about the thread terminason */
139     xbt_os_thread_join(ctx_thread->thread, NULL);
140
141     /* destroy the synchronisation objects */
142     xbt_os_sem_destroy(ctx_thread->begin);
143     xbt_os_sem_destroy(ctx_thread->end);
144
145     /* finally destroy the context */
146     free(context);
147   }
148 }
149
150 static void xbt_ctx_thread_kill(xbt_context_t context)
151 {
152   DEBUG1("Kill context '%s'", context->name);
153   context->iwannadie = 1;
154   xbt_ctx_thread_swap(context);
155 }
156
157 /** 
158  * \param context the winner
159  *
160  * Calling this function blocks the current context and schedule \a context.  
161  * When \a context will call xbt_context_yield, it will return
162  * to this function as if nothing had happened.
163  * 
164  * Only the maestro can call this function to run a given process.
165  */
166 static void xbt_ctx_thread_schedule(xbt_context_t context)
167 {
168   DEBUG1("Schedule context '%s'", context->name);
169   xbt_assert0((current_context == maestro_context),
170               "You are not supposed to run this function here!");
171   xbt_ctx_thread_swap(context);
172 }
173
174 /** 
175  * Calling this function makes the current context yield. The context
176  * that scheduled it returns from xbt_context_schedule as if nothing
177  * had happened.
178  * 
179  * Only the processes can call this function, giving back the control
180  * to the maestro
181  */
182 static void xbt_ctx_thread_yield(void)
183 {
184   DEBUG1("Yield context '%s'", current_context->name);
185   xbt_assert0((current_context != maestro_context),
186               "You are not supposed to run this function here!");
187   xbt_ctx_thread_swap(current_context);
188 }
189
190 static void xbt_ctx_thread_start(xbt_context_t context)
191 {
192   xbt_ctx_thread_t ctx_thread = (xbt_ctx_thread_t) context;
193
194   DEBUG1("Start context '%s'", context->name);
195   /* create and start the process */
196   ctx_thread->thread =
197     xbt_os_thread_create(ctx_thread->name, xbt_ctx_thread_wrapper,
198                          ctx_thread);
199
200   /* wait the starting of the newly created process */
201   xbt_os_sem_acquire(ctx_thread->end);
202 }
203
204 static void xbt_ctx_thread_stop(int exit_code)
205 {
206   /* please no debug here: our procdata was already free'd */
207   if (current_context->cleanup_func)
208     ((*current_context->cleanup_func)) (current_context->cleanup_arg);
209
210   xbt_swag_remove(current_context, context_living);
211   xbt_swag_insert(current_context, context_to_destroy);
212
213   /* signal to the maestro that it has finished */
214   xbt_os_sem_release(((xbt_ctx_thread_t) current_context)->end);
215
216   /* exit */
217   xbt_os_thread_exit(NULL);     /* We should provide return value in case other wants it */
218 }
219
220 static void xbt_ctx_thread_swap(xbt_context_t context)
221 {
222   DEBUG2("Swap context: '%s' -> '%s'", current_context->name, context->name);
223   if ((current_context != maestro_context) && !context->iwannadie) {
224     /* (0) it's not the scheduler and the process doesn't want to die, it just wants to yield */
225
226     /* yield itself, resume the maestro */
227     xbt_ctx_thread_suspend(context);
228   } else {
229     /* (1) the current process is the scheduler and the process doesn't want to die
230      *      <-> the maestro wants to schedule the process
231      *              -> the maestro schedules the process and waits
232      *
233      * (2) the current process is the scheduler and the process wants to die
234      *      <-> the maestro wants to kill the process (has called the function xbt_context_kill())
235      *              -> the maestro schedule the process and waits (xbt_os_sem_acquire(context->end))
236      *              -> if the process stops (xbt_context_stop())
237      *                      -> the process resumes the maestro (xbt_os_sem_release(current_context->end)) and exit (xbt_os_thread_exit())
238      *              -> else the process call xbt_context_yield()
239      *                      -> goto (3.1)
240      *
241      * (3) the current process is not the scheduler and the process wants to die
242      *              -> (3.1) if the current process is the process who wants to die
243      *                      -> (resume not need) goto (4)
244      *              -> (3.2) else the current process is not the process who wants to die
245      *                      <-> the current process wants to kill an other process
246      *                              -> the current process resumes the process to die and waits
247      *                              -> if the process to kill stops
248      *                                      -> it resumes the process who kill it and exit
249      *                              -> else if the process to kill calls to xbt_context_yield()
250      *                                      -> goto (3.1)
251      */
252     /* schedule the process associated with this context */
253     xbt_ctx_thread_resume(context);
254
255   }
256
257   /* (4) the current process wants to die */
258   if (current_context->iwannadie)
259     xbt_ctx_thread_stop(1);
260 }
261
262 static void *xbt_ctx_thread_wrapper(void *param)
263 {
264   xbt_ctx_thread_t context = (xbt_ctx_thread_t) param;
265
266   /* Tell the maestro we are starting, and wait for its green light */
267   xbt_os_sem_release(context->end);
268   xbt_os_sem_acquire(context->begin);
269
270   if (context->startup_func)
271     (*(context->startup_func)) (context->startup_arg);
272
273
274   xbt_ctx_thread_stop((context->code) (context->argc, context->argv));
275   return NULL;
276 }
277
278 static void xbt_ctx_thread_suspend(xbt_context_t context)
279 {
280   /* save the current context */
281   xbt_context_t self = current_context;
282
283   DEBUG1("Suspend context '%s'", context->name);
284
285   /* update the current context to this context */
286   current_context = context;
287
288   xbt_os_sem_release(((xbt_ctx_thread_t) context)->end);
289   xbt_os_sem_acquire(((xbt_ctx_thread_t) context)->begin);
290
291   /* restore the current context to the previously saved context */
292   current_context = self;
293 }
294
295 static void xbt_ctx_thread_resume(xbt_context_t context)
296 {
297   /* save the current context */
298   xbt_context_t self = current_context;
299
300   DEBUG1("Resume context '%s'", context->name);
301
302   /* update the current context */
303   current_context = context;
304
305   xbt_os_sem_release(((xbt_ctx_thread_t) context)->begin);
306   xbt_os_sem_acquire(((xbt_ctx_thread_t) context)->end);
307
308   /* restore the current context to the previously saved context */
309   current_context = self;
310 }