Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Add dsendBounded + sendBounded with timeout
[simgrid.git] / src / jmsg_task.c
1 /* Functions related to the java task instances.                            */
2
3 /* Copyright (c) 2007, 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 "jmsg.h"
10
11 #include "smx_context_java.h"
12
13 #include "jmsg_host.h"
14 #include "jmsg_task.h"
15
16 #include "jxbt_utilities.h"
17
18 #include <msg/msg.h>
19
20 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
21
22 static jmethodID jtask_method_Comm_constructor;
23
24 static jfieldID jtask_field_Task_bind;
25 static jfieldID jtask_field_Task_name;
26 static jfieldID jtask_field_Comm_bind;
27 static jfieldID jtask_field_Comm_taskBind;
28 static jfieldID jtask_field_Comm_receiving;
29
30 void jtask_bind(jobject jtask, msg_task_t task, JNIEnv * env)
31 {
32   (*env)->SetLongField(env, jtask, jtask_field_Task_bind, (jlong) (long) (task));
33 }
34
35 msg_task_t jtask_to_native_task(jobject jtask, JNIEnv * env)
36 {
37   return (msg_task_t) (long) (*env)->GetLongField(env, jtask, jtask_field_Task_bind);
38 }
39
40 jboolean jtask_is_valid(jobject jtask, JNIEnv * env)
41 {
42   return (*env)->GetLongField(env, jtask, jtask_field_Task_bind) ? JNI_TRUE : JNI_FALSE;
43 }
44
45 JNIEXPORT void JNICALL
46 Java_org_simgrid_msg_Task_nativeInit(JNIEnv *env, jclass cls) {
47   jclass jtask_class_Comm = (*env)->FindClass(env, "org/simgrid/msg/Comm");
48   jclass jtask_class_Task = (*env)->FindClass(env, "org/simgrid/msg/Task");
49
50   jtask_method_Comm_constructor = (*env)->GetMethodID(env, jtask_class_Comm, "<init>", "()V");
51   jtask_field_Task_bind = jxbt_get_jfield(env, jtask_class_Task, "bind", "J");
52   jtask_field_Task_name = jxbt_get_jfield(env, jtask_class_Task, "name", "Ljava/lang/String;");
53   jtask_field_Comm_bind = jxbt_get_jfield(env, jtask_class_Comm, "bind", "J");
54   jtask_field_Comm_taskBind = jxbt_get_jfield(env, jtask_class_Comm, "taskBind", "J");
55   jtask_field_Comm_receiving = jxbt_get_jfield(env, jtask_class_Comm, "receiving", "Z");
56   if (!jtask_field_Task_bind || !jtask_class_Task || !jtask_field_Comm_bind || !jtask_field_Comm_taskBind ||
57         !jtask_field_Comm_receiving || !jtask_method_Comm_constructor) {
58           jxbt_throw_native(env,bprintf("Can't find some fields in Java class."));
59   }
60 }
61
62 JNIEXPORT void JNICALL
63 Java_org_simgrid_msg_Task_create(JNIEnv * env,
64                                       jobject jtask, jstring jname,
65                                       jdouble jcomputeDuration,
66                                       jdouble jmessageSize)
67 {
68   msg_task_t task;                /* the native task to create                            */
69   const char *name = NULL;      /* the name of the task                                 */
70
71   if (jcomputeDuration < 0) {
72     jxbt_throw_illegal(env,
73                        bprintf
74                        ("Task ComputeDuration (%f) cannot be negative",
75                         (double) jcomputeDuration));
76     return;
77   }
78
79   if (jmessageSize < 0) {
80     jxbt_throw_illegal(env,
81                        bprintf("Task MessageSize (%f) cannot be negative",
82                        (double) jmessageSize));
83     return;
84   }
85
86   if (jname) {
87     /* get the C string from the java string */
88     name = (*env)->GetStringUTFChars(env, jname, 0);
89   }
90
91   /* create the task */
92   task =
93       MSG_task_create(name, (double) jcomputeDuration,
94                      (double) jmessageSize, NULL);
95   if (jname)
96     (*env)->ReleaseStringUTFChars(env, jname, name);
97   /* sets the task name */
98   (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
99   /* bind & store the task */
100   jtask_bind(jtask, task, env);
101   MSG_task_set_data(task, jtask);
102 }
103
104 JNIEXPORT void JNICALL
105 Java_org_simgrid_msg_Task_parallelCreate(JNIEnv * env,
106                                          jobject jtask,
107                                          jstring jname,
108                                          jobjectArray jhosts,
109                                          jdoubleArray
110                                          jcomputeDurations_arg,
111                                          jdoubleArray
112                                          jmessageSizes_arg) {
113
114   msg_task_t task;                /* the native parallel task to create           */
115   const char *name;             /* the name of the task                         */
116   int host_count;
117   msg_host_t *hosts;
118   double *computeDurations;
119   double *messageSizes;
120   jdouble *jcomputeDurations;
121   jdouble *jmessageSizes;
122
123   jobject jhost;
124   int index;
125
126   if (!jcomputeDurations_arg) {
127     jxbt_throw_null(env,
128                     xbt_strdup
129                     ("Parallel task compute durations cannot be null"));
130     return;
131   }
132
133   if (!jmessageSizes_arg) {
134     jxbt_throw_null(env,
135                     xbt_strdup
136                     ("Parallel task message sizes cannot be null"));
137     return;
138   }
139
140   if (!jname) {
141     jxbt_throw_null(env, xbt_strdup("Parallel task name cannot be null"));
142     return;
143   }
144
145   host_count = (int) (*env)->GetArrayLength(env, jhosts);
146
147
148   hosts = xbt_new0(msg_host_t, host_count);
149   computeDurations = xbt_new0(double, host_count);
150   messageSizes = xbt_new0(double, host_count * host_count);
151
152   jcomputeDurations =
153       (*env)->GetDoubleArrayElements(env, jcomputeDurations_arg, 0);
154   jmessageSizes =
155       (*env)->GetDoubleArrayElements(env, jmessageSizes_arg, 0);
156
157   for (index = 0; index < host_count; index++) {
158     jhost = (*env)->GetObjectArrayElement(env, jhosts, index);
159     hosts[index] = jhost_get_native(env, jhost);
160     computeDurations[index] = jcomputeDurations[index];
161   }
162   for (index = 0; index < host_count * host_count; index++) {
163     messageSizes[index] = jmessageSizes[index];
164   }
165
166   (*env)->ReleaseDoubleArrayElements(env, jcomputeDurations_arg,
167                                      jcomputeDurations, 0);
168   (*env)->ReleaseDoubleArrayElements(env, jmessageSizes_arg, jmessageSizes,
169                                      0);
170
171
172   /* get the C string from the java string */
173   name = (*env)->GetStringUTFChars(env, jname, 0);
174
175   task =
176       MSG_parallel_task_create(name, host_count, hosts, computeDurations,
177                                messageSizes, NULL);
178
179   (*env)->ReleaseStringUTFChars(env, jname, name);
180   /* sets the task name */
181   (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
182   /* associate the java task object and the native task */
183   jtask_bind(jtask, task, env);
184
185   MSG_task_set_data(task, (void *) jtask);
186
187   if (!MSG_task_get_data(task))
188     jxbt_throw_jni(env, "global ref allocation failed");
189 }
190
191 JNIEXPORT void JNICALL
192 Java_org_simgrid_msg_Task_cancel(JNIEnv * env,
193                                       jobject jtask)
194 {
195   msg_task_t ptask = jtask_to_native_task(jtask, env);
196
197   if (!ptask) {
198     jxbt_throw_notbound(env, "task", jtask);
199     return;
200   }
201
202   msg_error_t rv = MSG_task_cancel(ptask);
203
204   jxbt_check_res("MSG_task_cancel()", rv, MSG_OK,
205                  bprintf("unexpected error , please report this bug"));
206 }
207
208 JNIEXPORT void JNICALL
209 Java_org_simgrid_msg_Task_execute(JNIEnv * env,
210                                        jobject jtask)
211 {
212   msg_task_t task = jtask_to_native_task(jtask, env);
213
214   if (!task) {
215     jxbt_throw_notbound(env, "task", jtask);
216     return;
217   }
218   xbt_ex_t e;
219   msg_error_t rv;
220   TRY {
221      rv = MSG_task_execute(task);
222   }
223   CATCH(e) {
224     xbt_ex_free(e);
225         return;
226   }
227   if (rv != MSG_OK) {
228         jmsg_throw_status(env, rv);
229   }
230 }
231
232 JNIEXPORT jstring JNICALL
233 Java_org_simgrid_msg_Task_getName(JNIEnv * env,
234                                        jobject jtask) {
235   msg_task_t task = jtask_to_native_task(jtask, env);
236
237   if (!task) {
238     jxbt_throw_notbound(env, "task", jtask);
239     return NULL;
240   }
241
242   return (*env)->NewStringUTF(env, MSG_task_get_name(task));
243 }
244
245 JNIEXPORT jobject JNICALL
246 Java_org_simgrid_msg_Task_getSender(JNIEnv * env,
247                                          jobject jtask) {
248   msg_process_t process;
249
250   msg_task_t task = jtask_to_native_task(jtask, env);
251
252   if (!task) {
253     jxbt_throw_notbound(env, "task", jtask);
254     return NULL;
255   }
256
257   process = MSG_task_get_sender(task);
258   if (process == NULL) {
259         return NULL;
260   }
261   return (jobject) native_to_java_process(process);
262 }
263
264 JNIEXPORT jobject JNICALL
265 Java_org_simgrid_msg_Task_getSource(JNIEnv * env,
266                                          jobject jtask)
267 {
268   msg_host_t host;
269   msg_task_t task = jtask_to_native_task(jtask, env);
270
271   if (!task) {
272     jxbt_throw_notbound(env, "task", jtask);
273     return NULL;
274   }
275
276   host = MSG_task_get_source(task);
277   if (host == NULL) {
278         return NULL;
279   }
280   if (!MSG_host_get_data(host)) {
281     jxbt_throw_jni(env, "MSG_task_get_source() failed");
282     return NULL;
283   }
284
285   return (jobject) MSG_host_get_data(host);
286 }
287
288 JNIEXPORT jdouble JNICALL
289 Java_org_simgrid_msg_Task_getComputeDuration(JNIEnv * env,
290                                                   jobject jtask)
291 {
292   msg_task_t ptask = jtask_to_native_task(jtask, env);
293
294   if (!ptask) {
295     jxbt_throw_notbound(env, "task", jtask);
296     return -1;
297   }
298   return (jdouble) MSG_task_get_compute_duration(ptask);
299 }
300
301 JNIEXPORT jdouble JNICALL
302 Java_org_simgrid_msg_Task_getRemainingDuration(JNIEnv * env, jobject jtask)
303 {
304   msg_task_t ptask = jtask_to_native_task(jtask, env);
305
306   if (!ptask) {
307     jxbt_throw_notbound(env, "task", jtask);
308     return -1;
309   }
310   return (jdouble) MSG_task_get_remaining_computation(ptask);
311 }
312 JNIEXPORT void JNICALL
313 Java_org_simgrid_msg_Task_setName(JNIEnv *env, jobject jtask, jobject jname) {
314         msg_task_t task = jtask_to_native_task(jtask, env);
315
316         if (!task) {
317                 jxbt_throw_notbound(env, "task", jtask);
318                 return;
319         }
320         const char *name = (*env)->GetStringUTFChars(env, jname, 0);
321
322         (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
323         MSG_task_set_name(task, name);
324
325         (*env)->ReleaseStringUTFChars(env, jname, name);
326 }
327 JNIEXPORT void JNICALL
328 Java_org_simgrid_msg_Task_setPriority(JNIEnv * env,
329                                            jobject jtask, jdouble priority)
330 {
331   msg_task_t task = jtask_to_native_task(jtask, env);
332
333   if (!task) {
334     jxbt_throw_notbound(env, "task", jtask);
335     return;
336   }
337   MSG_task_set_priority(task, (double) priority);
338 }
339 JNIEXPORT void JNICALL
340 Java_org_simgrid_msg_Task_setComputeDuration
341                 (JNIEnv *env, jobject jtask, jdouble computationAmount) {
342         msg_task_t task = jtask_to_native_task(jtask, env);
343
344         if (!task) {
345     jxbt_throw_notbound(env, "task", jtask);
346     return;
347         }
348         MSG_task_set_compute_duration(task, (double) computationAmount);
349 }
350 JNIEXPORT void JNICALL
351 Java_org_simgrid_msg_Task_send(JNIEnv * env,jobject jtask,
352                                     jstring jalias,
353                                     jdouble jtimeout)
354 {
355   msg_error_t rv;
356   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
357
358   msg_task_t task = jtask_to_native_task(jtask, env);
359
360
361   if (!task) {
362     (*env)->ReleaseStringUTFChars(env, jalias, alias);
363     jxbt_throw_notbound(env, "task", jtask);
364     return;
365   }
366
367   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
368   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
369   xbt_ex_t e;
370   TRY {
371     rv = MSG_task_send_with_timeout(task, alias, (double) jtimeout);
372   }
373   CATCH(e) {
374     xbt_ex_free(e);
375   }
376   (*env)->ReleaseStringUTFChars(env, jalias, alias);
377
378   if (rv != MSG_OK) {
379         jmsg_throw_status(env, rv);
380   }
381 }
382
383 JNIEXPORT void JNICALL
384 Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env,jobject jtask,
385                                     jstring jalias,
386                                     jdouble jtimeout,
387                                     jdouble maxrate)
388 {
389   msg_error_t rv;
390   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
391
392   msg_task_t task = jtask_to_native_task(jtask, env);
393
394
395   if (!task) {
396     (*env)->ReleaseStringUTFChars(env, jalias, alias);
397     jxbt_throw_notbound(env, "task", jtask);
398     return;
399   }
400
401   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
402   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
403   xbt_ex_t e;
404   TRY {
405     rv = MSG_task_send_with_timeout_bounded(task, alias, (double) jtimeout, (double) maxrate);
406   }
407   CATCH(e) {
408     xbt_ex_free(e);
409   }
410   (*env)->ReleaseStringUTFChars(env, jalias, alias);
411
412   if (rv != MSG_OK) {
413         jmsg_throw_status(env, rv);
414   }
415 }
416
417 JNIEXPORT jobject JNICALL
418 Java_org_simgrid_msg_Task_receive(JNIEnv * env, jclass cls,
419                                        jstring jalias, jdouble jtimeout,
420                                        jobject jhost)
421 {
422   msg_error_t rv;
423   msg_task_t *task = xbt_new(msg_task_t,1);
424   *task = NULL;
425
426   msg_host_t host = NULL;
427   jobject jtask_global, jtask_local;
428   const char *alias;
429
430   if (jhost) {
431     host = jhost_get_native(env, jhost);
432
433     if (!host) {
434       jxbt_throw_notbound(env, "host", jhost);
435       return NULL;
436     }
437   }
438
439   alias = (*env)->GetStringUTFChars(env, jalias, 0);
440   xbt_ex_t e;
441   TRY {
442         rv = MSG_task_receive_ext(task, alias, (double) jtimeout, host);
443   }
444   CATCH(e) {
445     xbt_ex_free(e);
446         return NULL;
447   }
448   if (rv != MSG_OK) {
449         jmsg_throw_status(env,rv);
450         return NULL;
451   }
452   jtask_global = MSG_task_get_data(*task);
453
454   /* Convert the global ref into a local ref so that the JVM can free the stuff */
455   jtask_local = (*env)->NewLocalRef(env, jtask_global);
456   (*env)->DeleteGlobalRef(env, jtask_global);
457   MSG_task_set_data(*task, NULL);
458
459   (*env)->ReleaseStringUTFChars(env, jalias, alias);
460
461   xbt_free(task);
462
463   return (jobject) jtask_local;
464 }
465
466
467 JNIEXPORT jobject JNICALL
468 Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
469         msg_comm_t comm;
470         const char *mailbox;
471         jclass comm_class;
472         //pointer to store the task object pointer.
473         msg_task_t *task = xbt_new(msg_task_t,1);
474         *task = NULL;
475         /* There should be a cache here */
476         comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
477
478         if (!comm_class) {
479                 jxbt_throw_native(env,bprintf("fieldID or methodID or class not found."));
480                 return NULL;
481         }
482
483         jobject jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
484         if (!jcomm) {
485                 jxbt_throw_native(env,bprintf("Can't create a Comm object."));
486                 return NULL;
487         }
488
489         mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
490
491         comm = MSG_task_irecv(task,mailbox);
492
493         (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
494         (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(task));
495         (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_TRUE);
496
497         (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
498
499         return jcomm;
500 }
501
502 JNIEXPORT jobject JNICALL
503 Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox) {
504   jclass comm_class;
505
506   const char *mailbox;
507
508   msg_task_t task;
509
510   jobject jcomm;
511   msg_comm_t comm;
512
513   comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
514
515   if (!comm_class) return NULL;
516
517   jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
518   mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
519
520   task = jtask_to_native_task(jtask, env);
521
522   if (!task) {
523     (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
524     (*env)->DeleteLocalRef(env, jcomm);
525     jxbt_throw_notbound(env, "task", jtask);
526         return NULL;
527   }
528
529 MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
530   comm = MSG_task_isend(task,mailbox);
531
532   (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
533   (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(NULL));
534   (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_FALSE);
535
536   (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
537
538   return jcomm;
539 }
540
541 JNIEXPORT jobject JNICALL
542 Java_org_simgrid_msg_Task_isendBounded(JNIEnv *env, jobject jtask, jstring jmailbox, jdouble maxrate) {
543   jclass comm_class;
544
545   const char *mailbox;
546
547   msg_task_t task;
548
549   jobject jcomm;
550   msg_comm_t comm;
551
552   comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
553
554   if (!comm_class) return NULL;
555
556   jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
557   mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
558
559   task = jtask_to_native_task(jtask, env);
560
561   if (!task) {
562     (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
563     (*env)->DeleteLocalRef(env, jcomm);
564     jxbt_throw_notbound(env, "task", jtask);
565         return NULL;
566   }
567
568 MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
569   comm = MSG_task_isend_bounded(task,mailbox,maxrate);
570
571   (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
572   (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(NULL));
573   (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_FALSE);
574
575   (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
576
577   return jcomm;
578 }
579
580
581
582 static void msg_task_cancel_on_failed_dsend(void*t) {
583   msg_task_t task = t;
584   JNIEnv *env =get_current_thread_env();
585   jobject jtask_global = MSG_task_get_data(task);
586
587   /* Destroy the global ref so that the JVM can free the stuff */
588   (*env)->DeleteGlobalRef(env, jtask_global);
589   MSG_task_set_data(task, NULL);
590   MSG_task_destroy(task);
591 }
592
593 JNIEXPORT void JNICALL
594 Java_org_simgrid_msg_Task_dsend(JNIEnv * env, jobject jtask,
595                                 jstring jalias) {
596   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
597
598   msg_task_t task = jtask_to_native_task(jtask, env);
599
600
601   if (!task) {
602     (*env)->ReleaseStringUTFChars(env, jalias, alias);
603     jxbt_throw_notbound(env, "task", jtask);
604     return;
605   }
606
607   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
608   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
609   MSG_task_dsend(task, alias, msg_task_cancel_on_failed_dsend);
610
611   (*env)->ReleaseStringUTFChars(env, jalias, alias);
612 }
613
614 JNIEXPORT void JNICALL
615 Java_org_simgrid_msg_Task_dsendBounded(JNIEnv * env, jobject jtask,
616                                 jstring jalias, jdouble maxrate) {
617   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
618
619   msg_task_t task = jtask_to_native_task(jtask, env);
620
621
622   if (!task) {
623     (*env)->ReleaseStringUTFChars(env, jalias, alias);
624     jxbt_throw_notbound(env, "task", jtask);
625     return;
626   }
627
628   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
629   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
630   MSG_task_dsend_bounded(task, alias, msg_task_cancel_on_failed_dsend,(double)maxrate);
631
632   (*env)->ReleaseStringUTFChars(env, jalias, alias);
633 }
634
635
636
637 JNIEXPORT jboolean JNICALL
638 Java_org_simgrid_msg_Task_listen(JNIEnv * env, jclass cls,
639                                                                                                            jstring jalias) {
640
641   const char *alias;
642   int rv;
643   xbt_ex_t e;
644
645   alias = (*env)->GetStringUTFChars(env, jalias, 0);
646   TRY {
647         rv = MSG_task_listen(alias);
648   }
649   CATCH(e) {
650     xbt_ex_free(e);
651         return 0;
652   }
653   (*env)->ReleaseStringUTFChars(env, jalias, alias);
654
655   return (jboolean) rv;
656 }
657
658 JNIEXPORT jint JNICALL
659 Java_org_simgrid_msg_Task_listenFromHost(JNIEnv * env, jclass cls,
660                                                                                                                                            jstring jalias,
661                                                                                                                                            jobject jhost) {
662   int rv;
663   const char *alias;
664
665   msg_host_t host = jhost_get_native(env, jhost);
666
667   if (!host) {
668     jxbt_throw_notbound(env, "host", jhost);
669     return -1;
670   }
671   alias = (*env)->GetStringUTFChars(env, jalias, 0);
672   xbt_ex_t e;
673
674   TRY {
675         rv = MSG_task_listen_from_host(alias, host);
676   }
677   CATCH(e) {
678     xbt_ex_free(e);
679         return 0;
680   }
681   (*env)->ReleaseStringUTFChars(env, jalias, alias);
682
683   return (jint) rv;
684 }
685
686
687 JNIEXPORT jint JNICALL
688 Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls,
689                                                         jstring jalias) {
690
691   int rv;
692   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
693   xbt_ex_t e;
694   TRY {
695         rv = MSG_task_listen_from(alias);
696   }
697   CATCH(e) {
698     xbt_ex_free(e);
699         return 0;
700   }
701   (*env)->ReleaseStringUTFChars(env, jalias, alias);
702
703   return (jint) rv;
704 }