Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Don't catch exceptions if you don't know what to do after that!
[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_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, jobject jtask)
210 {
211   msg_task_t task = jtask_to_native_task(jtask, env);
212
213   if (!task) {
214     jxbt_throw_notbound(env, "task", jtask);
215     return;
216   }
217   msg_error_t rv;
218   rv = MSG_task_execute(task);
219   if (rv != MSG_OK) {
220     jmsg_throw_status(env, rv);
221   }
222 }
223
224 JNIEXPORT jstring JNICALL
225 Java_org_simgrid_msg_Task_getName(JNIEnv * env,
226                                        jobject jtask) {
227   msg_task_t task = jtask_to_native_task(jtask, env);
228
229   if (!task) {
230     jxbt_throw_notbound(env, "task", jtask);
231     return NULL;
232   }
233
234   return (*env)->NewStringUTF(env, MSG_task_get_name(task));
235 }
236
237 JNIEXPORT jobject JNICALL
238 Java_org_simgrid_msg_Task_getSender(JNIEnv * env,
239                                          jobject jtask) {
240   msg_process_t process;
241
242   msg_task_t task = jtask_to_native_task(jtask, env);
243
244   if (!task) {
245     jxbt_throw_notbound(env, "task", jtask);
246     return NULL;
247   }
248
249   process = MSG_task_get_sender(task);
250   if (process == NULL) {
251         return NULL;
252   }
253   return (jobject) native_to_java_process(process);
254 }
255
256 JNIEXPORT jobject JNICALL
257 Java_org_simgrid_msg_Task_getSource(JNIEnv * env,
258                                          jobject jtask)
259 {
260   msg_host_t host;
261   msg_task_t task = jtask_to_native_task(jtask, env);
262
263   if (!task) {
264     jxbt_throw_notbound(env, "task", jtask);
265     return NULL;
266   }
267
268   host = MSG_task_get_source(task);
269   if (host == NULL) {
270         return NULL;
271   }
272   if (!MSG_host_get_data(host)) {
273     jxbt_throw_jni(env, "MSG_task_get_source() failed");
274     return NULL;
275   }
276
277   return (jobject) MSG_host_get_data(host);
278 }
279
280 JNIEXPORT jdouble JNICALL
281 Java_org_simgrid_msg_Task_getComputeDuration(JNIEnv * env,
282                                                   jobject jtask)
283 {
284   msg_task_t ptask = jtask_to_native_task(jtask, env);
285
286   if (!ptask) {
287     jxbt_throw_notbound(env, "task", jtask);
288     return -1;
289   }
290   return (jdouble) MSG_task_get_compute_duration(ptask);
291 }
292
293 JNIEXPORT jdouble JNICALL
294 Java_org_simgrid_msg_Task_getRemainingDuration(JNIEnv * env, jobject jtask)
295 {
296   msg_task_t ptask = jtask_to_native_task(jtask, env);
297
298   if (!ptask) {
299     jxbt_throw_notbound(env, "task", jtask);
300     return -1;
301   }
302   return (jdouble) MSG_task_get_remaining_computation(ptask);
303 }
304 JNIEXPORT void JNICALL
305 Java_org_simgrid_msg_Task_setName(JNIEnv *env, jobject jtask, jobject jname) {
306         msg_task_t task = jtask_to_native_task(jtask, env);
307
308         if (!task) {
309                 jxbt_throw_notbound(env, "task", jtask);
310                 return;
311         }
312         const char *name = (*env)->GetStringUTFChars(env, jname, 0);
313
314         (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
315         MSG_task_set_name(task, name);
316
317         (*env)->ReleaseStringUTFChars(env, jname, name);
318 }
319 JNIEXPORT void JNICALL
320 Java_org_simgrid_msg_Task_setPriority(JNIEnv * env,
321                                            jobject jtask, jdouble priority)
322 {
323   msg_task_t task = jtask_to_native_task(jtask, env);
324
325   if (!task) {
326     jxbt_throw_notbound(env, "task", jtask);
327     return;
328   }
329   MSG_task_set_priority(task, (double) priority);
330 }
331 JNIEXPORT void JNICALL
332 Java_org_simgrid_msg_Task_setComputeDuration
333                 (JNIEnv *env, jobject jtask, jdouble computationAmount) {
334         msg_task_t task = jtask_to_native_task(jtask, env);
335
336         if (!task) {
337     jxbt_throw_notbound(env, "task", jtask);
338     return;
339         }
340         MSG_task_set_compute_duration(task, (double) computationAmount);
341 }
342 JNIEXPORT void JNICALL
343 Java_org_simgrid_msg_Task_setDataSize
344                 (JNIEnv *env, jobject jtask, jdouble dataSize) {
345         msg_task_t task = jtask_to_native_task(jtask, env);
346
347         if (!task) {
348     jxbt_throw_notbound(env, "task", jtask);
349     return;
350         }
351         MSG_task_set_data_size(task, (double) dataSize);
352 }
353
354 JNIEXPORT void JNICALL
355 Java_org_simgrid_msg_Task_send(JNIEnv * env,jobject jtask,
356                                jstring jalias,
357                                jdouble jtimeout)
358 {
359   msg_error_t rv;
360   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
361
362   msg_task_t task = jtask_to_native_task(jtask, env);
363
364
365   if (!task) {
366     (*env)->ReleaseStringUTFChars(env, jalias, alias);
367     jxbt_throw_notbound(env, "task", jtask);
368     return;
369   }
370
371   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
372   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
373   rv = MSG_task_send_with_timeout(task, alias, (double) jtimeout);
374   (*env)->ReleaseStringUTFChars(env, jalias, alias);
375
376   if (rv != MSG_OK) {
377     jmsg_throw_status(env, rv);
378   }
379 }
380
381 JNIEXPORT void JNICALL
382 Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env,jobject jtask,
383                                       jstring jalias,
384                                       jdouble jtimeout,
385                                       jdouble maxrate)
386 {
387   msg_error_t rv;
388   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
389
390   msg_task_t task = jtask_to_native_task(jtask, env);
391
392
393   if (!task) {
394     (*env)->ReleaseStringUTFChars(env, jalias, alias);
395     jxbt_throw_notbound(env, "task", jtask);
396     return;
397   }
398
399   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
400   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
401   rv = MSG_task_send_with_timeout_bounded(task, alias, (double) jtimeout, (double) maxrate);
402   (*env)->ReleaseStringUTFChars(env, jalias, alias);
403
404   if (rv != MSG_OK) {
405     jmsg_throw_status(env, rv);
406   }
407 }
408
409 JNIEXPORT jobject JNICALL
410 Java_org_simgrid_msg_Task_receive(JNIEnv * env, jclass cls,
411                                   jstring jalias, jdouble jtimeout,
412                                   jobject jhost)
413 {
414   msg_error_t rv;
415   msg_task_t *task = xbt_new(msg_task_t,1);
416   *task = NULL;
417
418   msg_host_t host = NULL;
419   jobject jtask_global, jtask_local;
420   const char *alias;
421
422   if (jhost) {
423     host = jhost_get_native(env, jhost);
424
425     if (!host) {
426       jxbt_throw_notbound(env, "host", jhost);
427       return NULL;
428     }
429   }
430
431   alias = (*env)->GetStringUTFChars(env, jalias, 0);
432   rv = MSG_task_receive_ext(task, alias, (double) jtimeout, host);
433   if (rv != MSG_OK) {
434     jmsg_throw_status(env,rv);
435     return NULL;
436   }
437   jtask_global = MSG_task_get_data(*task);
438
439   /* Convert the global ref into a local ref so that the JVM can free the stuff */
440   jtask_local = (*env)->NewLocalRef(env, jtask_global);
441   (*env)->DeleteGlobalRef(env, jtask_global);
442   MSG_task_set_data(*task, NULL);
443
444   (*env)->ReleaseStringUTFChars(env, jalias, alias);
445
446   xbt_free(task);
447
448   return (jobject) jtask_local;
449 }
450
451
452 JNIEXPORT jobject JNICALL
453 Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
454         msg_comm_t comm;
455         const char *mailbox;
456         jclass comm_class;
457         //pointer to store the task object pointer.
458         msg_task_t *task = xbt_new(msg_task_t,1);
459         *task = NULL;
460         /* There should be a cache here */
461         comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
462
463         if (!comm_class) {
464                 jxbt_throw_native(env,bprintf("fieldID or methodID or class not found."));
465                 return NULL;
466         }
467
468         jobject jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
469         if (!jcomm) {
470                 jxbt_throw_native(env,bprintf("Can't create a Comm object."));
471                 return NULL;
472         }
473
474         mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
475
476         comm = MSG_task_irecv(task,mailbox);
477
478         (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
479         (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(task));
480         (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_TRUE);
481
482         (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
483
484         return jcomm;
485 }
486
487 JNIEXPORT jobject JNICALL
488 Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox) {
489   jclass comm_class;
490
491   const char *mailbox;
492
493   msg_task_t task;
494
495   jobject jcomm;
496   msg_comm_t comm;
497
498   comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
499
500   if (!comm_class) return NULL;
501
502   jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
503   mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
504
505   task = jtask_to_native_task(jtask, env);
506
507   if (!task) {
508     (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
509     (*env)->DeleteLocalRef(env, jcomm);
510     jxbt_throw_notbound(env, "task", jtask);
511         return NULL;
512   }
513
514 MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
515   comm = MSG_task_isend(task,mailbox);
516
517   (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
518   (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(NULL));
519   (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_FALSE);
520
521   (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
522
523   return jcomm;
524 }
525
526 JNIEXPORT jobject JNICALL
527 Java_org_simgrid_msg_Task_isendBounded(JNIEnv *env, jobject jtask, jstring jmailbox, jdouble maxrate) {
528   jclass comm_class;
529
530   const char *mailbox;
531
532   msg_task_t task;
533
534   jobject jcomm;
535   msg_comm_t comm;
536
537   comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
538
539   if (!comm_class) return NULL;
540
541   jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
542   mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
543
544   task = jtask_to_native_task(jtask, env);
545
546   if (!task) {
547     (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
548     (*env)->DeleteLocalRef(env, jcomm);
549     jxbt_throw_notbound(env, "task", jtask);
550         return NULL;
551   }
552
553 MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
554   comm = MSG_task_isend_bounded(task,mailbox,maxrate);
555
556   (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
557   (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(NULL));
558   (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_FALSE);
559
560   (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
561
562   return jcomm;
563 }
564
565
566
567 static void msg_task_cancel_on_failed_dsend(void*t) {
568   msg_task_t task = t;
569   JNIEnv *env =get_current_thread_env();
570   jobject jtask_global = MSG_task_get_data(task);
571
572   /* Destroy the global ref so that the JVM can free the stuff */
573   (*env)->DeleteGlobalRef(env, jtask_global);
574   MSG_task_set_data(task, NULL);
575   MSG_task_destroy(task);
576 }
577
578 JNIEXPORT void JNICALL
579 Java_org_simgrid_msg_Task_dsend(JNIEnv * env, jobject jtask,
580                                 jstring jalias) {
581   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
582
583   msg_task_t task = jtask_to_native_task(jtask, env);
584
585
586   if (!task) {
587     (*env)->ReleaseStringUTFChars(env, jalias, alias);
588     jxbt_throw_notbound(env, "task", jtask);
589     return;
590   }
591
592   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
593   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
594   MSG_task_dsend(task, alias, msg_task_cancel_on_failed_dsend);
595
596   (*env)->ReleaseStringUTFChars(env, jalias, alias);
597 }
598
599 JNIEXPORT void JNICALL
600 Java_org_simgrid_msg_Task_dsendBounded(JNIEnv * env, jobject jtask,
601                                 jstring jalias, jdouble maxrate) {
602   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
603
604   msg_task_t task = jtask_to_native_task(jtask, env);
605
606
607   if (!task) {
608     (*env)->ReleaseStringUTFChars(env, jalias, alias);
609     jxbt_throw_notbound(env, "task", jtask);
610     return;
611   }
612
613   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
614   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
615   MSG_task_dsend_bounded(task, alias, msg_task_cancel_on_failed_dsend,(double)maxrate);
616
617   (*env)->ReleaseStringUTFChars(env, jalias, alias);
618 }
619
620
621
622 JNIEXPORT jboolean JNICALL
623 Java_org_simgrid_msg_Task_listen(JNIEnv * env, jclass cls, jstring jalias)
624 {
625   const char *alias;
626   int rv;
627
628   alias = (*env)->GetStringUTFChars(env, jalias, 0);
629   rv = MSG_task_listen(alias);
630   (*env)->ReleaseStringUTFChars(env, jalias, alias);
631
632   return (jboolean) rv;
633 }
634
635 JNIEXPORT jint JNICALL
636 Java_org_simgrid_msg_Task_listenFromHost(JNIEnv * env, jclass cls, jstring jalias, jobject jhost)
637  {
638   int rv;
639   const char *alias;
640
641   msg_host_t host = jhost_get_native(env, jhost);
642
643   if (!host) {
644     jxbt_throw_notbound(env, "host", jhost);
645     return -1;
646   }
647   alias = (*env)->GetStringUTFChars(env, jalias, 0);
648   rv = MSG_task_listen_from_host(alias, host);
649   (*env)->ReleaseStringUTFChars(env, jalias, alias);
650
651   return (jint) rv;
652 }
653
654
655 JNIEXPORT jint JNICALL
656 Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls, jstring jalias)
657 {
658   int rv;
659   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
660   rv = MSG_task_listen_from(alias);
661   (*env)->ReleaseStringUTFChars(env, jalias, alias);
662
663   return (jint) rv;
664 }