Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Move functions from MsgNative to Host, and from jmsg to jmsg_host
[simgrid.git] / src / jmsg.c
1 /* Java Wrappers to the MSG API.                                            */
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
9 #include <msg/msg.h>
10 #include <simgrid/simix.h>
11 #include <surf/surfxml_parse.h>
12
13
14 #include "smx_context_java.h"
15
16 #include "jmsg_process.h"
17
18 #include "jmsg_host.h"
19 #include "jmsg_task.h"
20 #include "jmsg_application_handler.h"
21 #include "jxbt_utilities.h"
22
23 #include "jmsg.h"
24
25 /* Shut up some errors in eclipse online compiler. I wish such a pimple wouldn't be needed */
26 #ifndef JNIEXPORT
27 #define JNIEXPORT
28 #endif
29 #ifndef JNICALL
30 #define JNICALL
31 #endif
32 /* end of eclipse-mandated pimple */
33
34 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
35
36 static JavaVM *__java_vm = NULL;
37
38
39 JavaVM *get_java_VM(void)
40 {
41   return __java_vm;
42 }
43
44 JNIEnv *get_current_thread_env(void)
45 {
46   JNIEnv *env;
47
48   (*__java_vm)->AttachCurrentThread(__java_vm, (void **) &env, NULL);
49
50   return env;
51 }
52
53 /*
54  * The MSG process connected functions implementation.                                 
55  */
56
57 JNIEXPORT void JNICALL
58 Java_org_simgrid_msg_MsgNative_processCreate(JNIEnv * env, jclass cls,
59                                          jobject jprocess_arg,
60                                          jobject jhostname)
61 {
62      
63    
64   jobject jprocess;             /* the global reference to the java process instance    */
65   jstring jname;                /* the name of the java process instance                */
66   const char *name;             /* the C name of the process                            */
67   const char *hostname;
68   m_process_t process;          /* the native process to create                         */
69   m_host_t host;                /* Where that process lives */
70    
71   hostname = (*env)->GetStringUTFChars(env, jhostname, 0);
72
73   XBT_DEBUG("Java_org_simgrid_msg_MsgNative_processCreate(env=%p,cls=%p,jproc=%p,host=%s)",
74          env, cls, jprocess_arg, hostname);
75    
76    
77   /* get the name of the java process */
78   jname = jprocess_get_name(jprocess_arg, env);
79   if (!jname) {
80     jxbt_throw_null(env,
81             xbt_strdup("Internal error: Process name cannot be NULL"));
82     return;
83   }
84
85   /* bind/retrieve the msg host */
86   host = MSG_get_host_by_name(hostname);
87
88   if (!(host)) {    /* not binded */
89     jxbt_throw_host_not_found(env, hostname);
90     return;
91   }
92
93   /* create a global java process instance */
94   jprocess = jprocess_new_global_ref(jprocess_arg, env);
95   if (!jprocess) {
96     jxbt_throw_jni(env, "Can't get a global ref to the java process");
97     return;
98   }
99
100   /* build the C name of the process */
101   name = (*env)->GetStringUTFChars(env, jname, 0);
102   name = xbt_strdup(name);
103   
104   /* Actually build the MSG process */
105   process = MSG_process_create_with_environment(name,
106                                                 (xbt_main_func_t) jprocess,
107                                                 /*data*/ NULL,
108                                                 host,
109                                                 /* kill_time */-1,
110                                                 /*argc, argv, properties*/
111                                                 0,NULL,NULL);
112      
113   MSG_process_set_data(process,&process);
114    
115   /* release our reference to the process name (variable name becomes invalid) */
116   //FIXME : This line should be uncommented but with mac it doesn't work. BIG WARNING
117   //(*env)->ReleaseStringUTFChars(env, jname, name);
118   (*env)->ReleaseStringUTFChars(env, jhostname, hostname);
119    
120   /* bind the java process instance to the native process */
121   jprocess_bind(jprocess, process, env);
122
123 }
124
125 JNIEXPORT void JNICALL
126 Java_org_simgrid_msg_MsgNative_processSuspend(JNIEnv * env, jclass cls,
127                                           jobject jprocess)
128 {
129   m_process_t process = jprocess_to_native_process(jprocess, env);
130
131   if (!process) {
132     jxbt_throw_notbound(env, "process", jprocess);
133     return;
134   }
135
136   /* try to suspend the process */
137   MSG_error_t rv = MSG_process_suspend(process);
138
139   jxbt_check_res("MSG_process_suspend()", rv, MSG_OK,
140                  bprintf("unexpected error , please report this bug"));
141
142 }
143
144 JNIEXPORT void JNICALL
145 Java_org_simgrid_msg_Process_simulatedSleep(JNIEnv * env, jobject jprocess,
146                                            jdouble jseconds) {
147           m_process_t process = jprocess_to_native_process(jprocess, env);
148
149           if (!process) {
150             jxbt_throw_notbound(env, "process", jprocess);
151             return;
152           }
153           MSG_error_t rv = MSG_process_sleep((double)jseconds);
154
155           jxbt_check_res("MSG_process_sleep()", rv, MSG_OK,
156                          bprintf("unexpected error , please report this bug"));
157 }
158
159
160 JNIEXPORT void JNICALL
161 Java_org_simgrid_msg_MsgNative_processResume(JNIEnv * env, jclass cls,
162                                          jobject jprocess)
163 {
164   m_process_t process = jprocess_to_native_process(jprocess, env);
165
166   if (!process) {
167     jxbt_throw_notbound(env, "process", jprocess);
168     return;
169   }
170
171   /* try to resume the process */
172   MSG_error_t rv = MSG_process_resume(process);
173
174   jxbt_check_res("MSG_process_resume()", rv, MSG_OK,
175                  bprintf("unexpected error , please report this bug"));
176 }
177
178 JNIEXPORT jboolean JNICALL
179 Java_org_simgrid_msg_MsgNative_processIsSuspended(JNIEnv * env, jclass cls,
180                                               jobject jprocess)
181 {
182   m_process_t process = jprocess_to_native_process(jprocess, env);
183
184   if (!process) {
185     jxbt_throw_notbound(env, "process", jprocess);
186     return 0;
187   }
188
189   /* true is the process is suspended, false otherwise */
190   return (jboolean) MSG_process_is_suspended(process);
191 }
192
193 JNIEXPORT void JNICALL
194 Java_org_simgrid_msg_MsgNative_processKill(JNIEnv * env, jclass cls,
195                                        jobject jprocess)
196 {
197   /* get the native instances from the java ones */
198   m_process_t process = jprocess_to_native_process(jprocess, env);
199
200   if (!process) {
201     jxbt_throw_notbound(env, "process", jprocess);
202     return;
203   }
204
205   /* kill the native process (this wrapper is call by the destructor of the java 
206    * process instance)
207    */
208   MSG_process_kill(process);
209 }
210
211 JNIEXPORT jobject JNICALL
212 Java_org_simgrid_msg_MsgNative_processGetHost(JNIEnv * env, jclass cls,
213                                           jobject jprocess)
214 {
215   /* get the native instances from the java ones */
216   m_process_t process = jprocess_to_native_process(jprocess, env);
217   m_host_t host;
218
219   if (!process) {
220     jxbt_throw_notbound(env, "process", jprocess);
221     return NULL;
222   }
223
224   host = MSG_process_get_host(process);
225   jobject res = (jobject)MSG_host_get_data(host);
226
227   if (!res) {
228           XBT_INFO("Binding error for host %s ",MSG_host_get_name(host));
229           jxbt_throw_jni(env, bprintf("Binding error for host %s ",MSG_host_get_name(host)));
230           return NULL;
231   }
232
233   /* return the global reference to the java host instance */
234   return res;
235
236 }
237
238 JNIEXPORT jobject JNICALL
239 Java_org_simgrid_msg_MsgNative_processFromPID(JNIEnv * env, jclass cls,
240                                           jint PID)
241 {
242   m_process_t process = MSG_process_from_PID(PID);
243
244   if (!process) {
245     jxbt_throw_process_not_found(env, bprintf("PID = %d",(int) PID));
246     return NULL;
247   }
248
249   if (!native_to_java_process(process)) {
250     jxbt_throw_jni(env, "SIMIX_process_get_jprocess() failed");
251     return NULL;
252   }
253
254   return (jobject) (native_to_java_process(process));
255 }
256
257
258 JNIEXPORT jint JNICALL
259 Java_org_simgrid_msg_MsgNative_processGetPID(JNIEnv * env, jclass cls,
260                                          jobject jprocess)
261 {
262   m_process_t process = jprocess_to_native_process(jprocess, env);
263
264   if (!process) {
265     jxbt_throw_notbound(env, "process", jprocess);
266     return 0;
267   }
268
269   return (jint) MSG_process_get_PID(process);
270 }
271
272
273 JNIEXPORT jint JNICALL
274 Java_org_simgrid_msg_MsgNative_processGetPPID(JNIEnv * env, jclass cls,
275                                           jobject jprocess)
276 {
277   m_process_t process = jprocess_to_native_process(jprocess, env);
278
279   if (!process) {
280     jxbt_throw_notbound(env, "process", jprocess);
281     return 0;
282   }
283
284   return (jint) MSG_process_get_PPID(process);
285 }
286
287 JNIEXPORT jobject JNICALL
288 Java_org_simgrid_msg_MsgNative_processSelf(JNIEnv * env, jclass cls)
289 {
290   m_process_t process = MSG_process_self();
291   jobject jprocess;
292
293   if (!process) {
294     jxbt_throw_jni(env, xbt_strdup("MSG_process_self() failed"));
295     return NULL;
296   }
297
298   jprocess = native_to_java_process(process);
299
300   if (!jprocess)
301     jxbt_throw_jni(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
302
303   return jprocess;
304 }
305
306 JNIEXPORT void JNICALL
307 Java_org_simgrid_msg_MsgNative_processMigrate(JNIEnv * env, jclass cls,
308                                              jobject jprocess, jobject jhost)
309 {
310   m_process_t process = jprocess_to_native_process(jprocess, env);
311
312   if (!process) {
313     jxbt_throw_notbound(env, "process", jprocess);
314     return;
315   }
316
317   m_host_t host = jhost_get_native(env, jhost);
318
319   if (!host) {
320     jxbt_throw_notbound(env, "host", jhost);
321     return;
322   }
323
324   /* try to change the host of the process */
325   MSG_error_t rv = MSG_process_migrate(process, host);
326   jxbt_check_res("MSG_process_migrate()", rv, MSG_OK,
327                  bprintf("unexpected error , please report this bug"));
328
329 }
330
331 JNIEXPORT void JNICALL
332 Java_org_simgrid_msg_MsgNative_processWaitFor(JNIEnv * env, jclass cls,
333                                           jdouble seconds)
334 {
335   MSG_error_t rv = MSG_process_sleep((double) seconds);
336
337   jxbt_check_res("MSG_process_sleep()", rv, MSG_HOST_FAILURE,
338                  bprintf("while process was waiting for %f seconds",
339                          (double) seconds));
340
341 }
342
343
344 /***************************************************************************************
345  * The MSG host connected functions implementation.                                    *
346  ***************************************************************************************/
347
348 JNIEXPORT jint JNICALL
349 Java_org_simgrid_msg_MsgNative_hostGetLoad(JNIEnv * env, jclass cls,
350                                        jobject jhost)
351 {
352   m_host_t host = jhost_get_native(env, jhost);
353
354   if (!host) {
355     jxbt_throw_notbound(env, "host", jhost);
356     return -1;
357   }
358
359   return (jint) MSG_get_host_msgload(host);
360 }
361
362
363 /***************************************************************************************
364  * Unsortable functions                                                        *
365  ***************************************************************************************/
366
367 JNIEXPORT jdouble JNICALL
368 Java_org_simgrid_msg_Msg_getClock(JNIEnv * env, jclass cls)
369 {
370   return (jdouble) MSG_get_clock();
371 }
372
373 JNIEXPORT void JNICALL
374 Java_org_simgrid_msg_Msg_init(JNIEnv * env, jclass cls, jobjectArray jargs)
375 {
376   char **argv = NULL;
377   int index;
378   int argc = 0;
379   jstring jval;
380   const char *tmp;
381
382   smx_factory_initializer_to_use = SIMIX_ctx_java_factory_init;
383
384   if (jargs)
385     argc = (int) (*env)->GetArrayLength(env, jargs);
386
387   argc++;
388   argv = xbt_new(char *, argc + 1);
389   argv[0] = strdup("java");
390
391   for (index = 0; index < argc - 1; index++) {
392     jval = (jstring) (*env)->GetObjectArrayElement(env, jargs, index);
393     tmp = (*env)->GetStringUTFChars(env, jval, 0);
394     argv[index + 1] = strdup(tmp);
395     (*env)->ReleaseStringUTFChars(env, jval, tmp);
396   }
397   argv[argc] = NULL;
398
399   MSG_global_init(&argc, argv);
400
401   for (index = 0; index < argc; index++)
402     free(argv[index]);
403
404   free(argv);
405
406   (*env)->GetJavaVM(env, &__java_vm);
407 }
408
409 JNIEXPORT void JNICALL
410     JNICALL Java_org_simgrid_msg_Msg_run(JNIEnv * env, jclass cls)
411 {
412   MSG_error_t rv;
413   int index;
414   xbt_dynar_t hosts;
415   jobject jhost;
416
417   /* Run everything */
418   XBT_INFO("Ready to run MSG_MAIN");
419   rv = MSG_main();
420   XBT_INFO("Done running MSG_MAIN");
421   jxbt_check_res("MSG_main()", rv, MSG_OK,
422                  bprintf
423                  ("unexpected error : MSG_main() failed .. please report this bug "));
424
425   XBT_INFO("MSG_main finished");
426
427   XBT_INFO("Clean java world");
428   /* Cleanup java hosts */
429   hosts = MSG_hosts_as_dynar();
430   for (index = 0; index < xbt_dynar_length(hosts) - 1; index++) {
431     jhost = (jobject) MSG_host_get_data(xbt_dynar_get_as(hosts,index,m_host_t));
432     if (jhost)
433       jhost_unref(env, jhost);
434
435   }
436   xbt_dynar_free(&hosts);
437   XBT_INFO("Clean native world");
438 }
439 JNIEXPORT void JNICALL
440     JNICALL Java_org_simgrid_msg_Msg_clean(JNIEnv * env, jclass cls)
441 {
442   /* cleanup native stuff. Calling it is ... useless since leaking memory at the end of the simulation is a non-issue */
443   MSG_error_t rv = MSG_OK != MSG_clean();
444   jxbt_check_res("MSG_clean()", rv, MSG_OK,
445                  bprintf
446                  ("unexpected error : MSG_clean() failed .. please report this bug "));
447 }
448    
449 JNIEXPORT jint JNICALL
450 Java_org_simgrid_msg_MsgNative_processKillAll(JNIEnv * env, jclass cls,
451                                           jint jresetPID)
452 {
453   return (jint) MSG_process_killall((int) jresetPID);
454 }
455
456 JNIEXPORT void JNICALL
457 Java_org_simgrid_msg_Msg_createEnvironment(JNIEnv * env, jclass cls,
458                                        jstring jplatformFile)
459 {
460
461   const char *platformFile =
462       (*env)->GetStringUTFChars(env, jplatformFile, 0);
463
464   MSG_create_environment(platformFile);
465
466   (*env)->ReleaseStringUTFChars(env, jplatformFile, platformFile);
467 }
468
469 JNIEXPORT void JNICALL
470 Java_org_simgrid_msg_MsgNative_processExit(JNIEnv * env, jclass cls,
471                                        jobject jprocess)
472 {
473
474   m_process_t process = jprocess_to_native_process(jprocess, env);
475
476   if (!process) {
477     jxbt_throw_notbound(env, "process", jprocess);
478     return;
479   }
480
481   smx_ctx_java_stop(MSG_process_get_smx_ctx(process));
482 }
483
484 JNIEXPORT void JNICALL
485 Java_org_simgrid_msg_Msg_info(JNIEnv * env, jclass cls, jstring js)
486 {
487   const char *s = (*env)->GetStringUTFChars(env, js, 0);
488   XBT_INFO("%s", s);
489   (*env)->ReleaseStringUTFChars(env, js, s);
490 }
491
492 JNIEXPORT jobjectArray JNICALL
493 Java_org_simgrid_msg_MsgNative_allHosts(JNIEnv * env, jclass cls_arg)
494 {
495   int index;
496   jobjectArray jtable;
497   jobject jhost;
498   jstring jname;
499   m_host_t host;
500
501   xbt_dynar_t table =  MSG_hosts_as_dynar();
502   int count = xbt_dynar_length(table);
503
504   jclass cls = jxbt_get_class(env, "org/simgrid/msg/Host");
505
506   if (!cls) {
507     return NULL;
508   }
509
510   jtable = (*env)->NewObjectArray(env, (jsize) count, cls, NULL);
511
512   if (!jtable) {
513     jxbt_throw_jni(env, "Hosts table allocation failed");
514     return NULL;
515   }
516
517   for (index = 0; index < count; index++) {
518     host = xbt_dynar_get_as(table,index,m_host_t);
519     jhost = (jobject) (MSG_host_get_data(host));
520
521     if (!jhost) {
522       jname = (*env)->NewStringUTF(env, MSG_host_get_name(host));
523
524       jhost =
525                 Java_org_simgrid_msg_Host_getByName(env, cls_arg, jname);
526       /* FIXME: leak of jname ? */
527     }
528
529     (*env)->SetObjectArrayElement(env, jtable, index, jhost);
530   }
531   xbt_dynar_free(&table);
532   return jtable;
533 }
534
535 JNIEXPORT void JNICALL
536 Java_org_simgrid_msg_Msg_deployApplication(JNIEnv * env, jclass cls,
537                                        jstring jdeploymentFile)
538 {
539
540   const char *deploymentFile =
541       (*env)->GetStringUTFChars(env, jdeploymentFile, 0);
542
543   surf_parse_reset_callbacks();
544
545   surfxml_add_callback(STag_surfxml_process_cb_list,
546                        japplication_handler_on_begin_process);
547
548   surfxml_add_callback(ETag_surfxml_argument_cb_list,
549                        japplication_handler_on_process_arg);
550
551   surfxml_add_callback(STag_surfxml_prop_cb_list,
552                        japplication_handler_on_property);
553
554   surfxml_add_callback(ETag_surfxml_process_cb_list,
555                        japplication_handler_on_end_process);
556
557   surf_parse_open(deploymentFile);
558
559   japplication_handler_on_start_document();
560
561   if (surf_parse())
562     jxbt_throw_jni(env, "surf_parse() failed");
563
564   surf_parse_close();
565
566   japplication_handler_on_end_document();
567
568   (*env)->ReleaseStringUTFChars(env, jdeploymentFile, deploymentFile);
569 }