Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
a7267ed0eac0982770b63d775b70134746781d69
[simgrid.git] / src / simix / smx_context_raw.c
1 /* context_raw - context switching with ucontextes from System V           */
2
3 /* Copyright (c) 2009, 2010. 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 "xbt/threadpool.h"
10 #include "simix/private.h"
11
12 #ifdef HAVE_VALGRIND_VALGRIND_H
13 #  include <valgrind/valgrind.h>
14 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
15
16 #ifdef _XBT_WIN32
17 #include "win32_ucontext.h"
18 #include "win32_ucontext.c"
19 #else
20 #include "ucontext.h"
21 #endif
22
23 /* lower this if you want to reduce the memory consumption  */
24 #ifndef CONTEXT_STACK_SIZE      /* allow lua to override this */
25 #define CONTEXT_STACK_SIZE 128*1024
26 #endif                          /*CONTEXT_STACK_SIZE */
27
28
29 typedef char * raw_stack_t;
30 typedef void (*rawctx_entry_point_t)(void *);
31
32 typedef struct s_smx_ctx_raw {
33   s_smx_ctx_base_t super;       /* Fields of super implementation */
34   char *malloced_stack; /* malloced area containing the stack */
35   raw_stack_t stack_top; /* pointer to stack top (within previous area) */
36 #ifdef HAVE_VALGRIND_VALGRIND_H
37   unsigned int valgrind_stack_id;       /* the valgrind stack id */
38 #endif
39 } s_smx_ctx_raw_t, *smx_ctx_raw_t;
40
41 smx_ctx_raw_t maestro_context;
42
43 extern raw_stack_t raw_makecontext(char* malloced_stack, int stack_size,
44                                    rawctx_entry_point_t entry_point, void* arg);
45 extern void raw_swapcontext(raw_stack_t* old, raw_stack_t* new);
46
47 #ifdef PROCESSOR_i686
48 __asm__ (
49 ".globl raw_makecontext\n"
50 "raw_makecontext:\n"
51 "   movl 4(%esp),%eax\n"  /* stack */
52 "   addl 8(%esp),%eax\n"  /* size  */
53 "   movl 12(%esp),%ecx\n" /* func  */
54 "   movl 16(%esp),%edx\n" /* arg   */
55 "   movl %edx, -4(%eax)\n"
56 "   movl $0,   -8(%eax)\n"
57 "   movl %ecx,-12(%eax)\n"
58 "   movl $0,  -16(%eax)\n"
59 "   movl $0,  -20(%eax)\n"
60 "   movl $0,  -24(%eax)\n"
61 "   movl $0,  -28(%eax)\n"
62 "   subl $28,%eax\n"
63 "   ret\n"
64 );
65
66 __asm__ (
67    ".globl raw_swapcontext\n"
68    "raw_swapcontext:\n"
69    "   movl 4(%esp),%eax\n" /* old */
70    "   movl 8(%esp),%edx\n" /* new */
71    "   pushl %ebp\n"
72    "   pushl %ebx\n"
73    "   pushl %esi\n"
74    "   pushl %edi\n"
75    "   movl %esp,(%eax)\n"
76    "   movl (%edx),%esp\n"
77    "   popl %edi\n"
78    "   popl %esi\n"
79    "   popl %ebx\n"
80    "   popl %ebp\n"
81    "   ret\n"
82 );
83 #else
84 #error "Cannot compile raw contexts for your architecture"
85 #endif
86
87 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
88
89 static xbt_tpool_t tpool;
90
91 static void smx_ctx_raw_wrapper(smx_ctx_raw_t context);
92
93
94 static int smx_ctx_raw_factory_finalize(smx_context_factory_t *factory)
95
96   if(tpool)
97     xbt_tpool_destroy(tpool);
98   return smx_ctx_base_factory_finalize(factory);
99 }
100
101 static smx_context_t
102 smx_ctx_raw_create_context_sized(size_t size, xbt_main_func_t code,
103     int argc, char **argv,
104     void_pfn_smxprocess_t cleanup_func,
105     void *data)
106 {
107
108   smx_ctx_raw_t context =
109       (smx_ctx_raw_t) smx_ctx_base_factory_create_context_sized(size,
110           code,
111           argc,
112           argv,
113           cleanup_func,
114           data);
115
116   /* If the user provided a function for the process then use it
117      otherwise is the context for maestro */
118      if (code) {
119        context->malloced_stack = xbt_malloc0(CONTEXT_STACK_SIZE);
120        context->stack_top =
121            raw_makecontext(context->malloced_stack,CONTEXT_STACK_SIZE,
122                (void(*)(void*))smx_ctx_raw_wrapper,context);
123
124 #ifdef HAVE_VALGRIND_VALGRIND_H
125        context->valgrind_stack_id =
126            VALGRIND_STACK_REGISTER(context->malloced_stack,
127                context->malloced_stack + CONTEXT_STACK_SIZE);
128 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
129
130      }else{
131        maestro_context = context;
132      }
133
134      return (smx_context_t) context;
135
136 }
137
138 static smx_context_t
139 smx_ctx_raw_create_context(xbt_main_func_t code, int argc, char **argv,
140     void_pfn_smxprocess_t cleanup_func,
141     void *data)
142 {
143
144   return smx_ctx_raw_create_context_sized(sizeof(s_smx_ctx_raw_t),
145       code, argc, argv, cleanup_func,
146       data);
147
148 }
149
150 static void smx_ctx_raw_free(smx_context_t context)
151 {
152
153   if (context) {
154
155 #ifdef HAVE_VALGRIND_VALGRIND_H
156     VALGRIND_STACK_DEREGISTER(((smx_ctx_raw_t)
157         context)->valgrind_stack_id);
158 #endif                          /* HAVE_VALGRIND_VALGRIND_H */
159
160   }
161   smx_ctx_base_free(context);
162 }
163
164 static void smx_ctx_raw_suspend(smx_context_t context)
165 {
166   smx_current_context = (smx_context_t)maestro_context;
167   raw_swapcontext(&((smx_ctx_raw_t) context)->stack_top, &maestro_context->stack_top);
168 }
169
170 static void smx_ctx_raw_stop(smx_context_t context)
171 {
172   smx_ctx_base_stop(context);
173   smx_ctx_raw_suspend(context);
174 }
175
176 static void smx_ctx_raw_wrapper(smx_ctx_raw_t context)
177
178   (context->super.code) (context->super.argc, context->super.argv);
179
180   smx_ctx_raw_stop((smx_context_t) context);
181 }
182
183 static void smx_ctx_raw_resume(smx_context_t context)
184 {
185   smx_current_context = context; 
186   raw_swapcontext(&maestro_context->stack_top, &((smx_ctx_raw_t) context)->stack_top);
187 }
188
189 static void smx_ctx_raw_runall(xbt_swag_t processes)
190 {
191   smx_process_t process;
192
193   while ((process = xbt_swag_extract(processes)))
194     smx_ctx_raw_resume(process->context);
195 }
196
197 static void smx_ctx_raw_resume_parallel(smx_context_t context)
198 {
199   xbt_os_thread_set_extra_data(context);
200   raw_swapcontext(&maestro_context->stack_top, &((smx_ctx_raw_t) context)->stack_top);
201 }
202
203 static void smx_ctx_raw_runall_parallel(xbt_swag_t processes)
204 {
205   smx_process_t process;
206   while((process = xbt_swag_extract(processes))){
207     xbt_tpool_queue_job(tpool, (void_f_pvoid_t)smx_ctx_raw_resume_parallel, process->context);
208   }
209   xbt_tpool_wait_all(tpool);
210 }
211
212 static smx_context_t smx_ctx_raw_self_parallel(void)
213 {
214   smx_context_t self_context = (smx_context_t) xbt_os_thread_get_extra_data();
215   return self_context ? self_context : (smx_context_t) maestro_context;
216 }
217
218 void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory)
219 {
220   smx_ctx_base_factory_init(factory);
221
222   (*factory)->finalize  = smx_ctx_raw_factory_finalize;
223   (*factory)->create_context = smx_ctx_raw_create_context;
224   /* Do not overload that method (*factory)->finalize */
225   (*factory)->free = smx_ctx_raw_free;
226   (*factory)->stop = smx_ctx_raw_stop;
227   (*factory)->suspend = smx_ctx_raw_suspend;
228   (*factory)->name = "smx_raw_context_factory";
229
230   if(_surf_parallel_contexts){
231 #ifdef CONTEXT_THREADS  /* To use parallel ucontexts a thread pool is needed */
232     tpool = xbt_tpool_new(2, 10);
233     (*factory)->runall = smx_ctx_raw_runall_parallel;
234     (*factory)->self = smx_ctx_raw_self_parallel;
235 #else
236     THROW0(arg_error, 0, "No thread support for parallel context execution");
237 #endif
238   }else{
239     (*factory)->runall = smx_ctx_raw_runall;
240   }
241 }