Logo AND Algorithmique Numérique Distribuée

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