Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
1e17340195a5c743f1d9e5065795e22508659657
[simgrid.git] / src / java / jxbt_context.c
1 /*
2  * $Id$
3  *
4  * Copyright 2006,2007 Arnaud Legrand,Martin Quinson,Malek Cherier         
5  * 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
11 #include "portable.h"
12 #include "xbt/log.h"
13 #include "xbt/dynar.h"
14 #include "xbt/xbt_os_thread.h"
15 #include "xbt/ex_interface.h"
16 #include "java/jxbt_context.h"
17 #include "java/jmsg.h"
18 #include "java/jmsg_process.h"
19
20 /* get the right definition of the xbt_ctx with all we need here */
21 #ifndef JAVA_SIMGRID
22 #define JAVA_SIMGRID
23 #endif 
24
25 #include "xbt/context_private.h"
26
27 pfn_schedule_t __process_schedule= NULL;
28 pfn_schedule_t __process_unschedule= NULL;
29
30
31 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ctx, xbt, "Context");
32
33
34 static xbt_context_t current_context = NULL;    /* the current context                  */
35 static xbt_context_t init_context = NULL;       /* the initial context                  */
36 static xbt_swag_t context_to_destroy = NULL;    /* the list of the contexs to destroy   */
37 static xbt_swag_t context_living = NULL;        /* the list of the contexts in use      */
38
39 static void
40 __xbt_process_schedule(xbt_context_t context);
41
42 static void
43 __xbt_process_unschedule(xbt_context_t context);
44
45 static void 
46 __xbt_context_yield(xbt_context_t context);
47
48 static void
49 __xbt_process_schedule(xbt_context_t context) {
50         (*(__process_schedule))(context);
51 }
52
53 static void
54 __xbt_process_unschedule(xbt_context_t context) {
55         (*(__process_unschedule))(context);
56 }
57
58 static void 
59 __xbt_context_yield(xbt_context_t context) {
60
61   if(context) {
62     xbt_context_t self = current_context;
63         current_context = context;
64         __xbt_process_schedule(context);
65
66         current_context = self;
67   }
68   
69   if(current_context->iwannadie)
70     __context_exit(current_context, 1);
71   
72 }
73 static void 
74 xbt_context_free(xbt_context_t context) {
75
76         if(context) 
77         {
78                 if(context->jprocess) 
79                 {
80                         jobject jprocess = context->jprocess;
81                         context->jprocess = NULL;
82
83                         /* if the java process is alive join it */
84                         if(jprocess_is_alive(jprocess,get_current_thread_env())) 
85                         {
86                                 jprocess_join(jprocess,get_current_thread_env());
87                         }
88                 }
89
90                 if(context->exception) 
91                         free(context->exception);
92
93                 free(context->name);
94                 free(context);
95                 context = NULL;
96   }
97 }
98 /*
99  * This function is only called by the main thread.
100  */
101 void 
102 __context_exit(xbt_context_t context ,int value) {
103   /* call the cleanup function of the context */
104         
105         if(context->cleanup_func)
106                 context->cleanup_func(context->cleanup_arg);
107         
108         /* remove the context from the list of the contexts in use. */
109         xbt_swag_remove(context, context_living);
110         
111         /* insert the context in the list of contexts to destroy. */ 
112         xbt_swag_insert(context, context_to_destroy);
113         
114         /*
115         * signal the condition of the java process 
116         */
117         if (context->jprocess) 
118         {
119                 if (jprocess_is_alive(context->jprocess,get_current_thread_env())) 
120                 {
121                         jobject jprocess;
122                         __xbt_process_schedule(context);
123                         jprocess = context->jprocess;
124                         context->jprocess = NULL;
125                         jprocess_exit(jprocess,get_current_thread_env());
126                 }
127         }
128 }
129
130 /*
131  * This function is called by a java process (only).
132  */
133 void 
134 jcontext_exit(xbt_context_t context ,int value,JNIEnv* env) {
135
136   jobject __jprocess = context->jprocess;
137   context->jprocess = NULL;
138         
139   if(context->cleanup_func)
140     context->cleanup_func(context->cleanup_arg);
141
142   /* remove the context of the list of living contexts */
143   xbt_swag_remove(context, context_living);
144
145   /* insert the context in the list of the contexts to destroy */
146   xbt_swag_insert(context, context_to_destroy);
147         
148   /* the global reference to the java process instance is deleted */
149   jprocess_delete_global_ref(__jprocess,get_current_thread_env());
150 }
151
152 /* callback: context fetching */
153 static ex_ctx_t *
154 __context_ex_ctx(void) {
155   return current_context->exception;
156 }
157
158 /* callback: termination */
159 static void 
160 __context_ex_terminate(xbt_ex_t *e) {
161   xbt_ex_display(e);
162
163   abort();
164 }
165
166 /**
167  * This function initialize the xbt module context which contains 
168  * all functions of the context API .
169  *
170  * @remark This function must be called before use all other function 
171  * of this API.
172  */
173 void 
174 xbt_context_init(void) {
175   if(!current_context) {
176     /* allocate the current context. */
177     current_context = init_context = xbt_new0(s_xbt_context_t,1);
178                 
179     /* context exception */
180     init_context->exception = xbt_new(ex_ctx_t,1);
181     XBT_CTX_INITIALIZE(init_context->exception);
182     __xbt_ex_ctx       = __context_ex_ctx;
183     __xbt_ex_terminate = __context_ex_terminate;
184     
185     /* this list contains the context to destroy */
186     context_to_destroy = xbt_swag_new(xbt_swag_offset(*current_context,hookup));
187     /* this list contains the context in use */
188     context_living = xbt_swag_new(xbt_swag_offset(*current_context,hookup));
189     
190     /* append the current context in the list of context in use */
191     xbt_swag_insert(init_context, context_living);
192     
193     __process_schedule = jprocess_schedule;
194         __process_unschedule = jprocess_unschedule;
195   }
196 }
197
198 /** 
199  * This function is used as a garbage collection
200  * Should be called some time to time to free the memory allocated for contexts
201  * that have finished executing their main functions.
202  */
203 void xbt_context_empty_trash(void) {
204   xbt_context_t context=NULL;
205         
206   /* destroy all the context contained in the list of context to destroy */
207   while((context=xbt_swag_extract(context_to_destroy)))
208     xbt_context_free(context);
209 }
210
211 void 
212 xbt_context_start(xbt_context_t context)  {
213   DEBUG3("xbt_context_start of %p (jproc=%p, jenv=%p)",
214          context, context->jprocess, get_current_thread_env());
215
216   /* the main thread starts the java process                            */
217   jprocess_start(context->jprocess,get_current_thread_env());
218 }
219
220
221 xbt_context_t 
222 xbt_context_new(const char *name, xbt_main_func_t code, 
223                 void_f_pvoid_t startup_func, void *startup_arg,
224                 void_f_pvoid_t cleanup_func, void *cleanup_arg,
225                 int argc, char *argv[]) {
226   xbt_context_t context = xbt_new0(s_xbt_context_t,1);
227
228   context->code = code;
229   context->name = xbt_strdup(name);
230         
231   context->argc = argc;
232   context->argv = argv;
233   context->startup_func = startup_func;
234   context->startup_arg = startup_arg;
235   context->cleanup_func = cleanup_func;
236   context->cleanup_arg = cleanup_arg;
237   context->exception = xbt_new(ex_ctx_t,1);
238   XBT_CTX_INITIALIZE(context->exception);
239         
240   xbt_swag_insert(context, context_living);
241         
242   return context;
243 }
244
245
246 void xbt_context_yield(void) {
247   __xbt_process_unschedule(current_context);
248
249
250 }
251
252 /** 
253  * \param context the winner
254  *
255  * Calling this function blocks the current context and schedule \a context.  
256  * When \a context will call xbt_context_yield, it will return
257  * to this function as if nothing had happened.
258  */
259 void xbt_context_schedule(xbt_context_t context) {
260   xbt_assert0((current_context==init_context),"You are not supposed to run this function here!");
261   __xbt_context_yield(context);
262 }
263
264 /** 
265  * This function kill all existing context and free all the memory
266  * that has been allocated in this module.
267  */
268 void xbt_context_exit(void)  {
269
270   xbt_context_t context=NULL;
271         
272   xbt_context_empty_trash();
273         
274   while((context=xbt_swag_extract(context_living))) {
275     if(context!=init_context) 
276       xbt_context_kill(context);
277   }
278
279   free(init_context->exception); 
280   free(init_context);   
281
282   init_context = current_context = NULL ;
283
284   xbt_context_empty_trash();
285
286   xbt_swag_free(context_to_destroy);
287   xbt_swag_free(context_living);
288 }
289
290 /** 
291  * \param context poor victim
292  *
293  * This function simply kills \a context... scarry isn't it ?
294  */
295 void xbt_context_kill(xbt_context_t context) {
296
297   context->iwannadie=1;
298   __xbt_context_yield(context);
299 }
300
301 void  xbt_context_set_jprocess(xbt_context_t context, void *jp) {
302   context->jprocess = jp;
303 }
304 void* xbt_context_get_jprocess(xbt_context_t context)           { 
305    return context->jprocess;
306 }
307
308 void  xbt_context_set_jenv(xbt_context_t context,void* je)      {
309    context->jenv = je;
310 }
311 void* xbt_context_get_jenv(xbt_context_t context)               { 
312    return get_current_thread_env();
313 }
314
315
316
317 /* @} */