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