Logo AND Algorithmique Numérique Distribuée

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