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