Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
f4a4a169c19b95b479b9446830e42c567ac2c18a
[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 <simix/context.h>
11 #include <surf/surfxml_parse.h>
12
13 #include "smx_context_java.h"
14
15 #include "jmsg_process.h"
16 #include "jmsg_host.h"
17 #include "jmsg_task.h"
18 #include "jmsg_application_handler.h"
19 #include "jxbt_utilities.h"
20
21 #include "jmsg.h"
22
23 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
24
25 static JavaVM *__java_vm = NULL;
26
27 static jobject native_to_java_process(m_process_t process);
28
29 JavaVM *get_java_VM(void)
30 {
31   return __java_vm;
32 }
33
34 JNIEnv *get_current_thread_env(void)
35 {
36   JNIEnv *env;
37
38   (*__java_vm)->AttachCurrentThread(__java_vm, (void **) &env, NULL);
39
40   return env;
41 }
42
43 static jobject native_to_java_process(m_process_t process)
44 {
45   return ((smx_ctx_java_t)MSG_process_get_smx_ctx(process))->jprocess;
46 }
47
48 /*
49  * The MSG process connected functions implementation.                                 
50  */
51
52 JNIEXPORT void JNICALL
53 Java_org_simgrid_msg_MsgNative_processCreate(JNIEnv * env, jclass cls,
54                                          jobject jprocess_arg,
55                                          jobject jhost)
56 {
57      
58    
59   jobject jprocess;             /* the global reference to the java process instance    */
60   jstring jname;                /* the name of the java process instance                */
61   const char *name;             /* the C name of the process                            */
62   m_process_t process;          /* the native process to create                         */
63   m_host_t host;                /* Where that process lives */
64    
65   XBT_DEBUG("Java_org_simgrid_msg_MsgNative_processCreate(env=%p,cls=%p,jproc=%p,jhost=%p)",
66          env, cls, jprocess_arg, jhost);
67    
68    
69   /* get the name of the java process */
70   jname = jprocess_get_name(jprocess_arg, env);
71   if (!jname) {
72     jxbt_throw_null(env,
73             xbt_strdup("Internal error: Process name cannot be NULL"));
74     return;
75   }
76
77   /* bind/retrieve the msg host */
78   host = jhost_get_native(env, jhost);
79
80   if (!(host)) {    /* not binded */
81     jxbt_throw_notbound(env, "host", jhost);
82     return;
83   }
84
85   /* create a global java process instance */
86   jprocess = jprocess_new_global_ref(jprocess_arg, env);
87   if (!jprocess) {
88     jxbt_throw_jni(env, "Can't get a global ref to the java process");
89     return;
90   }
91
92   /* build the C name of the process */
93   name = (*env)->GetStringUTFChars(env, jname, 0);
94   name = xbt_strdup(name);
95   
96   /* Actually build the MSG process */
97   process = MSG_process_create_with_environment(name,
98                                                 (xbt_main_func_t) jprocess,
99                                                 /*data*/ NULL,
100                                                 host,
101                                                 /*argc, argv, properties*/
102                                                 0,NULL,NULL);
103      
104   MSG_process_set_data(process,&process);
105    
106   /* release our reference to the process name (variable name becomes invalid) */
107   //FIXME : This line should be uncommented but with mac it doesn't work. BIG WARNING
108   //(*env)->ReleaseStringUTFChars(env, jname, name);
109    
110   /* bind the java process instance to the native process */
111   jprocess_bind(jprocess, process, env);
112
113 }
114
115 JNIEXPORT void JNICALL
116 Java_org_simgrid_msg_MsgNative_processSuspend(JNIEnv * env, jclass cls,
117                                           jobject jprocess)
118 {
119   m_process_t process = jprocess_to_native_process(jprocess, env);
120
121   if (!process) {
122     jxbt_throw_notbound(env, "process", jprocess);
123     return;
124   }
125
126   /* try to suspend the process */
127   MSG_error_t rv = MSG_process_suspend(process);
128
129   jxbt_check_res("MSG_process_suspend()", rv, MSG_OK,
130                  bprintf("unexpected error , please report this bug"));
131
132 }
133
134 JNIEXPORT void JNICALL
135 Java_org_simgrid_msg_MsgNative_processResume(JNIEnv * env, jclass cls,
136                                          jobject jprocess)
137 {
138   m_process_t process = jprocess_to_native_process(jprocess, env);
139
140   if (!process) {
141     jxbt_throw_notbound(env, "process", jprocess);
142     return;
143   }
144
145   /* try to resume the process */
146   MSG_error_t rv = MSG_process_resume(process);
147
148   jxbt_check_res("MSG_process_resume()", rv, MSG_OK,
149                  bprintf("unexpected error , please report this bug"));
150 }
151
152 JNIEXPORT jboolean JNICALL
153 Java_org_simgrid_msg_MsgNative_processIsSuspended(JNIEnv * env, jclass cls,
154                                               jobject jprocess)
155 {
156   m_process_t process = jprocess_to_native_process(jprocess, env);
157
158   if (!process) {
159     jxbt_throw_notbound(env, "process", jprocess);
160     return 0;
161   }
162
163   /* true is the process is suspended, false otherwise */
164   return (jboolean) MSG_process_is_suspended(process);
165 }
166
167 JNIEXPORT void JNICALL
168 Java_org_simgrid_msg_MsgNative_processKill(JNIEnv * env, jclass cls,
169                                        jobject jprocess)
170 {
171   /* get the native instances from the java ones */
172   m_process_t process = jprocess_to_native_process(jprocess, env);
173
174   if (!process) {
175     jxbt_throw_notbound(env, "process", jprocess);
176     return;
177   }
178
179   /* kill the native process (this wrapper is call by the destructor of the java 
180    * process instance)
181    */
182   MSG_process_kill(process);
183 }
184
185 JNIEXPORT jobject JNICALL
186 Java_org_simgrid_msg_MsgNative_processGetHost(JNIEnv * env, jclass cls,
187                                           jobject jprocess)
188 {
189   /* get the native instances from the java ones */
190   m_process_t process = jprocess_to_native_process(jprocess, env);
191   m_host_t host;
192
193   if (!process) {
194     jxbt_throw_notbound(env, "process", jprocess);
195     return NULL;
196   }
197
198   host = MSG_process_get_host(process);
199
200   if (!MSG_host_get_data(host)) {
201     jxbt_throw_jni(env, "MSG_process_get_host() failed");
202     return NULL;
203   }
204
205   /* return the global reference to the java host instance */
206   return (jobject) MSG_host_get_data(host);
207
208 }
209
210 JNIEXPORT jobject JNICALL
211 Java_org_simgrid_msg_MsgNative_processFromPID(JNIEnv * env, jclass cls,
212                                           jint PID)
213 {
214   m_process_t process = MSG_process_from_PID(PID);
215
216   if (!process) {
217     jxbt_throw_process_not_found(env, bprintf("PID = %d",(int) PID));
218     return NULL;
219   }
220
221   if (!native_to_java_process(process)) {
222     jxbt_throw_jni(env, "SIMIX_process_get_jprocess() failed");
223     return NULL;
224   }
225
226   return (jobject) (native_to_java_process(process));
227 }
228
229
230 JNIEXPORT jint JNICALL
231 Java_org_simgrid_msg_MsgNative_processGetPID(JNIEnv * env, jclass cls,
232                                          jobject jprocess)
233 {
234   m_process_t process = jprocess_to_native_process(jprocess, env);
235
236   if (!process) {
237     jxbt_throw_notbound(env, "process", jprocess);
238     return 0;
239   }
240
241   return (jint) MSG_process_get_PID(process);
242 }
243
244
245 JNIEXPORT jint JNICALL
246 Java_org_simgrid_msg_MsgNative_processGetPPID(JNIEnv * env, jclass cls,
247                                           jobject jprocess)
248 {
249   m_process_t process = jprocess_to_native_process(jprocess, env);
250
251   if (!process) {
252     jxbt_throw_notbound(env, "process", jprocess);
253     return 0;
254   }
255
256   return (jint) MSG_process_get_PPID(process);
257 }
258
259 JNIEXPORT jobject JNICALL
260 Java_org_simgrid_msg_MsgNative_processSelf(JNIEnv * env, jclass cls)
261 {
262   m_process_t process = MSG_process_self();
263   jobject jprocess;
264
265   if (!process) {
266     jxbt_throw_jni(env, xbt_strdup("MSG_process_self() failed"));
267     return NULL;
268   }
269
270   jprocess = native_to_java_process(process);
271
272   if (!jprocess)
273     jxbt_throw_jni(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
274
275   return jprocess;
276 }
277
278 JNIEXPORT void JNICALL
279 Java_org_simgrid_msg_MsgNative_processMigrate(JNIEnv * env, jclass cls,
280                                              jobject jprocess, jobject jhost)
281 {
282   m_process_t process = jprocess_to_native_process(jprocess, env);
283
284   if (!process) {
285     jxbt_throw_notbound(env, "process", jprocess);
286     return;
287   }
288
289   m_host_t host = jhost_get_native(env, jhost);
290
291   if (!host) {
292     jxbt_throw_notbound(env, "host", jhost);
293     return;
294   }
295
296   /* try to change the host of the process */
297   MSG_error_t rv = MSG_process_migrate(process, host);
298   jxbt_check_res("MSG_process_migrate()", rv, MSG_OK,
299                  bprintf("unexpected error , please report this bug"));
300
301 }
302
303 JNIEXPORT void JNICALL
304 Java_org_simgrid_msg_MsgNative_processWaitFor(JNIEnv * env, jclass cls,
305                                           jdouble seconds)
306 {
307   MSG_error_t rv = MSG_process_sleep((double) seconds);
308
309   jxbt_check_res("MSG_process_sleep()", rv, MSG_HOST_FAILURE,
310                  bprintf("while process was waiting for %f seconds",
311                          (double) seconds));
312
313 }
314
315
316 /***************************************************************************************
317  * The MSG host connected functions implementation.                                    *
318  ***************************************************************************************/
319
320 JNIEXPORT jobject JNICALL
321 Java_org_simgrid_msg_MsgNative_hostGetByName(JNIEnv * env, jclass cls,
322                                          jstring jname)
323 {
324   m_host_t host;                /* native host                                          */
325   jobject jhost;                /* global reference to the java host instance returned  */
326
327   /* get the C string from the java string */
328   const char *name = (*env)->GetStringUTFChars(env, jname, 0);
329   XBT_DEBUG("Looking for host '%s'",name);
330   /* get the host by name       (the hosts are created during the grid resolution) */
331   host = MSG_get_host_by_name(name);
332   XBT_DEBUG("MSG gave %p as native host (simdata=%p)", host,host? host->simdata:NULL);
333
334   if (!host) {                  /* invalid name */
335     jxbt_throw_host_not_found(env, name);
336     (*env)->ReleaseStringUTFChars(env, jname, name);
337     return NULL;
338   }
339   (*env)->ReleaseStringUTFChars(env, jname, name);
340
341   if (!MSG_host_get_data(host)) {       /* native host not associated yet with java host */
342
343     /* instanciate a new java host */
344     jhost = jhost_new_instance(env);
345
346     if (!jhost) {
347       jxbt_throw_jni(env, "java host instantiation failed");
348       return NULL;
349     }
350
351     /* get a global reference to the newly created host */
352     jhost = jhost_ref(env, jhost);
353
354     if (!jhost) {
355       jxbt_throw_jni(env, "new global ref allocation failed");
356       return NULL;
357     }
358
359     /* bind the java host and the native host */
360     jhost_bind(jhost, host, env);
361
362     /* the native host data field is set with the global reference to the 
363      * java host returned by this function 
364      */
365     MSG_host_set_data(host, (void *) jhost);
366   }
367
368   /* return the global reference to the java host instance */
369   return (jobject) MSG_host_get_data(host);
370 }
371
372 JNIEXPORT jstring JNICALL
373 Java_org_simgrid_msg_MsgNative_hostGetName(JNIEnv * env, jclass cls,
374                                        jobject jhost)
375 {
376   m_host_t host = jhost_get_native(env, jhost);
377
378   if (!host) {
379     jxbt_throw_notbound(env, "host", jhost);
380     return NULL;
381   }
382
383   return (*env)->NewStringUTF(env, MSG_host_get_name(host));
384 }
385
386 JNIEXPORT jint JNICALL
387 Java_org_simgrid_msg_MsgNative_hostGetNumber(JNIEnv * env, jclass cls)
388 {
389   xbt_dynar_t hosts =  MSG_hosts_as_dynar();
390   int nb_host = xbt_dynar_length(hosts);
391   xbt_dynar_free(&hosts);
392   return (jint) nb_host;
393 }
394
395 JNIEXPORT jobject JNICALL
396 Java_org_simgrid_msg_MsgNative_hostSelf(JNIEnv * env, jclass cls)
397 {
398   jobject jhost;
399
400   m_host_t host = MSG_host_self();
401
402   if (!MSG_host_get_data(host)) {
403     /* the native host not yet associated with the java host instance */
404
405     /* instanciate a new java host instance */
406     jhost = jhost_new_instance(env);
407
408     if (!jhost) {
409       jxbt_throw_jni(env, "java host instantiation failed");
410       return NULL;
411     }
412
413     /* get a global reference to the newly created host */
414     jhost = jhost_ref(env, jhost);
415
416     if (!jhost) {
417       jxbt_throw_jni(env, "global ref allocation failed");
418       return NULL;
419     }
420
421     /* Bind & store it */
422     jhost_bind(jhost, host, env);
423     MSG_host_set_data(host, (void *) jhost);
424   } else {
425     jhost = (jobject) MSG_host_get_data(host);
426   }
427
428   return jhost;
429 }
430
431 JNIEXPORT jdouble JNICALL
432 Java_org_simgrid_msg_MsgNative_hostGetSpeed(JNIEnv * env, jclass cls,
433                                         jobject jhost)
434 {
435   m_host_t host = jhost_get_native(env, jhost);
436
437   if (!host) {
438     jxbt_throw_notbound(env, "host", jhost);
439     return -1;
440   }
441
442   return (jdouble) MSG_get_host_speed(host);
443 }
444
445 JNIEXPORT jint JNICALL
446 Java_org_simgrid_msg_MsgNative_hostGetLoad(JNIEnv * env, jclass cls,
447                                        jobject jhost)
448 {
449   m_host_t host = jhost_get_native(env, jhost);
450
451   if (!host) {
452     jxbt_throw_notbound(env, "host", jhost);
453     return -1;
454   }
455
456   return (jint) MSG_get_host_msgload(host);
457 }
458
459
460 JNIEXPORT jboolean JNICALL
461 Java_org_simgrid_msg_MsgNative_hostIsAvail(JNIEnv * env, jclass cls,
462                                        jobject jhost)
463 {
464   m_host_t host = jhost_get_native(env, jhost);
465
466   if (!host) {
467     jxbt_throw_notbound(env, "host", jhost);
468     return 0;
469   }
470
471   return (jboolean) MSG_host_is_avail(host);
472 }
473
474
475 /***************************************************************************************
476  * The MSG task connected functions implementation.                                    *
477  ***************************************************************************************/
478
479 JNIEXPORT void JNICALL
480 Java_org_simgrid_msg_MsgNative_taskCreate(JNIEnv * env, jclass cls,
481                                       jobject jtask, jstring jname,
482                                       jdouble jcomputeDuration,
483                                       jdouble jmessageSize)
484 {
485   m_task_t task;                /* the native task to create                            */
486   const char *name = NULL;      /* the name of the task                                 */
487
488   if (jcomputeDuration < 0) {
489     jxbt_throw_illegal(env,
490                        bprintf
491                        ("Task ComputeDuration (%f) cannot be negative",
492                         (double) jcomputeDuration));
493     return;
494   }
495
496   if (jmessageSize < 0) {
497     jxbt_throw_illegal(env,
498                        bprintf("Task MessageSize (%f) cannot be negative",
499                                (double) jmessageSize));
500     return;
501   }
502
503   if (jname) {
504     /* get the C string from the java string */
505     name = (*env)->GetStringUTFChars(env, jname, 0);
506   }
507
508
509   /* create the task */
510   task =
511       MSG_task_create(name, (double) jcomputeDuration,
512                       (double) jmessageSize, NULL);
513
514   if (jname)
515     (*env)->ReleaseStringUTFChars(env, jname, name);
516
517   /* bind & store the task */
518   jtask_bind(jtask, task, env);
519   MSG_task_set_data(task, jtask);
520 }
521
522 JNIEXPORT void JNICALL
523 Java_org_simgrid_msg_MsgNative_parallel_taskCreate(JNIEnv * env, jclass cls,
524                                                jobject jtask,
525                                                jstring jname,
526                                                jobjectArray jhosts,
527                                                jdoubleArray
528                                                jcomputeDurations_arg,
529                                                jdoubleArray
530                                                jmessageSizes_arg)
531 {
532
533   m_task_t task;                /* the native parallel task to create           */
534   const char *name;             /* the name of the task                         */
535   int host_count;
536   m_host_t *hosts;
537   double *computeDurations;
538   double *messageSizes;
539   jdouble *jcomputeDurations;
540   jdouble *jmessageSizes;
541
542   jobject jhost;
543   int index;
544
545
546   if (!jcomputeDurations_arg) {
547     jxbt_throw_null(env,
548                     xbt_strdup
549                     ("Parallel task compute durations cannot be null"));
550     return;
551   }
552
553   if (!jmessageSizes_arg) {
554     jxbt_throw_null(env,
555                     xbt_strdup
556                     ("Parallel task message sizes cannot be null"));
557     return;
558   }
559
560   if (!jname) {
561     jxbt_throw_null(env, xbt_strdup("Parallel task name cannot be null"));
562     return;
563   }
564
565   host_count = (int) (*env)->GetArrayLength(env, jhosts);
566
567
568   hosts = xbt_new0(m_host_t, host_count);
569   computeDurations = xbt_new0(double, host_count);
570   messageSizes = xbt_new0(double, host_count * host_count);
571
572   jcomputeDurations =
573       (*env)->GetDoubleArrayElements(env, jcomputeDurations_arg, 0);
574   jmessageSizes =
575       (*env)->GetDoubleArrayElements(env, jmessageSizes_arg, 0);
576
577   for (index = 0; index < host_count; index++) {
578     jhost = (*env)->GetObjectArrayElement(env, jhosts, index);
579     hosts[index] = jhost_get_native(env, jhost);
580     computeDurations[index] = jcomputeDurations[index];
581   }
582   for (index = 0; index < host_count * host_count; index++) {
583     messageSizes[index] = jmessageSizes[index];
584   }
585
586   (*env)->ReleaseDoubleArrayElements(env, jcomputeDurations_arg,
587                                      jcomputeDurations, 0);
588   (*env)->ReleaseDoubleArrayElements(env, jmessageSizes_arg, jmessageSizes,
589                                      0);
590
591
592   /* get the C string from the java string */
593   name = (*env)->GetStringUTFChars(env, jname, 0);
594
595   task =
596       MSG_parallel_task_create(name, host_count, hosts, computeDurations,
597                                messageSizes, NULL);
598
599   (*env)->ReleaseStringUTFChars(env, jname, name);
600
601   /* associate the java task object and the native task */
602   jtask_bind(jtask, task, env);
603
604   MSG_task_set_data(task, (void *) jtask);
605
606   if (!MSG_task_get_data(task))
607     jxbt_throw_jni(env, "global ref allocation failed");
608 }
609
610 JNIEXPORT jobject JNICALL
611 Java_org_simgrid_msg_MsgNative_taskGetSender(JNIEnv * env, jclass cls,
612                                          jobject jtask)
613 {
614   m_process_t process;
615
616   m_task_t task = jtask_to_native_task(jtask, env);
617
618   if (!task) {
619     jxbt_throw_notbound(env, "task", jtask);
620     return NULL;
621   }
622
623   process = MSG_task_get_sender(task);
624   return (jobject) native_to_java_process(process);
625 }
626
627 JNIEXPORT jobject JNICALL
628 Java_org_simgrid_msg_MsgNative_taskGetSource(JNIEnv * env, jclass cls,
629                                          jobject jtask)
630 {
631   m_host_t host;
632   m_task_t task = jtask_to_native_task(jtask, env);
633
634   if (!task) {
635     jxbt_throw_notbound(env, "task", jtask);
636     return NULL;
637   }
638
639   host = MSG_task_get_source(task);
640
641   if (!MSG_host_get_data(host)) {
642     jxbt_throw_jni(env, "MSG_task_get_source() failed");
643     return NULL;
644   }
645
646   return (jobject) MSG_host_get_data(host);
647 }
648
649
650 JNIEXPORT jstring JNICALL
651 Java_org_simgrid_msg_MsgNative_taskGetName(JNIEnv * env, jclass cls,
652                                        jobject jtask)
653 {
654   m_task_t task = jtask_to_native_task(jtask, env);
655
656   if (!task) {
657     jxbt_throw_notbound(env, "task", jtask);
658     return NULL;
659   }
660
661   return (*env)->NewStringUTF(env, MSG_task_get_name(task));
662 }
663
664 JNIEXPORT void JNICALL
665 Java_org_simgrid_msg_MsgNative_taskCancel(JNIEnv * env, jclass cls,
666                                       jobject jtask)
667 {
668   m_task_t ptask = jtask_to_native_task(jtask, env);
669
670   if (!ptask) {
671     jxbt_throw_notbound(env, "task", jtask);
672     return;
673   }
674
675   MSG_error_t rv = MSG_task_cancel(ptask);
676
677   jxbt_check_res("MSG_task_cancel()", rv, MSG_OK,
678                  bprintf("unexpected error , please report this bug"));
679 }
680
681 JNIEXPORT jdouble JNICALL
682 Java_org_simgrid_msg_MsgNative_taskGetComputeDuration(JNIEnv * env, jclass cls,
683                                                   jobject jtask)
684 {
685   m_task_t ptask = jtask_to_native_task(jtask, env);
686
687   if (!ptask) {
688     jxbt_throw_notbound(env, "task", jtask);
689     return -1;
690   }
691   return (jdouble) MSG_task_get_compute_duration(ptask);
692 }
693
694 JNIEXPORT jdouble JNICALL
695 Java_org_simgrid_msg_MsgNative_taskGetRemainingDuration(JNIEnv * env,
696                                                     jclass cls,
697                                                     jobject jtask)
698 {
699   m_task_t ptask = jtask_to_native_task(jtask, env);
700
701   if (!ptask) {
702     jxbt_throw_notbound(env, "task", jtask);
703     return -1;
704   }
705   return (jdouble) MSG_task_get_remaining_computation(ptask);
706 }
707
708 JNIEXPORT void JNICALL
709 Java_org_simgrid_msg_MsgNative_taskSetPriority(JNIEnv * env, jclass cls,
710                                            jobject jtask, jdouble priority)
711 {
712   m_task_t task = jtask_to_native_task(jtask, env);
713
714   if (!task) {
715     jxbt_throw_notbound(env, "task", jtask);
716     return;
717   }
718   MSG_task_set_priority(task, (double) priority);
719 }
720
721 JNIEXPORT void JNICALL
722 Java_org_simgrid_msg_MsgNative_taskDestroy(JNIEnv * env, jclass cls,
723                                        jobject jtask_arg)
724 {
725
726   /* get the native task */
727   m_task_t task = jtask_to_native_task(jtask_arg, env);
728
729   if (!task) {
730     jxbt_throw_notbound(env, "task", task);
731     return;
732   }
733
734   MSG_error_t rv = MSG_task_destroy(task);
735
736   jxbt_check_res("MSG_task_destroy()", rv, MSG_OK,
737                  bprintf("unexpected error , please report this bug"));
738 }
739
740 JNIEXPORT void JNICALL
741 Java_org_simgrid_msg_MsgNative_taskExecute(JNIEnv * env, jclass cls,
742                                        jobject jtask)
743 {
744   m_task_t task = jtask_to_native_task(jtask, env);
745
746   if (!task) {
747     jxbt_throw_notbound(env, "task", jtask);
748     return;
749   }
750
751   MSG_error_t rv = MSG_task_execute(task);
752
753   jxbt_check_res("MSG_task_execute()", rv,
754                  MSG_HOST_FAILURE | MSG_TASK_CANCELED,
755                  bprintf("while executing task %s",
756                          MSG_task_get_name(task)));
757 }
758
759 /***************************************************************************************
760  * Unsortable functions                                                        *
761  ***************************************************************************************/
762
763 JNIEXPORT jdouble JNICALL
764 Java_org_simgrid_msg_Msg_getClock(JNIEnv * env, jclass cls)
765 {
766   return (jdouble) MSG_get_clock();
767 }
768
769 JNIEXPORT void JNICALL
770 Java_org_simgrid_msg_Msg_init(JNIEnv * env, jclass cls, jobjectArray jargs)
771 {
772   char **argv = NULL;
773   int index;
774   int argc = 0;
775   jstring jval;
776   const char *tmp;
777
778   smx_factory_initializer_to_use = SIMIX_ctx_java_factory_init;
779
780   if (jargs)
781     argc = (int) (*env)->GetArrayLength(env, jargs);
782
783   argc++;
784   argv = xbt_new(char *, argc + 1);
785   argv[0] = strdup("java");
786
787   for (index = 0; index < argc - 1; index++) {
788     jval = (jstring) (*env)->GetObjectArrayElement(env, jargs, index);
789     tmp = (*env)->GetStringUTFChars(env, jval, 0);
790     argv[index + 1] = strdup(tmp);
791     (*env)->ReleaseStringUTFChars(env, jval, tmp);
792   }
793   argv[argc] = NULL;
794
795   MSG_global_init(&argc, argv);
796
797   for (index = 0; index < argc; index++)
798     free(argv[index]);
799
800   free(argv);
801
802   (*env)->GetJavaVM(env, &__java_vm);
803 }
804
805 JNIEXPORT void JNICALL
806     JNICALL Java_org_simgrid_msg_Msg_run(JNIEnv * env, jclass cls)
807 {
808   MSG_error_t rv;
809   int index;
810   xbt_dynar_t hosts;
811   jobject jhost;
812
813   /* Run everything */
814   XBT_INFO("Ready to run MSG_MAIN");
815   rv = MSG_main();
816   XBT_INFO("Done running MSG_MAIN");
817   jxbt_check_res("MSG_main()", rv, MSG_OK,
818                  bprintf
819                  ("unexpected error : MSG_main() failed .. please report this bug "));
820
821   XBT_INFO("MSG_main finished");
822
823   XBT_INFO("Clean java world");
824   /* Cleanup java hosts */
825   hosts = MSG_hosts_as_dynar();
826   for (index = 0; index < xbt_dynar_length(hosts) - 1; index++) {
827     jhost = (jobject) xbt_dynar_get_as(hosts,index,m_host_t)->data;
828     if (jhost)
829       jhost_unref(env, jhost);
830
831   }
832   xbt_dynar_free(&hosts);
833   XBT_INFO("Clean native world");
834 }
835 JNIEXPORT void JNICALL
836     JNICALL Java_org_simgrid_msg_Msg_clean(JNIEnv * env, jclass cls)
837 {
838   /* cleanup native stuff. Calling it is ... useless since leaking memory at the end of the simulation is a non-issue */
839   MSG_error_t rv = MSG_OK != MSG_clean();
840   jxbt_check_res("MSG_clean()", rv, MSG_OK,
841                  bprintf
842                  ("unexpected error : MSG_clean() failed .. please report this bug "));
843 }
844    
845 JNIEXPORT jint JNICALL
846 Java_org_simgrid_msg_MsgNative_processKillAll(JNIEnv * env, jclass cls,
847                                           jint jresetPID)
848 {
849   return (jint) MSG_process_killall((int) jresetPID);
850 }
851
852 JNIEXPORT void JNICALL
853 Java_org_simgrid_msg_Msg_createEnvironment(JNIEnv * env, jclass cls,
854                                        jstring jplatformFile)
855 {
856
857   const char *platformFile =
858       (*env)->GetStringUTFChars(env, jplatformFile, 0);
859
860   MSG_create_environment(platformFile);
861
862   (*env)->ReleaseStringUTFChars(env, jplatformFile, platformFile);
863 }
864
865 JNIEXPORT void JNICALL
866 Java_org_simgrid_msg_MsgNative_processExit(JNIEnv * env, jclass cls,
867                                        jobject jprocess)
868 {
869
870   m_process_t process = jprocess_to_native_process(jprocess, env);
871
872   if (!process) {
873     jxbt_throw_notbound(env, "process", jprocess);
874     return;
875   }
876
877   smx_ctx_java_stop(MSG_process_get_smx_ctx(process));
878 }
879
880 JNIEXPORT void JNICALL
881 Java_org_simgrid_msg_Msg_info(JNIEnv * env, jclass cls, jstring js)
882 {
883   const char *s = (*env)->GetStringUTFChars(env, js, 0);
884   XBT_INFO("%s", s);
885   (*env)->ReleaseStringUTFChars(env, js, s);
886 }
887
888 JNIEXPORT jobjectArray JNICALL
889 Java_org_simgrid_msg_MsgNative_allHosts(JNIEnv * env, jclass cls_arg)
890 {
891   int index;
892   jobjectArray jtable;
893   jobject jhost;
894   jstring jname;
895   m_host_t host;
896
897   xbt_dynar_t table =  MSG_hosts_as_dynar();
898   int count = xbt_dynar_length(table);
899
900   jclass cls = jxbt_get_class(env, "org/simgrid/msg/Host");
901
902   if (!cls) {
903     return NULL;
904   }
905
906   jtable = (*env)->NewObjectArray(env, (jsize) count, cls, NULL);
907
908   if (!jtable) {
909     jxbt_throw_jni(env, "Hosts table allocation failed");
910     return NULL;
911   }
912
913   for (index = 0; index < count; index++) {
914     host = xbt_dynar_get_as(table,index,m_host_t);
915     jhost = (jobject) (MSG_host_get_data(host));
916
917     if (!jhost) {
918       jname = (*env)->NewStringUTF(env, MSG_host_get_name(host));
919
920       jhost =
921           Java_org_simgrid_msg_MsgNative_hostGetByName(env, cls_arg, jname);
922       /* FIXME: leak of jname ? */
923     }
924
925     (*env)->SetObjectArrayElement(env, jtable, index, jhost);
926   }
927   xbt_dynar_free(&table);
928   return jtable;
929 }
930
931 JNIEXPORT void JNICALL
932 Java_org_simgrid_msg_MsgNative_taskSend(JNIEnv * env, jclass cls,
933                                     jstring jalias, jobject jtask,
934                                     jdouble jtimeout)
935 {
936
937   MSG_error_t rv;
938   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
939
940   m_task_t task = jtask_to_native_task(jtask, env);
941
942
943   if (!task) {
944     (*env)->ReleaseStringUTFChars(env, jalias, alias);
945     jxbt_throw_notbound(env, "task", jtask);
946     return;
947   }
948
949   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
950   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
951   rv = MSG_task_send_with_timeout(task, alias, (double) jtimeout);
952
953   (*env)->ReleaseStringUTFChars(env, jalias, alias);
954
955   jxbt_check_res("MSG_task_send_with_timeout()", rv,
956                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
957                  bprintf("while sending task %s to mailbox %s",
958                          MSG_task_get_name(task), alias));
959 }
960
961 JNIEXPORT void JNICALL
962 Java_org_simgrid_msg_MsgNative_taskSendBounded(JNIEnv * env, jclass cls,
963                                            jstring jalias, jobject jtask,
964                                            jdouble jmaxRate)
965 {
966   m_task_t task = jtask_to_native_task(jtask, env);
967   MSG_error_t rv;
968   const char *alias;
969
970   if (!task) {
971     jxbt_throw_notbound(env, "task", jtask);
972     return;
973   }
974
975   alias = (*env)->GetStringUTFChars(env, jalias, 0);
976
977   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
978   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
979   rv = MSG_task_send_bounded(task, alias, (double) jmaxRate);
980
981   (*env)->ReleaseStringUTFChars(env, jalias, alias);
982
983   jxbt_check_res("MSG_task_send_bounded()", rv,
984                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
985                  bprintf
986                  ("while sending task %s to mailbox %s with max rate %f",
987                   MSG_task_get_name(task), alias, (double) jmaxRate));
988
989 }
990
991 JNIEXPORT jobject JNICALL
992 Java_org_simgrid_msg_MsgNative_taskReceive(JNIEnv * env, jclass cls,
993                                        jstring jalias, jdouble jtimeout,
994                                        jobject jhost)
995 {
996   MSG_error_t rv;
997   m_task_t task = NULL;
998   m_host_t host = NULL;
999   jobject jtask_global, jtask_local;
1000   const char *alias;
1001
1002   if (jhost) {
1003     host = jhost_get_native(env, jhost);
1004
1005     if (!host) {
1006       jxbt_throw_notbound(env, "host", jhost);
1007       return NULL;
1008     }
1009   }
1010
1011   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1012
1013   rv = MSG_task_receive_ext(&task, alias, (double) jtimeout, host);
1014   jtask_global = MSG_task_get_data(task);
1015
1016   /* Convert the global ref into a local ref so that the JVM can free the stuff */
1017   jtask_local = (*env)->NewLocalRef(env, jtask_global);
1018   (*env)->DeleteGlobalRef(env, jtask_global);
1019   MSG_task_set_data(task, NULL);
1020
1021   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1022
1023   jxbt_check_res("MSG_task_receive_ext()", rv,
1024                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
1025                  bprintf("while receiving from mailbox %s", alias));
1026
1027   return (jobject) jtask_local;
1028 }
1029
1030 JNIEXPORT jboolean JNICALL
1031 Java_org_simgrid_msg_MsgNative_taskListen(JNIEnv * env, jclass cls,
1032                                       jstring jalias)
1033 {
1034
1035   const char *alias;
1036   int rv;
1037
1038   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1039
1040   rv = MSG_task_listen(alias);
1041
1042   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1043
1044   return (jboolean) rv;
1045 }
1046
1047 JNIEXPORT jint JNICALL
1048 Java_org_simgrid_msg_MsgNative_taskListenFromHost(JNIEnv * env, jclass cls,
1049                                               jstring jalias,
1050                                               jobject jhost)
1051 {
1052   int rv;
1053   const char *alias;
1054
1055   m_host_t host = jhost_get_native(env, jhost);
1056
1057   if (!host) {
1058     jxbt_throw_notbound(env, "host", jhost);
1059     return -1;
1060   }
1061   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1062
1063   rv = MSG_task_listen_from_host(alias, host);
1064
1065   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1066
1067   return (jint) rv;
1068 }
1069
1070 JNIEXPORT jint JNICALL
1071 Java_org_simgrid_msg_MsgNative_taskListenFrom(JNIEnv * env, jclass cls,
1072                                           jstring jalias)
1073 {
1074
1075   int rv;
1076   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
1077
1078   rv = MSG_task_listen_from(alias);
1079
1080   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1081
1082   return (jint) rv;
1083 }
1084
1085 JNIEXPORT void JNICALL
1086 Java_org_simgrid_msg_Msg_deployApplication(JNIEnv * env, jclass cls,
1087                                        jstring jdeploymentFile)
1088 {
1089
1090   const char *deploymentFile =
1091       (*env)->GetStringUTFChars(env, jdeploymentFile, 0);
1092
1093   surf_parse_reset_callbacks();
1094
1095   surfxml_add_callback(STag_surfxml_process_cb_list,
1096                        japplication_handler_on_begin_process);
1097
1098   surfxml_add_callback(ETag_surfxml_argument_cb_list,
1099                        japplication_handler_on_process_arg);
1100
1101   surfxml_add_callback(STag_surfxml_prop_cb_list,
1102                        japplication_handler_on_property);
1103
1104   surfxml_add_callback(ETag_surfxml_process_cb_list,
1105                        japplication_handler_on_end_process);
1106
1107   surf_parse_open(deploymentFile);
1108
1109   japplication_handler_on_start_document();
1110
1111   if (surf_parse())
1112     jxbt_throw_jni(env, "surf_parse() failed");
1113
1114   surf_parse_close();
1115
1116   japplication_handler_on_end_document();
1117
1118   (*env)->ReleaseStringUTFChars(env, jdeploymentFile, deploymentFile);
1119 }