Logo AND Algorithmique Numérique Distribuée

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