Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Deleted simulatedSleep, use waitFor instead. Moved everything from MsgNative to their...
[simgrid.git] / src / jmsg_process.c
1 /* Functions related to the java process instances.                         */
2
3 /* Copyright (c) 2007, 2008, 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 #include "jmsg_process.h"
9
10 #include "jmsg.h"
11 #include "jmsg_host.h"
12 #include "jxbt_utilities.h"
13
14 #include "smx_context_java.h"  
15
16 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
17
18 static jfieldID jprocess_field_Process_pid;
19 static jfieldID jprocess_field_Process_ppid;
20 static jfieldID jprocess_field_Process_host;
21
22 jobject native_to_java_process(m_process_t process)
23 {
24   return ((smx_ctx_java_t)MSG_process_get_smx_ctx(process))->jprocess;
25 }
26
27 jobject jprocess_new_global_ref(jobject jprocess, JNIEnv * env)
28 {
29   return (*env)->NewGlobalRef(env, jprocess);
30 }
31
32 void jprocess_delete_global_ref(jobject jprocess, JNIEnv * env)
33 {
34   (*env)->DeleteGlobalRef(env, jprocess);
35 }
36
37 jboolean jprocess_is_alive(jobject jprocess, JNIEnv * env)
38 {
39   jmethodID id =
40       jxbt_get_smethod(env, "org/simgrid/msg/Process", "isAlive", "()Z");
41
42   if (!id)
43     return 0;
44
45   return (*env)->CallBooleanMethod(env, jprocess, id);
46 }
47
48 void jprocess_join(jobject jprocess, JNIEnv * env)
49 {
50   jmethodID id =
51       jxbt_get_smethod(env, "org/simgrid/msg/Process", "join", "()V");
52
53   if (!id)
54     return;
55
56   (*env)->CallVoidMethod(env, jprocess, id);
57 }
58
59 void jprocess_exit(jobject jprocess, JNIEnv * env)
60 {
61   jmethodID id =
62       jxbt_get_smethod(env, "org/simgrid/msg/Process", "interrupt", "()V");
63
64   if (!id)
65     return;
66
67   (*env)->CallVoidMethod(env, jprocess, id);
68 }
69
70 void jprocess_yield(jobject jprocess, JNIEnv * env)
71 {
72   jmethodID id =
73       jxbt_get_smethod(env, "org/simgrid/msg/Process", "switchProcess", "()V");
74
75   if (!id)
76     return;
77
78   (*env)->CallVoidMethod(env, jprocess, id);
79 }
80
81 void jprocess_lock_mutex(jobject jprocess, JNIEnv * env)
82 {
83   jmethodID id =
84       jxbt_get_smethod(env, "org/simgrid/msg/Process", "lockMutex", "()V");
85
86   if (!id)
87     return;
88
89   (*env)->CallVoidMethod(env, jprocess, id);
90 }
91
92 void jprocess_unlock_mutex(jobject jprocess, JNIEnv * env)
93 {
94   jmethodID id =
95       jxbt_get_smethod(env, "org/simgrid/msg/Process", "unlockMutex", "()V");
96
97   if (!id)
98     return;
99
100   (*env)->CallVoidMethod(env, jprocess, id);
101 }
102
103
104 void jprocess_signal_cond(jobject jprocess, JNIEnv * env)
105 {
106   jmethodID id =
107       jxbt_get_smethod(env, "org/simgrid/msg/Process", "signalCond", "()V");
108
109   if (!id)
110     return;
111
112   (*env)->CallVoidMethod(env, jprocess, id);
113 }
114
115 void jprocess_wait_cond(jobject jprocess, JNIEnv * env)
116 {
117   jmethodID id =
118       jxbt_get_smethod(env, "org/simgrid/msg/Process", "waitCond", "()V");
119
120   if (!id)
121     return;
122
123   (*env)->CallVoidMethod(env, jprocess, id);
124 }
125
126
127 void jprocess_start(jobject jprocess, JNIEnv * env)
128 {
129   jmethodID id =
130       jxbt_get_smethod(env, "org/simgrid/msg/Process", "start", "()V");
131
132   if (!id)
133     return;
134
135   XBT_DEBUG("jprocess_start(jproc=%p,env=%p)", jprocess, env);
136   (*env)->CallVoidMethod(env, jprocess, id);
137   XBT_DEBUG("jprocess started");
138 }
139
140 m_process_t jprocess_to_native_process(jobject jprocess, JNIEnv * env)
141 {
142   jfieldID id = jxbt_get_sfield(env, "org/simgrid/msg/Process", "bind", "J");
143
144   if (!id)
145     return NULL;
146
147   return (m_process_t) (long) (*env)->GetLongField(env, jprocess, id);
148 }
149
150 void jprocess_bind(jobject jprocess, m_process_t process, JNIEnv * env)
151 {
152   jfieldID id = jxbt_get_sfield(env, "org/simgrid/msg/Process", "bind", "J");
153   if (!id)
154     return;
155
156   (*env)->SetLongField(env, jprocess, id, (jlong) (long) (process));
157 }
158
159 jlong jprocess_get_id(jobject jprocess, JNIEnv * env)
160 {
161   jfieldID id = jxbt_get_sfield(env, "org/simgrid/msg/Process", "id", "J");
162
163   if (!id)
164     return 0;
165
166   return (*env)->GetLongField(env, jprocess, id);
167 }
168
169 jstring jprocess_get_name(jobject jprocess, JNIEnv * env)
170 {
171   jfieldID id = jxbt_get_sfield(env, "org/simgrid/msg/Process", "name",
172                                 "Ljava/lang/String;");
173   jobject jname;
174
175   if (!id)
176     return NULL;
177
178   jname = (jstring) (*env)->GetObjectField(env, jprocess, id);
179
180   return (*env)->NewGlobalRef(env, jname);
181
182 }
183
184 jboolean jprocess_is_valid(jobject jprocess, JNIEnv * env)
185 {
186   jfieldID id = jxbt_get_sfield(env, "org/simgrid/msg/Process", "bind", "J");
187
188   if (!id)
189     return JNI_FALSE;
190
191   return (*env)->GetLongField(env, jprocess, id) ? JNI_TRUE : JNI_FALSE;
192 }
193
194 void jprocess_schedule(smx_context_t context)
195 {
196   JNIEnv *env;
197   jmethodID id;
198
199   env = get_current_thread_env();
200
201   id = jxbt_get_smethod(env, "org/simgrid/msg/Process", "schedule", "()V");
202
203   if (!id) {
204     XBT_CRITICAL("Cannot find java method org/simgrid/msg/Process/schedule()V");
205     return;
206   }
207
208   (*env)->CallVoidMethod(env, ((smx_ctx_java_t) context)->jprocess, id);
209 }
210
211
212
213 void jprocess_unschedule(smx_context_t context)
214 {
215   JNIEnv *env;
216   jmethodID id;
217
218   env = get_current_thread_env();
219
220
221   id = jxbt_get_smethod(env, "org/simgrid/msg/Process", "unschedule", "()V");
222
223   if (!id)
224     return;
225
226   (*env)->CallVoidMethod(env, ((smx_ctx_java_t) context)->jprocess, id);
227 }
228 JNIEXPORT void JNICALL
229 Java_org_simgrid_msg_Process_nativeInit(JNIEnv *env, jclass cls) {
230         jclass jprocess_class_Process = (*env)->FindClass(env, "org/simgrid/msg/Process");
231
232         jprocess_field_Process_pid = jxbt_get_sfield(env, "org/simgrid/msg/Process", "pid", "I");
233         jprocess_field_Process_ppid = jxbt_get_sfield(env, "org/simgrid/msg/Process", "ppid", "I");
234         jprocess_field_Process_host = jxbt_get_jfield(env, jprocess_class_Process, "host", "Lorg/simgrid/msg/Host;");
235 }
236 JNIEXPORT void JNICALL
237 Java_org_simgrid_msg_Process_create(JNIEnv * env,
238                                     jobject jprocess_arg,
239                                     jobject jhostname)
240 {
241
242
243   jobject jprocess;             /* the global reference to the java process instance    */
244   jstring jname;                /* the name of the java process instance                */
245   const char *name;             /* the C name of the process                            */
246   const char *hostname;
247   m_process_t process;          /* the native process to create                         */
248   m_host_t host;                /* Where that process lives */
249
250   hostname = (*env)->GetStringUTFChars(env, jhostname, 0);
251
252   XBT_DEBUG("Java_org_simgrid_msg_MsgNative_processCreate(env=%p,jproc=%p,host=%s)",
253          env, jprocess_arg, hostname);
254
255
256   /* get the name of the java process */
257   jname = jprocess_get_name(jprocess_arg, env);
258   if (!jname) {
259     jxbt_throw_null(env,
260             xbt_strdup("Internal error: Process name cannot be NULL"));
261     return;
262   }
263
264   /* bind/retrieve the msg host */
265   host = MSG_get_host_by_name(hostname);
266
267   if (!(host)) {    /* not binded */
268     jxbt_throw_host_not_found(env, hostname);
269     return;
270   }
271
272   /* create a global java process instance */
273   jprocess = jprocess_new_global_ref(jprocess_arg, env);
274   if (!jprocess) {
275     jxbt_throw_jni(env, "Can't get a global ref to the java process");
276     return;
277   }
278
279   /* build the C name of the process */
280   name = (*env)->GetStringUTFChars(env, jname, 0);
281   name = xbt_strdup(name);
282
283   /* Actually build the MSG process */
284   process = MSG_process_create_with_environment(name,
285                                                 (xbt_main_func_t) jprocess,
286                                                 /*data*/ NULL,
287                                                 host,
288                                                 /* kill_time */-1,
289                                                 /*argc, argv, properties*/
290                                                 0,NULL,NULL);
291
292   MSG_process_set_data(process,&process);
293
294   /* release our reference to the process name (variable name becomes invalid) */
295   //FIXME : This line should be uncommented but with mac it doesn't work. BIG WARNING
296   //(*env)->ReleaseStringUTFChars(env, jname, name);
297   (*env)->ReleaseStringUTFChars(env, jhostname, hostname);
298
299   /* bind the java process instance to the native process */
300   jprocess_bind(jprocess, process, env);
301
302   /* sets the PID and the PPID of the process */
303   (*env)->SetIntField(env, jprocess, jprocess_field_Process_pid,(jint) MSG_process_get_PID(process));
304   (*env)->SetIntField(env, jprocess, jprocess_field_Process_ppid, (jint) MSG_process_get_PPID(process));
305   /* sets the Host of the process */
306   jobject jhost = Java_org_simgrid_msg_Host_getByName(env,NULL,jhostname);
307
308   (*env)->SetObjectField(env, jprocess, jprocess_field_Process_host, jhost);
309 }
310
311 JNIEXPORT jint JNICALL
312 Java_org_simgrid_msg_Process_killAll(JNIEnv * env, jclass cls,
313                                      jint jresetPID)
314 {
315   return (jint) MSG_process_killall((int) jresetPID);
316 }
317
318 JNIEXPORT jobject JNICALL
319 Java_org_simgrid_msg_Process_fromPID(JNIEnv * env, jclass cls,
320                                      jint PID)
321 {
322   m_process_t process = MSG_process_from_PID(PID);
323
324   if (!process) {
325     jxbt_throw_process_not_found(env, bprintf("PID = %d",(int) PID));
326     return NULL;
327   }
328
329   jobject jprocess = native_to_java_process(process);
330
331   if (!jprocess) {
332     jxbt_throw_jni(env, "SIMIX_process_get_jprocess() failed");
333     return NULL;
334   }
335
336   return jprocess;
337 }
338
339 JNIEXPORT jobject JNICALL
340 Java_org_simgrid_msg_Process_currentProcess(JNIEnv * env, jclass cls)
341 {
342   m_process_t process = MSG_process_self();
343   jobject jprocess;
344
345   if (!process) {
346     jxbt_throw_jni(env, xbt_strdup("MSG_process_self() failed"));
347     return NULL;
348   }
349
350   jprocess = native_to_java_process(process);
351
352   if (!jprocess)
353     jxbt_throw_jni(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
354
355   return jprocess;
356 }
357
358 JNIEXPORT void JNICALL
359 Java_org_simgrid_msg_Process_pause(JNIEnv * env,
360                                    jobject jprocess)
361 {
362   m_process_t process = jprocess_to_native_process(jprocess, env);
363
364   if (!process) {
365     jxbt_throw_notbound(env, "process", jprocess);
366     return;
367   }
368
369   /* try to suspend the process */
370   MSG_error_t rv = MSG_process_suspend(process);
371
372   jxbt_check_res("MSG_process_suspend()", rv, MSG_OK,
373                  bprintf("unexpected error , please report this bug"));
374
375 }
376 JNIEXPORT void JNICALL
377 Java_org_simgrid_msg_Process_restart(JNIEnv * env,
378                                      jobject jprocess)
379 {
380   m_process_t process = jprocess_to_native_process(jprocess, env);
381
382   if (!process) {
383     jxbt_throw_notbound(env, "process", jprocess);
384     return;
385   }
386
387   /* try to resume the process */
388   MSG_error_t rv = MSG_process_resume(process);
389
390   jxbt_check_res("MSG_process_resume()", rv, MSG_OK,
391                  bprintf("unexpected error , please report this bug"));
392 }
393 JNIEXPORT jboolean JNICALL
394 Java_org_simgrid_msg_Process_isSuspended(JNIEnv * env,
395                                          jobject jprocess)
396 {
397   m_process_t process = jprocess_to_native_process(jprocess, env);
398
399   if (!process) {
400     jxbt_throw_notbound(env, "process", jprocess);
401     return 0;
402   }
403
404   /* true is the process is suspended, false otherwise */
405   return (jboolean) MSG_process_is_suspended(process);
406 }
407 JNIEXPORT void JNICALL
408 Java_org_simgrid_msg_Process_waitFor(JNIEnv * env, jobject jprocess,
409                                      jdouble jseconds)
410 {
411   m_process_t process = jprocess_to_native_process(jprocess, env);
412
413   if (!process) {
414     jxbt_throw_notbound(env, "process", jprocess);
415     return;
416   }
417   MSG_error_t rv = MSG_process_sleep((double)jseconds);
418
419   jxbt_check_res("MSG_process_sleep()", rv, MSG_OK,
420                  bprintf("unexpected error , please report this bug"));
421
422 }
423
424 JNIEXPORT void JNICALL
425 Java_org_simgrid_msg_Process_exit(JNIEnv * env,
426                                   jobject jprocess)
427 {
428
429   m_process_t process = jprocess_to_native_process(jprocess, env);
430
431   if (!process) {
432     jxbt_throw_notbound(env, "process", jprocess);
433     return;
434   }
435
436   smx_ctx_java_stop(MSG_process_get_smx_ctx(process));
437 }
438
439 JNIEXPORT void JNICALL
440 Java_org_simgrid_msg_Process_kill(JNIEnv * env, jclass cls,
441                                   jobject jprocess)
442 {
443   /* get the native instances from the java ones */
444   m_process_t process = jprocess_to_native_process(jprocess, env);
445
446   if (!process) {
447     jxbt_throw_notbound(env, "process", jprocess);
448     return;
449   }
450
451   /* kill the native process (this wrapper is call by the destructor of the java
452    * process instance)
453    */
454   MSG_process_kill(process);
455 }
456 JNIEXPORT void JNICALL
457 Java_org_simgrid_msg_Process_migrate(JNIEnv * env,
458                                      jobject jprocess, jobject jhost)
459 {
460   m_process_t process = jprocess_to_native_process(jprocess, env);
461
462   if (!process) {
463     jxbt_throw_notbound(env, "process", jprocess);
464     return;
465   }
466
467   m_host_t host = jhost_get_native(env, jhost);
468
469   if (!host) {
470     jxbt_throw_notbound(env, "host", jhost);
471     return;
472   }
473
474   /* try to change the host of the process */
475   MSG_error_t rv = MSG_process_migrate(process, host);
476   jxbt_check_res("MSG_process_migrate()", rv, MSG_OK,
477                  bprintf("unexpected error , please report this bug"));
478   /* change the host java side */
479   (*env)->SetObjectField(env, jprocess, jprocess_field_Process_host, jhost);
480 }