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 = NULL;      /* 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, NULL);
  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, NULL);
 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 NULL;
 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 NULL;
 221   }
 222
 223   process = MSG_task_get_sender(task);
 224   if (process == NULL) {
 225     return NULL;
 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 NULL;
 238   }
 239
 240   host = MSG_task_get_source(task);
 241   if (host == NULL) {
 242     return NULL;
 243   }
 244   if (!host->extension(JAVA_HOST_LEVEL)) {
 245     jxbt_throw_jni(env, "MSG_task_get_source() failed");
 246     return NULL;
 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_error_t rv;
 363   msg_task_t *task = xbt_new(msg_task_t,1);
 364   *task = NULL;
 365
 366   msg_host_t host = NULL;
 367   jobject jtask_global, jtask_local;
 368   const char *alias;
 369
 370   if (jhost) {
 371     host = jhost_get_native(env, jhost);
 372
 373     if (!host) {
 374       jxbt_throw_notbound(env, "host", jhost);
 375       return NULL;
 376     }
 377   }
 378
 379   alias = env->GetStringUTFChars(jalias, 0);
 380   rv = MSG_task_receive_ext(task, alias, (double) jtimeout, host);
 381   if (env->ExceptionOccurred())
 382     return NULL;
 383   if (rv != MSG_OK) {
 384     jmsg_throw_status(env,rv);
 385     return NULL;
 386   }
 387   jtask_global = (jobject) MSG_task_get_data(*task);
 388
 389   /* Convert the global ref into a local ref so that the JVM can free the stuff */
 390   jtask_local = env->NewLocalRef(jtask_global);
 391   env->DeleteGlobalRef(jtask_global);
 392   MSG_task_set_data(*task, NULL);
 393
 394   env->ReleaseStringUTFChars(jalias, alias);
 395
 396   xbt_free(task);
 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 = NULL;
 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 NULL;
 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 NULL;
 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 = NULL;
 441
 442   msg_host_t host = NULL;
 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 NULL;
 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 NULL;
 459   if (rv != MSG_OK) {
 460     jmsg_throw_status(env,rv);
 461     return NULL;
 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, NULL);
 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 = NULL;
 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 NULL;
 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 NULL;
 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 NULL;
 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 NULL;
 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)(NULL));
 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 NULL;
 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 NULL;
 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)(NULL));
 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, NULL);
 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_listenFromHost(JNIEnv * env, jclass cls, jstring jalias, jobject jhost)
 661 {
 662   int rv;
 663   const char *alias;
 664
 665   msg_host_t host = jhost_get_native(env, jhost);
 666
 667   if (!host) {
 668     jxbt_throw_notbound(env, "host", jhost);
 669     return -1;
 670   }
 671   alias = env->GetStringUTFChars(jalias, 0);
 672   rv = MSG_task_listen_from_host(alias, host);
 673   env->ReleaseStringUTFChars(jalias, alias);
 674
 675   return (jint) rv;
 676 }
 677
 678 JNIEXPORT jint JNICALL Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls, jstring jalias)
 679 {
 680   int rv;
 681   const char *alias = env->GetStringUTFChars(jalias, 0);
 682   rv = MSG_task_listen_from(alias);
 683   env->ReleaseStringUTFChars(jalias, alias);
 684
 685   return (jint) rv;
 686 }