Logo AND Algorithmique Numérique Distribuée

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