src/jmsg_task.c

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