Logo AND Algorithmique Numérique Distribuée

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