Logo AND Algorithmique Numérique Distribuée

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