Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Make sure all the source files have an reference of the copyright and of the licence
[simgrid.git] / src / xbt / xbt_context_java.c
1 /* $Id$ */
2
3 /* context_java - implementation of context switching for java threads */
4
5 /* Copyright (c) 2007-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
11 #include "xbt/function_types.h"
12 #include "xbt/ex_interface.h"
13 #include "xbt/xbt_context_private.h"
14 #include "xbt/xbt_context_java.h"
15
16 XBT_LOG_NEW_DEFAULT_CATEGORY(jmsg, "MSG for Java(TM)");
17
18 /* callback: context fetching */
19 static ex_ctx_t *xbt_ctx_java_ex_ctx(void);
20
21 /* callback: termination */
22 static void xbt_ctx_java_ex_terminate(xbt_ex_t * e);
23
24 static xbt_context_t
25 xbt_ctx_java_factory_create_context(const char *name, xbt_main_func_t code,
26                                     void_f_pvoid_t startup_func,
27                                     void *startup_arg,
28                                     void_f_pvoid_t cleanup_func,
29                                     void *cleanup_arg, int argc, char **argv);
30
31 static int
32 xbt_ctx_java_factory_create_maestro_context(xbt_context_t * maestro);
33
34 static int xbt_ctx_java_factory_finalize(xbt_context_factory_t * factory);
35
36 static void xbt_ctx_java_free(xbt_context_t context);
37
38 static void xbt_ctx_java_kill(xbt_context_t context);
39
40 static void xbt_ctx_java_schedule(xbt_context_t context);
41
42 static void xbt_ctx_java_yield(void);
43
44 static void xbt_ctx_java_start(xbt_context_t context);
45
46 static void xbt_ctx_java_stop(int exit_code);
47
48 static void xbt_ctx_java_swap(xbt_context_t context);
49
50 static void xbt_ctx_java_schedule(xbt_context_t context);
51
52 static void xbt_ctx_java_yield(void);
53
54 static void xbt_ctx_java_suspend(xbt_context_t context);
55
56 static void xbt_ctx_java_resume(xbt_context_t context);
57
58
59 /* callback: context fetching */
60 static ex_ctx_t *xbt_ctx_java_ex_ctx(void)
61 {
62   return current_context->exception;
63 }
64
65 /* callback: termination */
66 static void xbt_ctx_java_ex_terminate(xbt_ex_t * e)
67 {
68   xbt_ex_display(e);
69   abort();
70 }
71
72 void xbt_ctx_java_factory_init(xbt_context_factory_t * factory)
73 {
74   /* context exception handlers */
75   __xbt_ex_ctx = xbt_ctx_java_ex_ctx;
76   __xbt_ex_terminate = xbt_ctx_java_ex_terminate;
77
78   /* instantiate the context factory */
79   *factory = xbt_new0(s_xbt_context_factory_t, 1);
80
81   (*factory)->create_context = xbt_ctx_java_factory_create_context;
82   (*factory)->finalize = xbt_ctx_java_factory_finalize;
83   (*factory)->create_maestro_context =
84     xbt_ctx_java_factory_create_maestro_context;
85   (*factory)->name = "ctx_java_factory";
86 }
87
88 static int
89 xbt_ctx_java_factory_create_maestro_context(xbt_context_t * maestro)
90 {
91   xbt_ctx_java_t context = xbt_new0(s_xbt_ctx_java_t, 1);
92
93   context->exception = xbt_new(ex_ctx_t, 1);
94   XBT_CTX_INITIALIZE(context->exception);
95
96   *maestro = (xbt_context_t) context;
97
98   return 0;
99 }
100
101 static int xbt_ctx_java_factory_finalize(xbt_context_factory_t * factory)
102 {
103   free(maestro_context->exception);
104   free(*factory);
105   *factory = NULL;
106
107   return 0;
108 }
109
110 static xbt_context_t
111 xbt_ctx_java_factory_create_context(const char *name, xbt_main_func_t code,
112                                     void_f_pvoid_t startup_func,
113                                     void *startup_arg,
114                                     void_f_pvoid_t cleanup_func,
115                                     void *cleanup_arg, int argc, char **argv)
116 {
117   xbt_ctx_java_t context = xbt_new0(s_xbt_ctx_java_t, 1);
118
119   context->name = xbt_strdup(name);
120
121   context->cleanup_func = cleanup_func;
122   context->cleanup_arg = cleanup_arg;
123
124   context->exception = xbt_new(ex_ctx_t, 1);
125   XBT_CTX_INITIALIZE(context->exception);
126
127   context->free = xbt_ctx_java_free;
128   context->kill = xbt_ctx_java_kill;
129   context->schedule = xbt_ctx_java_schedule;
130   context->yield = xbt_ctx_java_yield;
131   context->start = xbt_ctx_java_start;
132   context->stop = xbt_ctx_java_stop;
133   context->jprocess = (jobject) startup_arg;
134   context->jenv = get_current_thread_env();
135
136   return (xbt_context_t) context;
137 }
138
139 static void xbt_ctx_java_free(xbt_context_t context)
140 {
141   if (context) {
142     xbt_ctx_java_t ctx_java = (xbt_ctx_java_t) context;
143
144     free(ctx_java->name);
145
146     if (ctx_java->jprocess) {
147       jobject jprocess = ctx_java->jprocess;
148
149       ctx_java->jprocess = NULL;
150
151       /* if the java process is alive join it */
152       if (jprocess_is_alive(jprocess, get_current_thread_env()))
153         jprocess_join(jprocess, get_current_thread_env());
154     }
155
156     if (ctx_java->exception)
157       free(ctx_java->exception);
158
159     free(context);
160     context = NULL;
161   }
162 }
163
164 static void xbt_ctx_java_kill(xbt_context_t context)
165 {
166   context->iwannadie = 1;
167   xbt_ctx_java_swap(context);
168 }
169
170 /** 
171  * \param context the winner
172  *
173  * Calling this function blocks the current context and schedule \a context.  
174  * When \a context will call xbt_context_yield, it will return
175  * to this function as if nothing had happened.
176  * 
177  * Only the maestro can call this function to run a given process.
178  */
179 static void xbt_ctx_java_schedule(xbt_context_t context)
180 {
181   xbt_assert0((current_context == maestro_context),
182               "You are not supposed to run this function here!");
183   xbt_ctx_java_swap(context);
184 }
185
186 /** 
187  * Calling this function makes the current context yield. The context
188  * that scheduled it returns from xbt_context_schedule as if nothing
189  * had happened.
190  * 
191  * Only the processes can call this function, giving back the control
192  * to the maestro
193  */
194 static void xbt_ctx_java_yield(void)
195 {
196   xbt_assert0((current_context != maestro_context),
197               "You are not supposed to run this function here!");
198   jprocess_unschedule(current_context);
199 }
200
201 static void xbt_ctx_java_start(xbt_context_t context)
202 {
203   jprocess_start(((xbt_ctx_java_t) context)->jprocess,
204                  get_current_thread_env());
205 }
206
207 static void xbt_ctx_java_stop(int exit_code)
208 {
209   jobject jprocess = NULL;
210   xbt_ctx_java_t ctx_java;
211
212   if (current_context->cleanup_func)
213     (*(current_context->cleanup_func)) (current_context->cleanup_arg);
214
215   xbt_swag_remove(current_context, context_living);
216   xbt_swag_insert(current_context, context_to_destroy);
217
218   ctx_java = (xbt_ctx_java_t) current_context;
219
220   if (ctx_java->iwannadie) {
221     /* The maestro call xbt_context_stop() with an exit code set to one */
222     if (ctx_java->jprocess) {
223       /* if the java process is alive schedule it */
224       if (jprocess_is_alive(ctx_java->jprocess, get_current_thread_env())) {
225         jprocess_schedule(current_context);
226         jprocess = ctx_java->jprocess;
227         ctx_java->jprocess = NULL;
228
229         /* interrupt the java process */
230         jprocess_exit(jprocess, get_current_thread_env());
231
232       }
233     }
234   } else {
235     /* the java process exits */
236     jprocess = ctx_java->jprocess;
237     ctx_java->jprocess = NULL;
238   }
239
240   /* delete the global reference associated with the java process */
241   jprocess_delete_global_ref(jprocess, get_current_thread_env());
242 }
243
244 static void xbt_ctx_java_swap(xbt_context_t context)
245 {
246   if (context) {
247     xbt_context_t self = current_context;
248
249     current_context = context;
250
251     jprocess_schedule(context);
252
253     current_context = self;
254   }
255
256   if (current_context->iwannadie)
257     xbt_ctx_java_stop(1);
258 }