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