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